eyelang 1.3.8 → 1.4.0

package/examples/proof/ancestor.pl

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

package/examples/proof/animal.pl

@@ -0,0 +1,68 @@
+type(joe, human).
+why(
+  type(joe, human),
+  proof(
+    goal(type(joe, human)),
+    by(rule("animal.pl", clause(7))),
+    uses([
+      proof(
+        goal(human(joe)),
+        by(fact("animal.pl", clause(4)))
+      )
+    ])
+  )
+).
+
+type(joe, animal).
+why(
+  type(joe, animal),
+  proof(
+    goal(type(joe, animal)),
+    by(rule("animal.pl", clause(8))),
+    uses([
+      proof(
+        goal(animal(joe)),
+        by(rule("animal.pl", clause(6))),
+        bindings([binding("X", joe)]),
+        uses([
+          proof(
+            goal(human(joe)),
+            by(fact("animal.pl", clause(4)))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+subclassOf(human, animal).
+why(
+  subclassOf(human, animal),
+  proof(
+    goal(subclassOf(human, animal)),
+    by(rule("animal.pl", clause(9))),
+    uses([
+      proof(
+        goal(animal(human)),
+        by(fact("animal.pl", clause(5)))
+      )
+    ])
+  )
+).
+
+succeeds(animalExample, true).
+why(
+  succeeds(animalExample, true),
+  proof(
+    goal(succeeds(animalExample, true)),
+    by(rule("animal.pl", clause(10))),
+    bindings([binding("__anon0", human)]),
+    uses([
+      proof(
+        goal(animal(human)),
+        by(fact("animal.pl", clause(5)))
+      )
+    ])
+  )
+).
+

package/examples/proof/annotation.pl

@@ -0,0 +1,80 @@
+name(a, "Alice").
+why(
+  name(a, "Alice"),
+  proof(
+    goal(name(a, "Alice")),
+    by(rule("annotation.pl", clause(6))),
+    bindings([binding("S", a), binding("O", "Alice"), binding("_T", t), binding("Formula", (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(5)))
+      ),
+      proof(
+        goal(formula_binary((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), a, name, "Alice")),
+        by(builtin(formula_binary, 4))
+      )
+    ])
+  )
+).
+
+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(7))),
+    bindings([binding("T", t), binding("S", a), binding("O", "Alice"), binding("Formula", (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(5)))
+      ),
+      proof(
+        goal(formula_binary((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), a, name, "Alice")),
+        by(builtin(formula_binary, 4))
+      )
+    ])
+  )
+).
+
+statedBy(t, bob).
+why(
+  statedBy(t, bob),
+  proof(
+    goal(statedBy(t, bob)),
+    by(rule("annotation.pl", clause(8))),
+    bindings([binding("S", t), binding("O", bob), binding("_T", t), binding("Formula", (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(5)))
+      ),
+      proof(
+        goal(formula_binary((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), t, statedBy, bob)),
+        by(builtin(formula_binary, 4))
+      )
+    ])
+  )
+).
+
+recorded(t, "2021-07-07").
+why(
+  recorded(t, "2021-07-07"),
+  proof(
+    goal(recorded(t, "2021-07-07")),
+    by(rule("annotation.pl", clause(9))),
+    bindings([binding("S", t), binding("O", "2021-07-07"), binding("_T", t), binding("Formula", (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(5)))
+      ),
+      proof(
+        goal(formula_binary((name(a, "Alice"), statedBy(t, bob), recorded(t, "2021-07-07")), t, recorded, "2021-07-07")),
+        by(builtin(formula_binary, 4))
+      )
+    ])
+  )
+).
+

package/examples/proof/backward.pl

@@ -0,0 +1,22 @@
+isIndeedMoreInterestingThan(5, 3).
+why(
+  isIndeedMoreInterestingThan(5, 3),
+  proof(
+    goal(isIndeedMoreInterestingThan(5, 3)),
+    by(rule("backward.pl", clause(3))),
+    uses([
+      proof(
+        goal(moreInterestingThan(5, 3)),
+        by(rule("backward.pl", clause(2))),
+        bindings([binding("X", 5), binding("Y", 3)]),
+        uses([
+          proof(
+            goal(gt(5, 3)),
+            by(builtin(gt, 2))
+          )
+        ])
+      )
+    ])
+  )
+).
+

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)))
+      )
+    ])
+  )
+).
+