eyeprolog 1.6.0 → 1.6.2

package/examples/proof/ancestor.pl

@@ -1,140 +1,110 @@
 ancestor(pat, jan).
 why(
   ancestor(pat, jan),
-  proof(
-    goal(ancestor(pat, jan)),
-    by(rule("ancestor.pl", clause(4))),
-    bindings([binding("X", pat), binding("Y", jan)]),
-    uses([
-      proof(
-        goal(parent(pat, jan)),
-        by(fact("ancestor.pl", clause(1)))
-      )
-    ])
+  step(
+    ancestor(pat, jan),
+    rule("ancestor.pl", clause(4)),
+    ['X' = pat, 'Y' = jan],
+    [
+      step(parent(pat, jan), fact("ancestor.pl", clause(1)), [], [])
+    ]
   )
 ).
 
 ancestor(jan, lies).
 why(
   ancestor(jan, lies),
-  proof(
-    goal(ancestor(jan, lies)),
-    by(rule("ancestor.pl", clause(4))),
-    bindings([binding("X", jan), binding("Y", lies)]),
-    uses([
-      proof(
-        goal(parent(jan, lies)),
-        by(fact("ancestor.pl", clause(2)))
-      )
-    ])
+  step(
+    ancestor(jan, lies),
+    rule("ancestor.pl", clause(4)),
+    ['X' = jan, 'Y' = lies],
+    [
+      step(parent(jan, lies), fact("ancestor.pl", clause(2)), [], [])
+    ]
   )
 ).
 
 ancestor(lies, emma).
 why(
   ancestor(lies, emma),
-  proof(
-    goal(ancestor(lies, emma)),
-    by(rule("ancestor.pl", clause(4))),
-    bindings([binding("X", lies), binding("Y", emma)]),
-    uses([
-      proof(
-        goal(parent(lies, emma)),
-        by(fact("ancestor.pl", clause(3)))
-      )
-    ])
+  step(
+    ancestor(lies, emma),
+    rule("ancestor.pl", clause(4)),
+    ['X' = lies, 'Y' = emma],
+    [
+      step(parent(lies, emma), fact("ancestor.pl", clause(3)), [], [])
+    ]
   )
 ).
 
 ancestor(pat, lies).
 why(
   ancestor(pat, lies),
-  proof(
-    goal(ancestor(pat, lies)),
-    by(rule("ancestor.pl", clause(5))),
-    bindings([binding("X", pat), binding("Z", lies), binding("Y", jan)]),
-    uses([
-      proof(
-        goal(parent(pat, jan)),
-        by(fact("ancestor.pl", clause(1)))
-      ),
-      proof(
-        goal(ancestor(jan, lies)),
-        by(rule("ancestor.pl", clause(4))),
-        bindings([binding("X", jan), binding("Y", lies)]),
-        uses([
-          proof(
-            goal(parent(jan, lies)),
-            by(fact("ancestor.pl", clause(2)))
-          )
-        ])
+  step(
+    ancestor(pat, lies),
+    rule("ancestor.pl", clause(5)),
+    ['X' = pat, 'Z' = lies, 'Y' = jan],
+    [
+      step(parent(pat, jan), fact("ancestor.pl", clause(1)), [], []),
+      step(
+        ancestor(jan, lies),
+        rule("ancestor.pl", clause(4)),
+        ['X' = jan, 'Y' = lies],
+        [
+          step(parent(jan, lies), fact("ancestor.pl", clause(2)), [], [])
+        ]
       )
-    ])
+    ]
   )
 ).
 
 ancestor(pat, emma).
 why(
   ancestor(pat, emma),
-  proof(
-    goal(ancestor(pat, emma)),
-    by(rule("ancestor.pl", clause(5))),
-    bindings([binding("X", pat), binding("Z", emma), binding("Y", jan)]),
-    uses([
-      proof(
-        goal(parent(pat, jan)),
-        by(fact("ancestor.pl", clause(1)))
-      ),
-      proof(
-        goal(ancestor(jan, emma)),
-        by(rule("ancestor.pl", clause(5))),
-        bindings([binding("X", jan), binding("Z", emma), binding("Y", lies)]),
-        uses([
-          proof(
-            goal(parent(jan, lies)),
-            by(fact("ancestor.pl", clause(2)))
-          ),
-          proof(
-            goal(ancestor(lies, emma)),
-            by(rule("ancestor.pl", clause(4))),
-            bindings([binding("X", lies), binding("Y", emma)]),
-            uses([
-              proof(
-                goal(parent(lies, emma)),
-                by(fact("ancestor.pl", clause(3)))
-              )
-            ])
+  step(
+    ancestor(pat, emma),
+    rule("ancestor.pl", clause(5)),
+    ['X' = pat, 'Z' = emma, 'Y' = jan],
+    [
+      step(parent(pat, jan), fact("ancestor.pl", clause(1)), [], []),
+      step(
+        ancestor(jan, emma),
+        rule("ancestor.pl", clause(5)),
+        ['X' = jan, 'Z' = emma, 'Y' = lies],
+        [
+          step(parent(jan, lies), fact("ancestor.pl", clause(2)), [], []),
+          step(
+            ancestor(lies, emma),
+            rule("ancestor.pl", clause(4)),
+            ['X' = lies, 'Y' = emma],
+            [
+              step(parent(lies, emma), fact("ancestor.pl", clause(3)), [], [])
+            ]
           )
-        ])
+        ]
       )
-    ])
+    ]
   )
 ).
 
 ancestor(jan, emma).
 why(
   ancestor(jan, emma),
-  proof(
-    goal(ancestor(jan, emma)),
-    by(rule("ancestor.pl", clause(5))),
-    bindings([binding("X", jan), binding("Z", emma), binding("Y", lies)]),
-    uses([
-      proof(
-        goal(parent(jan, lies)),
-        by(fact("ancestor.pl", clause(2)))
-      ),
-      proof(
-        goal(ancestor(lies, emma)),
-        by(rule("ancestor.pl", clause(4))),
-        bindings([binding("X", lies), binding("Y", emma)]),
-        uses([
-          proof(
-            goal(parent(lies, emma)),
-            by(fact("ancestor.pl", clause(3)))
-          )
-        ])
+  step(
+    ancestor(jan, emma),
+    rule("ancestor.pl", clause(5)),
+    ['X' = jan, 'Z' = emma, 'Y' = lies],
+    [
+      step(parent(jan, lies), fact("ancestor.pl", clause(2)), [], []),
+      step(
+        ancestor(lies, emma),
+        rule("ancestor.pl", clause(4)),
+        ['X' = lies, 'Y' = emma],
+        [
+          step(parent(lies, emma), fact("ancestor.pl", clause(3)), [], [])
+        ]
       )
-    ])
+    ]
   )
 ).
 

package/examples/proof/animal.pl

@@ -1,68 +1,59 @@
 type(joe, human).
 why(
   type(joe, human),
-  proof(
-    goal(type(joe, human)),
-    by(rule("animal.pl", clause(4))),
-    uses([
-      proof(
-        goal(human(joe)),
-        by(fact("animal.pl", clause(1)))
-      )
-    ])
+  step(
+    type(joe, human),
+    rule("animal.pl", clause(4)),
+    [],
+    [
+      step(human(joe), fact("animal.pl", clause(1)), [], [])
+    ]
   )
 ).
 
 type(joe, animal).
 why(
   type(joe, animal),
-  proof(
-    goal(type(joe, animal)),
-    by(rule("animal.pl", clause(5))),
-    uses([
-      proof(
-        goal(animal(joe)),
-        by(rule("animal.pl", clause(3))),
-        bindings([binding("X", joe)]),
-        uses([
-          proof(
-            goal(human(joe)),
-            by(fact("animal.pl", clause(1)))
-          )
-        ])
+  step(
+    type(joe, animal),
+    rule("animal.pl", clause(5)),
+    [],
+    [
+      step(
+        animal(joe),
+        rule("animal.pl", clause(3)),
+        ['X' = joe],
+        [
+          step(human(joe), fact("animal.pl", clause(1)), [], [])
+        ]
       )
-    ])
+    ]
   )
 ).
 
 subclassOf(human, animal).
 why(
   subclassOf(human, animal),
-  proof(
-    goal(subclassOf(human, animal)),
-    by(rule("animal.pl", clause(6))),
-    uses([
-      proof(
-        goal(animal(human)),
-        by(fact("animal.pl", clause(2)))
-      )
-    ])
+  step(
+    subclassOf(human, animal),
+    rule("animal.pl", clause(6)),
+    [],
+    [
+      step(animal(human), fact("animal.pl", clause(2)), [], [])
+    ]
   )
 ).
 
 succeeds(animalExample, true).
 why(
   succeeds(animalExample, true),
-  proof(
-    goal(succeeds(animalExample, true)),
-    by(rule("animal.pl", clause(7))),
-    bindings([binding("__anon0", human)]),
-    uses([
-      proof(
-        goal(animal(human)),
-        by(fact("animal.pl", clause(2)))
-      )
-    ])
+  step(
+    succeeds(animalExample, true),
+    rule("animal.pl", clause(7)),
+    ['__anon0' = human],
+    [
+      step(animal(human), fact("animal.pl", clause(2)), [], [])
+    ]
   )
 ).
 

package/examples/proof/annotation.pl

@@ -1,150 +1,126 @@
 name(a, "Alice").
 why(
   name(a, "Alice"),
-  proof(
-    goal(name(a, "Alice")),
-    by(rule("annotation.pl", clause(5))),
-    bindings([binding("S", a), binding("O", "Alice"), binding("_t", t), binding("Context", (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))]),
-    uses([
-      proof(
-        goal(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))),
-        by(fact("annotation.pl", clause(1)))
-      ),
-      proof(
-        goal(context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), name(a, "Alice"))),
-        by(rule("annotation.pl", clause(2))),
-        bindings([binding("Left", name(a, "Alice")), binding("_right", (statedBy(t, bob), recorded(t, "2021-07-07"))), binding("Member", name(a, "Alice"))]),
-        uses([
-          proof(
-            goal(context_member(name(a, "Alice"), name(a, "Alice"))),
-            by(rule("annotation.pl", clause(4))),
-            bindings([binding("Member", name(a, "Alice"))]),
-            uses([
-              proof(
-                goal(\=(name(a, "Alice"), (_left, _right))),
-                by(builtin(\=, 2))
-              )
-            ])
+  step(
+    name(a, "Alice"),
+    rule("annotation.pl", clause(5)),
+    ['S' = a, 'O' = "Alice", '_t' = t, 'Context' = (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))],
+    [
+      step(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))), fact("annotation.pl", clause(1)), [], []),
+      step(
+        context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), name(a, "Alice")),
+        rule("annotation.pl", clause(2)),
+        ['Left' = name(a, "Alice"), '_right' = (statedBy(t, bob), recorded(t, "2021-07-07")), 'Member' = name(a, "Alice")],
+        [
+          step(
+            context_member(name(a, "Alice"), name(a, "Alice")),
+            rule("annotation.pl", clause(4)),
+            ['Member' = name(a, "Alice")],
+            [
+              step(\=(name(a, "Alice"), (_left, _right)), builtin(\=, 2), [], [])
+            ]
           )
-        ])
+        ]
       )
-    ])
+    ]
   )
 ).
 
 log_nameOf(t, name(a, "Alice")).
 why(
   log_nameOf(t, name(a, "Alice")),
-  proof(
-    goal(log_nameOf(t, name(a, "Alice"))),
-    by(rule("annotation.pl", clause(6))),
-    bindings([binding("T", t), binding("S", a), binding("O", "Alice"), binding("Context", (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))]),
-    uses([
-      proof(
-        goal(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))),
-        by(fact("annotation.pl", clause(1)))
-      ),
-      proof(
-        goal(context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), name(a, "Alice"))),
-        by(rule("annotation.pl", clause(2))),
-        bindings([binding("Left", name(a, "Alice")), binding("_right", (statedBy(t, bob), recorded(t, "2021-07-07"))), binding("Member", name(a, "Alice"))]),
-        uses([
-          proof(
-            goal(context_member(name(a, "Alice"), name(a, "Alice"))),
-            by(rule("annotation.pl", clause(4))),
-            bindings([binding("Member", name(a, "Alice"))]),
-            uses([
-              proof(
-                goal(\=(name(a, "Alice"), (_left, _right))),
-                by(builtin(\=, 2))
-              )
-            ])
+  step(
+    log_nameOf(t, name(a, "Alice")),
+    rule("annotation.pl", clause(6)),
+    ['T' = t, 'S' = a, 'O' = "Alice", 'Context' = (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))],
+    [
+      step(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))), fact("annotation.pl", clause(1)), [], []),
+      step(
+        context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), name(a, "Alice")),
+        rule("annotation.pl", clause(2)),
+        ['Left' = name(a, "Alice"), '_right' = (statedBy(t, bob), recorded(t, "2021-07-07")), 'Member' = name(a, "Alice")],
+        [
+          step(
+            context_member(name(a, "Alice"), name(a, "Alice")),
+            rule("annotation.pl", clause(4)),
+            ['Member' = name(a, "Alice")],
+            [
+              step(\=(name(a, "Alice"), (_left, _right)), builtin(\=, 2), [], [])
+            ]
           )
-        ])
+        ]
       )
-    ])
+    ]
   )
 ).
 
 statedBy(t, bob).
 why(
   statedBy(t, bob),
-  proof(
-    goal(statedBy(t, bob)),
-    by(rule("annotation.pl", clause(7))),
-    bindings([binding("S", t), binding("O", bob), binding("_t", t), binding("Context", (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))]),
-    uses([
-      proof(
-        goal(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))),
-        by(fact("annotation.pl", clause(1)))
-      ),
-      proof(
-        goal(context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), statedBy(t, bob))),
-        by(rule("annotation.pl", clause(3))),
-        bindings([binding("_left", name(a, "Alice")), binding("Right", (statedBy(t, bob), recorded(t, "2021-07-07"))), binding("Member", statedBy(t, bob))]),
-        uses([
-          proof(
-            goal(context_member((statedBy(t, bob), recorded(t, "2021-07-07")), statedBy(t, bob))),
-            by(rule("annotation.pl", clause(2))),
-            bindings([binding("Left", statedBy(t, bob)), binding("_right", recorded(t, "2021-07-07")), binding("Member", statedBy(t, bob))]),
-            uses([
-              proof(
-                goal(context_member(statedBy(t, bob), statedBy(t, bob))),
-                by(rule("annotation.pl", clause(4))),
-                bindings([binding("Member", statedBy(t, bob))]),
-                uses([
-                  proof(
-                    goal(\=(statedBy(t, bob), (_left, _right))),
-                    by(builtin(\=, 2))
-                  )
-                ])
+  step(
+    statedBy(t, bob),
+    rule("annotation.pl", clause(7)),
+    ['S' = t, 'O' = bob, '_t' = t, 'Context' = (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))],
+    [
+      step(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))), fact("annotation.pl", clause(1)), [], []),
+      step(
+        context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), statedBy(t, bob)),
+        rule("annotation.pl", clause(3)),
+        ['_left' = name(a, "Alice"), 'Right' = (statedBy(t, bob), recorded(t, "2021-07-07")), 'Member' = statedBy(t, bob)],
+        [
+          step(
+            context_member((statedBy(t, bob), recorded(t, "2021-07-07")), statedBy(t, bob)),
+            rule("annotation.pl", clause(2)),
+            ['Left' = statedBy(t, bob), '_right' = recorded(t, "2021-07-07"), 'Member' = statedBy(t, bob)],
+            [
+              step(
+                context_member(statedBy(t, bob), statedBy(t, bob)),
+                rule("annotation.pl", clause(4)),
+                ['Member' = statedBy(t, bob)],
+                [
+                  step(\=(statedBy(t, bob), (_left, _right)), builtin(\=, 2), [], [])
+                ]
               )
-            ])
+            ]
           )
-        ])
+        ]
       )
