eyelang 1.3.8 → 1.4.0

package/examples/output/greatest-lower-bound-uniqueness.pl

@@ -1,150 +1,2 @@
 sameGreatestLowerBound(a, b, g1, g2).
-why(
-  sameGreatestLowerBound(a, b, g1, g2),
-  proof(
-    goal(sameGreatestLowerBound(a, b, g1, g2)),
-    by(rule("greatest-lower-bound-uniqueness.pl", clause(7))),
-    bindings([binding("A", a), binding("B", b), binding("M", g1), binding("N", g2)]),
-    uses([
-      proof(
-        goal(glbOf(g1, a, b)),
-        by(fact("greatest-lower-bound-uniqueness.pl", clause(2)))
-      ),
-      proof(
-        goal(glbOf(g2, a, b)),
-        by(fact("greatest-lower-bound-uniqueness.pl", clause(3)))
-      ),
-      proof(
-        goal(sameTerm(g1, g2)),
-        by(rule("greatest-lower-bound-uniqueness.pl", clause(6))),
-        bindings([binding("M", g1), binding("N", g2)]),
-        uses([
-          proof(
-            goal(leq(g1, g2)),
-            by(rule("greatest-lower-bound-uniqueness.pl", clause(5))),
-            bindings([binding("L", g1), binding("M", g2), binding("A", a), binding("B", b)]),
-            uses([
-              proof(
-                goal(glbOf(g2, a, b)),
-                by(fact("greatest-lower-bound-uniqueness.pl", clause(3)))
-              ),
-              proof(
-                goal(lowerBoundOf(g1, a, b)),
-                by(rule("greatest-lower-bound-uniqueness.pl", clause(4))),
-                bindings([binding("M", g1), binding("A", a), binding("B", b)]),
-                uses([
-                  proof(
-                    goal(glbOf(g1, a, b)),
-                    by(fact("greatest-lower-bound-uniqueness.pl", clause(2)))
-                  )
-                ])
-              )
-            ])
-          ),
-          proof(
-            goal(leq(g2, g1)),
-            by(rule("greatest-lower-bound-uniqueness.pl", clause(5))),
-            bindings([binding("L", g2), binding("M", g1), binding("A", a), binding("B", b)]),
-            uses([
-              proof(
-                goal(glbOf(g1, a, b)),
-                by(fact("greatest-lower-bound-uniqueness.pl", clause(2)))
-              ),
-              proof(
-                goal(lowerBoundOf(g2, a, b)),
-                by(rule("greatest-lower-bound-uniqueness.pl", clause(4))),
-                bindings([binding("M", g2), binding("A", a), binding("B", b)]),
-                uses([
-                  proof(
-                    goal(glbOf(g2, a, b)),
-                    by(fact("greatest-lower-bound-uniqueness.pl", clause(3)))
-                  )
-                ])
-              )
-            ])
-          )
-        ])
-      ),
-      proof(
-        goal(neq(g1, g2)),
-        by(builtin(neq, 2))
-      )
-    ])
-  )
-).
-
 sameGreatestLowerBound(a, b, g2, g1).
-why(
-  sameGreatestLowerBound(a, b, g2, g1),
-  proof(
-    goal(sameGreatestLowerBound(a, b, g2, g1)),
-    by(rule("greatest-lower-bound-uniqueness.pl", clause(7))),
-    bindings([binding("A", a), binding("B", b), binding("M", g2), binding("N", g1)]),
-    uses([
-      proof(
-        goal(glbOf(g2, a, b)),
-        by(fact("greatest-lower-bound-uniqueness.pl", clause(3)))
-      ),
-      proof(
-        goal(glbOf(g1, a, b)),
-        by(fact("greatest-lower-bound-uniqueness.pl", clause(2)))
-      ),
-      proof(
-        goal(sameTerm(g2, g1)),
-        by(rule("greatest-lower-bound-uniqueness.pl", clause(6))),
-        bindings([binding("M", g2), binding("N", g1)]),
-        uses([
-          proof(
-            goal(leq(g2, g1)),
-            by(rule("greatest-lower-bound-uniqueness.pl", clause(5))),
-            bindings([binding("L", g2), binding("M", g1), binding("A", a), binding("B", b)]),
-            uses([
-              proof(
-                goal(glbOf(g1, a, b)),
-                by(fact("greatest-lower-bound-uniqueness.pl", clause(2)))
-              ),
-              proof(
-                goal(lowerBoundOf(g2, a, b)),
-                by(rule("greatest-lower-bound-uniqueness.pl", clause(4))),
-                bindings([binding("M", g2), binding("A", a), binding("B", b)]),
-                uses([
-                  proof(
-                    goal(glbOf(g2, a, b)),
-                    by(fact("greatest-lower-bound-uniqueness.pl", clause(3)))
-                  )
-                ])
-              )
-            ])
-          ),
-          proof(
-            goal(leq(g1, g2)),
-            by(rule("greatest-lower-bound-uniqueness.pl", clause(5))),
-            bindings([binding("L", g1), binding("M", g2), binding("A", a), binding("B", b)]),
-            uses([
-              proof(
-                goal(glbOf(g2, a, b)),
-                by(fact("greatest-lower-bound-uniqueness.pl", clause(3)))
-              ),
-              proof(
-                goal(lowerBoundOf(g1, a, b)),
-                by(rule("greatest-lower-bound-uniqueness.pl", clause(4))),
-                bindings([binding("M", g1), binding("A", a), binding("B", b)]),
-                uses([
-                  proof(
-                    goal(glbOf(g1, a, b)),
-                    by(fact("greatest-lower-bound-uniqueness.pl", clause(2)))
-                  )
-                ])
-              )
-            ])
-          )
-        ])
-      ),
-      proof(
-        goal(neq(g2, g1)),
-        by(builtin(neq, 2))
-      )
-    ])
-  )
-).
-

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

