Toán học có rất nhiều biểu tượng. Một số có thể nói quá nhiều biểu tượng. Vì vậy, hãy làm một số toán học với hình ảnh.

Hãy có một tờ giấy, mà chúng ta sẽ vẽ. Để bắt đầu bài báo là có sản phẩm nào, chúng tôi sẽ nói đó là tương đương với hoặc đúng .$\top$$\textit{true}$

Nếu chúng ta viết những thứ khác trên giấy thì chúng cũng sẽ đúng.

Ví dụ

Chỉ ra rằng các yêu cầu và Q là đúng.$P$$Q$

Bây giờ chúng ta hãy nói rằng nếu chúng ta vẽ một vòng tròn xung quanh một số tuyên bố rằng tuyên bố đó là sai. Điều này đại diện cho logic không.

Ví dụ:

Chỉ ra rằng sai và Q đúng.$P$$Q$

Chúng tôi thậm chí có thể đặt vòng tròn xung quanh nhiều câu lệnh phụ:

Vì phần bên trong vòng tròn thường đọc là bằng cách đặt một vòng tròn xung quanh nó, nó có nghĩa là không  ( P  và  Q ) . Chúng ta thậm chí có thể làm tổ$P\text{ and }Q$$\text{not }(P\text{ and }Q)$

$\text{not }((\text{not }P)\text{ and }Q)$

$\bot$$\textit{false}$

Vì không gian trống là đúng, nên phủ định của đúng là sai.

Bây giờ bằng cách sử dụng phương pháp trực quan đơn giản này, chúng ta thực sự có thể biểu diễn bất kỳ câu lệnh nào trong logic mệnh đề.

Bằng chứng

Bước tiếp theo sau khi có thể trình bày các tuyên bố là có thể chứng minh chúng. Để chứng minh, chúng tôi có 4 quy tắc khác nhau có thể được sử dụng để biến đổi biểu đồ. Chúng ta luôn bắt đầu với một tờ giấy trắng mà như chúng ta biết là một sự thật trống rỗng và sau đó sử dụng các quy tắc khác nhau này để biến tờ giấy trống của chúng ta thành một định lý.

Quy tắc suy luận đầu tiên của chúng tôi là Chèn .

Chèn

Chúng tôi sẽ gọi số lượng phủ định giữa biểu đồ con và mức cao nhất là "độ sâu". Chèn cho phép chúng tôi giới thiệu bất kỳ tuyên bố nào chúng tôi muốn ở độ sâu kỳ lạ.

Dưới đây là một ví dụ về chúng tôi thực hiện chèn:

$P$

Xóa

Quy tắc suy luận tiếp theo là Erasure . Erasure nói với chúng ta rằng nếu chúng ta có một tuyên bố ở độ sâu thậm chí chúng ta có thể loại bỏ nó hoàn toàn.

Dưới đây là một ví dụ về tẩy xóa đang được áp dụng:

$Q$$2$$P$$1$

Cắt đôi

Cắt đôi là một tương đương. Có nghĩa là, không giống như các suy luận trước đó, nó cũng có thể được đảo ngược. Double Cut cho chúng ta biết rằng chúng ta có thể vẽ hai vòng tròn xung quanh bất kỳ biểu đồ con nào và nếu có hai vòng tròn xung quanh biểu đồ con, chúng ta có thể xóa cả hai vòng tròn.

Dưới đây là một ví dụ về Double Cut đang được sử dụng

$Q$

Lặp lại

Lặp lại là một tương đương là tốt. ¹ Đảo ngược của nó được gọi là Deiteration Nếu chúng ta có một câu lệnh và một vết cắt ở cùng cấp độ, chúng ta có thể sao chép câu lệnh đó bên trong vết cắt.

Ví dụ:

Việc xác định cho phép chúng ta đảo ngược một Lặp lại . Một tuyên bố có thể được loại bỏ thông qua Deiteration nếu có một bản sao của nó ở cấp độ tiếp theo.

Định dạng đại diện và bằng chứng này không phải là phát minh của riêng tôi. Chúng là một sửa đổi nhỏ của logic sơ đồ được gọi là Đồ thị Hiện sinh Alpha . Nếu bạn muốn đọc thêm về điều này, không có nhiều tài liệu, nhưng bài viết được liên kết là một khởi đầu tốt.

Bài tập

Nhiệm vụ của bạn sẽ là chứng minh định lý sau:

Điều này, khi được dịch thành biểu tượng logic truyền thống là

$((A\to(B\to A))\to(((\neg C\to(D\to\neg E))\to((C\to(D\to F))\to((E\to D)\to(E\to F))))\to G))\to(H\to G)$.

Còn được gọi là Tiên đề Łukasiewicz-Tarski .

