Matematiğin çok fazla sembolü var. Bazıları çok fazla sembol söyleyebilir. Bu yüzden resimlerle biraz matematik yapalım.

Hadi üzerinde çizeceğimiz bir kağıt verelim. başlatmak için boş, şunu söyleyelim equivalent veya true .$\top$$\textit{true}$

Kağıda başka şeyler yazarsak, bunlar da doğru olacaktır.

Örneğin

ve Q iddialarının doğru olduğunu gösterir .$P$$Q$

Şimdi şunu söyleyelim; bazı ifadelerin etrafına bir daire çizersek, bu ifadenin yanlış olduğunu söyleyelim. Bu mantıklı değil temsil eder.

Örneğin:

yanlış ve Q'nun doğru olduğunu gösterir .$P$$Q$

Çevreyi birden fazla alt ifadenin etrafına bile yerleştirebiliriz:

Çemberin içindeki kısım normalde etrafına bir daire koyarak olarak okuduğundan, ( P  ve  Q ) anlamına gelmez  . Daireleri bile yuvalayabiliriz$P\text{ and }Q$$\text{not }(P\text{ and }Q)$

Bu gibi okur .$\text{not }((\text{not }P)\text{ and }Q)$

Biz temsil İçinde hiçbir şey, bir çember çizerseniz veya FALSE . $\bot$$\textit{false}$

Boş alan doğru olduğundan, doğru olmadığını kabul etmek yanlıştır.

Şimdi bu basit görsel yöntemi kullanarak, önermeli mantıktaki herhangi bir ifadeyi temsil edebiliriz.

Kanıtlar

İfadeleri temsil edebilmenin ardından bir sonraki adım onları ispatlayabilmektir. Kanıtlar için, bir grafiği dönüştürmek için kullanılabilecek 4 farklı kural vardır. Her zaman bildiğimiz gibi boş bir gerçek olan boş bir sayfa ile başlıyoruz ve sonra bu boş kuralları bir teoremi dönüştürmek için bu farklı kuralları kullanıyoruz.

İlk çıkarım kuralımız Ekleme'dir .

sokma

Bir alt grafik ile "derinlik" olan en üst seviye arasındaki olumsuzlukları arayacağız. Ekleme , dilediğimiz herhangi bir ifadeyi garip bir derinlikte sunmamızı sağlar.

İşte ekleme yapmamıza bir örnek:

$P$

silme

Bir sonraki çıkarım kuralı Silme'dir . Erasure bize, derinlemesine derinlikte olan bir ifademiz varsa onu tamamen kaldırabileceğimizi söyler.

İşte uygulanmakta olan bir silme örneği:

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

Çift kesim

Çift Kesim bir eşdeğerdir. Bu, önceki çıkarımlardan farklı olarak tersine çevrilebileceği anlamına gelir. Double Cut , bize herhangi bir alt grafiğin etrafına iki daire çizebileceğimizi ve alt grafiğin etrafında iki daire varsa ikisini de kaldırabileceğimizi söyler.

İşte kullanılan Çift Kesim örneği

$Q$

tekrarlama

Yineleme de bir denkliktir . ¹ Tersine Deiteration (Deneme) olarak adlandırılır . Aynı seviyede bir cümleyiz ve bir kesimimiz varsa, o cümleyi bir kesimin içine kopyalayabiliriz.

Örneğin:

Deiterasyon , bir Yinelemeyi tersine çevirmemize izin verir . Bir sonraki aşamada bir kopyası varsa bir açıklama Deiteration aracılığıyla kaldırılabilir .

Bu temsil ve ispat formatı kendi buluşum değil. Bunlar şematik bir mantık üzerinde ufak bir değişikliktir ve bunlara Alfa Mevcut Grafikler denir . Bununla ilgili daha fazla şey okumak istiyorsanız, bir ton literatür yok, ancak bağlantılı makale iyi bir başlangıç.

Görev

Göreviniz aşağıdaki teoremi ispatlamak olacaktır:

Bu, geleneksel mantık sembolizasyonuna çevrildiğinde

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

Ayrıca asukasiewicz-Tarski Aksiyomu olarak da bilinir .

İlgili gözükebilir, ancak varoluşsal grafikler kanıt uzunluğuna gelince çok verimlidir. Bu teoremi seçtim, çünkü eğlenceli ve zorlu bir bulmacanın uygun bir uzunluk olduğunu düşünüyorum. Bununla ilgili sorun yaşarsanız, önce sistemi kapatmak için bazı temel teoremleri denemenizi tavsiye ederim. Bunların bir listesi yazının altında bulunabilir.

Bu ispat golfüdür, böylece skorunuz baştan sona kanıtınızdaki toplam adım sayısı olacaktır. Amaç puanınızı en aza indirmektir.

Biçim

Bu zorluğun formatı esnektir, elle çizilmiş veya oluşturulmuş formatlar da dahil olmak üzere, açıkça okunabilir herhangi bir formatta cevaplar gönderebilirsiniz. Ancak netlik için aşağıdaki basit formatı öneririm:

• Parantezli bir kesimi temsil ediyoruz, kesiyorsak ne olursa olsun paraların içine. Boş kesim sadece ()mesela.

• Atomları sadece harfleriyle temsil ediyoruz.

Örnek olarak, bu formattaki gol ifadesi şöyle:

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

Bu biçim güzel, çünkü hem insan hem de makine tarafından okunabiliyor, bu nedenle gönderinize eklemeniz iyi olurdu.