@@ -1,84 +1,2 @@
 sameInverse(x, i, j).
-why(
-  sameInverse(x, i, j),
-  proof(
-    goal(sameInverse(x, i, j)),
-    by(rule("group-inverse-uniqueness.pl", clause(17))),
-    bindings([binding("A", x), binding("B", i), binding("C", j)]),
-    uses([
-      proof(
-        goal(leftInverse(x, i)),
-        by(rule("group-inverse-uniqueness.pl", clause(15))),
-        bindings([binding("A", x), binding("B", i)]),
-        uses([
-          proof(
-            goal(op(i, x, e)),
-            by(fact("group-inverse-uniqueness.pl", clause(8)))
-          )
-        ])
-      ),
-      proof(
-        goal(rightInverse(x, j)),
-        by(rule("group-inverse-uniqueness.pl", clause(16))),
-        bindings([binding("A", x), binding("B", j)]),
-        uses([
-          proof(
-            goal(op(x, j, e)),
-            by(fact("group-inverse-uniqueness.pl", clause(9)))
-          )
-        ])
-      ),
-      proof(
-        goal(sameTerm(i, j)),
-        by(fact("group-inverse-uniqueness.pl", clause(13)))
-      ),
-      proof(
-        goal(neq(i, j)),
-        by(builtin(neq, 2))
-      )
-    ])
-  )
-).
-
 sameInverse(x, j, i).
-why(
-  sameInverse(x, j, i),
-  proof(
-    goal(sameInverse(x, j, i)),
-    by(rule("group-inverse-uniqueness.pl", clause(17))),
-    bindings([binding("A", x), binding("B", j), binding("C", i)]),
-    uses([
-      proof(
-        goal(leftInverse(x, j)),
-        by(rule("group-inverse-uniqueness.pl", clause(15))),
-        bindings([binding("A", x), binding("B", j)]),
-        uses([
-          proof(
-            goal(op(j, x, e)),
-            by(fact("group-inverse-uniqueness.pl", clause(10)))
-          )
-        ])
-      ),
-      proof(
-        goal(rightInverse(x, i)),
-        by(rule("group-inverse-uniqueness.pl", clause(16))),
-        bindings([binding("A", x), binding("B", i)]),
-        uses([
-          proof(
-            goal(op(x, i, e)),
-            by(fact("group-inverse-uniqueness.pl", clause(11)))
-          )
-        ])
-      ),
-      proof(
-        goal(sameTerm(j, i)),
-        by(fact("group-inverse-uniqueness.pl", clause(14)))
-      ),
-      proof(
-        goal(neq(j, i)),
-        by(builtin(neq, 2))
-      )
-    ])
-  )
-).
-

package/examples/output/hamiltonian-cycle.pl

@@ -1,106 +1,4 @@
 status(hamiltonian_cycle, exists).
