अस्तित्वगत गोल्फ

Question

मठ में बहुत सारे प्रतीक हैं। कुछ लोग बहुत अधिक प्रतीक कह सकते हैं। तो चित्रों के साथ कुछ गणित करते हैं।

आओ हम एक कागज दें, जिसे हम तैयार करेंगे। कागज को खाली करने के लिए, हम कहेंगे कि यह या सत्य के बराबर है ।$\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$

मिटाना

अगले अनुमान नियम Erasure है । एरासुर हमें बताता है कि अगर हमारे पास एक बयान है जो एक और भी गहराई पर है तो हम इसे पूरी तरह से हटा सकते हैं।

यहाँ erasure का उदाहरण दिया जा रहा है:

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

डबल कट

डबल कट एक समतुल्यता है। जिसका अर्थ है, पिछले इनफॉर्म्स के विपरीत यह उलटा भी हो सकता है। डबल कट हमें बताता है कि हम किसी भी उप-ग्राफ़ के चारों ओर दो वृत्त खींच सकते हैं, और यदि उप-ग्राफ़ के चारों ओर दो वृत्त हैं तो हम उन दोनों को निकाल सकते हैं।

यहाँ डबल कट का उदाहरण दिया जा रहा है

$Q$

यात्रा

Iteration एक तुल्यता भी है। ¹ यह रिवर्स कहा जाता है है Deiteration हम एक बयान और एक ही स्तर पर एक कट है, तो हम एक कट के अंदर कि बयान कॉपी कर सकते हैं।

उदाहरण के लिए:

भटकाव हमें एक Iteration को उलटने की अनुमति देता है । एक बयान के माध्यम से हटाया जा सकता है 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)$।

Asukasiewicz-Tarski Axiom के रूप में भी जाना जाता है ।

यह शामिल प्रतीत हो सकता है, लेकिन जब प्रूफ लंबाई की बात आती है तो अस्तित्वगत ग्राफ बहुत कुशल होते हैं । मैंने इस प्रमेय को चुना क्योंकि मुझे लगता है कि यह एक मजेदार और चुनौतीपूर्ण पहेली के लिए एक उपयुक्त लंबाई है। अगर आपको इससे परेशानी हो रही है, तो मैं सिस्टम के हैंग होने के लिए पहले कुछ और बुनियादी प्रमेयों को आजमाने की सलाह दूंगा। इनकी एक सूची पोस्ट के नीचे पाई जा सकती है।

यह प्रूफ-गोल्फ है इसलिए आपका स्कोर शुरू से अंत तक आपके प्रूफ में कुल चरणों की संख्या होगी। लक्ष्य अपने स्कोर को कम से कम करना है।

स्वरूप

इस चुनौती के लिए प्रारूप लचीला है आप किसी भी प्रारूप में उत्तर प्रस्तुत कर सकते हैं जो स्पष्ट रूप से पठनीय है, जिसमें हाथ से तैयार या रेंडर किए गए प्रारूप भी शामिल हैं। हालांकि स्पष्टता के लिए मैं निम्नलिखित सरल प्रारूप का सुझाव देता हूं:

• हम कोष्ठक के साथ एक कट का प्रतिनिधित्व करते हैं, जो कुछ भी हम काट रहे हैं वह पेरेन्स के अंदर रखा गया है। खाली कटौती सिर्फ ()उदाहरण के लिए होगी।

• हम परमाणुओं को सिर्फ उनके अक्षरों से दर्शाते हैं।

एक उदाहरण के रूप में इस प्रारूप में लक्ष्य विवरण दिया गया है:

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

यह प्रारूप अच्छा है क्योंकि यह मानव और मशीन दोनों पठनीय है, इसलिए इसे अपनी पोस्ट में शामिल करना अच्छा होगा।

यदि आप कुछ अच्छे (ish) आरेख चाहते हैं तो कुछ कोड है जो इस प्रारूप को परिवर्तित करता है$\LaTeX$

इसे ऑनलाइन आज़माएं!

