คณิตศาสตร์มีสัญลักษณ์มากมาย บางคนอาจพูดสัญลักษณ์มากเกินไป ลองทำคณิตศาสตร์พร้อมรูปภาพกัน

ให้มีกระดาษซึ่งเราจะวาดบน ในการเริ่มต้นกระดาษที่ว่างเปล่าที่เราจะบอกว่าเทียบเท่ากับหรือจริง$\top$$\textit{true}$

ถ้าเราเขียนสิ่งอื่น ๆ ลงบนกระดาษพวกเขาก็จะเป็นจริง

ตัวอย่างเช่น

ระบุว่าการอ้างสิทธิ์และQเป็นจริง$P$$Q$

ตอนนี้ให้เราบอกว่าถ้าเราวาดวงกลมรอบคำสั่งบางคำที่เป็นเท็จ สิ่งนี้แสดงถึงตรรกะไม่ใช่

ตัวอย่างเช่น:

บ่งชี้ว่าเป็นเท็จและQเป็นจริง$P$$Q$

เรายังสามารถวางวงกลมรอบคำสั่งย่อยหลายรายการ:

ตั้งแต่ส่วนภายในวงกลมตามปกติอ่านเป็นโดยการวางวงกลมรอบ ๆ มันจะหมายถึงการไม่ได้  ( P  และ  Q ) เราสามารถทำรังเป็นวงกลมได้$P\text{ and }Q$$\text{not }(P\text{ and }Q)$

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

$\bot$$\textit{false}$

เนื่องจากพื้นที่ว่างเป็นความจริงดังนั้นการปฏิเสธความจริงจึงเป็นเท็จ

ตอนนี้ใช้วิธีวิชวลวิชั่นนี้เราสามารถแสดงข้อความใด ๆ ในตรรกะเชิงประพจน์

พิสูจน์

ขั้นตอนต่อไปหลังจากที่สามารถแสดงข้อความได้ก็คือสามารถพิสูจน์ได้ สำหรับการพิสูจน์เรามีกฎที่แตกต่างกัน 4 ข้อที่สามารถใช้ในการแปลงกราฟ เรามักจะเริ่มต้นด้วยแผ่นเปล่าที่เรารู้ว่าเป็นความจริงที่ว่างเปล่าและจากนั้นใช้กฎที่แตกต่างกันเหล่านี้เพื่อแปลงแผ่นกระดาษเปล่าของเราเป็นทฤษฎีบท

กฎการอนุมานแรกของเราคือการแทรก

การแทรก

เราจะเรียกจำนวนการปฏิเสธระหว่างกราฟย่อยและระดับบนสุดว่า "ความลึก" การแทรกช่วยให้เราสามารถแนะนำข้อความใด ๆ ที่เราต้องการได้อย่างลึกซึ้ง

นี่คือตัวอย่างของการทำการแทรก:

$P$

การลบออก

กฎการอนุมานต่อไปคือลบ การลบบอกเราว่าหากเรามีข้อความที่ระดับความลึกเท่ากันเราสามารถลบออกได้อย่างสิ้นเชิง

นี่คือตัวอย่างของการลบออกที่ถูกนำไปใช้:

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

ดับเบิ้ลคัต

Double Cutเป็นสิ่งที่เท่าเทียมกัน ซึ่งหมายความว่าไม่เหมือนข้อสรุปก่อนหน้านี้ซึ่งสามารถย้อนกลับ Double Cutบอกเราว่าเราสามารถวาดวงกลมสองวงรอบกราฟย่อยใดก็ได้และหากมีวงกลมสองวงรอบกราฟย่อยเราสามารถลบทั้งสองออกได้

นี่คือตัวอย่างของที่คู่ตัดถูกนำมาใช้

$Q$

การย้ำ

การวนซ้ำก็มีความเท่าเทียมเช่นกัน ¹สิ่งที่ตรงกันข้ามเรียกว่าDeiteration หากเรามีคำสั่งและการตัดในระดับเดียวกันเราสามารถคัดลอกคำสั่งนั้นในการตัดได้

ตัวอย่างเช่น:

Deiterationช่วยให้เราสามารถกลับรายการคำซ้ำ สามารถลบคำสั่งผ่านDeiterationหากมีสำเนาอยู่ในระดับถัดไป

