From d0ba6ce9d4e1fd76784c06c8e86da7029ad3d713 Mon Sep 17 00:00:00 2001
From: hi <hi>
Date: Tue, 12 Aug 2025 03:57:13 +0000
Subject: [PATCH] minor: substatements function, comments

---
 Logic/Statement.hs      |  8 ++++++++
 Logic/Statement/Laws.hs | 17 ++++++++++++-----
 2 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/Logic/Statement.hs b/Logic/Statement.hs
index 6902140..f85fe26 100644
--- a/Logic/Statement.hs
+++ b/Logic/Statement.hs
@@ -20,3 +20,11 @@ atoms = toAscList . mkSet
     mkSet (Or s1 s2)      = union (mkSet s1) (mkSet s2)
     mkSet (Implies s1 s2) = union (mkSet s1) (mkSet s2)
     mkSet (Iff s1 s2)     = union (mkSet s1) (mkSet s2)
+
+substatements :: Statement -> [Statement]
+substatements s@(Atom _) = [s]
+substatements s@(Not s1) = s:(substatements s1)
+substatements s@(And s1 s2)     = (s:) $ substatements s1 ++ substatements s2
+substatements s@(Or s1 s2)      = (s:) $ substatements s1 ++ substatements s2
+substatements s@(Implies s1 s2) = (s:) $ substatements s1 ++ substatements s2
+substatements s@(Iff s1 s2)     = (s:) $ substatements s1 ++ substatements s2
diff --git a/Logic/Statement/Laws.hs b/Logic/Statement/Laws.hs
index 43855be..b38b1ed 100644
--- a/Logic/Statement/Laws.hs
+++ b/Logic/Statement/Laws.hs
@@ -41,6 +41,12 @@ laws =
   , mkLaw "iff_or"  "(A<->B)" "((A&B)|(!A&!B))"
   ]
 
+{-
+ghci> import Logic.Statement.Eval (bucket, Bucket(Tautology))
+ghci> all (== Tautology) $ map (\law -> bucket $ Iff (lawLhs law) (lawRhs law)) laws
+True
+-}
+
 lookupLaw :: String -> Maybe Law
 lookupLaw name = listToMaybe $ filter (\law -> lawName law == name) laws
 
@@ -48,7 +54,7 @@ match
   :: Statement
   -- ^ pattern
   -> Statement
-  -- ^ statement to search
+  -- ^ statement to search within
   -> Maybe [(String, Statement)]
   -- ^ mapping from pattern-statement atoms to search-statement parts
 match = aux []
@@ -104,19 +110,20 @@ Just [("C",Atom "r"),("B",Atom "q"),("A",Atom "p")]
 -}
 
 data SwapError
-  = Indeterminate
+  = IndeterminateSwap
   -- ^ An atom in p2 doesn't exist in p1.
   -- Strictly: an atom in p2 doesn't exist in the result from `match`
   -- (matters only if `match` is implemented incorrectly).
-  -- If for atoms we used terms of a type instead of strings,
-  -- we could avoid needing this error.
+  -- Theoretically if for atoms we used terms of a type instead of strings, we
+  -- could avoid needing this error, but I think we still wouldn't be able
+  -- to return a mapping from atom-type-1 to atom-type-2 in a type safe way.
   | NonMatchingPattern
   deriving Show
 
 swap :: Statement -> Statement -> Statement -> Either SwapError Statement
 swap p1 p2 s = do
   mapping <- maybe (Left NonMatchingPattern) Right $ match p1 s
-  maybe (Left Indeterminate) Right $ aux mapping p2
+  maybe (Left IndeterminateSwap) Right $ aux mapping p2
   where
     aux :: [(String, Statement)] -> Statement -> Maybe Statement
     aux mapping (Atom key) = lookup key mapping