-    ])
+    ]
   )
 ).
 
 recorded(t, "2021-07-07").
 why(
   recorded(t, "2021-07-07"),
-  proof(
-    goal(recorded(t, "2021-07-07")),
-    by(rule("annotation.pl", clause(8))),
-    bindings([binding("S", t), binding("O", "2021-07-07"), binding("_t", t), binding("Context", (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))]),
-    uses([
-      proof(
-        goal(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")))),
-        by(fact("annotation.pl", clause(1)))
-      ),
-      proof(
-        goal(context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), recorded(t, "2021-07-07"))),
-        by(rule("annotation.pl", clause(3))),
-        bindings([binding("_left", name(a, "Alice")), binding("Right", (statedBy(t, bob), recorded(t, "2021-07-07"))), binding("Member", recorded(t, "2021-07-07"))]),
-        uses([
-          proof(
-            goal(context_member((statedBy(t, bob), recorded(t, "2021-07-07")), recorded(t, "2021-07-07"))),
-            by(rule("annotation.pl", clause(3))),
-            bindings([binding("_left", statedBy(t, bob)), binding("Right", recorded(t, "2021-07-07")), binding("Member", recorded(t, "2021-07-07"))]),
-            uses([
-              proof(
-                goal(context_member(recorded(t, "2021-07-07"), recorded(t, "2021-07-07"))),
-                by(rule("annotation.pl", clause(4))),
-                bindings([binding("Member", recorded(t, "2021-07-07"))]),
-                uses([
-                  proof(
-                    goal(\=(recorded(t, "2021-07-07"), (_left, _right))),
-                    by(builtin(\=, 2))
-                  )
-                ])
+  step(
+    recorded(t, "2021-07-07"),
+    rule("annotation.pl", clause(8)),
+    ['S' = t, 'O' = "2021-07-07", '_t' = t, 'Context' = (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))],
+    [
+      step(annotation(t, (name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07"))), fact("annotation.pl", clause(1)), [], []),
+      step(
+        context_member((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), recorded(t, "2021-07-07")),
+        rule("annotation.pl", clause(3)),
+        ['_left' = name(a, "Alice"), 'Right' = (statedBy(t, bob), recorded(t, "2021-07-07")), 'Member' = recorded(t, "2021-07-07")],
+        [
+          step(
+            context_member((statedBy(t, bob), recorded(t, "2021-07-07")), recorded(t, "2021-07-07")),
+            rule("annotation.pl", clause(3)),
+            ['_left' = statedBy(t, bob), 'Right' = recorded(t, "2021-07-07"), 'Member' = recorded(t, "2021-07-07")],
+            [
+              step(
+                context_member(recorded(t, "2021-07-07"), recorded(t, "2021-07-07")),
+                rule("annotation.pl", clause(4)),
+                ['Member' = recorded(t, "2021-07-07")],
+                [
+                  step(\=(recorded(t, "2021-07-07"), (_left, _right)), builtin(\=, 2), [], [])
+                ]
               )
-            ])
+            ]
           )
-        ])
+        ]
       )
-    ])
+    ]
   )
 ).
 

package/examples/proof/attributed-variables.pl

@@ -1,62 +1,44 @@
 accepts_required_value(ok).
 why(
   accepts_required_value(ok),
-  proof(
-    goal(accepts_required_value(ok)),
-    by(rule("attributed-variables.pl", clause(4))),
-    bindings([binding("X", 7)]),
-    uses([
-      proof(
-        goal(attach_required(Variable, 7)),
-        by(rule("attributed-variables.pl", clause(1))),
-        bindings([binding("Value", 7)]),
-        uses([
-          proof(
-            goal(put_atts(Variable, required(7))),
-            by(builtin(put_atts, 2))
-          )
-        ])
+  step(
+    accepts_required_value(ok),
+    rule("attributed-variables.pl", clause(4)),
+    ['X' = 7],
+    [
+      step(
+        attach_required(Variable, 7),
+        rule("attributed-variables.pl", clause(1)),
+        ['Value' = 7],
+        [
+          step(put_atts(Variable, required(7)), builtin(put_atts, 2), [], [])
+        ]
       ),
-      proof(
-        goal(=(7, 7)),
-        by(builtin(=, 2))
-      )
-    ])
+      step(=(7, 7), builtin(=, 2), [], [])
+    ]
   )
 ).
 
 alias_preserves_attribute(ok).
 why(
   alias_preserves_attribute(ok),
-  proof(
-    goal(alias_preserves_attribute(ok)),
-    by(rule("attributed-variables.pl", clause(5))),
-    bindings([binding("X", ready), binding("Y", ready)]),
-    uses([
-      proof(
-        goal(attach_required(Variable, ready)),
-        by(rule("attributed-variables.pl", clause(1))),
-        bindings([binding("Value", ready)]),
-        uses([
-          proof(
-            goal(put_atts(Variable, required(ready))),
-            by(builtin(put_atts, 2))
-          )
-        ])
+  step(
+    alias_preserves_attribute(ok),
+    rule("attributed-variables.pl", clause(5)),
+    ['X' = ready, 'Y' = ready],
+    [
+      step(
+        attach_required(Variable, ready),
+        rule("attributed-variables.pl", clause(1)),
+        ['Value' = ready],
+        [
+          step(put_atts(Variable, required(ready)), builtin(put_atts, 2), [], [])
+        ]
       ),
-      proof(
-        goal(=(Y, Y)),
-        by(builtin(=, 2))
-      ),
-      proof(
-        goal(get_atts(Y, required(ready))),
-        by(builtin(get_atts, 2))
-      ),
-      proof(
-        goal(=(ready, ready)),
-        by(builtin(=, 2))
-      )
-    ])
+      step(=(Y, Y), builtin(=, 2), [], []),
+      step(get_atts(Y, required(ready)), builtin(get_atts, 2), [], []),
+      step(=(ready, ready), builtin(=, 2), [], [])
+    ]
   )
 ).