seam-lang 2.0.0

package/examples/peano-arithmetic.pl

@@ -0,0 +1,33 @@
+% Peano arithmetic port from EYE reasoning/peano.
+%
+% The EYE example defines add, multiply and factorial over Peano numerals.
+% Its selected output computes (1 * 2 + 3)! and emits the factorial of 5.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(factorial, 2).
+
+% Numbers are represented only with 0 and successor terms s(...).  The final
+% query constructs the Peano value for five through add and multiply.
+peano_add(A, 0, A).
+% peano_add/3, peano_multiply/3, and fac/3 are structurally recursive, so
+% the proof mirrors the Peano definitions of arithmetic.
+peano_add(A, s(B), s(C)) :-
+  peano_add(A, B, C).
+
+peano_multiply(_a, 0, 0).
+peano_multiply(A, s(B), C) :-
+  peano_multiply(A, B, D),
+  peano_add(A, D, C).
+
+factorial(A, B) :-
+  fac(A, s(0), B).
+
+fac(0, A, A).
+fac(s(A), B, C) :-
+  peano_multiply(B, s(A), D),
+  fac(A, D, C).
+
+factorial(B, C) :-
+  peano_multiply(s(0), s(s(0)), A),
+  peano_add(A, s(s(s(0))), B),
+  factorial(B, C).

package/examples/peano-calculus.pl

@@ -0,0 +1,40 @@
+% Peano addition, multiplication, and factorial over explicit Herbrand terms.
+%
+% The original logic-programming example uses `0` and `s(...)`.  Here zero is
+% the atom `z`, so every natural number is an ordinary Seam term: z, s(z),
+% s(s(z)), and so on.  The rules are relational; the materialized facts choose
+% a few finite calculations as readable examples.
+
+materialize(peano_answer, 2).
+table(padd, 3).
+table(pmul, 3).
+table(pfact, 2).
+
+% Addition.
+padd(A, z, A).
+padd(A, s(B), s(C)) :-
+  padd(A, B, C).
+
+% Multiplication by repeated addition.
+pmul(_a, z, z).
+pmul(A, s(B), C) :-
+  pmul(A, B, D),
+  padd(A, D, C).
+
+% Factorial with an accumulator.
+pfact(N, Value) :-
+  pfac(N, s(z), Value).
+
+pfac(z, Acc, Acc).
+pfac(s(N), Acc, Value) :-
+  pmul(Acc, s(N), Next),
+  pfac(N, Next, Value).
+
+peano_answer(two_plus_three, N) :-
+  padd(s(s(z)), s(s(s(z))), N).
+
+peano_answer(two_times_three, N) :-
+  pmul(s(s(z)), s(s(s(z))), N).
+
+peano_answer(factorial_four, N) :-
+  pfact(s(s(s(s(z)))), N).

package/examples/peasant.pl

@@ -0,0 +1,29 @@
+% Peasant multiplication and exponentiation cases, adapted from Eyelet.
+% The selected inputs include very large integers to exercise native numeric
+% built-ins through ordinary relations.  The want_* facts keep the example from
+% enumerating an unbounded arithmetic domain.
+
+materialize(prod, 2).
+materialize(pow, 2).
+
+% Inputs are explicit so the example does not enumerate an unbounded domain.
+want_prod([3, 0]).
+want_prod([5, 6]).
+want_prod([238, 13]).
+want_prod([8367238, 27133]).
+want_prod([62713345408367238, 40836723862713345]).
+want_prod([4083672386271334562713345408367238, 4083672386271334562713345408367238]).
+
+want_pow([3, 0]).
+want_pow([5, 6]).
+want_pow([238, 13]).
+want_pow([8367238, 2713]).
+
+% The arithmetic itself is delegated to the native numeric built-ins.
+prod([A, B], C) :-
+  want_prod([A, B]),
+  mul(A, B, C).
+
+pow([A, B], C) :-
+  want_pow([A, B]),
+  pow(A, B, C).

