Mathe hat viele Symbole. Einige sagen vielleicht zu viele Symbole. Lassen Sie uns also ein bisschen mit Bildern rechnen.

Lassen Sie uns ein Papier haben, auf das wir zurückgreifen werden. Um zu beginnen, dass das Papier leer ist, werden wir sagen, dass dies gleichbedeutend mit oder wahr ist .$\top$$\textit{true}$

Wenn wir andere Dinge auf das Papier schreiben, werden sie auch wahr sein.

Beispielsweise

Gibt an, dass die Behauptungen und Q wahr sind.$P$$Q$

Sagen wir nun, wenn wir einen Kreis um eine Aussage ziehen, ist diese Aussage falsch. Dies stellt logischerweise nicht.

Beispielsweise:

Zeigt an, dass falsch und Q wahr ist.$P$$Q$

Wir können den Kreis sogar um mehrere Unteranweisungen platzieren:

Da der Teil innerhalb des Kreises normalerweise als gelesen wird, indem ein Kreis um ihn gelegt wird, bedeutet dies nicht  ( P  und  Q ) . Wir können sogar Kreise nisten$P\text{ and }Q$$\text{not }(P\text{ and }Q)$

Dies lautet .$\text{not }((\text{not }P)\text{ and }Q)$

Wenn wir einen Kreis ohne zeichnen, bedeutet dies represents oder falsch . $\bot$$\textit{false}$

Da der leere Raum wahr war, ist die Negation von wahr falsch.

Mit dieser einfachen visuellen Methode können wir nun tatsächlich jede Aussage in der Aussagenlogik darstellen.

Beweise

Der nächste Schritt, nachdem Sie Aussagen darstellen können, besteht darin, sie zu beweisen. Für Beweise haben wir 4 verschiedene Regeln, die zum Transformieren eines Graphen verwendet werden können. Wir beginnen immer mit einem leeren Blatt, von dem wir wissen, dass es eine leere Wahrheit ist, und verwenden dann diese unterschiedlichen Regeln, um unser leeres Blatt Papier in einen Satz umzuwandeln.

Unsere erste Folgerungsregel lautet Einfügung .

Einfügung

Wir nennen die Anzahl der Negationen zwischen einem Subgraphen und der obersten Ebene "Tiefe". Das Einfügen ermöglicht es uns, eine beliebige Aussage in einer ungeraden Tiefe einzuführen.

Hier ist ein Beispiel, wie wir das Einfügen durchführen:

$P$

Löschen

Die nächste Folgerungsregel ist Löschen . Erasure sagt uns, dass wir eine Aussage, die sich in einer gleichmäßigen Tiefe befindet, vollständig entfernen können.

Hier ist ein Beispiel für die Löschung:

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

Doppelschnitt

Double Cut ist eine Äquivalenz. Dies bedeutet, dass es im Gegensatz zu den vorherigen Schlussfolgerungen auch umgekehrt werden kann. Double Cut sagt uns, dass wir zwei Kreise um jedes Untergraph zeichnen können, und wenn es zwei Kreise um ein Untergraph gibt, können wir beide entfernen.

Hier ist ein Beispiel für die Double Cut verwendet wird

$Q$

Iteration

Iteration ist ebenfalls eine Äquivalenz. ¹ Das Gegenteil heißt Deiteration. Wenn wir eine Anweisung und einen Schnitt auf derselben Ebene haben, können wir diese Anweisung innerhalb eines Schnitts kopieren.

Beispielsweise:

Durch Deiteration können wir eine Iteration umkehren . Eine Anweisung kann über Deiteration entfernt werden, wenn auf der nächsthöheren Ebene eine Kopie vorhanden ist.

Dieses Format der Darstellung und des Beweises ist nicht meine eigene Erfindung. Sie sind eine geringfügige Modifikation einer Diagrammlogik, die als Alpha-Existenzgraphen bezeichnet wird . Wenn Sie mehr darüber lesen möchten, gibt es nicht viel Literatur, aber der verlinkte Artikel ist ein guter Anfang.

Aufgabe

Ihre Aufgabe wird es sein, den folgenden Satz zu beweisen:

Dies ist, wenn in die traditionelle Logik übersetzt, die Symbolisierung

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

Wird auch als Łukasiewicz-Tarski-Axiom bezeichnet .

Es mag kompliziert erscheinen, aber existenzielle Graphen sind sehr effizient, wenn es um die Länge von Proofs geht. Ich habe diesen Satz gewählt, weil ich denke, dass er eine angemessene Länge für ein unterhaltsames und herausforderndes Puzzle ist. Wenn Sie Probleme mit diesem haben, würde ich empfehlen, zunächst einige grundlegendere Theoreme auszuprobieren, um den Überblick über das System zu behalten. Eine Liste davon finden Sie am Ende des Beitrags.

Dies ist Proof-Golf, sodass Ihre Punktzahl die Gesamtzahl der Schritte in Ihrem Proof von Anfang bis Ende ist. Das Ziel ist es, Ihre Punktzahl zu minimieren.

Format

Das Format für diese Herausforderung ist flexibel. Sie können Antworten in jedem gut lesbaren Format einreichen, einschließlich handgezeichneter oder gerenderter Formate. Aus Gründen der Übersichtlichkeit schlage ich jedoch folgendes einfaches Format vor:

• Wir stellen einen Schnitt mit Klammern dar, alles, was wir schneiden, wird in die Klammern gesetzt. Der leere Schnitt wäre nur ()zum Beispiel.

• Wir repräsentieren Atome nur mit ihren Buchstaben.