-why(
-  status(hamiltonian_cycle, exists),
-  proof(
-    goal(status(hamiltonian_cycle, exists)),
-    by(rule("hamiltonian-cycle.pl", clause(26))),
-    bindings([binding("_Cycle", [a, b, c, d, e, f, g, h, a])]),
-    uses([
-      proof(
-        goal(once(hamiltonian_cycle([a, b, c, d, e, f, g, h, a]))),
-        by(builtin(once, 1)),
-        uses([
-          proof(
-            goal(hamiltonian_cycle([a, b, c, d, e, f, g, h, a])),
-            by(rule("hamiltonian-cycle.pl", clause(25))),
-            bindings([binding("Cycle", [a, b, c, d, e, f, g, h, a]), binding("Vertices", [a, b, c, d, e, f, g, h])]),
-            uses([
-              proof(
-                goal(vertices([a, b, c, d, e, f, g, h])),
-                by(fact("hamiltonian-cycle.pl", clause(24)))
-              ),
-              proof(
-                goal(hamiltonian_cycle(edge, [a, b, c, d, e, f, g, h], [a, b, c, d, e, f, g, h, a])),
-                by(builtin(hamiltonian_cycle, 3))
-              )
-            ])
-          )
-        ])
-      )
-    ])
-  )
-).
-
 witness(hamiltonian_cycle, [a, b, c, d, e, f, g, h, a]).
-why(
-  witness(hamiltonian_cycle, [a, b, c, d, e, f, g, h, a]),
-  proof(
-    goal(witness(hamiltonian_cycle, [a, b, c, d, e, f, g, h, a])),
-    by(rule("hamiltonian-cycle.pl", clause(27))),
-    bindings([binding("Cycle", [a, b, c, d, e, f, g, h, a])]),
-    uses([
-      proof(
-        goal(once(hamiltonian_cycle([a, b, c, d, e, f, g, h, a]))),
-        by(builtin(once, 1)),
-        uses([
-          proof(
-            goal(hamiltonian_cycle([a, b, c, d, e, f, g, h, a])),
-            by(rule("hamiltonian-cycle.pl", clause(25))),
-            bindings([binding("Cycle", [a, b, c, d, e, f, g, h, a]), binding("Vertices", [a, b, c, d, e, f, g, h])]),
-            uses([
-              proof(
-                goal(vertices([a, b, c, d, e, f, g, h])),
-                by(fact("hamiltonian-cycle.pl", clause(24)))
-              ),
-              proof(
-                goal(hamiltonian_cycle(edge, [a, b, c, d, e, f, g, h], [a, b, c, d, e, f, g, h, a])),
-                by(builtin(hamiltonian_cycle, 3))
-              )
-            ])
-          )
-        ])
-      )
-    ])
-  )
-).
-
 vertexCount(hamiltonian_cycle, 8).
-why(
-  vertexCount(hamiltonian_cycle, 8),
-  proof(
-    goal(vertexCount(hamiltonian_cycle, 8)),
-    by(rule("hamiltonian-cycle.pl", clause(28))),
-    bindings([binding("Count", 8), binding("Vertices", [a, b, c, d, e, f, g, h])]),
-    uses([
-      proof(
-        goal(vertices([a, b, c, d, e, f, g, h])),
-        by(fact("hamiltonian-cycle.pl", clause(24)))
-      ),
-      proof(
-        goal(length([a, b, c, d, e, f, g, h], 8)),
-        by(builtin(length, 2))
-      )
-    ])
-  )
-).
-
 cycleCountFromA(hamiltonian_cycle, 72).
