La matematica ha molti simboli. Alcuni potrebbero dire troppi simboli. Quindi facciamo un po 'di matematica con le immagini.

Diamo un foglio su cui attingeremo. Per iniziare il foglio è vuoto, diremo che equivale a o .$\top$$\textit{true}$

Se scriviamo altre cose sul foglio, saranno vere.

Per esempio

Indica che le rivendicazioni e sono vere.$P$$Q$

Ora diciamo che se tracciamo un cerchio attorno ad un'affermazione tale affermazione è falsa. Questo rappresenta logicamente no.

Per esempio:

Indica che è falso e Q è vero.$P$$Q$

Possiamo persino posizionare il cerchio attorno a più sotto-dichiarazioni:

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

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

$\bot$$\textit{false}$

Poiché lo spazio vuoto era vero, allora la negazione del vero è falsa.

Ora usando questo semplice metodo visivo possiamo effettivamente rappresentare qualsiasi affermazione nella logica proposizionale.

prove

Il prossimo passo dopo essere stati in grado di rappresentare le dichiarazioni è riuscire a dimostrarle. Per le prove abbiamo 4 regole diverse che possono essere utilizzate per trasformare un grafico. Iniziamo sempre con un foglio vuoto che, come sappiamo, è una verità vacua e quindi usiamo queste diverse regole per trasformare il nostro foglio di carta vuoto in un teorema.

La nostra prima regola di inferenza è Insertion .

Inserimento

Chiameremo il numero di negazioni tra un sotto-grafico e il livello superiore è "profondità". L'inserimento ci consente di presentare qualsiasi affermazione desideriamo a una profondità dispari.

Ecco un esempio di noi che eseguiamo l'inserimento:

$P$

cancellatura

La prossima regola di inferenza è la cancellazione . La cancellazione ci dice che se abbiamo un'affermazione a una profondità uniforme possiamo rimuoverla del tutto.

Ecco un esempio di cancellazione applicata:

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

Doppio taglio

Double Cut è un'equivalenza. Ciò significa che, a differenza delle inferenze precedenti, può anche essere invertito. Double Cut ci dice che possiamo disegnare due cerchi attorno a qualsiasi sotto-grafico e se ci sono due cerchi attorno a un sotto-grafico possiamo rimuoverli entrambi.

Ecco un esempio del Double Cut utilizzato

$Q$

Iterazione

Anche l'iterazione è un'equivalenza. ¹ Il suo contrario si chiama Deiterazione Se abbiamo un'istruzione e un taglio sullo stesso livello, possiamo copiare quell'istruzione all'interno di un taglio.

Per esempio:

La deiterazione ci consente di invertire un'iterazione . Una dichiarazione può essere rimossa tramite Deiterazione se ne esiste una copia al livello successivo.

Questo formato di rappresentazione e prova non è di mia invenzione. Sono una modifica minore di una logica schematica sono chiamati Alpha Existential Graphs . Se vuoi leggere di più su questo, non c'è un sacco di letteratura, ma l'articolo collegato è un buon inizio.

Compito

Il tuo compito sarà dimostrare il seguente teorema:

Questo, quando tradotto in simbolizzazione logica tradizionale è

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

Conosciuto anche come Łukasiewicz-Tarski Axiom .

Può sembrare coinvolto, ma i grafici esistenziali sono molto efficienti quando si tratta della lunghezza della prova. Ho selezionato questo teorema perché penso che sia una lunghezza appropriata per un puzzle divertente e stimolante. Se hai problemi con questo, ti consiglio di provare prima alcuni teoremi di base per ottenere il blocco del sistema. Un elenco di questi può essere trovato in fondo al post.

Questo è il golf di prova, quindi il tuo punteggio sarà il numero totale di passaggi nella prova dall'inizio alla fine. L'obiettivo è ridurre al minimo il tuo punteggio.

Formato

