eyeprolog 0.5.13 → 0.5.15

package/examples/proof/composition-of-injective-functions-is-injective.pl

@@ -3,113 +3,110 @@ why(
   sameInputByCompositeInjectivity(h, a, b),
   proof(
     goal(sameInputByCompositeInjectivity(h, a, b)),
-    by(rule("composition-of-injective-functions-is-injective.pl", clause(19))),
+    by(rule("composition-of-injective-functions-is-injective.pl", clause(21))),
     bindings([binding("H", h), binding("X", a), binding("Y", b), binding("G", g), binding("F", f), binding("Z", e)]),
     uses([
       proof(
         goal(compositeOf(h, g, f)),
-        by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
+        by(fact("composition-of-injective-functions-is-injective.pl", clause(18)))
       ),
       proof(
         goal(injective(g)),
-        by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
+        by(fact("composition-of-injective-functions-is-injective.pl", clause(17)))
       ),
       proof(
         goal(injective(f)),
-        by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
+        by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
       ),
       proof(
         goal(app(h, a, e)),
-        by(rule("composition-of-injective-functions-is-injective.pl", clause(17))),
+        by(rule("composition-of-injective-functions-is-injective.pl", clause(19))),
         bindings([binding("H", h), binding("X", a), binding("Z", e), binding("G", g), binding("F", f), binding("Y", c)]),
         uses([
           proof(
             goal(compositeOf(h, g, f)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(18)))
           ),
           proof(
             goal(app(f, a, c)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(10)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
           ),
           proof(
             goal(app(g, c, e)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
           )
         ])
       ),
       proof(
         goal(app(h, b, e)),
-        by(rule("composition-of-injective-functions-is-injective.pl", clause(17))),
+        by(rule("composition-of-injective-functions-is-injective.pl", clause(19))),
         bindings([binding("H", h), binding("X", b), binding("Z", e), binding("G", g), binding("F", f), binding("Y", d)]),
         uses([
           proof(
             goal(compositeOf(h, g, f)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(18)))
           ),
           proof(
             goal(app(f, b, d)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(11)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
           ),
           proof(
             goal(app(g, d, e)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
           )
         ])
       ),
       proof(
         goal(sameTerm(a, b)),
-        by(rule("composition-of-injective-functions-is-injective.pl", clause(9))),
+        by(rule("composition-of-injective-functions-is-injective.pl", clause(11))),
         bindings([binding("Y", a), binding("X", b)]),
         uses([
+          proof(
+            goal(@<(a, b)),
+            by(builtin(@<, 2))
+          ),
           proof(
             goal(sameTerm(b, a)),
-            by(rule("composition-of-injective-functions-is-injective.pl", clause(18))),
+            by(rule("composition-of-injective-functions-is-injective.pl", clause(20))),
             bindings([binding("X", b), binding("Y", a), binding("F", f), binding("U", d), binding("V", c)]),
             uses([
               proof(
                 goal(injective(f)),
-                by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
+                by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
               ),
               proof(
                 goal(app(f, b, d)),
-                by(fact("composition-of-injective-functions-is-injective.pl", clause(11)))
+                by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
               ),
               proof(
                 goal(app(f, a, c)),
-                by(fact("composition-of-injective-functions-is-injective.pl", clause(10)))
+                by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
               ),
               proof(
                 goal(sameTerm(d, c)),
-                by(rule("composition-of-injective-functions-is-injective.pl", clause(9))),
-                bindings([binding("Y", d), binding("X", c)]),
+                by(rule("composition-of-injective-functions-is-injective.pl", clause(20))),
+                bindings([binding("X", d), binding("Y", c), binding("F", g), binding("U", e), binding("V", e)]),
                 uses([
                   proof(
-                    goal(sameTerm(c, d)),
-                    by(rule("composition-of-injective-functions-is-injective.pl", clause(18))),
-                    bindings([binding("X", c), binding("Y", d), binding("F", g), binding("U", e), binding("V", e)]),
+                    goal(injective(g)),
+                    by(fact("composition-of-injective-functions-is-injective.pl", clause(17)))
+                  ),
+                  proof(
+                    goal(app(g, d, e)),
+                    by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
+                  ),
+                  proof(
+                    goal(app(g, c, e)),
+                    by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
+                  ),
+                  proof(
+                    goal(sameTerm(e, e)),
+                    by(rule("composition-of-injective-functions-is-injective.pl", clause(10))),
+                    bindings([binding("X", e)]),
                     uses([
                       proof(
-                        goal(injective(g)),
-                        by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
-                      ),
-                      proof(
-                        goal(app(g, c, e)),
-                        by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
-                      ),
-                      proof(
-                        goal(app(g, d, e)),
-                        by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
-                      ),
-                      proof(
-                        goal(sameTerm(e, e)),
-                        by(rule("composition-of-injective-functions-is-injective.pl", clause(8))),
-                        bindings([binding("X", e)]),
-                        uses([
-                          proof(
-                            goal(inZ(e)),
-                            by(fact("composition-of-injective-functions-is-injective.pl", clause(5)))
-                          )
-                        ])
+                        goal(inZ(e)),
+                        by(fact("composition-of-injective-functions-is-injective.pl", clause(7)))
                       )
                     ])
                   )
@@ -132,115 +129,101 @@ why(
   sameInputByCompositeInjectivity(h, b, a),
   proof(
     goal(sameInputByCompositeInjectivity(h, b, a)),
-    by(rule("composition-of-injective-functions-is-injective.pl", clause(19))),
+    by(rule("composition-of-injective-functions-is-injective.pl", clause(21))),
     bindings([binding("H", h), binding("X", b), binding("Y", a), binding("G", g), binding("F", f), binding("Z", e)]),
     uses([
       proof(
         goal(compositeOf(h, g, f)),
-        by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
+        by(fact("composition-of-injective-functions-is-injective.pl", clause(18)))
       ),
       proof(
         goal(injective(g)),
-        by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
+        by(fact("composition-of-injective-functions-is-injective.pl", clause(17)))
       ),
       proof(
         goal(injective(f)),
-        by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
+        by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
       ),
       proof(
         goal(app(h, b, e)),
-        by(rule("composition-of-injective-functions-is-injective.pl", clause(17))),
+        by(rule("composition-of-injective-functions-is-injective.pl", clause(19))),
         bindings([binding("H", h), binding("X", b), binding("Z", e), binding("G", g), binding("F", f), binding("Y", d)]),
         uses([
           proof(
             goal(compositeOf(h, g, f)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(18)))
           ),
           proof(
             goal(app(f, b, d)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(11)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
           ),
           proof(
             goal(app(g, d, e)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
           )
         ])
       ),
       proof(
         goal(app(h, a, e)),
-        by(rule("composition-of-injective-functions-is-injective.pl", clause(17))),
+        by(rule("composition-of-injective-functions-is-injective.pl", clause(19))),
         bindings([binding("H", h), binding("X", a), binding("Z", e), binding("G", g), binding("F", f), binding("Y", c)]),
         uses([
           proof(
             goal(compositeOf(h, g, f)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(18)))
           ),
           proof(
             goal(app(f, a, c)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(10)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
           ),
           proof(
             goal(app(g, c, e)),
-            by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
           )
         ])
       ),
       proof(
         goal(sameTerm(b, a)),
-        by(rule("composition-of-injective-functions-is-injective.pl", clause(9))),
-        bindings([binding("Y", b), binding("X", a)]),
+        by(rule("composition-of-injective-functions-is-injective.pl", clause(20))),
+        bindings([binding("X", b), binding("Y", a), binding("F", f), binding("U", d), binding("V", c)]),
         uses([
           proof(
-            goal(sameTerm(a, b)),
-            by(rule("composition-of-injective-functions-is-injective.pl", clause(18))),
-            bindings([binding("X", a), binding("Y", b), binding("F", f), binding("U", c), binding("V", d)]),
+            goal(injective(f)),
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(16)))
+          ),
+          proof(
+            goal(app(f, b, d)),
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
+          ),
+          proof(
+            goal(app(f, a, c)),
+            by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
+          ),
+          proof(
+            goal(sameTerm(d, c)),
+            by(rule("composition-of-injective-functions-is-injective.pl", clause(20))),
+            bindings([binding("X", d), binding("Y", c), binding("F", g), binding("U", e), binding("V", e)]),
             uses([
               proof(
-                goal(injective(f)),
-                by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
+                goal(injective(g)),
+                by(fact("composition-of-injective-functions-is-injective.pl", clause(17)))
               ),
               proof(
-                goal(app(f, a, c)),
-                by(fact("composition-of-injective-functions-is-injective.pl", clause(10)))
+                goal(app(g, d, e)),
+                by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
               ),
               proof(
-                goal(app(f, b, d)),
-                by(fact("composition-of-injective-functions-is-injective.pl", clause(11)))
+                goal(app(g, c, e)),
+                by(fact("composition-of-injective-functions-is-injective.pl", clause(14)))
               ),
               proof(
-                goal(sameTerm(c, d)),
-                by(rule("composition-of-injective-functions-is-injective.pl", clause(9))),
-                bindings([binding("Y", c), binding("X", d)]),
+                goal(sameTerm(e, e)),
+                by(rule("composition-of-injective-functions-is-injective.pl", clause(10))),
+                bindings([binding("X", e)]),
                 uses([
                   proof(
-                    goal(sameTerm(d, c)),
-                    by(rule("composition-of-injective-functions-is-injective.pl", clause(18))),
-                    bindings([binding("X", d), binding("Y", c), binding("F", g), binding("U", e), binding("V", e)]),
-                    uses([
-                      proof(
-                        goal(injective(g)),
-                        by(fact("composition-of-injective-functions-is-injective.pl", clause(15)))
-                      ),
-                      proof(
-                        goal(app(g, d, e)),
-                        by(fact("composition-of-injective-functions-is-injective.pl", clause(13)))
-                      ),
-                      proof(
-                        goal(app(g, c, e)),
-                        by(fact("composition-of-injective-functions-is-injective.pl", clause(12)))
-                      ),
-                      proof(
-                        goal(sameTerm(e, e)),
-                        by(rule("composition-of-injective-functions-is-injective.pl", clause(8))),
-                        bindings([binding("X", e)]),
-                        uses([
-                          proof(
-                            goal(inZ(e)),
-                            by(fact("composition-of-injective-functions-is-injective.pl", clause(5)))
-                          )
-                        ])
-                      )
-                    ])
+                    goal(inZ(e)),
+                    by(fact("composition-of-injective-functions-is-injective.pl", clause(7)))
                   )
                 ])
               )

package/examples/proof/graph-reachability.pl

@@ -11,48 +11,48 @@ why(
         bindings([binding("Start", a), binding("Goal", f)]),
         uses([
           proof(
-            goal(reachable(a, f, [a])),
+            goal(reachable(a, f, "a")),
             by(rule("graph-reachability.pl", clause(9))),
-            bindings([binding("Start", a), binding("Goal", f), binding("Visited", [a]), binding("Next", b)]),
+            bindings([binding("Start", a), binding("Goal", f), binding("Visited", "a"), binding("Next", b)]),
             uses([
               proof(
                 goal(edge(a, b)),
                 by(fact("graph-reachability.pl", clause(1)))
               ),
               proof(
-                goal('\\+'(member(b, [a]))),
+                goal('\\+'(member(b, "a"))),
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(b, f, [b, a])),
+                goal(reachable(b, f, "ba")),
                 by(rule("graph-reachability.pl", clause(9))),
-                bindings([binding("Start", b), binding("Goal", f), binding("Visited", [b, a]), binding("Next", d)]),
+                bindings([binding("Start", b), binding("Goal", f), binding("Visited", "ba"), binding("Next", d)]),
                 uses([
                   proof(
                     goal(edge(b, d)),
                     by(fact("graph-reachability.pl", clause(3)))
                   ),
                   proof(
-                    goal('\\+'(member(d, [b, a]))),
+                    goal('\\+'(member(d, "ba"))),
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(d, f, [d, b, a])),
+                    goal(reachable(d, f, "dba")),
                     by(rule("graph-reachability.pl", clause(9))),
-                    bindings([binding("Start", d), binding("Goal", f), binding("Visited", [d, b, a]), binding("Next", f)]),
+                    bindings([binding("Start", d), binding("Goal", f), binding("Visited", "dba"), binding("Next", f)]),
                     uses([
                       proof(
                         goal(edge(d, f)),
                         by(fact("graph-reachability.pl", clause(5)))
                       ),
                       proof(
-                        goal('\\+'(member(f, [d, b, a]))),
+                        goal('\\+'(member(f, "dba"))),
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(f, f, [f, d, b, a])),
+                        goal(reachable(f, f, "fdba")),
                         by(fact("graph-reachability.pl", clause(8))),
-                        bindings([binding("Node", f), binding("_visited", [f, d, b, a])])
+                        bindings([binding("Node", f), binding("_visited", "fdba")])
                       )
                     ])
                   )
@@ -79,48 +79,48 @@ why(
         bindings([binding("Start", c), binding("Goal", g)]),
         uses([
           proof(
-            goal(reachable(c, g, [c])),
+            goal(reachable(c, g, "c")),
             by(rule("graph-reachability.pl", clause(9))),
-            bindings([binding("Start", c), binding("Goal", g), binding("Visited", [c]), binding("Next", e)]),
+            bindings([binding("Start", c), binding("Goal", g), binding("Visited", "c"), binding("Next", e)]),
             uses([
               proof(
                 goal(edge(c, e)),
                 by(fact("graph-reachability.pl", clause(4)))
               ),
               proof(
-                goal('\\+'(member(e, [c]))),
+                goal('\\+'(member(e, "c"))),
                 by(builtin('\\+', 1))
               ),
               proof(
-                goal(reachable(e, g, [e, c])),
+                goal(reachable(e, g, "ec")),
                 by(rule("graph-reachability.pl", clause(9))),
-                bindings([binding("Start", e), binding("Goal", g), binding("Visited", [e, c]), binding("Next", f)]),
+                bindings([binding("Start", e), binding("Goal", g), binding("Visited", "ec"), binding("Next", f)]),
                 uses([
                   proof(
                     goal(edge(e, f)),
                     by(fact("graph-reachability.pl", clause(6)))
                   ),
                   proof(
-                    goal('\\+'(member(f, [e, c]))),
+                    goal('\\+'(member(f, "ec"))),
                     by(builtin('\\+', 1))
                   ),
                   proof(
-                    goal(reachable(f, g, [f, e, c])),
+                    goal(reachable(f, g, "fec")),
                     by(rule("graph-reachability.pl", clause(9))),
-                    bindings([binding("Start", f), binding("Goal", g), binding("Visited", [f, e, c]), binding("Next", g)]),
+                    bindings([binding("Start", f), binding("Goal", g), binding("Visited", "fec"), binding("Next", g)]),
                     uses([
                       proof(
                         goal(edge(f, g)),
                         by(fact("graph-reachability.pl", clause(7)))
                       ),
                       proof(
-                        goal('\\+'(member(g, [f, e, c]))),
+                        goal('\\+'(member(g, "fec"))),
                         by(builtin('\\+', 1))
                       ),
                       proof(
-                        goal(reachable(g, g, [g, f, e, c])),
+                        goal(reachable(g, g, "gfec")),
                         by(fact("graph-reachability.pl", clause(8))),
-                        bindings([binding("Node", g), binding("_visited", [g, f, e, c])])
+                        bindings([binding("Node", g), binding("_visited", "gfec")])
                       )
                     ])
                   )

package/examples/proof/group-inverse-uniqueness.pl

@@ -12,7 +12,7 @@ why(
         bindings([binding("A", x), binding("B", i)]),
         uses([
           proof(
-            goal(op(i, x, e)),
+            goal(group_op(i, x, e)),
             by(fact("group-inverse-uniqueness.pl", clause(7)))
           )
         ])
@@ -23,7 +23,7 @@ why(
         bindings([binding("A", x), binding("B", j)]),
         uses([
           proof(
-            goal(op(x, j, e)),
+            goal(group_op(x, j, e)),
             by(fact("group-inverse-uniqueness.pl", clause(8)))
           )
         ])
@@ -54,7 +54,7 @@ why(
         bindings([binding("A", x), binding("B", j)]),
         uses([
           proof(
-            goal(op(j, x, e)),
+            goal(group_op(j, x, e)),
             by(fact("group-inverse-uniqueness.pl", clause(9)))
           )
         ])
@@ -65,7 +65,7 @@ why(
         bindings([binding("A", x), binding("B", i)]),
         uses([
           proof(
-            goal(op(x, i, e)),
+            goal(group_op(x, i, e)),
             by(fact("group-inverse-uniqueness.pl", clause(10)))
           )
         ])

package/examples/proof/list-collection.pl

@@ -1,53 +1,97 @@
-length(numbers, 3).
+collectionLength(numbers, 3).
 why(
-  length(numbers, 3),
+  collectionLength(numbers, 3),
   proof(
-    goal(length(numbers, 3)),
-    by(library(length, 2))
+    goal(collectionLength(numbers, 3)),
+    by(rule("list-collection.pl", clause(3))),
+    bindings([binding("N", 3), binding("List", [1, 2, 3])]),
+    uses([
+      proof(
+        goal(collection(numbers, [1, 2, 3])),
+        by(fact("list-collection.pl", clause(1)))
+      ),
+      proof(
+        goal(length([1, 2, 3], 3)),
+        by(library(length, 2))
+      )
+    ])
   )
 ).
 
-member(numbers, 1).
+collectionMember(numbers, 1).
 why(
-  member(numbers, 1),
+  collectionMember(numbers, 1),
   proof(
-    goal(member(numbers, 1)),
-    by(library(member, 2))
+    goal(collectionMember(numbers, 1)),
+    by(rule("list-collection.pl", clause(4))),
+    bindings([binding("X", 1), binding("List", [1, 2, 3])]),
+    uses([
+      proof(
+        goal(collection(numbers, [1, 2, 3])),
+        by(fact("list-collection.pl", clause(1)))
+      ),
+      proof(
+        goal(member(1, [1, 2, 3])),
+        by(library(member, 2))
+      )
+    ])
   )
 ).
 
-member(numbers, 2).
+collectionMember(numbers, 2).
 why(
-  member(numbers, 2),
+  collectionMember(numbers, 2),
   proof(
-    goal(member(numbers, 2)),
-    by(library(member, 2))
+    goal(collectionMember(numbers, 2)),
+    by(rule("list-collection.pl", clause(4))),
+    bindings([binding("X", 2), binding("List", [1, 2, 3])]),
+    uses([
+      proof(
+        goal(collection(numbers, [1, 2, 3])),
+        by(fact("list-collection.pl", clause(1)))
+      ),
+      proof(
+        goal(member(2, [1, 2, 3])),
+        by(library(member, 2))
+      )
+    ])
   )
 ).
 
-member(numbers, 3).
+collectionMember(numbers, 3).
 why(
-  member(numbers, 3),
+  collectionMember(numbers, 3),
   proof(
-    goal(member(numbers, 3)),
-    by(library(member, 2))
+    goal(collectionMember(numbers, 3)),
+    by(rule("list-collection.pl", clause(4))),
+    bindings([binding("X", 3), binding("List", [1, 2, 3])]),
+    uses([
+      proof(
+        goal(collection(numbers, [1, 2, 3])),
+        by(fact("list-collection.pl", clause(1)))
+      ),
+      proof(
+        goal(member(3, [1, 2, 3])),
+        by(library(member, 2))
+      )
+    ])
   )
 ).
 
-append(letters, [a, b, c]).
+collectionAppend(letters, "abc").
 why(
-  append(letters, [a, b, c]),
+  collectionAppend(letters, "abc"),
   proof(
-    goal(append(letters, [a, b, c])),
+    goal(collectionAppend(letters, "abc")),
     by(rule("list-collection.pl", clause(5))),
-    bindings([binding("Extended", [a, b, c]), binding("List", [a, b])]),
+    bindings([binding("Extended", "abc"), binding("List", "ab")]),
     uses([
       proof(
-        goal(collection(letters, [a, b])),
+        goal(collection(letters, "ab")),
         by(fact("list-collection.pl", clause(2)))
       ),
       proof(
-        goal(append([a, b], [c], [a, b, c])),
+        goal(append("ab", "c", "abc")),
         by(library(append, 3))
       )
     ])
@@ -60,26 +104,26 @@ why(
   proof(
     goal(head(letters, a)),
     by(rule("list-collection.pl", clause(6))),
-    bindings([binding("Head", a), binding("_tail", [b])]),
+    bindings([binding("Head", a), binding("_tail", "b")]),
     uses([
       proof(
-        goal(collection(letters, [a, b])),
+        goal(collection(letters, "ab")),
         by(fact("list-collection.pl", clause(2)))
       )
     ])
   )
 ).
 
-tail(letters, [b]).
+tail(letters, "b").
 why(
-  tail(letters, [b]),
+  tail(letters, "b"),
   proof(
-    goal(tail(letters, [b])),
+    goal(tail(letters, "b")),
     by(rule("list-collection.pl", clause(7))),
-    bindings([binding("Tail", [b]), binding("_head", a)]),
+    bindings([binding("Tail", "b"), binding("_head", a)]),
     uses([
       proof(
-        goal(collection(letters, [a, b])),
+        goal(collection(letters, "ab")),
         by(fact("list-collection.pl", clause(2)))
       )
     ])