eyelang 0.1.0

package/examples/proof/cat-koko.pl

@@ -0,0 +1,86 @@
+type(sk_0, cat).
+why(
+  type(sk_0, cat),
+  proof(
+    goal(type(sk_0, cat)),
+    by(rule("cat-koko.pl", clause(6))),
+    bindings([binding("X", sk_0)]),
+    uses([
+      proof(
+        goal(animal(koko)),
+        by(fact("cat-koko.pl", clause(3)))
+      ),
+      proof(
+        goal(witness(cat, sk_0)),
+        by(fact("cat-koko.pl", clause(4)))
+      )
+    ])
+  )
+).
+
+type(sk_1, british_short_hair).
+why(
+  type(sk_1, british_short_hair),
+  proof(
+    goal(type(sk_1, british_short_hair)),
+    by(rule("cat-koko.pl", clause(7))),
+    bindings([binding("X", sk_1)]),
+    uses([
+      proof(
+        goal(animal(koko)),
+        by(fact("cat-koko.pl", clause(3)))
+      ),
+      proof(
+        goal(witness(british_short_hair, sk_1)),
+        by(fact("cat-koko.pl", clause(5)))
+      )
+    ])
+  )
+).
+
+is(test, true).
+why(
+  is(test, true),
+  proof(
+    goal(is(test, true)),
+    by(rule("cat-koko.pl", clause(8))),
+    bindings([binding("X", sk_0), binding("Y", sk_1)]),
+    uses([
+      proof(
+        goal(type(sk_0, cat)),
+        by(rule("cat-koko.pl", clause(6))),
+        bindings([binding("X", sk_0)]),
+        uses([
+          proof(
+            goal(animal(koko)),
+            by(fact("cat-koko.pl", clause(3)))
+          ),
+          proof(
+            goal(witness(cat, sk_0)),
+            by(fact("cat-koko.pl", clause(4)))
+          )
+        ])
+      ),
+      proof(
+        goal(type(sk_1, british_short_hair)),
+        by(rule("cat-koko.pl", clause(7))),
+        bindings([binding("X", sk_1)]),
+        uses([
+          proof(
+            goal(animal(koko)),
+            by(fact("cat-koko.pl", clause(3)))
+          ),
+          proof(
+            goal(witness(british_short_hair, sk_1)),
+            by(fact("cat-koko.pl", clause(5)))
+          )
+        ])
+      ),
+      proof(
+        goal(neq(sk_0, sk_1)),
+        by(builtin(neq, 2))
+      )
+    ])
+  )
+).
+

package/examples/proof/data-negotiation.pl

