seam-lang 2.0.0

package/examples/proof/existential-rule.pl

@@ -0,0 +1,32 @@
+is(socrates, human_witness(socrates)).
+why(
+  is(socrates, human_witness(socrates)),
+  proof(
+    goal(is(socrates, human_witness(socrates))),
+    by(rule("existential-rule.pl", clause(4))),
+    bindings([binding("Person", socrates)]),
+    uses([
+      proof(
+        goal(type(socrates, human)),
+        by(fact("existential-rule.pl", clause(2)))
+      )
+    ])
+  )
+).
+
+is(plato, human_witness(plato)).
+why(
+  is(plato, human_witness(plato)),
+  proof(
+    goal(is(plato, human_witness(plato))),
+    by(rule("existential-rule.pl", clause(4))),
+    bindings([binding("Person", plato)]),
+    uses([
+      proof(
+        goal(type(plato, human)),
+        by(fact("existential-rule.pl", clause(3)))
+      )
+    ])
+  )
+).
+

package/examples/proof/expression-eval.pl

@@ -0,0 +1,105 @@
+result(root, 12).
+why(
+  result(root, 12),
+  proof(
+    goal(result(root, 12)),
+    by(rule("expression-eval.pl", clause(14))),
+    bindings([binding("Value", 12), binding("Node", eAdd)]),
+    uses([
+      proof(
+        goal(root(eAdd)),
+        by(fact("expression-eval.pl", clause(9)))
+      ),
+      proof(
+        goal(value(eAdd, 12)),
+        by(rule("expression-eval.pl", clause(11))),
+        bindings([binding("Node", eAdd), binding("Value", 12), binding("Left", eMul), binding("Right", eSub), binding("Leftvalue", 6), binding("Rightvalue", 6)]),
+        uses([
+          proof(
+            goal(expr(eAdd, add, eMul, eSub)),
+            by(fact("expression-eval.pl", clause(8)))
+          ),
+          proof(
+            goal(value(eMul, 6)),
+            by(rule("expression-eval.pl", clause(13))),
+            bindings([binding("Node", eMul), binding("Value", 6), binding("Left", n2), binding("Right", n3), binding("Leftvalue", 2), binding("Rightvalue", 3)]),
+            uses([
+              proof(
+                goal(expr(eMul, mul, n2, n3)),
+                by(fact("expression-eval.pl", clause(6)))
+              ),
+              proof(
+                goal(value(n2, 2)),
+                by(rule("expression-eval.pl", clause(10))),
+                bindings([binding("Node", n2), binding("Value", 2)]),
+                uses([
+                  proof(
+                    goal(number(n2, 2)),
+                    by(fact("expression-eval.pl", clause(2)))
+                  )
+                ])
+              ),
+              proof(
+                goal(value(n3, 3)),
+                by(rule("expression-eval.pl", clause(10))),
+                bindings([binding("Node", n3), binding("Value", 3)]),
+                uses([
+                  proof(
+                    goal(number(n3, 3)),
+                    by(fact("expression-eval.pl", clause(3)))
+                  )
+                ])
+              ),
+              proof(
+                goal(mul(2, 3, 6)),
+                by(builtin(mul, 3))
+              )
+            ])
+          ),
+          proof(
+            goal(value(eSub, 6)),
+            by(rule("expression-eval.pl", clause(12))),
+            bindings([binding("Node", eSub), binding("Value", 6), binding("Left", n10), binding("Right", n4), binding("Leftvalue", 10), binding("Rightvalue", 4)]),
+            uses([
+              proof(
+                goal(expr(eSub, sub, n10, n4)),
+                by(fact("expression-eval.pl", clause(7)))
+              ),
+              proof(
+                goal(value(n10, 10)),
+                by(rule("expression-eval.pl", clause(10))),
+                bindings([binding("Node", n10), binding("Value", 10)]),
+                uses([
+                  proof(
+                    goal(number(n10, 10)),
+                    by(fact("expression-eval.pl", clause(4)))
+                  )
+                ])
+              ),
+              proof(
+                goal(value(n4, 4)),
+                by(rule("expression-eval.pl", clause(10))),
+                bindings([binding("Node", n4), binding("Value", 4)]),
+                uses([
+                  proof(
+                    goal(number(n4, 4)),
+                    by(fact("expression-eval.pl", clause(5)))
+                  )
+                ])
+              ),
+              proof(
+                goal(sub(10, 4, 6)),
+                by(builtin(sub, 3))
+              )
+            ])
+          ),
+          proof(
+            goal(add(6, 6, 12)),
+            by(builtin(add, 3))
+          )
+        ])
+      )
+    ])
+  )
+).
+

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/gdpr-compliance.pl