-why(
-  cycleCountFromA(hamiltonian_cycle, 72),
-  proof(
-    goal(cycleCountFromA(hamiltonian_cycle, 72)),
-    by(rule("hamiltonian-cycle.pl", clause(29))),
-    bindings([binding("Count", 72), binding("Cycles", [[a, b, c, d, e, f, g, h, a], [a, b, c, e, d, h, g, f, a], [a, b, c, e, f, g, d, h, a], [a, b, c, g, f, e, d, h, a], [a, b, c, g, h, d, e, f, a], [a, b, d, c, e, f, g, h, a], [a, b, d, h, g, c, e, f, a], [a, b, g, f, e, c, d, h, a], [a, b, g, h, d, c, e, f, a], [a, b, h, d, c, e, f, g, a], [a, b, h, d, e, c, g, f, a], [a, b, h, d, g, c, e, f, a], [a, b, h, g, c, d, e, f, a], [a, b, h, g, d, c, e, f, a], [a, f, e, c, b, d, g, h, a], [a, f, e, c, b, d, h, g, a], [a, f, e, c, b, g, d, h, a], [a, f, e, c, b, h, d, g, a], [a, f, e, c, d, b, g, h, a], [a, f, e, c, d, b, h, g, a], [a, f, e, c, d, g, b, h, a], [a, f, e, c, d, g, h, b, a], [a, f, e, c, d, h, b, g, a], [a, f, e, c, d, h, g, b, a], [a, f, e, c, g, b, d, h, a], [a, f, e, c, g, d, b, h, a], [a, f, e, c, g, d, h, b, a], [a, f, e, c, g, h, d, b, a], [a, f, e, d, b, c, g, h, a], [a, f, e, d, c, b, g, h, a], [a, f, e, d, c, b, h, g, a], [a, f, e, d, c, g, b, h, a], [a, f, e, d, c, g, h, b, a], [a, f, e, d, g, c, b, h, a], [a, f, e, d, h, b, c, g, a], [a, f, e, d, h, g, c, b, a], [a, f, g, b, c, e, d, h, a], [a, f, g, c, e, d, b, h, a], [a, f, g, c, e, d, h, b, a], [a, f, g, d, e, c, b, h, a], [a, f, g, h, d, e, c, b, a], [a, g, b, h, d, c, e, f, a], [a, g, c, b, h, d, e, f, a], [a, g, d, h, b, c, e, f, a], [a, g, f, e, c, b, d, h, a], [a, g, f, e, c, d, b, h, a], [a, g, f, e, c, d, h, b, a], [a, g, f, e, d, c, b, h, a], [a, g, h, b, c, d, e, f, a], [a, g, h, b, d, c, e, f, a], [a, g, h, d, b, c, e, f, a], [a, h, b, c, d, e, f, g, a], [a, h, b, c, e, d, g, f, a], [a, h, b, c, g, d, e, f, a], [a, h, b, d, c, e, f, g, a], [a, h, b, d, e, c, g, f, a], [a, h, b, d, g, c, e, f, a], [a, h, b, g, c, d, e, f, a], [a, h, b, g, d, c, e, f, a], [a, h, d, b, c, e, f, g, a], [a, h, d, b, g, c, e, f, a], [a, h, d, c, e, f, g, b, a], [a, h, d, e, c, b, g, f, a], [a, h, d, e, f, g, c, b, a], [a, h, d, g, b, c, e, f, a], [a, h, d, g, f, e, c, b, a], [a, h, g, b, c, d, e, f, a], [a, h, g, b, d, c, e, f, a], [a, h, g, c, b, d, e, f, a], [a, h, g, d, b, c, e, f, a], [a, h, g, f, e, c, d, b, a], [a, h, g, f, e, d, c, b, a]])]),
-    uses([
-      proof(
-        goal(findall(Cycle, hamiltonian_cycle(Cycle), [[a, b, c, d, e, f, g, h, a], [a, b, c, e, d, h, g, f, a], [a, b, c, e, f, g, d, h, a], [a, b, c, g, f, e, d, h, a], [a, b, c, g, h, d, e, f, a], [a, b, d, c, e, f, g, h, a], [a, b, d, h, g, c, e, f, a], [a, b, g, f, e, c, d, h, a], [a, b, g, h, d, c, e, f, a], [a, b, h, d, c, e, f, g, a], [a, b, h, d, e, c, g, f, a], [a, b, h, d, g, c, e, f, a], [a, b, h, g, c, d, e, f, a], [a, b, h, g, d, c, e, f, a], [a, f, e, c, b, d, g, h, a], [a, f, e, c, b, d, h, g, a], [a, f, e, c, b, g, d, h, a], [a, f, e, c, b, h, d, g, a], [a, f, e, c, d, b, g, h, a], [a, f, e, c, d, b, h, g, a], [a, f, e, c, d, g, b, h, a], [a, f, e, c, d, g, h, b, a], [a, f, e, c, d, h, b, g, a], [a, f, e, c, d, h, g, b, a], [a, f, e, c, g, b, d, h, a], [a, f, e, c, g, d, b, h, a], [a, f, e, c, g, d, h, b, a], [a, f, e, c, g, h, d, b, a], [a, f, e, d, b, c, g, h, a], [a, f, e, d, c, b, g, h, a], [a, f, e, d, c, b, h, g, a], [a, f, e, d, c, g, b, h, a], [a, f, e, d, c, g, h, b, a], [a, f, e, d, g, c, b, h, a], [a, f, e, d, h, b, c, g, a], [a, f, e, d, h, g, c, b, a], [a, f, g, b, c, e, d, h, a], [a, f, g, c, e, d, b, h, a], [a, f, g, c, e, d, h, b, a], [a, f, g, d, e, c, b, h, a], [a, f, g, h, d, e, c, b, a], [a, g, b, h, d, c, e, f, a], [a, g, c, b, h, d, e, f, a], [a, g, d, h, b, c, e, f, a], [a, g, f, e, c, b, d, h, a], [a, g, f, e, c, d, b, h, a], [a, g, f, e, c, d, h, b, a], [a, g, f, e, d, c, b, h, a], [a, g, h, b, c, d, e, f, a], [a, g, h, b, d, c, e, f, a], [a, g, h, d, b, c, e, f, a], [a, h, b, c, d, e, f, g, a], [a, h, b, c, e, d, g, f, a], [a, h, b, c, g, d, e, f, a], [a, h, b, d, c, e, f, g, a], [a, h, b, d, e, c, g, f, a], [a, h, b, d, g, c, e, f, a], [a, h, b, g, c, d, e, f, a], [a, h, b, g, d, c, e, f, a], [a, h, d, b, c, e, f, g, a], [a, h, d, b, g, c, e, f, a], [a, h, d, c, e, f, g, b, a], [a, h, d, e, c, b, g, f, a], [a, h, d, e, f, g, c, b, a], [a, h, d, g, b, c, e, f, a], [a, h, d, g, f, e, c, b, a], [a, h, g, b, c, d, e, f, a], [a, h, g, b, d, c, e, f, a], [a, h, g, c, b, d, e, f, a], [a, h, g, d, b, c, e, f, a], [a, h, g, f, e, c, d, b, a], [a, h, g, f, e, d, c, b, a]])),
-        by(builtin(findall, 3))
-      ),
-      proof(
-        goal(length([[a, b, c, d, e, f, g, h, a], [a, b, c, e, d, h, g, f, a], [a, b, c, e, f, g, d, h, a], [a, b, c, g, f, e, d, h, a], [a, b, c, g, h, d, e, f, a], [a, b, d, c, e, f, g, h, a], [a, b, d, h, g, c, e, f, a], [a, b, g, f, e, c, d, h, a], [a, b, g, h, d, c, e, f, a], [a, b, h, d, c, e, f, g, a], [a, b, h, d, e, c, g, f, a], [a, b, h, d, g, c, e, f, a], [a, b, h, g, c, d, e, f, a], [a, b, h, g, d, c, e, f, a], [a, f, e, c, b, d, g, h, a], [a, f, e, c, b, d, h, g, a], [a, f, e, c, b, g, d, h, a], [a, f, e, c, b, h, d, g, a], [a, f, e, c, d, b, g, h, a], [a, f, e, c, d, b, h, g, a], [a, f, e, c, d, g, b, h, a], [a, f, e, c, d, g, h, b, a], [a, f, e, c, d, h, b, g, a], [a, f, e, c, d, h, g, b, a], [a, f, e, c, g, b, d, h, a], [a, f, e, c, g, d, b, h, a], [a, f, e, c, g, d, h, b, a], [a, f, e, c, g, h, d, b, a], [a, f, e, d, b, c, g, h, a], [a, f, e, d, c, b, g, h, a], [a, f, e, d, c, b, h, g, a], [a, f, e, d, c, g, b, h, a], [a, f, e, d, c, g, h, b, a], [a, f, e, d, g, c, b, h, a], [a, f, e, d, h, b, c, g, a], [a, f, e, d, h, g, c, b, a], [a, f, g, b, c, e, d, h, a], [a, f, g, c, e, d, b, h, a], [a, f, g, c, e, d, h, b, a], [a, f, g, d, e, c, b, h, a], [a, f, g, h, d, e, c, b, a], [a, g, b, h, d, c, e, f, a], [a, g, c, b, h, d, e, f, a], [a, g, d, h, b, c, e, f, a], [a, g, f, e, c, b, d, h, a], [a, g, f, e, c, d, b, h, a], [a, g, f, e, c, d, h, b, a], [a, g, f, e, d, c, b, h, a], [a, g, h, b, c, d, e, f, a], [a, g, h, b, d, c, e, f, a], [a, g, h, d, b, c, e, f, a], [a, h, b, c, d, e, f, g, a], [a, h, b, c, e, d, g, f, a], [a, h, b, c, g, d, e, f, a], [a, h, b, d, c, e, f, g, a], [a, h, b, d, e, c, g, f, a], [a, h, b, d, g, c, e, f, a], [a, h, b, g, c, d, e, f, a], [a, h, b, g, d, c, e, f, a], [a, h, d, b, c, e, f, g, a], [a, h, d, b, g, c, e, f, a], [a, h, d, c, e, f, g, b, a], [a, h, d, e, c, b, g, f, a], [a, h, d, e, f, g, c, b, a], [a, h, d, g, b, c, e, f, a], [a, h, d, g, f, e, c, b, a], [a, h, g, b, c, d, e, f, a], [a, h, g, b, d, c, e, f, a], [a, h, g, c, b, d, e, f, a], [a, h, g, d, b, c, e, f, a], [a, h, g, f, e, c, d, b, a], [a, h, g, f, e, d, c, b, a]], 72)),
-        by(builtin(length, 2))
-      )
-    ])
-  )
-).
-