@@ -0,0 +1,76 @@
+negotiate(agent1, [agent2, data4]).
+why(
+  negotiate(agent1, [agent2, data4]),
+  proof(
+    goal(negotiate(agent1, [agent2, data4])),
+    by(rule("data-negotiation.pl", clause(11))),
+    bindings([binding("AgentA", agent1), binding("AgentB", agent2), binding("Data", data4)]),
+    uses([
+      proof(
+        goal(want_negotiate(agent1, [agent2, data4])),
+        by(fact("data-negotiation.pl", clause(4)))
+      ),
+      proof(
+        goal(request_data(agent1, agent2, data4)),
+        by(rule("data-negotiation.pl", clause(9))),
+        bindings([binding("AgentA", agent1), binding("AgentB", agent2), binding("Data", data4), binding("DataListA", [data1, data2, data3]), binding("DataListB", [data4, data5, data6])]),
+        uses([
+          proof(
+            goal(hasData(agent1, [data1, data2, data3])),
+            by(fact("data-negotiation.pl", clause(2)))
+          ),
+          proof(
+            goal(hasData(agent2, [data4, data5, data6])),
+            by(fact("data-negotiation.pl", clause(3)))
+          ),
+          proof(
+            goal(member(data4, [data4, data5, data6])),
+            by(builtin(member, 2))
+          ),
+          proof(
+            goal(not_member(data4, [data1, data2, data3])),
+            by(builtin(not_member, 2))
+          ),
+          proof(
+            goal(policy(agent1, [request, data4])),
+            by(rule("data-negotiation.pl", clause(7))),
+            bindings([binding("Data", data4)]),
+            uses([
+              proof(
+                goal(member(data4, [data4, data6])),
+                by(builtin(member, 2))
+              )
+            ])
+          )
+        ])
+      ),
+      proof(
+        goal(accept_request(agent2, agent1, data4)),
+        by(rule("data-negotiation.pl", clause(10))),
+        bindings([binding("AgentB", agent2), binding("_AgentA", agent1), binding("Data", data4), binding("DataListB", [data4, data5, data6])]),
+        uses([
+          proof(
+            goal(hasData(agent2, [data4, data5, data6])),
+            by(fact("data-negotiation.pl", clause(3)))
+          ),
+          proof(
+            goal(member(data4, [data4, data5, data6])),
+            by(builtin(member, 2))
+          ),
+          proof(
+            goal(policy(agent2, [accept, data4])),
+            by(rule("data-negotiation.pl", clause(8))),
+            bindings([binding("Data", data4)]),
+            uses([
+              proof(
+                goal(neq(data4, data5)),
+                by(builtin(neq, 2))
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/proof/derived-rule.pl

@@ -0,0 +1,43 @@
+log_implies(type(var(y), dog), is(test, true)).
+why(
+  log_implies(type(var(y), dog), is(test, true)),
+  proof(
+    goal(log_implies(type(var(y), dog), is(test, true))),
+    by(rule("derived-rule.pl", clause(6))),
+    bindings([binding("_X", minka)]),
+    uses([
+      proof(
+        goal(type(minka, cat)),
+        by(fact("derived-rule.pl", clause(4)))
+      )
+    ])
+  )
+).
+
+is(test, true).
+why(
+  is(test, true),
+  proof(
+    goal(is(test, true)),
+    by(rule("derived-rule.pl", clause(7))),
+    bindings([binding("_Y", charly)]),
+    uses([
+      proof(
+        goal(log_implies(type(var(y), dog), is(test, true))),
+        by(rule("derived-rule.pl", clause(6))),
+        bindings([binding("_X", minka)]),
+        uses([
+          proof(
+            goal(type(minka, cat)),
+            by(fact("derived-rule.pl", clause(4)))
+          )
+        ])
+      ),
+      proof(
+        goal(type(charly, dog)),
+        by(fact("derived-rule.pl", clause(5)))
+      )
+    ])
+  )
+).
+

package/examples/proof/dog.pl

@@ -0,0 +1,31 @@
+mustHave(alice, dogLicense).
+why(
+  mustHave(alice, dogLicense),
+  proof(
+    goal(mustHave(alice, dogLicense)),
+    by(rule("dog.pl", clause(10))),
+    bindings([binding("Subject", alice), binding("Count", 5)]),
+    uses([
+      proof(
+        goal(dogCount(alice, 5)),
+        by(rule("dog.pl", clause(9))),
+        bindings([binding("Subject", alice), binding("Count", 5), binding("_Any", dog1)]),
+        uses([
+          proof(
+            goal(hasDog(alice, dog1)),
+            by(fact("dog.pl", clause(2)))
+          ),
+          proof(
+            goal(countall(hasDog(alice, _Dog), 5)),
+            by(builtin(countall, 2))
+          )
+        ])
+      ),
+      proof(
+        goal(gt(5, 4)),
+        by(builtin(gt, 2))
+      )
+    ])
+  )
+).
+

package/examples/proof/electrical-rc-filter.pl

@@ -0,0 +1,105 @@
+type(filter1, first_order_low_pass).
+why(
+  type(filter1, first_order_low_pass),
+  proof(
+    goal(type(filter1, first_order_low_pass)),
+    by(rule("electrical-rc-filter.pl", clause(9))),
+    bindings([binding("Filter", filter1), binding("_R", 10000.0), binding("_C", 0.000001)]),
+    uses([
+      proof(
+        goal(component(filter1, resistor_ohm, 10000.0)),
+        by(fact("electrical-rc-filter.pl", clause(4)))
+      ),
+      proof(
+        goal(component(filter1, capacitor_f, 0.000001)),
+        by(fact("electrical-rc-filter.pl", clause(5)))
+      )
+    ])
+  )
+).
+
+timeConstant_s(filter1, 0.01).
+why(
+  timeConstant_s(filter1, 0.01),
+  proof(
+    goal(timeConstant_s(filter1, 0.01)),
+    by(rule("electrical-rc-filter.pl", clause(10))),
+    bindings([binding("Filter", filter1), binding("Tau", 0.01)]),
+    uses([
+      proof(
+        goal(time_constant(filter1, 0.01)),
+        by(rule("electrical-rc-filter.pl", clause(7))),
+        bindings([binding("Filter", filter1), binding("Tau", 0.01), binding("R", 10000.0), binding("C", 0.000001)]),
+        uses([
+          proof(
+            goal(component(filter1, resistor_ohm, 10000.0)),
+            by(fact("electrical-rc-filter.pl", clause(4)))
+          ),
+          proof(
+            goal(component(filter1, capacitor_f, 0.000001)),
+            by(fact("electrical-rc-filter.pl", clause(5)))
+          ),
+          proof(
+            goal(mul(10000.0, 0.000001, 0.01)),
+            by(builtin(mul, 3))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+cutoffFrequency_Hz(filter1, 15.915494309189533).
+why(
+  cutoffFrequency_Hz(filter1, 15.915494309189533),
+  proof(
+    goal(cutoffFrequency_Hz(filter1, 15.915494309189533)),
+    by(rule("electrical-rc-filter.pl", clause(11))),
+    bindings([binding("Filter", filter1), binding("Frequency", 15.915494309189533)]),
+    uses([
+      proof(
+        goal(cutoff_frequency(filter1, 15.915494309189533)),
+        by(rule("electrical-rc-filter.pl", clause(8))),
+        bindings([binding("Filter", filter1), binding("Frequency", 15.915494309189533), binding("Tau", 0.01), binding("Pi", 3.141592653589793), binding("TwoPi", 6.2831853071795862), binding("Denominator", 0.062831853071795868)]),
+        uses([
+          proof(
+            goal(time_constant(filter1, 0.01)),
+            by(rule("electrical-rc-filter.pl", clause(7))),
+            bindings([binding("Filter", filter1), binding("Tau", 0.01), binding("R", 10000.0), binding("C", 0.000001)]),
+            uses([
+              proof(
+                goal(component(filter1, resistor_ohm, 10000.0)),
+                by(fact("electrical-rc-filter.pl", clause(4)))
+              ),
+              proof(
+                goal(component(filter1, capacitor_f, 0.000001)),
+                by(fact("electrical-rc-filter.pl", clause(5)))
+              ),
+              proof(
+                goal(mul(10000.0, 0.000001, 0.01)),
+                by(builtin(mul, 3))
+              )
+            ])
+          ),
+          proof(
+            goal(constant(pi, 3.141592653589793)),
+            by(fact("electrical-rc-filter.pl", clause(6)))
+          ),
+          proof(
+            goal(mul(2.0, 3.141592653589793, 6.2831853071795862)),
+            by(builtin(mul, 3))
+          ),
+          proof(
+            goal(mul(6.2831853071795862, 0.01, 0.062831853071795868)),
+            by(builtin(mul, 3))
+          ),
+          proof(
+            goal(div(1.0, 0.062831853071795868, 15.915494309189533)),
+            by(builtin(div, 3))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/proof/existential-rule.pl

@@ -0,0 +1,40 @@
+is(socrates, sk_0).
+why(
+  is(socrates, sk_0),
+  proof(
+    goal(is(socrates, sk_0)),
+    by(rule("existential-rule.pl", clause(6))),
+    bindings([binding("Person", socrates), binding("Witness", sk_0)]),
+    uses([
+      proof(
+        goal(type(socrates, human)),
+        by(fact("existential-rule.pl", clause(2)))
+      ),
+      proof(
+        goal(witness(socrates, sk_0)),
+        by(fact("existential-rule.pl", clause(4)))
+      )
+    ])
+  )
+).
+
+is(plato, sk_1).
+why(
+  is(plato, sk_1),
+  proof(
+    goal(is(plato, sk_1)),
+    by(rule("existential-rule.pl", clause(6))),
+    bindings([binding("Person", plato), binding("Witness", sk_1)]),
+    uses([
+      proof(
+        goal(type(plato, human)),
+        by(fact("existential-rule.pl", clause(3)))
+      ),
+      proof(
+        goal(witness(plato, sk_1)),
+        by(fact("existential-rule.pl", clause(5)))
+      )
+    ])
+  )
+).
+

package/examples/proof/floating-point.pl

@@ -0,0 +1,160 @@
+value(sum, 3.75).
+why(
+  value(sum, 3.75),
+  proof(
+    goal(value(sum, 3.75)),
+    by(rule("floating-point.pl", clause(5))),
+    bindings([binding("X", 3.75)]),
+    uses([
+      proof(
+        goal(add(1.5, 2.25, 3.75)),
+        by(builtin(add, 3))
+      )
+    ])
+  )
+).
+
+value(difference, 6.875).
+why(
+  value(difference, 6.875),
+  proof(
+    goal(value(difference, 6.875)),
+    by(rule("floating-point.pl", clause(6))),
+    bindings([binding("X", 6.875)]),
+    uses([
+      proof(
+        goal(sub(10.0, 3.125, 6.875)),
+        by(builtin(sub, 3))
+      )
+    ])
+  )
+).
+
+value(product, 10.0).
+why(
+  value(product, 10.0),
+  proof(
+    goal(value(product, 10.0)),
+    by(rule("floating-point.pl", clause(7))),
+    bindings([binding("X", 10.0)]),
+    uses([
+      proof(
+        goal(mul(2.5, 4.0, 10.0)),
+        by(builtin(mul, 3))
+      )
+    ])
+  )
+).
+
+value(quotient, 3.75).
+why(
+  value(quotient, 3.75),
+  proof(
+    goal(value(quotient, 3.75)),
+    by(rule("floating-point.pl", clause(8))),
+    bindings([binding("X", 3.75)]),
+    uses([
+      proof(
+        goal(div(7.5, 2, 3.75)),
+        by(builtin(div, 3))
+      )
+    ])
+  )
+).
+
+value(sqrtByPower, 3.0).
+why(
+  value(sqrtByPower, 3.0),
+  proof(
+    goal(value(sqrtByPower, 3.0)),
+    by(rule("floating-point.pl", clause(9))),
+    bindings([binding("X", 3.0)]),
+    uses([
+      proof(
+        goal(pow(9.0, 0.5, 3.0)),
+        by(builtin(pow, 3))
+      )
+    ])
+  )
+).
+
+value(mathSum, 1.0).
+why(
+  value(mathSum, 1.0),
+  proof(
+    goal(value(mathSum, 1.0)),
+    by(rule("floating-point.pl", clause(10))),
+    bindings([binding("X", 1.0)]),
+    uses([
+      proof(
+        goal(add(0.125, 0.875, 1.0)),
+        by(builtin(add, 3))
+      )
+    ])
+  )
+).
+
+value(mathProduct, 3.0).
+why(
+  value(mathProduct, 3.0),
+  proof(
+    goal(value(mathProduct, 3.0)),
+    by(rule("floating-point.pl", clause(11))),
+    bindings([binding("X", 3.0)]),
+    uses([
+      proof(
+        goal(mul(6.0, 0.5, 3.0)),
+        by(builtin(mul, 3))
+      )
+    ])
+  )
+).
+
+value(comfortable, true).
+why(
+  value(comfortable, true),
+  proof(
+    goal(value(comfortable, true)),
+    by(rule("floating-point.pl", clause(13))),
+    bindings([binding("R", 21.5)]),
+    uses([
+      proof(
+        goal(sample(roomC, 21.5)),
+        by(fact("floating-point.pl", clause(3)))
+      ),
+      proof(
+        goal(ge(21.5, 21.0)),
+        by(builtin(ge, 2))
+      ),
+      proof(
+        goal(le(21.5, 22.0)),
+        by(builtin(le, 2))
+      )
+    ])
+  )
+).
+
+than(warmer, targetC).
+why(
+  than(warmer, targetC),
+  proof(
+    goal(than(warmer, targetC)),
+    by(rule("floating-point.pl", clause(12))),
+    bindings([binding("R", 21.5), binding("T", 19.25)]),
+    uses([
+      proof(
+        goal(sample(roomC, 21.5)),
+        by(fact("floating-point.pl", clause(3)))
+      ),
+      proof(
+        goal(sample(targetC, 19.25)),
+        by(fact("floating-point.pl", clause(4)))
+      ),
+      proof(
+        goal(gt(21.5, 19.25)),
+        by(builtin(gt, 2))
+      )
+    ])
+  )
+).
+

package/examples/proof/good-cobbler.pl

@@ -0,0 +1,16 @@
+is(test, is(joe, good(cobbler))).
+why(
+  is(test, is(joe, good(cobbler))),
+  proof(
+    goal(is(test, is(joe, good(cobbler)))),
+    by(rule("good-cobbler.pl", clause(3))),
+    bindings([binding("X", joe), binding("Y", cobbler)]),
+    uses([
+      proof(
+        goal(assertedIs(joe, good(cobbler))),
+        by(fact("good-cobbler.pl", clause(2)))
+      )
+    ])
+  )
+).
+

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

@@ -0,0 +1,84 @@
+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/proof/list-collection.pl

@@ -0,0 +1,52 @@
+append(letters, [a, b, c]).
+why(
+  append(letters, [a, b, c]),
+  proof(
+    goal(append(letters, [a, b, c])),
+    by(rule("list-collection.pl", clause(10))),
+    bindings([binding("Extended", [a, b, c]), binding("List", [a, b])]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.pl", clause(7)))
+      ),
+      proof(
+        goal(append([a, b], [c], [a, b, c])),
+        by(builtin(append, 3))
+      )
+    ])
+  )
+).
+
+head(letters, a).
+why(
+  head(letters, a),
+  proof(
+    goal(head(letters, a)),
+    by(rule("list-collection.pl", clause(11))),
+    bindings([binding("Head", a), binding("_Tail", [b])]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.pl", clause(7)))
+      )
+    ])
+  )
+).
+
+tail(letters, [b]).
+why(
+  tail(letters, [b]),
+  proof(
+    goal(tail(letters, [b])),
+    by(rule("list-collection.pl", clause(12))),
+    bindings([binding("Tail", [b]), binding("_Head", a)]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.pl", clause(7)))
+      )
+    ])
+  )
+).
+