Nó có vẻ liên quan nhưng đồ thị hiện sinh rất hiệu quả khi nói đến độ dài bằng chứng. Tôi đã chọn định lý này bởi vì tôi nghĩ nó là một độ dài thích hợp cho một câu đố vui và đầy thử thách. Nếu bạn gặp rắc rối với điều này, trước tiên tôi khuyên bạn nên thử một số định lý cơ bản hơn để hiểu rõ hơn về hệ thống. Một danh sách này có thể được tìm thấy ở dưới cùng của bài viết.

Đây là bằng chứng golf , điểm số của bạn sẽ là tổng số bước trong chứng minh của bạn từ đầu đến cuối. Mục tiêu là để giảm thiểu điểm số của bạn.

định dạng

Định dạng cho thử thách này rất linh hoạt, bạn có thể gửi câu trả lời ở bất kỳ định dạng nào có thể đọc rõ ràng, bao gồm các định dạng vẽ tay hoặc kết xuất. Tuy nhiên để rõ ràng, tôi đề nghị định dạng đơn giản sau:

• Chúng tôi đại diện cho một vết cắt với dấu ngoặc đơn, bất cứ điều gì chúng tôi đang cắt được đặt bên trong các ô. Việc cắt trống sẽ chỉ là ()ví dụ.

• Chúng tôi đại diện cho các nguyên tử chỉ bằng chữ cái của họ.

Như một ví dụ ở đây là tuyên bố mục tiêu theo định dạng này:

(((A((B(A))))(((((C)((D((E)))))(((C((D(F))))(((E(D))((E(F))))))))(G))))((H(G))))

Định dạng này là tốt vì nó có thể đọc được cả người và máy, vì vậy bao gồm nó trong bài viết của bạn sẽ rất hay.

$\LaTeX$

Hãy thử trực tuyến!

Đối với công việc thực tế của bạn, tôi khuyên bạn nên dùng bút chì và giấy khi làm việc. Tôi thấy rằng văn bản không trực quan như giấy khi nói đến đồ thị hiện sinh.

Ví dụ bằng chứng

Trong ví dụ này, chúng tôi sẽ chứng minh định lý sau:

$(A\rightarrow B)\rightarrow(\neg B\rightarrow \neg A)$

Bằng chứng:

Định lý thực hành

Dưới đây là một số định lý đơn giản bạn có thể sử dụng để thực hành hệ thống:

Łukasiewicz 'Tiên đề thứ hai

Tiên đề của Meredith

^{1: Hầu hết các nguồn sử dụng phiên bản Lặp lại tinh vi và mạnh mẽ hơn , nhưng để đơn giản hóa thử thách này, tôi đang sử dụng phiên bản này. Chúng tương đương về chức năng.}

19 bước