Als Beispiel hier ist die Zielaussage in diesem Format:

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

Dieses Format ist nett, weil es sowohl von Menschen als auch von Maschinen gelesen werden kann. Es wäre also nett, es in Ihren Beitrag aufzunehmen.

Wenn Sie ein paar schöne (ish) Diagramme haben möchten, finden Sie hier einen Code, der dieses Format in konvertiert$\LaTeX$

Probieren Sie es online!

Was deine eigentliche Arbeit angeht, empfehle ich beim Training Bleistift und Papier. Ich finde, dass Text in Bezug auf existenzielle Grafiken nicht so intuitiv ist wie Papier.

Beispielbeweis

In diesem Beispielbeweis werden wir den folgenden Satz beweisen:

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

Beweis:

Übungssätze

Hier sind einige einfache Sätze, mit denen Sie das System üben können:

Łukasiewicz 'zweites Axiom

Merediths Axiom

^{1: Die meisten Quellen verwenden eine komplexere und leistungsfähigere Version von Iteration . Um diese Herausforderung einfach zu halten, verwende ich diese Version. Sie sind funktional gleichwertig.}

19 Schritte

1. (()) [Doppelschnitt]
2. (AB()(((G)))) [Einfügung]
3. (AB(A)(((G)))) [Iteration]
4. (((AB(A)))(((G)))) [Doppelschnitt]
5. (((AB(A))(((G))))(((G)))) [Iteration]
6. (((AB(A))(((G))))((H(G)))) [Einfügung]
7. (((AB(A))(((G)(()))))((H(G)))) [Doppelschnitt]
8. (((AB(A))(((DE()(C)(F))(G))))((H(G)))) [Einfügung]
9. (((AB(A))(((DE(C)(DE(C))(F))(G))))((H(G)))) [Iteration]
10. (((AB(A))(((DE(CD(F))(DE(C))(F))(G))))((H(G)))) [Iteration]
11. (((AB(A))(((E(CD(F))(DE(C))(F)((D)))(G))))((H(G)))) [Doppelschnitt]
12. (((AB(A))(((E(CD(F))(DE(C))(E(D))(F))(G))))((H(G)))) [Iteration]
13. (((AB(A))(((G)((CD(F))(DE(C))(E(D))((E(F)))))))((H(G)))) [Doppelschnitt]
14. (((AB(A))(((G)((CD(F))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [Doppelschnitt]
15. (((AB(A))(((G)((C((D(F))))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [Doppelschnitt]
16. (((AB(A))(((G)((DE(C))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [Doppelschnitt]
17. (((AB(A))(((G)((D(C)((E)))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [Doppelschnitt]
18. (((AB(A))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [Doppelschnitt]
19. (((A((B(A))))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [Doppelschnitt]

Übungssätze

Łukasiewicz 'zweites Axiom: 7 Schritte

1. (()) [Doppelschnitt]
2. (A()(B)(C)) [Einfügung]
3. (A(A(B))(B)(C)) [Iteration]
4. (A(AB(C))(A(B))(C)) [Iteration]
5. ((AB(C))(A(B))((A(C)))) [Doppelschnitt]
6. ((AB(C))(((A(B))((A(C)))))) [Doppelschnitt]
7. ((A((B(C))))(((A(B))((A(C)))))) [Doppelschnitt]

Merediths Axiom: 11 Schritte

1. (()) [Doppelschnitt]
2. (()(D(A)(E))) [Einfügung]
3. ((D(A)(E))((D(A)(E)))) [Iteration]
4. ((D(A)(E))((D(A)(E(A))))) [Iteration]
5. ((D(A)(E))(((E(A))((D(A)))))) [Doppelschnitt]
6. (((E)((D(A))))(((E(A))((D(A)))))) [Doppelschnitt]
7. (((E)((C)(D(A))))(((E(A))((D(A)))))) [Einfügung]
8. (((E)((C)(D(A)(C))))(((E(A))((D(A)))))) [Iteration]
9. (((E)((C)((A)(C)((D)))))(((E(A))((D(A)))))) [Doppelschnitt]
10. (((E)((C)((A)(((C)((D)))))))(((E(A))((D(A)))))) [Doppelschnitt]
11. (((E)((C)((A(B))(((C)((D)))))))(((E(A))((D(A)))))) [Einfügung]

Haskell Proof Searcher

(Was, du dachtest ich würde das von Hand machen? :-P)

Hiermit werden nur das Einfügen, das Double Cut-Einführen und die Iteration versucht. Es ist also immer noch möglich, dass diese Lösungen durch Löschen, Double Cut Elimination oder Deiteration besiegt werden.

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

$\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)))) [Doppelschnitt]

Ein paar Dinge, die ich durch das Lösen dieses Puzzles gelernt habe:

• Reduzieren Sie die bereitgestellte Darstellung. Dies beinhaltet das Umkehren von Doppelschnitten und Iterationen. Beispielsweise reduziert sich dieses Axiom (((AB(A))(((C)DE)(CD(F))(E(D))(E(F)))(G))H(G))nach dem Umkehren auf Doppelschnitte und(((AB(A))(()CDE(F)))H(G))) nach dem Umkehren von Iterationen.

• Suche nach verirrten Atomen. Beispielsweise wird H als Dummy-Variable verwendet und kann daher an jeder Stelle eingefügt werden.

Übungssatz-Lösungen:

Lösung für Łukasiewicz 'zweites Axiom: [8 Schritte]

$\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)))))) [Doppelschnitt x2]

Lösung für Merediths Axiom: [12 Schritte]

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