รูปแบบของการเป็นตัวแทนและการพิสูจน์ไม่ใช่การประดิษฐ์ของฉันเอง พวกเขามีการเปลี่ยนแปลงเล็ก ๆ น้อย ๆ ของตรรกะแผนภาพจะเรียกว่าอัลฟาอัตถิภาวนิยมกราฟ หากคุณต้องการอ่านเพิ่มเติมเกี่ยวกับเรื่องนี้ไม่มีวรรณกรรมมากมาย แต่บทความที่เชื่อมโยงเป็นการเริ่มต้นที่ดี

งาน

งานของคุณคือการพิสูจน์ทฤษฎีบทต่อไปนี้:

สิ่งนี้เมื่อแปลเป็นสัญลักษณ์เชิงตรรกะดั้งเดิมแล้ว

$((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)$.

ยังเป็นที่รู้จักŁukasiewicz-Tarski ความจริง

มันอาจดูเหมือนเกี่ยวข้อง แต่กราฟอัตถิภาวนิยมมีประสิทธิภาพมากเมื่อมันมาถึงความยาวของการพิสูจน์ ฉันเลือกทฤษฎีบทนี้เพราะฉันคิดว่ามันเป็นความยาวที่เหมาะสมสำหรับปริศนาที่สนุกและท้าทาย หากคุณกำลังมีปัญหากับเรื่องนี้ฉันขอแนะนำให้ลองใช้ทฤษฎีพื้นฐานขั้นพื้นฐานเพิ่มเติมก่อนเพื่อให้ระบบหยุดชะงัก รายการเหล่านี้สามารถพบได้ที่ด้านล่างของโพสต์

นี่คือหลักฐานการเล่นกอล์ฟดังนั้นคะแนนของคุณจะเป็นจำนวนขั้นตอนทั้งหมดในการพิสูจน์ตั้งแต่ต้นจนจบ เป้าหมายคือเพื่อลดคะแนนของคุณ

รูป

รูปแบบสำหรับความท้าทายนี้มีความยืดหยุ่นคุณสามารถส่งคำตอบในรูปแบบใด ๆ ที่อ่านได้ชัดเจนรวมถึงรูปแบบที่วาดด้วยมือหรือแสดงผล อย่างไรก็ตามเพื่อความชัดเจนฉันขอแนะนำรูปแบบง่าย ๆ ต่อไปนี้:

• เราเป็นตัวแทนของการตัดด้วยวงเล็บสิ่งที่เรากำลังตัดอยู่ภายในของ parens ตัวอย่างการเจียระไนเปล่า()ๆ

• เราเป็นตัวแทนอะตอมด้วยตัวอักษรของพวกเขา

เป็นตัวอย่างที่นี่เป็นคำสั่งเป้าหมายในรูปแบบนี้:

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

รูปแบบนี้ดีเพราะเป็นทั้งมนุษย์และเครื่องที่อ่านได้ดังนั้นการรวมไว้ในโพสต์ของคุณน่าจะดี

$\LaTeX$

ลองออนไลน์!

สำหรับงานจริงของคุณฉันขอแนะนำดินสอและกระดาษเมื่อออกกำลังกาย ฉันพบว่าข้อความไม่ง่ายเหมือนกระดาษเมื่อพูดถึงกราฟที่มีอยู่

ตัวอย่างหลักฐาน

ในตัวอย่างนี้เราจะพิสูจน์ทฤษฎีบทต่อไปนี้:

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

พิสูจน์:

ทฤษฎีการปฏิบัติ

นี่คือทฤษฎีบทง่ายๆที่คุณสามารถใช้ในการฝึกระบบ:

สัจพจน์ที่สองของŁukasiewicz

สัจพจน์ของเมเรดิ ธ

^{1: แหล่งข้อมูลส่วนใหญ่ใช้เวอร์ชันIteration ที่มีความซับซ้อนและทรงพลังมากขึ้นแต่เพื่อให้ความท้าทายนี้ง่ายขึ้นฉันกำลังใช้เวอร์ชันนี้อยู่ พวกมันมีหน้าที่เทียบเท่า}

19 ขั้นตอน

1. (()) [ตัดสองครั้ง]
2. (AB()(((G)))) [แทรก]
3. (AB(A)(((G)))) [ซ้ำ]
4. (((AB(A)))(((G)))) [ตัดสองครั้ง]
5. (((AB(A))(((G))))(((G)))) [ซ้ำ]
6. (((AB(A))(((G))))((H(G)))) [แทรก]
7. (((AB(A))(((G)(()))))((H(G)))) [ตัดสองครั้ง]
8. (((AB(A))(((DE()(C)(F))(G))))((H(G)))) [แทรก]
9. (((AB(A))(((DE(C)(DE(C))(F))(G))))((H(G)))) [ซ้ำ]
10. (((AB(A))(((DE(CD(F))(DE(C))(F))(G))))((H(G)))) [ซ้ำ]
11. (((AB(A))(((E(CD(F))(DE(C))(F)((D)))(G))))((H(G)))) [ตัดสองครั้ง]
12. (((AB(A))(((E(CD(F))(DE(C))(E(D))(F))(G))))((H(G)))) [ซ้ำ]
13. (((AB(A))(((G)((CD(F))(DE(C))(E(D))((E(F)))))))((H(G)))) [ตัดสองครั้ง]
14. (((AB(A))(((G)((CD(F))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [ตัดสองครั้ง]
15. (((AB(A))(((G)((C((D(F))))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [ตัดสองครั้ง]
16. (((AB(A))(((G)((DE(C))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [ตัดสองครั้ง]
17. (((AB(A))(((G)((D(C)((E)))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [ตัดสองครั้ง]
18. (((AB(A))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [ตัดสองครั้ง]
19. (((A((B(A))))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [ตัดสองครั้ง]

ทฤษฎีการปฏิบัติ

สัจพจน์ที่สองของŁukasiewicz: 7 ขั้นตอน

1. (()) [ตัดสองครั้ง]
2. (A()(B)(C)) [แทรก]
3. (A(A(B))(B)(C)) [ซ้ำ]
4. (A(AB(C))(A(B))(C)) [ซ้ำ]
5. ((AB(C))(A(B))((A(C)))) [ตัดสองครั้ง]
6. ((AB(C))(((A(B))((A(C)))))) [ตัดสองครั้ง]
7. ((A((B(C))))(((A(B))((A(C)))))) [ตัดสองครั้ง]

สัจพจน์ของเมเรดิ ธ : 11 ขั้นตอน

1. (()) [ตัดสองครั้ง]
2. (()(D(A)(E))) [แทรก]
3. ((D(A)(E))((D(A)(E)))) [ซ้ำ]
4. ((D(A)(E))((D(A)(E(A))))) [ซ้ำ]
5. ((D(A)(E))(((E(A))((D(A)))))) [ตัดสองครั้ง]
6. (((E)((D(A))))(((E(A))((D(A)))))) [ตัดสองครั้ง]
7. (((E)((C)(D(A))))(((E(A))((D(A)))))) [แทรก]
8. (((E)((C)(D(A)(C))))(((E(A))((D(A)))))) [ซ้ำ]
9. (((E)((C)((A)(C)((D)))))(((E(A))((D(A)))))) [ตัดสองครั้ง]
10. (((E)((C)((A)(((C)((D)))))))(((E(A))((D(A)))))) [ตัดสองครั้ง]
11. (((E)((C)((A(B))(((C)((D)))))))(((E(A))((D(A)))))) [แทรก]

เครื่องมือค้นหา Haskell

(คุณคิดว่าฉันจะทำด้วยมือ? :-P)

เพียงลองใช้การแทรกการตัดซ้ำสองครั้งและการทำซ้ำ ดังนั้นจึงยังคงเป็นไปได้ที่วิธีแก้ปัญหาเหล่านี้อาจถูกตีด้วยการลบการกำจัดแบบตัดสองครั้งหรือการหักล้าง

{-# 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 ขั้นตอน

$\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))))

บางสิ่งที่ฉันเรียนรู้จากการไขปริศนานี้ให้สมบูรณ์:

• ลดการเป็นตัวแทนที่ให้ไว้ สิ่งนี้เกี่ยวข้องกับการย้อนกลับการตัดซ้ำสองครั้งและการวนซ้ำ ตัวอย่างเช่นสัจพจน์นี้จะลดลง(((AB(A))(((C)DE)(CD(F))(E(D))(E(F)))(G))H(G))หลังจากย้อนกลับการตัดซ้ำสองครั้งและ(((AB(A))(()CDE(F)))H(G)))หลังการทำซ้ำ

• มองหาอะตอมจรจัด ตัวอย่างเช่น H ถูกใช้เป็นตัวแปรจำลองและสามารถแทรกได้ทุกจุด

ฝึกทฤษฎีการแก้ปัญหา:

โซลูชันสำหรับสัจพจน์ที่สองของŁukasiewicz: [8 ขั้นตอน]

$\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))))))

คำตอบสำหรับความจริงของเมเรดิ ธ : [12 ขั้นตอน]

$\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)))))