1. (()) [cắt đôi]
2. (AB()(((G)))) [chèn]
3. (AB(A)(((G)))) [lặp lại]
4. (((AB(A)))(((G)))) [cắt đôi]
5. (((AB(A))(((G))))(((G)))) [lặp lại]
6. (((AB(A))(((G))))((H(G)))) [chèn]
7. (((AB(A))(((G)(()))))((H(G)))) [cắt đôi]
8. (((AB(A))(((DE()(C)(F))(G))))((H(G)))) [chèn]
9. (((AB(A))(((DE(C)(DE(C))(F))(G))))((H(G)))) [lặp lại]
10. (((AB(A))(((DE(CD(F))(DE(C))(F))(G))))((H(G)))) [lặp lại]
11. (((AB(A))(((E(CD(F))(DE(C))(F)((D)))(G))))((H(G)))) [cắt đôi]
12. (((AB(A))(((E(CD(F))(DE(C))(E(D))(F))(G))))((H(G)))) [lặp lại]
13. (((AB(A))(((G)((CD(F))(DE(C))(E(D))((E(F)))))))((H(G)))) [cắt đôi]
14. (((AB(A))(((G)((CD(F))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [cắt đôi]
15. (((AB(A))(((G)((C((D(F))))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [cắt đôi]
16. (((AB(A))(((G)((DE(C))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [cắt đôi]
17. (((AB(A))(((G)((D(C)((E)))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [cắt đôi]
18. (((AB(A))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [cắt đôi]
19. (((A((B(A))))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [cắt đôi]

Định lý thực hành

Tiên đề thứ hai của Łukasiewicz: 7 bước

1. (()) [cắt đôi]
2. (A()(B)(C)) [chèn]
3. (A(A(B))(B)(C)) [lặp lại]
4. (A(AB(C))(A(B))(C)) [lặp lại]
5. ((AB(C))(A(B))((A(C)))) [cắt đôi]
6. ((AB(C))(((A(B))((A(C)))))) [cắt đôi]
7. ((A((B(C))))(((A(B))((A(C)))))) [cắt đôi]

Tiên đề của Meredith: 11 bước

1. (()) [cắt đôi]
2. (()(D(A)(E))) [chèn]
3. ((D(A)(E))((D(A)(E)))) [lặp lại]
4. ((D(A)(E))((D(A)(E(A))))) [lặp lại]
5. ((D(A)(E))(((E(A))((D(A)))))) [cắt đôi]
6. (((E)((D(A))))(((E(A))((D(A)))))) [cắt đôi]
7. (((E)((C)(D(A))))(((E(A))((D(A)))))) [chèn]
8. (((E)((C)(D(A)(C))))(((E(A))((D(A)))))) [lặp lại]
9. (((E)((C)((A)(C)((D)))))(((E(A))((D(A)))))) [cắt đôi]
10. (((E)((C)((A)(((C)((D)))))))(((E(A))((D(A)))))) [cắt đôi]
11. (((E)((C)((A(B))(((C)((D)))))))(((E(A))((D(A)))))) [chèn]

Tìm kiếm bằng chứng Haskell

(Cái gì, bạn nghĩ rằng tôi sẽ làm điều đó bằng tay? :-P)

Điều này chỉ cố gắng chèn, giới thiệu cắt đôi và lặp lại. Vì vậy, vẫn có khả năng các giải pháp này có thể được đánh bại bằng cách sử dụng tẩy xóa, loại bỏ cắt đôi hoặc khử màu.

{-# LANGUAGE ViewPatterns #-}

import Control.Applicative hiding (many)
import Data.Char
import Data.Function hiding ((&))
import qualified Data.Map as M
import Data.Maybe
import qualified Data.MultiSet as S
import qualified Data.PQueue.Prio.Min as Q
import System.IO
import Text.ParserCombinators.ReadP

type Var = Char

data Part
  = Var Var
  | Not Conj
  deriving (Eq, Ord)

instance Show Part where
  show (Var s) = [s]
  show (Not c) = "(" ++ show c ++ ")"

newtype Conj = Conj
  { parts :: S.MultiSet Part
  } deriving (Eq, Ord)

instance Show Conj where
  show (Conj (S.toAscList -> [])) = ""
  show (Conj (S.toAscList -> g:gs)) =
    show g ++ concat ["" ++ show g1 | g1 <- gs]

true :: Conj
true = Conj S.empty

not_ :: Conj -> Conj
not_ = Conj . S.singleton . Not

(&) :: Conj -> Conj -> Conj
Conj as & Conj bs = Conj (S.union as bs)

intersect :: Conj -> Conj -> Conj
intersect (Conj as) (Conj bs) = Conj (S.intersection as bs)

diff :: Conj -> Conj -> Conj
diff (Conj as) (Conj bs) = Conj (S.difference as bs)

splits :: Conj -> [(Conj, Conj)]
splits =
  S.foldOccur
    (\a o bcs ->
       [ (Conj (S.insertMany a o1 bs), Conj (S.insertMany a (o - o1) cs))
       | (Conj bs, Conj cs) <- bcs
       , o1 <- [0 .. o]
       ])
    [(true, true)] .
  parts

moves :: Bool -> Conj -> [(Conj, String)]
moves ev a =
  (do (b, c) <- splits a
      andMoves ev b c) ++
  (do (p, _) <- S.toOccurList (parts a)
      partMoves ev p (Conj (S.delete p (parts a))))

andMoves :: Bool -> Conj -> Conj -> [(Conj, String)]
andMoves ev a b = [(a, "insertion") | not ev]

partMoves :: Bool -> Part -> Conj -> [(Conj, String)]
partMoves ev (Not a) b =
  [(a1 & b, why) | (a1, why) <- notMoves ev a] ++
  [ (not_ (diff a d) & b, "iteration")
  | (d, _) <- splits (intersect a b)
  , d /= true
  ]
partMoves _ (Var _) _ = []

notMoves :: Bool -> Conj -> [(Conj, String)]
notMoves ev a =
  (case S.toList (parts a) of
     [Not b] -> [(b, "double cut")]
     _ -> []) ++
  [(not_ a1, why) | (a1, why) <- moves (not ev) a]

partSat :: Part -> Bool -> M.Map Var Bool -> [M.Map Var Bool]
partSat (Var var) b m =
  case M.lookup var m of
    Nothing -> [M.insert var b m]
    Just b1 -> [m | b1 == b]
partSat (Not c) b m = conjSat c (not b) m

conjSat :: Conj -> Bool -> M.Map Var Bool -> [M.Map Var Bool]
conjSat c False m = do
  (p, _) <- S.toOccurList (parts c)
  partSat p False m
conjSat c True m = S.foldOccur (\p _ -> (partSat p True =<<)) [m] (parts c)

readConj :: ReadP Conj
readConj = Conj . S.fromList <$> many readPart

readPart :: ReadP Part
readPart =
  Var <$> satisfy isAlphaNum <|> Not <$> (char '(' *> readConj <* char ')')

parse :: String -> Maybe Conj
parse s = listToMaybe [c | (c, "") <- readP_to_S readConj s]

partSize :: Part -> Int
partSize (Var _) = 1
partSize (Not c) = 1 + conjSize c

conjSize :: Conj -> Int
conjSize c = sum [partSize p * o | (p, o) <- S.toOccurList (parts c)]

data Pri = Pri
  { dist :: Int
  , size :: Int
  } deriving (Eq, Show)

instance Ord Pri where
  compare = compare `on` \(Pri d s) -> (s + d, d)

search ::
     Q.MinPQueue Pri (Conj, [(Conj, String)])
  -> M.Map Conj Int
  -> [[(Conj, String)]]
search (Q.minViewWithKey -> Nothing) _ = []
search (Q.minViewWithKey -> Just ((pri, (a, proof)), q)) m =
  [proof | a == true] ++
  uncurry search (foldr (addMove pri a proof) (q, m) (moves True a))

addMove ::
     Pri
  -> Conj
  -> [(Conj, String)]
  -> (Conj, String)
  -> (Q.MinPQueue Pri (Conj, [(Conj, String)]), M.Map Conj Int)
  -> (Q.MinPQueue Pri (Conj, [(Conj, String)]), M.Map Conj Int)
addMove pri b proof (a, why) (q, m) =
  case M.lookup a m of
    Just d
      | d <= d1 -> (q, m)
    _
      | null (conjSat a False M.empty) ->
        ( Q.insert (Pri d1 (conjSize a)) (a, (b, why) : proof) q
        , M.insert a d1 m)
    _ -> (q, m)
  where
    d1 = dist pri + 1

prove :: Conj -> [[(Conj, String)]]
prove c = search (Q.singleton (Pri 0 (conjSize c)) (c, [])) (M.singleton c 0)

printProof :: [(Conj, String)] -> IO ()
printProof proof = do
  mapM_
    (\(i, (a, why)) ->
       putStrLn (show i ++ ". `" ++ show a ++ "`  [" ++ why ++ "]"))
    (zip [1 ..] proof)
  putStrLn ""
  hFlush stdout

main :: IO ()
main = do
  Just theorem <- parse <$> getLine
  mapM_ printProof (prove theorem)

22 bước

$\to$(((())(())))

$\to$(((AB())(CDE(F)()))H(G))

$\to$(((AB(A))(CDE(F)(CD(F)))(G))H(G))

$\to$(((A((B(A))))(((((C))DE(F)(C((D(F)))))(G))))((H(G))))

$\to$(((A((B(A))))(((((C)DE)DE(F)(C((D(F)))))(G))))((H(G))))

$\to$(((A((B(A))))(((((C)((D((E)))))((((((D))E(F)))(C((D(F)))))))(G))))((H(G))))

$\to$(((A((B(A))))(((((C)((D((E)))))((((((D)E)E(F)))(C((D(F)))))))(G))))((H(G))))

$\to$(((A((B(A))))(((((C)((D((E)))))((((((D)E)((E(F)))))(C((D(F)))))(G))))))((H(G))))

Một vài điều tôi học được khi hoàn thành câu đố này:

• Giảm đại diện được cung cấp. Điều này liên quan đến việc đảo ngược các lần cắt đôi và lặp lại. Ví dụ, tiên đề này giảm xuống (((AB(A))(((C)DE)(CD(F))(E(D))(E(F)))(G))H(G))sau khi đảo ngược các lần cắt đôi và (((AB(A))(()CDE(F)))H(G)))sau khi đảo ngược các lần lặp.

• Tìm kiếm các nguyên tử đi lạc. Ví dụ, H được sử dụng như một biến giả, và do đó có thể được chèn tại bất kỳ điểm nào.

Thực hành các giải pháp định lý:

Giải pháp cho Tiên đề thứ hai của Łukasiewicz: [8 bước]

$\to$(())

$\to$(()AB(C))

$\to$((AB(C))AB(C))

$\to$((A((B(C))))A((B))(C))

$\to$((A((B(C))))A(A(B))(C))

$\to$((A((B(C))))(((A(B))((A(C))))))

Giải pháp cho Tiên đề của Meredith: [12 bước]

$\to$(())

$\to$(()(A)D(E))

$\to$(((A)D(E))(A)D(E(A)))

$\to$(((((A)D))(E))(A)D(E(A)))

$\to$(((((A(B))D)(C))(E))(A)D(E(A)))

$\to$(((((A(B))(C)D)(C))(E))(A)D(E(A)))

$\to$(((((A(B))(((C)((D)))))(C))(E))(((((A)D))(E(A)))))