Il formato di questa sfida è flessibile e puoi inviare le risposte in qualsiasi formato chiaramente leggibile, inclusi i formati disegnati a mano o renderizzati. Tuttavia, per chiarezza, suggerisco il seguente formato semplice:

• Rappresentiamo un taglio tra parentesi, qualunque cosa stiamo tagliando viene messa all'interno delle parentesi. Il taglio vuoto sarebbe solo ()per esempio.

• Rappresentiamo gli atomi con solo le loro lettere.

A titolo di esempio, ecco la dichiarazione obiettivo in questo formato:

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

Questo formato è bello perché è leggibile sia dall'uomo che dalla macchina, quindi includerlo nel tuo post sarebbe bello.

$\LaTeX$

Provalo online!

Per quanto riguarda il tuo lavoro effettivo, ti consiglio di usare carta e matita quando ti alleni. Trovo che il testo non sia intuitivo quanto la carta quando si tratta di grafici esistenziali.

Esempio di prova

In questo esempio dimostreremo il seguente teorema:

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

Prova:

Teoremi di pratica

Ecco alcuni semplici teoremi che puoi usare per esercitarti nel sistema:

Secondo assioma di Łukasiewicz

L'assioma di Meredith

^{1: La maggior parte delle fonti utilizza una versione più sofisticata e potente di Iteration , ma per mantenere questa sfida semplice sto usando questa versione. Sono funzionalmente equivalenti.}

19 passaggi

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

Pratica teoremi

Secondo assioma di Łukasiewicz: 7 passi

1. (()) [doppio taglio]
2. (A()(B)(C)) [inserimento]
3. (A(A(B))(B)(C)) [iterazione]
4. (A(AB(C))(A(B))(C)) [iterazione]
5. ((AB(C))(A(B))((A(C)))) [doppio taglio]
6. ((AB(C))(((A(B))((A(C)))))) [doppio taglio]
7. ((A((B(C))))(((A(B))((A(C)))))) [doppio taglio]

L'assioma di Meredith: 11 passi

1. (()) [doppio taglio]
2. (()(D(A)(E))) [inserimento]
3. ((D(A)(E))((D(A)(E)))) [iterazione]
4. ((D(A)(E))((D(A)(E(A))))) [iterazione]
5. ((D(A)(E))(((E(A))((D(A)))))) [doppio taglio]
6. (((E)((D(A))))(((E(A))((D(A)))))) [doppio taglio]
7. (((E)((C)(D(A))))(((E(A))((D(A)))))) [inserimento]
8. (((E)((C)(D(A)(C))))(((E(A))((D(A)))))) [iterazione]
9. (((E)((C)((A)(C)((D)))))(((E(A))((D(A)))))) [doppio taglio]
10. (((E)((C)((A)(((C)((D)))))))(((E(A))((D(A)))))) [doppio taglio]
11. (((E)((C)((A(B))(((C)((D)))))))(((E(A))((D(A)))))) [inserimento]

Cercatore di prove Haskell

(Cosa, pensavi che l'avrei fatto a mano? :-P)

Questo prova solo all'inserimento, all'introduzione a doppio taglio e all'iterazione. Quindi è ancora possibile che queste soluzioni possano essere battute usando la cancellazione, l'eliminazione del doppio taglio o la deiterazione.

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

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

Alcune cose che ho imparato completando questo puzzle:

• Ridurre la rappresentazione fornita. Ciò comporta l'inversione di doppi tagli e iterazioni. Ad esempio, questo assioma si riduce a (((AB(A))(((C)DE)(CD(F))(E(D))(E(F)))(G))H(G))dopo aver invertito i doppi tagli e (((AB(A))(()CDE(F)))H(G)))dopo aver invertito le iterazioni.

• Cerca atomi vaganti. Ad esempio, H viene utilizzato come variabile fittizia e quindi può essere inserito in qualsiasi punto.

Pratica Teorema Soluzioni:

Soluzione per il secondo assioma di Łukasiewicz: [8 passaggi]

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

Soluzione per l'assioma di Meredith: [12 passaggi]

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