package/examples/pell-equation.pl

@@ -0,0 +1,34 @@
+% Pell equation x^2 - 2y^2 = 1 by tabled recurrence.
+%
+% The fundamental solution (3,2) induces a linear recurrence for all positive
+% solutions of x^2 - 2y^2 = 1.  The example materializes later solutions and also
+% rechecks the Diophantine identity so the generated sequence is auditable.
+materialize(pell_answer, 2).
+
+table(pell, 3).
+
+% N=0 is the neutral solution; each recursive step multiplies by 3 + 2*sqrt(2).
+pell(0, 1, 0).
+pell(N, X, Y) :-
+  gt(N, 0),
+  sub(N, 1, N1),
+  pell(N1, X0, Y0),
+  mul(3, X0, Ax),
+  mul(4, Y0, By),
+  add(Ax, By, X),
+  mul(2, X0, Cx),
+  mul(3, Y0, Dy),
+  add(Cx, Dy, Y).
+
+% Verification is intentionally independent of the recurrence equations above.
+pell_holds(N, true) :-
+  pell(N, X, Y),
+  mul(X, X, X2),
+  mul(Y, Y, Y2),
+  mul(2, Y2, Twicey2),
+  sub(X2, Twicey2, 1).
+
+pell_answer(solution_5, solution(X, Y)) :- pell(5, X, Y).
+pell_answer(solution_8, solution(X, Y)) :- pell(8, X, Y).
+pell_answer(check_8, true) :- pell_holds(8, true).
+pell_answer(y_sum_1_to_8, Sum) :- sumall(Y, (between(1, 8, N), pell(N, _x, Y)), Sum).

package/examples/pendulum-period.pl