Eğer bazı hoş (ish) diyagramları istiyorsanız, bu formatı çeviren bir kod var.$\LaTeX$

Çevrimiçi deneyin!

Asıl çalışmanıza gelince, çalışma sırasında kalem ve kağıt öneririm. Bu metnin varoluşsal grafiklere gelince, kağıt kadar sezgisel olmadığını düşünüyorum.

Örnek kanıt

Bu örnekte kanıt olarak aşağıdaki teoremi ispatlayacağız:

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

Kanıt:

Uygulama Teoremleri

Sistemi uygulamak için kullanabileceğiniz bazı basit teoremler:

Asukasiewicz 'İkinci Aksiyomu

Meredith'in Aksiyomu

^{1: Çoğu kaynak, yinelemenin daha sofistike ve güçlü bir sürümünü kullanır , ancak bu zorluğu basit tutmak için bu sürümü kullanıyorum. İşlevsel olarak eşdeğerdirler.}

19 adım

1. (()) [çift kesim]
2. (AB()(((G)))) [Ekleme]
3. (AB(A)(((G)))) [Yineleme]
4. (((AB(A)))(((G)))) [çift kesim]
5. (((AB(A))(((G))))(((G)))) [Yineleme]
6. (((AB(A))(((G))))((H(G)))) [Ekleme]
7. (((AB(A))(((G)(()))))((H(G)))) [çift kesim]
8. (((AB(A))(((DE()(C)(F))(G))))((H(G)))) [Ekleme]
9. (((AB(A))(((DE(C)(DE(C))(F))(G))))((H(G)))) [Yineleme]
10. (((AB(A))(((DE(CD(F))(DE(C))(F))(G))))((H(G)))) [Yineleme]
11. (((AB(A))(((E(CD(F))(DE(C))(F)((D)))(G))))((H(G)))) [çift kesim]
12. (((AB(A))(((E(CD(F))(DE(C))(E(D))(F))(G))))((H(G)))) [Yineleme]
13. (((AB(A))(((G)((CD(F))(DE(C))(E(D))((E(F)))))))((H(G)))) [çift kesim]
14. (((AB(A))(((G)((CD(F))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [çift kesim]
15. (((AB(A))(((G)((C((D(F))))(DE(C))(((E(D))((E(F)))))))))((H(G)))) [çift kesim]
16. (((AB(A))(((G)((DE(C))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [çift kesim]
17. (((AB(A))(((G)((D(C)((E)))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [çift kesim]
18. (((AB(A))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [çift kesim]
19. (((A((B(A))))(((G)(((C)((D((E)))))(((C((D(F))))(((E(D))((E(F)))))))))))((H(G)))) [çift kesim]

Uygulama teoremleri

Asukasiewicz 'ikinci aksiyomu: 7 adım

1. (()) [çift kesim]
2. (A()(B)(C)) [Ekleme]
3. (A(A(B))(B)(C)) [Yineleme]
4. (A(AB(C))(A(B))(C)) [Yineleme]
5. ((AB(C))(A(B))((A(C)))) [çift kesim]
6. ((AB(C))(((A(B))((A(C)))))) [çift kesim]
7. ((A((B(C))))(((A(B))((A(C)))))) [çift kesim]

Meredith'in aksiyomu: 11 adım

1. (()) [çift kesim]
2. (()(D(A)(E))) [Ekleme]
3. ((D(A)(E))((D(A)(E)))) [Yineleme]
4. ((D(A)(E))((D(A)(E(A))))) [Yineleme]
5. ((D(A)(E))(((E(A))((D(A)))))) [çift kesim]
6. (((E)((D(A))))(((E(A))((D(A)))))) [çift kesim]
7. (((E)((C)(D(A))))(((E(A))((D(A)))))) [Ekleme]
8. (((E)((C)(D(A)(C))))(((E(A))((D(A)))))) [Yineleme]
9. (((E)((C)((A)(C)((D)))))(((E(A))((D(A)))))) [çift kesim]
10. (((E)((C)((A)(((C)((D)))))))(((E(A))((D(A)))))) [çift kesim]
11. (((E)((C)((A(B))(((C)((D)))))))(((E(A))((D(A)))))) [Ekleme]

Haskell geçirmez arama

(Ne, bunu elle yapacağımı mı düşündün? :-P)

Bu sadece ekleme, çift kesimli giriş ve yinelemeyi dener. Bu yüzden hala bu çözümler silme, çift kesilmiş eleme veya deiterasyon kullanarak yenilebilir.

{-# 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 adım

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

Bu bulmacayı tamamlamayı öğrendiğim birkaç şey:

• Sağlanan gösterimi azaltın. Bu, çift kesimlerin ve yinelemelerin tersine çevrilmesini içerir. Örneğin, bu aksiyom (((AB(A))(((C)DE)(CD(F))(E(D))(E(F)))(G))H(G))çift ​​kesiklerin (((AB(A))(()CDE(F)))H(G)))ters çevrilmesinden sonra ve yinelemelerin ters çevrilmesinden sonra azalır .

• Başıboş atomları arayın. Örneğin, H kukla değişken olarak kullanılır ve bu nedenle herhangi bir noktaya yerleştirilebilir.

Teorem Çözümleri Uygulama:

Asukasiewicz 'İkinci Aksiyomu için Çözüm: [8 Adım]

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

Meredith'in Aksiyomu için Çözüm: [12 Adım]

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