अपने वास्तविक काम के रूप में मैं बाहर काम करते समय पेंसिल और कागज की सलाह देता हूं। मुझे लगता है कि पाठ सिर्फ कागज के रूप में सहज नहीं है जब यह अस्तित्वगत रेखांकन की बात आती है।

उदाहरण प्रमाण

इस उदाहरण के प्रमाण में हम निम्नलिखित प्रमेय को सिद्ध करेंगे:

$(A\rightarrow B)\rightarrow(\neg B\rightarrow \neg A)$ , जिसे गर्भ-निरोधकों के नियम के रूप में भी जाना जाता है।

प्रमाण:

प्रमेयों का अभ्यास करें

यहां कुछ सरल प्रमेय दिए गए हैं, जिनका उपयोग आप सिस्टम का अभ्यास करने के लिए कर सकते हैं:

Łukasiewicz 'दूसरी Axiom

मेरेडिथ की एक्सिस

^{1: अधिकांश स्रोत Iteration के अधिक परिष्कृत और शक्तिशाली संस्करण का उपयोग करते हैं , लेकिन इस चुनौती को सरल रखने के लिए मैं इस संस्करण का उपयोग कर रहा हूं। वे कार्यात्मक रूप से समतुल्य हैं।}

Comments

मुझे ऐसा लगता है कि यह सवाल

— गूंजने के

@ ConorO'Brien क्यों? पज़लिंग मुख्य रूप से अनुकूलन के बजाय जवाब देने से संबंधित है। इस सवाल का जवाब देना बहुत आसान है, यह ज्यादातर गोल्फ चुनौती है।

— गेहूं जादूगर

Puzzling का अनुकूलन के साथ बहुत संबंध हो सकता है। मुझे लगता है कि इस चुनौती से एक बेहतर घर मिल सकता है, लेकिन यह सिर्फ मेरी राय है

— Conor O'Brien

@connorobrien प्रूफ-गोल्फ इस समुदाय का एक लंबा स्थापित हिस्सा है, और लंबे समय तक यह जारी रह सकता है।

— नाथनियल

यहाँ इस तरह की अभिव्यक्ति के बारे में एक मजेदार इंटरैक्टिव फ़्लैश एप्लेट के साथ एक साइट है: markability.net

— Woofmao

Answer 1

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)))))) [प्रविष्टि]

हास्केल प्रूफ खोजकर्ता

(क्या, तुमने सोचा था कि मैं हाथ से करने जा रहा हूँ ?:-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)

Answer 2

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)))को उलटने के बाद और पुनरावृत्तियों के बाद कम हो जाता है ।

• आवारा परमाणुओं के लिए देखो। उदाहरण के लिए, एच का उपयोग डमी चर के रूप में किया जाता है, और इस प्रकार किसी भी बिंदु पर डाला जा सकता है।

---

प्रैक्टिस प्रमेय समाधान:

Forukasiewicz 'के लिए समाधान दूसरा प्रश्न: [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)))))

Comments

मैंने अपना पूर्ण समाधान शामिल करने के लिए अद्यतन किया है। मजेदार पहेली! कृपया मुझे बताएं कि मैं अपनी पोस्ट को कैसे सुधार सकता हूं।

— 21

आम तौर पर यहां उत्तर छिपे नहीं होते हैं - यह धारणा कि उत्तर पढ़ने से समाधान के लिए एक "स्पॉइलर" निकलता है। इसके अलावा, हमारे पास यहाँ MathJax है, जिसका उपयोग शुरुआती \$/ अंत के रूप में किया जाता है जो मुझे लगता है कि आपके समाधान को पढ़ने में बहुत आसान बना देगा। मुझे आशा है कि आपके पास यहां अच्छा समय है :)

— FryAmTheEggman

मैंने उपयोग किए गए नियमों की संख्या अपडेट की है (प्रमाण समान है)। क्या कोई व्यक्ति जो प्रारूपण में अच्छा है, कृपया मेरे उत्तर को बेहतर बनाने में मदद कर सकता है?

— 22