@@ -0,0 +1,50 @@
+% Science example: simple pendulum period.
+%
+% For small oscillations, T = 2*pi*sqrt(length / gravity).  Gravity is chosen
+% as pi^2 m/s^2 so a one-meter pendulum has a period of two seconds.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(period_s, 2).
+materialize(periodError_s, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+constant(pi, 3.141592653589793).
+experiment(pendulum1, length_m, 1.0).
+experiment(pendulum1, gravity_m_s2, 9.869604401089358).
+limit(pendulum1, target_period_s, 2.0).
+limit(pendulum1, tolerance_s, 0.01).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+period(Experiment, Period) :-
+  experiment(Experiment, length_m, Length),
+  experiment(Experiment, gravity_m_s2, Gravity),
+  div(Length, Gravity, Ratio),
+  pow(Ratio, 0.5, Root),
+  constant(pi, Pi),
+  mul(2.0, Pi, Twopi),
+  mul(Twopi, Root, Period).
+
+period_error(Experiment, Error) :-
+  period(Experiment, Period),
+  limit(Experiment, target_period_s, Target),
+  sub(Period, Target, Rawerror),
+  abs(Rawerror, Error).
+
+within_period_tolerance(Experiment) :-
+  period_error(Experiment, Error),
+  limit(Experiment, tolerance_s, Tolerance),
+  lt(Error, Tolerance).
+
+period_s(Experiment, Period) :-
+  period(Experiment, Period).
+
+periodError_s(Experiment, Error) :-
+  period_error(Experiment, Error).
+
+status(Experiment, within_period_tolerance) :-
+  within_period_tolerance(Experiment).
+
+reason(Experiment, "small-angle period matches the two-second target") :-
+  within_period_tolerance(Experiment).

package/examples/pointer-analysis.pl

@@ -0,0 +1,50 @@
+% Andersen-style inclusion-based pointer analysis.
+%
+% The program being analyzed has address-taking, assignment, store, and load
+% statements.  The logic rules compute a fixed point of points_to/2 and
+% field_points_to/2 facts.  This is the classic Datalog shape used in scalable
+% pointer-analysis papers, reduced to a small readable instance.
+
+materialize(pointsTo, 2).
+materialize(heapField, 2).
+materialize(pointerFlow, 2).
+materialize(pointerConclusion, 2).
+
+table(points_to, 2).
+table(field_points_to, 2).
+
+% Source-program statements:
+%   x = &object_a
+%   z = &object_b
+%   y = x
+%   *y = z
+%   q = *x
+%   r = q
+addr(x, object_a).
+addr(z, object_b).
+assign(y, x).
+store(y, z).
+load(q, x).
+assign(r, q).
+
+% Address-taking and assignment constraints.
+points_to(Var, Object) :- addr(Var, Object).
+points_to(To, Object) :- assign(To, From), points_to(From, Object).
+
+% Store and load constraints.  If y may point to object_a and z may point to
+% object_b, then object_a's abstract field may point to object_b.  A later load
+% from x therefore gives q the same target.
+field_points_to(Heap_object, Value_object) :-
+  store(Pointer, Value),
+  points_to(Pointer, Heap_object),
+  points_to(Value, Value_object).
+points_to(To, Value_object) :-
+  load(To, Pointer),
+  points_to(Pointer, Heap_object),
+  field_points_to(Heap_object, Value_object).
+
+pointsTo(Var, Object) :- points_to(Var, Object).
+heapField(Heap_object, Value_object) :- field_points_to(Heap_object, Value_object).
+pointerFlow(load_q_from_x, Object) :- points_to(q, Object).
+pointerConclusion(case, "the load q = *x recovers object_b through the store *y = z and y = x") :-
+  points_to(q, object_b).

package/examples/polynomial.pl

@@ -0,0 +1,124 @@
+% Polynomial roots over complex integer candidates, adapted from Eyelet's
+% input/polynomial.pl.
+%
+% Complex numbers are represented as [Real, Imaginary].  This seam version
+% keeps the example generic by evaluating a polynomial with Horner's rule and
+% searching a finite complex-integer candidate grid.  The two cases below are
+% the same quartic polynomials used by the Eyelet source.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(polynomial, 2).
+materialize(root, 2).
+materialize(reconstructedPolynomial, 2).
+materialize(reconstructionMatches, 2).
+materialize(allRootsVerified, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+case(real_quartic).
+case(complex_quartic).
+
+polynomial(real_quartic, [[1, 0], [-10, 0], [35, 0], [-50, 0], [24, 0]]).
+polynomial(complex_quartic, [[1, 0], [-9, -5], [14, 33], [24, -44], [-26, 0]]).
+
+% Finite search domains for the two sample quartics.
+real_domain(real_quartic, 0, 5).
+imag_domain(real_quartic, 0, 0).
+real_domain(complex_quartic, 0, 5).
+imag_domain(complex_quartic, 0, 2).
+
+% The known roots are used only to reconstruct the polynomial and check that
+% the coefficient list matches the case polynomial.  Root discovery below is
+% driven by polynomial evaluation over the candidate grid.
+known_roots(real_quartic, [[1, 0], [2, 0], [3, 0], [4, 0]]).
+known_roots(complex_quartic, [[0, 1], [1, 1], [3, 2], [5, 1]]).
+
+c_zero([0, 0]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+c_add([A, B], [C, D], [E, F]) :-
+  add(A, C, E),
+  add(B, D, F).
+
+c_sub([A, B], [C, D], [E, F]) :-
+  sub(A, C, E),
+  sub(B, D, F).
+
+c_neg([A, B], [C, D]) :-
+  neg(A, C),
+  neg(B, D).
+
+c_mul([A, B], [C, D], [E, F]) :-
+  mul(A, C, Ac),
+  mul(B, D, Bd),
+  sub(Ac, Bd, E),
+  mul(A, D, Ad),
+  mul(B, C, Bc),
+  add(Ad, Bc, F).
+
+poly_eval([Coeff|Rest], X, Value) :-
+  poly_eval_acc(Rest, X, Coeff, Value).
+
+poly_eval_acc([], _x, Acc, Acc).
+poly_eval_acc([Coeff|Rest], X, Acc, Value) :-
+  c_mul(Acc, X, Product),
+  c_add(Product, Coeff, Next),
+  poly_eval_acc(Rest, X, Next, Value).
+
+candidate(Case, [R, I]) :-
+  real_domain(Case, R0, R1),
+  imag_domain(Case, I0, I1),
+  between(R0, R1, R),
+  between(I0, I1, I).
+
+root(Case, Root) :-
+  polynomial(Case, Coeffs),
+  candidate(Case, Root),
+  poly_eval(Coeffs, Root, Value),
+  c_zero(Value).
+
+poly_from_roots(Roots, Coeffs) :-
+  poly_from_roots_acc(Roots, [[1, 0]], Coeffs).
+
+poly_from_roots_acc([], Coeffs, Coeffs).
+poly_from_roots_acc([Root|Rest], Coeffs, Result) :-
+  poly_mul_linear(Coeffs, Root, Next),
+  poly_from_roots_acc(Rest, Next, Result).
+
+poly_mul_linear(Coeffs, Root, Product) :-
+  append(Coeffs, [[0, 0]], Shifted),
+  c_neg(Root, Minusroot),
+  poly_scale(Minusroot, Coeffs, Scaled),
+  append([[0, 0]], Scaled, Lower),
+  poly_add(Shifted, Lower, Product).
+
+poly_scale(_factor, [], []).
+poly_scale(Factor, [Coeff|Rest], [Product|Scaled]) :-
+  c_mul(Factor, Coeff, Product),
+  poly_scale(Factor, Rest, Scaled).
+
+poly_add([], [], []).
+poly_add([A|As], [B|Bs], [C|Cs]) :-
+  c_add(A, B, C),
+  poly_add(As, Bs, Cs).
+
+reconstructed(Case, Coeffs) :-
+  known_roots(Case, Roots),
+  poly_from_roots(Roots, Coeffs).
+
+
+
+reconstructedPolynomial(Case, Coeffs) :-
+  reconstructed(Case, Coeffs).
+
+reconstructionMatches(Case, true) :-
+  polynomial(Case, Coeffs),
+  reconstructed(Case, Coeffs).
+
+allRootsVerified(Case, true) :-
+  known_roots(Case, Roots),
+  all_roots_verify(Case, Roots).
+
+all_roots_verify(_case, []).
+all_roots_verify(Case, [Root|Rest]) :-
+  root(Case, Root),
+  all_roots_verify(Case, Rest).

package/examples/prime-range.pl

@@ -0,0 +1,45 @@
+% Prime ranges and Euler totient over finite integer domains.
+%
+% The source example combines prime search with Euler's totient function.  This
+% Seam version keeps the computation finite and declarative: composite
+% numbers are described by proper divisors, primes are candidates that are not
+% composite, and `totient/2` counts numbers coprime with the input.
+
+materialize(prime_result, 2).
+table(gcd, 3).
+
+candidate(N) :-
+  between(2, 30, N).
+
+composite(N) :-
+  candidate(N),
+  between(2, N, D),
+  lt(D, N),
+  mod(N, D, 0).
+
+prime(N) :-
+  candidate(N),
+  not(composite(N)).
+
+% Euclid's algorithm, used for the totient calculation.
+gcd(N, 0, N).
+gcd(N, M, G) :-
+  gt(M, 0),
+  mod(N, M, R),
+  gcd(M, R, G).
+
+coprime(N, K) :-
+  between(1, N, K),
+  gcd(N, K, 1).
+
+totient(N, Phi) :-
+  countall(coprime(N, _k), Phi).
+
+prime_result(range_2_30, Primes) :-
+  findall(P, prime(P), Primes).
+
+prime_result(count_2_30, Count) :-
+  countall(prime(P), Count).
+
+prime_result(totient_271, Phi) :-
+  totient(271, Phi).

package/examples/proof/access-control-policy.pl

@@ -0,0 +1,158 @@
+status(test1, policy_passed).
+why(
+  status(test1, policy_passed),
+  proof(
+    goal(status(test1, policy_passed)),
+    by(rule("access-control-policy.pl", clause(18))),
+    uses([
+      proof(
+        goal(passes_policy(test1, policy_x)),
+        by(rule("access-control-policy.pl", clause(16))),
+        bindings([binding("Request", test1), binding("Policy", policy_x)]),
+        uses([
+          proof(
+            goal(passes_all_of(test1, policy_x)),
+            by(rule("access-control-policy.pl", clause(13))),
+            bindings([binding("Request", test1), binding("Policy", policy_x)]),
+            uses([
+              proof(
+                goal(policy_request(test1, policy_x)),
+                by(fact("access-control-policy.pl", clause(4)))
+              ),
+              proof(
+                goal(policy(policy_x)),
+                by(fact("access-control-policy.pl", clause(8)))
+              ),
+              proof(
+                goal(not((allOf(policy_x, Claim), not(has(test1, Claim))))),
+                by(builtin(not, 1))
+              )
+            ])
+          ),
+          proof(
+            goal(passes_any_of(test1, policy_x)),
+            by(rule("access-control-policy.pl", clause(14))),
+            bindings([binding("Request", test1), binding("Policy", policy_x), binding("Claim", claim_c)]),
+            uses([
+              proof(
+                goal(policy_request(test1, policy_x)),
+                by(fact("access-control-policy.pl", clause(4)))
+              ),
+              proof(
+                goal(policy(policy_x)),
+                by(fact("access-control-policy.pl", clause(8)))
+              ),
+              proof(
+                goal(anyOf(policy_x, claim_c)),
+                by(fact("access-control-policy.pl", clause(11)))
+              ),
+              proof(
+                goal(has(test1, claim_c)),
+                by(fact("access-control-policy.pl", clause(7)))
+              )
+            ])
+          ),
+          proof(
+            goal(passes_none_of(test1, policy_x)),
+            by(rule("access-control-policy.pl", clause(15))),
+            bindings([binding("Request", test1), binding("Policy", policy_x)]),
+            uses([
+              proof(
+                goal(policy_request(test1, policy_x)),
+                by(fact("access-control-policy.pl", clause(4)))
+              ),
+              proof(
+                goal(policy(policy_x)),
+                by(fact("access-control-policy.pl", clause(8)))
+              ),
+              proof(
+                goal(not((noneOf(policy_x, Claim), has(test1, Claim)))),
+                by(builtin(not, 1))
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(test1, "all required claims are present, one allowed claim is present, and no forbidden claim is present").
+why(
+  reason(test1, "all required claims are present, one allowed claim is present, and no forbidden claim is present"),
+  proof(
+    goal(reason(test1, "all required claims are present, one allowed claim is present, and no forbidden claim is present")),
+    by(rule("access-control-policy.pl", clause(19))),
+    uses([
+      proof(
+        goal(passes_policy(test1, policy_x)),
+        by(rule("access-control-policy.pl", clause(16))),
+        bindings([binding("Request", test1), binding("Policy", policy_x)]),
+        uses([
+          proof(
+            goal(passes_all_of(test1, policy_x)),
+            by(rule("access-control-policy.pl", clause(13))),
+            bindings([binding("Request", test1), binding("Policy", policy_x)]),
+            uses([
+              proof(
+                goal(policy_request(test1, policy_x)),
+                by(fact("access-control-policy.pl", clause(4)))
+              ),
+              proof(
+                goal(policy(policy_x)),
+                by(fact("access-control-policy.pl", clause(8)))
+              ),
+              proof(
+                goal(not((allOf(policy_x, Claim), not(has(test1, Claim))))),
+                by(builtin(not, 1))
+              )
+            ])
+          ),
+          proof(
+            goal(passes_any_of(test1, policy_x)),
+            by(rule("access-control-policy.pl", clause(14))),
+            bindings([binding("Request", test1), binding("Policy", policy_x), binding("Claim", claim_c)]),
+            uses([
+              proof(
+                goal(policy_request(test1, policy_x)),
+                by(fact("access-control-policy.pl", clause(4)))
+              ),
+              proof(
+                goal(policy(policy_x)),
+                by(fact("access-control-policy.pl", clause(8)))
+              ),
+              proof(
+                goal(anyOf(policy_x, claim_c)),
+                by(fact("access-control-policy.pl", clause(11)))
+              ),
+              proof(
+                goal(has(test1, claim_c)),
+                by(fact("access-control-policy.pl", clause(7)))
+              )
+            ])
+          ),
+          proof(
+            goal(passes_none_of(test1, policy_x)),
+            by(rule("access-control-policy.pl", clause(15))),
+            bindings([binding("Request", test1), binding("Policy", policy_x)]),
+            uses([
+              proof(
+                goal(policy_request(test1, policy_x)),
+                by(fact("access-control-policy.pl", clause(4)))
+              ),
+              proof(
+                goal(policy(policy_x)),
+                by(fact("access-control-policy.pl", clause(8)))
+              ),
+              proof(
+                goal(not((noneOf(policy_x, Claim), has(test1, Claim)))),
+                by(builtin(not, 1))
+              )
+            ])
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/proof/age.pl

@@ -0,0 +1,71 @@
+ageAbove(patH, "P80Y").
+why(
+  ageAbove(patH, "P80Y"),
+  proof(
+    goal(ageAbove(patH, "P80Y")),
+    by(rule("age.pl", clause(7))),
+    bindings([binding("S", patH), binding("A", "P80Y"), binding("B", "1944-08-21"), binding("D", "2026-05-30"), binding("F", "P81Y9M9D")]),
+    uses([
+      proof(
+        goal(birthDay(patH, "1944-08-21")),
+        by(fact("age.pl", clause(5)))
+      ),
+      proof(
+        goal(duration(check, "P80Y")),
+        by(fact("age.pl", clause(6)))
+      ),
+      proof(
+        goal(local_time("2026-05-30")),
+        by(builtin(local_time, 1))
+      ),
+      proof(
+        goal(difference("2026-05-30", "1944-08-21", "P81Y9M9D")),
+        by(builtin(difference, 3))
+      ),
+      proof(
+        goal(gt("P81Y9M9D", "P80Y")),
+        by(builtin(gt, 2))
+      )
+    ])
+  )
+).
+
+is(test, true).
+why(
+  is(test, true),
+  proof(
+    goal(is(test, true)),
+    by(rule("age.pl", clause(8))),
+    bindings([binding("S", patH)]),
+    uses([
+      proof(
+        goal(ageAbove(patH, "P80Y")),
+        by(rule("age.pl", clause(7))),
+        bindings([binding("S", patH), binding("A", "P80Y"), binding("B", "1944-08-21"), binding("D", "2026-05-30"), binding("F", "P81Y9M9D")]),
+        uses([
+          proof(
+            goal(birthDay(patH, "1944-08-21")),
+            by(fact("age.pl", clause(5)))
+          ),
+          proof(
+            goal(duration(check, "P80Y")),
+            by(fact("age.pl", clause(6)))
+          ),
+          proof(
+            goal(local_time("2026-05-30")),
+            by(builtin(local_time, 1))
+          ),
+          proof(
+            goal(difference("2026-05-30", "1944-08-21", "P81Y9M9D")),
+            by(builtin(difference, 3))
+          ),
+          proof(
+            goal(gt("P81Y9M9D", "P80Y")),
+            by(builtin(gt, 2))
+          )
+        ])
+      )
+    ])
+  )
+).
+