Matematika memiliki banyak simbol. Beberapa mungkin mengatakan terlalu banyak simbol. Jadi mari kita lakukan matematika dengan gambar.

Mari kita punya kertas, yang akan kita gambar. Untuk memulai kertas kosong, kita akan mengatakan itu setara dengan atau $\top$$\textit{true}$ .

Jika kita menulis hal-hal lain di atas kertas itu juga akan benar.

Sebagai contoh

Menunjukkan bahwa klaim dan Q benar.$P$$Q$

Sekarang mari kita katakan bahwa jika kita menggambar lingkaran di sekitar pernyataan, pernyataan itu salah. Ini tidak logis.

Sebagai contoh:

Menunjukkan bahwa salah dan Q benar.$P$$Q$

Kami bahkan dapat menempatkan lingkaran di sekitar beberapa sub-pernyataan:

Karena bagian di dalam lingkaran biasanya dibaca sebagai dengan meletakkan lingkaran di sekitarnya itu berarti tidak  ( P  dan  Q ) . Kita bahkan dapat membuat lingkaran sarang$P\text{ and }Q$$\text{not }(P\text{ and }Q)$

Ini berbunyi $\text{not }((\text{not }P)\text{ and }Q)$ .

Jika kita menggambar lingkaran dengan tidak ada di dalamnya, itu mewakili atau salah . $\bot$$\textit{false}$

Karena ruang kosong itu benar, maka negasi yang benar itu salah.

Sekarang menggunakan metode visual sederhana ini, kita sebenarnya dapat mewakili pernyataan apa pun dalam logika proposisional.

Bukti

Langkah selanjutnya setelah dapat mewakili pernyataan adalah mampu membuktikannya. Sebagai bukti, kami memiliki 4 aturan berbeda yang dapat digunakan untuk mengubah grafik. Kita selalu mulai dengan lembaran kosong yang seperti kita ketahui adalah kebenaran yang kosong dan kemudian menggunakan aturan yang berbeda ini untuk mengubah lembaran kertas kosong kita menjadi teorema.

Aturan inferensi pertama kami adalah Penyisipan .

Insersi

Kami akan menyebut jumlah negasi antara sub-grafik dan tingkat atas adalah "kedalaman". Insersi memungkinkan kita untuk memperkenalkan pernyataan apa pun yang kita inginkan pada kedalaman yang aneh.

Berikut adalah contoh kami melakukan penyisipan:

$P$

Penghapusan

Aturan inferensi berikutnya adalah Erasure . Penghapusan memberi tahu kita bahwa jika kita memiliki pernyataan yang pada kedalaman yang sama kita dapat menghapusnya sepenuhnya.

Berikut adalah contoh penghapusan yang diterapkan:

$Q$$2$$P$$1$ bersarang tingkat.

Potong ganda

Double Cut adalah persamaan. Yang berarti, tidak seperti kesimpulan sebelumnya, itu juga dapat dibalik. Potong ganda memberi tahu kita bahwa kita dapat menggambar dua lingkaran di sekitar sub-grafik, dan jika ada dua lingkaran di sekitar sub-grafik, kita bisa menghapus keduanya.

Berikut adalah contoh dari Double Cut yang digunakan

$Q$

Perulangan

Iterasi adalah kesetaraan juga. ¹ Itu terbalik disebut Deiterasi Jika kita memiliki pernyataan dan potongan pada tingkat yang sama, kita dapat menyalin pernyataan itu di dalam potongan.

Sebagai contoh:

Deiterasi memungkinkan kita untuk membalik Iterasi . Pernyataan dapat dihapus melalui Deiterasi jika ada salinannya di tingkat berikutnya.

Format representasi dan bukti ini bukan dari penemuan saya sendiri. Mereka adalah modifikasi kecil dari logika diagram yang disebut Alpha Existential Graphs . Jika Anda ingin membaca lebih lanjut tentang ini, tidak ada banyak literatur, tetapi artikel yang terhubung adalah awal yang baik.

Tugas

Tugas Anda adalah membuktikan teorema berikut:

Ini, ketika diterjemahkan ke dalam simbolisasi logika tradisional

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

Juga dikenal sebagai Aksioma Łukasiewicz-Tarski .

Ini mungkin tampak terlibat tetapi grafik eksistensial sangat efisien dalam hal panjang bukti. Saya memilih teorema ini karena saya pikir itu adalah panjang yang sesuai untuk teka-teki yang menyenangkan dan menantang. Jika Anda mengalami masalah dengan yang satu ini saya akan merekomendasikan mencoba beberapa teorema yang lebih dasar terlebih dahulu untuk memahami sistem. Daftar ini dapat ditemukan di bagian bawah posting.

Ini adalah golf bukti sehingga skor Anda akan menjadi jumlah total langkah dalam bukti Anda dari awal hingga selesai. Tujuannya adalah untuk meminimalkan skor Anda.

Format

Format untuk tantangan ini fleksibel, Anda dapat mengirimkan jawaban dalam format apa pun yang dapat dibaca dengan jelas, termasuk format yang dibuat sendiri atau dirender. Namun untuk kejelasan saya sarankan format sederhana berikut:

• Kami mewakili potongan dengan tanda kurung, apa pun yang kami potong dimasukkan ke dalam parens. Potongan kosong hanya akan menjadi ()contoh.