@@ -0,0 +1,199 @@
+status(case_alpha, gdpr_compliant).
+why(
+  status(case_alpha, gdpr_compliant),
+  proof(
+    goal(status(case_alpha, gdpr_compliant)),
+    by(rule("gdpr-compliance.pl", clause(27))),
+    bindings([binding("Case", case_alpha)]),
+    uses([
+      proof(
+        goal(compliant(case_alpha)),
+        by(rule("gdpr-compliance.pl", clause(22))),
+        bindings([binding("Case", case_alpha)]),
+        uses([
+          proof(
+            goal(processing(case_alpha)),
+            by(fact("gdpr-compliance.pl", clause(3)))
+          ),
+          proof(
+            goal(has_required_basis(case_alpha)),
+            by(rule("gdpr-compliance.pl", clause(17))),
+            bindings([binding("Case", case_alpha)]),
+            uses([
+              proof(
+                goal(legal_basis(case_alpha, explicit_consent)),
+                by(fact("gdpr-compliance.pl", clause(7)))
+              )
+            ])
+          ),
+          proof(
+            goal(minimized(case_alpha)),
+            by(fact("gdpr-compliance.pl", clause(8)))
+          ),
+          proof(
+            goal(has_health_safeguards(case_alpha)),
+            by(rule("gdpr-compliance.pl", clause(19))),
+            bindings([binding("Case", case_alpha)]),
+            uses([
+              proof(
+                goal(special_category(case_alpha, health_data)),
+                by(fact("gdpr-compliance.pl", clause(10)))
+              ),
+              proof(
+                goal(safeguard(case_alpha, encryption)),
+                by(fact("gdpr-compliance.pl", clause(12)))
+              ),
+              proof(
+                goal(safeguard(case_alpha, access_logging)),
+                by(fact("gdpr-compliance.pl", clause(13)))
+              )
+            ])
+          ),
+          proof(
+            goal(transfer_ok(case_alpha)),
+            by(rule("gdpr-compliance.pl", clause(20))),
+            bindings([binding("Case", case_alpha)]),
+            uses([
+              proof(
+                goal(not(third_country_transfer(case_alpha))),
+                by(builtin(not, 1))
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+
+status(case_beta, gdpr_noncompliant).
+why(
+  status(case_beta, gdpr_noncompliant),
+  proof(
+    goal(status(case_beta, gdpr_noncompliant)),
+    by(rule("gdpr-compliance.pl", clause(28))),
+    bindings([binding("Case", case_beta), binding("_reason", missing_legal_basis)]),
+    uses([
+      proof(
+        goal(noncompliance_reason(case_beta, missing_legal_basis)),
+        by(rule("gdpr-compliance.pl", clause(23))),
+        bindings([binding("Case", case_beta)]),
+        uses([
+          proof(
+            goal(processing(case_beta)),
+            by(fact("gdpr-compliance.pl", clause(4)))
+          ),
+          proof(
+            goal(not(has_required_basis(case_beta))),
+            by(builtin(not, 1))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(case_beta, missing_legal_basis).
+why(
+  reason(case_beta, missing_legal_basis),
+  proof(
+    goal(reason(case_beta, missing_legal_basis)),
+    by(rule("gdpr-compliance.pl", clause(29))),
+    bindings([binding("Case", case_beta), binding("Reason", missing_legal_basis)]),
+    uses([
+      proof(
+        goal(noncompliance_reason(case_beta, missing_legal_basis)),
+        by(rule("gdpr-compliance.pl", clause(23))),
+        bindings([binding("Case", case_beta)]),
+        uses([
+          proof(
+            goal(processing(case_beta)),
+            by(fact("gdpr-compliance.pl", clause(4)))
+          ),
+          proof(
+            goal(not(has_required_basis(case_beta))),
+            by(builtin(not, 1))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(case_beta, not_minimized).
+why(
+  reason(case_beta, not_minimized),
+  proof(
+    goal(reason(case_beta, not_minimized)),
+    by(rule("gdpr-compliance.pl", clause(29))),
+    bindings([binding("Case", case_beta), binding("Reason", not_minimized)]),
+    uses([
+      proof(
+        goal(noncompliance_reason(case_beta, not_minimized)),
+        by(rule("gdpr-compliance.pl", clause(24))),
+        bindings([binding("Case", case_beta)]),
+        uses([
+          proof(
+            goal(not_minimized(case_beta)),
+            by(fact("gdpr-compliance.pl", clause(9)))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(case_beta, missing_access_logging).
+why(
+  reason(case_beta, missing_access_logging),
+  proof(
+    goal(reason(case_beta, missing_access_logging)),
+    by(rule("gdpr-compliance.pl", clause(29))),
+    bindings([binding("Case", case_beta), binding("Reason", missing_access_logging)]),
+    uses([
+      proof(
+        goal(noncompliance_reason(case_beta, missing_access_logging)),
+        by(rule("gdpr-compliance.pl", clause(25))),
+        bindings([binding("Case", case_beta)]),
+        uses([
+          proof(
+            goal(special_category(case_beta, health_data)),
+            by(fact("gdpr-compliance.pl", clause(11)))
+          ),
+          proof(
+            goal(not(safeguard(case_beta, access_logging))),
+            by(builtin(not, 1))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(case_beta, transfer_without_adequacy).
+why(
+  reason(case_beta, transfer_without_adequacy),
+  proof(
+    goal(reason(case_beta, transfer_without_adequacy)),
+    by(rule("gdpr-compliance.pl", clause(29))),
+    bindings([binding("Case", case_beta), binding("Reason", transfer_without_adequacy)]),
+    uses([
+      proof(
+        goal(noncompliance_reason(case_beta, transfer_without_adequacy)),
+        by(rule("gdpr-compliance.pl", clause(26))),
+        bindings([binding("Case", case_beta)]),
+        uses([
+          proof(
+            goal(third_country_transfer(case_beta)),
+            by(fact("gdpr-compliance.pl", clause(15)))
+          ),
+          proof(
+            goal(not(adequacy_decision(case_beta))),
+            by(builtin(not, 1))
+          )
+        ])
+      )
+    ])
+  )
+).
+

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/graph-reachability.pl

@@ -0,0 +1,151 @@
+reachable(reachability_case, path(a, f)).
+why(
+  reachable(reachability_case, path(a, f)),
+  proof(
+    goal(reachable(reachability_case, path(a, f))),
+    by(rule("graph-reachability.pl", clause(13))),
+    uses([
+      proof(
+        goal(is_reachable(a, f)),
+        by(rule("graph-reachability.pl", clause(12))),
+        bindings([binding("Start", a), binding("Goal", f)]),
+        uses([
+          proof(
+            goal(reachable(a, f, [a])),
+            by(rule("graph-reachability.pl", clause(11))),
+            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(3)))
+              ),
+              proof(
+                goal(not(member(b, [a]))),
+                by(builtin(not, 1))
+              ),
+              proof(
+                goal(reachable(b, f, [b, a])),
+                by(rule("graph-reachability.pl", clause(11))),
+                bindings([binding("Start", b), binding("Goal", f), binding("Visited", [b, a]), binding("Next", d)]),
+                uses([
+                  proof(
+                    goal(edge(b, d)),
+                    by(fact("graph-reachability.pl", clause(5)))
+                  ),
+                  proof(
+                    goal(not(member(d, [b, a]))),
+                    by(builtin(not, 1))
+                  ),
+                  proof(
+                    goal(reachable(d, f, [d, b, a])),
+                    by(rule("graph-reachability.pl", clause(11))),
+                    bindings([binding("Start", d), binding("Goal", f), binding("Visited", [d, b, a]), binding("Next", f)]),
+                    uses([
+                      proof(
+                        goal(edge(d, f)),
+                        by(fact("graph-reachability.pl", clause(7)))
+                      ),
+                      proof(
+                        goal(not(member(f, [d, b, a]))),
+                        by(builtin(not, 1))
+                      ),
+                      proof(
+                        goal(reachable(f, f, [f, d, b, a])),
+                        by(fact("graph-reachability.pl", clause(10))),
+                        bindings([binding("Node", f), binding("_visited", [f, d, b, a])])
+                      )
+                    ])
+                  )
+                ])
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reachable(reachability_case, path(c, g)).
+why(
+  reachable(reachability_case, path(c, g)),
+  proof(
+    goal(reachable(reachability_case, path(c, g))),
+    by(rule("graph-reachability.pl", clause(14))),
+    uses([
+      proof(
+        goal(is_reachable(c, g)),
+        by(rule("graph-reachability.pl", clause(12))),
+        bindings([binding("Start", c), binding("Goal", g)]),
+        uses([
+          proof(
+            goal(reachable(c, g, [c])),
+            by(rule("graph-reachability.pl", clause(11))),
+            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(6)))
+              ),
+              proof(
+                goal(not(member(e, [c]))),
+                by(builtin(not, 1))
+              ),
+              proof(
+                goal(reachable(e, g, [e, c])),
+                by(rule("graph-reachability.pl", clause(11))),
+                bindings([binding("Start", e), binding("Goal", g), binding("Visited", [e, c]), binding("Next", f)]),
+                uses([
+                  proof(
+                    goal(edge(e, f)),
+                    by(fact("graph-reachability.pl", clause(8)))
+                  ),
+                  proof(
+                    goal(not(member(f, [e, c]))),
+                    by(builtin(not, 1))
+                  ),
+                  proof(
+                    goal(reachable(f, g, [f, e, c])),
+                    by(rule("graph-reachability.pl", clause(11))),
+                    bindings([binding("Start", f), binding("Goal", g), binding("Visited", [f, e, c]), binding("Next", g)]),
+                    uses([
+                      proof(
+                        goal(edge(f, g)),
+                        by(fact("graph-reachability.pl", clause(9)))
+                      ),
+                      proof(
+                        goal(not(member(g, [f, e, c]))),
+                        by(builtin(not, 1))
+                      ),
+                      proof(
+                        goal(reachable(g, g, [g, f, e, c])),
+                        by(fact("graph-reachability.pl", clause(10))),
+                        bindings([binding("Node", g), binding("_visited", [g, f, e, c])])
+                      )
+                    ])
+                  )
+                ])
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+
+not_reachable(reachability_case, path(b, e)).
+why(
+  not_reachable(reachability_case, path(b, e)),
+  proof(
+    goal(not_reachable(reachability_case, path(b, e))),
+    by(rule("graph-reachability.pl", clause(15))),
+    uses([
+      proof(
+        goal(not(is_reachable(b, e))),
+        by(builtin(not, 1))
+      )
+    ])
+  )
+).
+