• Kami mewakili atom hanya dengan surat-surat mereka.

Sebagai contoh di sini adalah pernyataan sasaran dalam format ini:

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

Format ini bagus karena dapat dibaca oleh manusia dan mesin, jadi memasukkannya dalam posting Anda akan menyenangkan.

$\LaTeX$

Cobalah online!

Sedangkan untuk pekerjaan Anda yang sebenarnya, saya merekomendasikan pensil dan kertas saat berolahraga. Saya menemukan bahwa teks tidak seintuitif kertas ketika menyangkut grafik eksistensial.

Contoh bukti

Dalam contoh bukti ini kita akan membuktikan teorema berikut:

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

Bukti:

Praktekkan Teorema

Berikut adalah beberapa teorema sederhana yang dapat Anda gunakan untuk berlatih sistem:

Xiukasiewicz 'Aksioma Kedua

Aksioma Meredith

^{1: Sebagian besar sumber menggunakan versi Iterasi yang lebih canggih dan kuat , tetapi untuk menyederhanakan tantangan ini, saya menggunakan versi ini. Mereka setara secara fungsional.}

19 langkah

1. (()) [potong ganda]
2. (AB()(((G)))) [insersi]
3. (AB(A)(((G)))) [perulangan]
4. (((AB(A)))(((G)))) [potong ganda]
5. (((AB(A))(((G))))(((G)))) [perulangan]
6. (((AB(A))(((G))))((H(G)))) [insersi]
7. (((AB(A))(((G)(()))))((H(G)))) [potong ganda]
8. (((AB(A))(((DE()(C)(F))(G))))((H(G)))) [insersi]
9. (((AB(A))(((DE(C)(DE(C))(F))(G))))((H(G)))) [perulangan]
10. (((AB(A))(((DE(CD(F))(DE(C))(F))(G))))((H(G)))) [perulangan]
11. (((AB(A))(((E(CD(F))(DE(C))(F)((D)))(G))))((H(G)))) [potong ganda]
12. (((AB(A))(((E(CD(F))(DE(C))(E(D))(F))(G))))((H(G)))) [perulangan]
13. (((AB(A))(((G)((CD(F))(DE(C))(E(D))((E(F)))))))((H(G)))) [potong ganda]
14. (((AB(A))(((G)((CD(F))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [potong ganda]
15. (((AB(A))(((G)((C((D(F))))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [potong ganda]
16. (((AB(A))(((G)((DE(C))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [potong ganda]
17. (((AB(A))(((G)((D(C)((E)))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [potong ganda]
18. (((AB(A))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [potong ganda]
19. (((A((B(A))))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [potong ganda]

Praktekkan teorema

Aksioma kedua Łukasiewicz: 7 langkah

1. (()) [potong ganda]
2. (A()(B)(C)) [insersi]
3. (A(A(B))(B)(C)) [perulangan]
4. (A(AB(C))(A(B))(C)) [perulangan]
5. ((AB(C))(A(B))((A(C)))) [potong ganda]
6. ((AB(C))(((A(B))((A(C)))))) [potong ganda]
7. ((A((B(C))))(((A(B))((A(C)))))) [potong ganda]

Aksioma Meredith: 11 langkah

1. (()) [potong ganda]
2. (()(D(A)(E))) [insersi]
3. ((D(A)(E))((D(A)(E)))) [perulangan]
4. ((D(A)(E))((D(A)(E(A))))) [perulangan]
5. ((D(A)(E))(((E(A))((D(A)))))) [potong ganda]
6. (((E)((D(A))))(((E(A))((D(A)))))) [potong ganda]
7. (((E)((C)(D(A))))(((E(A))((D(A)))))) [insersi]
8. (((E)((C)(D(A)(C))))(((E(A))((D(A)))))) [perulangan]
9. (((E)((C)((A)(C)((D)))))(((E(A))((D(A)))))) [potong ganda]
10. (((E)((C)((A)(((C)((D)))))))(((E(A))((D(A)))))) [potong ganda]
11. (((E)((C)((A(B))(((C)((D)))))))(((E(A))((D(A)))))) [insersi]

Pencari bukti Haskell

(Apa, kamu pikir aku akan melakukannya dengan tangan? :-P)

Ini hanya mencoba penyisipan, pengantar pemotongan ganda, dan iterasi. Jadi masih mungkin solusi ini bisa dikalahkan dengan menggunakan penghapusan, eliminasi potongan ganda, atau deiterasi.

{-# 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 Langkah

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

Beberapa hal yang saya pelajari dari menyelesaikan puzzle ini:

• Kurangi representasi yang disediakan. Ini melibatkan membalikkan pemotongan ganda dan iterasi. Misalnya, aksioma ini berkurang (((AB(A))(((C)DE)(CD(F))(E(D))(E(F)))(G))H(G))setelah membalikkan pemotongan ganda, dan (((AB(A))(()CDE(F)))H(G)))setelah membalikkan iterasi.

• Cari atom yang tersesat. Misalnya, H digunakan sebagai variabel dummy, dan dengan demikian dapat dimasukkan pada titik mana pun.

Praktik Solusi Teorema:

Solusi untuk Aksioma Kedua Łukasiewicz ': [8 Langkah]

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

Solusi untuk Aksioma Meredith: [12 Langkah]

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