eyeling 1.32.1 → 1.33.1

package/examples/eyelang/peano-arithmetic.pl

@@ -0,0 +1,31 @@
+% 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).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+peano_add(A, 0, A).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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/eyelang/peasant.pl

@@ -0,0 +1,30 @@
+% Peasant multiplication and exponentiation cases, adapted from Eyelet
+% input/peasant.pl.  The selected answers match Eyelet output-swipl/peasant.pl.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(prod, 2).
+materialize(pow, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% 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.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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/eyelang/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/eyelang/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 eyelang 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/eyelang/project-portfolio-optimization.pl

@@ -0,0 +1,101 @@
+% Capital project portfolio optimization.
+%
+% This is a practical finite-search benchmark: enumerate project portfolios
+% under budget and risk caps, pruning infeasible branches as cost and risk
+% accumulate, then use aggregate builtins to select useful optima without
+% building and sorting a large bag of candidate portfolios.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(bestPortfolio, 2).
+materialize(lowRiskTarget, 2).
+materialize(feasibleCount, 2).
+materialize(projectCount, 2).
+materialize(totalAvailableValue, 2).
+materialize(note, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+budget(portfolio2026, 75).
+riskCap(portfolio2026, 28).
+targetValue(portfolio2026, 125).
+
+allProjectData([
+  p(solar, 22, 15, 4),
+  p(battery, 28, 20, 5),
+  p(hvac, 20, 13, 3),
+  p(analytics, 18, 8, 7),
+  p(training, 16, 6, 2),
+  p(robotics, 35, 30, 9),
+  p(iot, 24, 12, 8),
+  p(quality, 19, 9, 4),
+  p(resilience, 26, 18, 6),
+  p(recycling, 14, 5, 3),
+  p(cloud, 21, 11, 5),
+  p(security, 25, 16, 7)
+]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+project(Name, Value, Cost, Risk) :-
+  allProjectData(Projects),
+  member(p(Name, Value, Cost, Risk), Projects).
+
+% Cache this finite relation so bestPortfolio/2, lowRiskTarget/2, and
+% feasibleCount/2 do not re-enumerate the same search space independently.
+memoize(feasiblePortfolio, 4).
+
+choosePortfolio([], _BudgetLeft, _RiskLeft, [], 0, 0, 0).
+choosePortfolio([p(Name, ProjectValue, ProjectCost, ProjectRisk) | Rest], BudgetLeft, RiskLeft, [Name | Chosen], Value, Cost, Risk) :-
+  le(ProjectCost, BudgetLeft),
+  le(ProjectRisk, RiskLeft),
+  sub(BudgetLeft, ProjectCost, NextBudget),
+  sub(RiskLeft, ProjectRisk, NextRisk),
+  choosePortfolio(Rest, NextBudget, NextRisk, Chosen, RestValue, RestCost, RestRisk),
+  add(ProjectValue, RestValue, Value),
+  add(ProjectCost, RestCost, Cost),
+  add(ProjectRisk, RestRisk, Risk).
+choosePortfolio([_Project | Rest], BudgetLeft, RiskLeft, Chosen, Value, Cost, Risk) :-
+  choosePortfolio(Rest, BudgetLeft, RiskLeft, Chosen, Value, Cost, Risk).
+
+feasiblePortfolio(Selected, Value, Cost, Risk) :-
+  budget(portfolio2026, Budget),
+  riskCap(portfolio2026, Cap),
+  allProjectData(Projects),
+  bounded_subset(Projects, Budget, Cap, Selected, Value, Cost, Risk),
+  gt(Value, 0).
+
+scoredPortfolio(Selected, Value, Cost, Risk, NegCost, NegRisk) :-
+  feasiblePortfolio(Selected, Value, Cost, Risk),
+  neg(Cost, NegCost),
+  neg(Risk, NegRisk).
+
+targetPortfolio(Target, Selected, Value, Cost, Risk) :-
+  feasiblePortfolio(Selected, Value, Cost, Risk),
+  ge(Value, Target).
+
+bestPortfolio(portfolio2026, result(Value, Cost, Risk, Selected)) :-
+  aggregate_max(
+    [Value, NegCost, NegRisk, Selected],
+    result(Value, Cost, Risk, Selected),
+    scoredPortfolio(Selected, Value, Cost, Risk, NegCost, NegRisk),
+    _Key,
+    result(Value, Cost, Risk, Selected)).
+
+lowRiskTarget(portfolio2026, result(Value, Cost, Risk, Selected)) :-
+  targetValue(portfolio2026, Target),
+  aggregate_min(
+    [Risk, Cost, Selected],
+    result(Value, Cost, Risk, Selected),
+    targetPortfolio(Target, Selected, Value, Cost, Risk),
+    _Key,
+    result(Value, Cost, Risk, Selected)).
+
+feasibleCount(portfolio2026, Count) :-
+  countall(feasiblePortfolio(_Selected, _Value, _Cost, _Risk), Count).
+
+projectCount(portfolio2026, Count) :-
+  countall(project(_Name, _Value, _Cost, _Risk), Count).
+
+totalAvailableValue(portfolio2026, Total) :-
+  sumall(Value, project(_Name, Value, _Cost, _Risk), Total).
+
+note(portfolio2026, "aggregate builtins combine with pruning and memoization to avoid sorted candidate bags") :-
+  eq(ok, ok).

package/examples/eyelang/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))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/eyelang/proof/aliases-and-namespaces.pl

@@ -0,0 +1,78 @@
+value(nativeMath, 1.0).
+why(
+  value(nativeMath, 1.0),
+  proof(
+    goal(value(nativeMath, 1.0)),
+    by(rule("aliases-and-namespaces.pl", clause(5))),
+    bindings([binding("X", 1.0)]),
+    uses([
+      proof(
+        goal(add(0.125, 0.875, 1.0)),
+        by(builtin(add, 3))
+      )
+    ])
+  )
+).
+
+ok(nativeCompare, true).
+why(
+  ok(nativeCompare, true),
+  proof(
+    goal(ok(nativeCompare, true)),
+    by(rule("aliases-and-namespaces.pl", clause(6))),
+    uses([
+      proof(
+        goal(lt(2, 3)),
+        by(builtin(lt, 2))
+      )
+    ])
+  )
+).
+
+ok(nativeString, true).
+why(
+  ok(nativeString, true),
+  proof(
+    goal(ok(nativeString, true)),
+    by(rule("aliases-and-namespaces.pl", clause(7))),
+    uses([
+      proof(
+        goal(matches("scoped retail insight", "retail|medical")),
+        by(builtin(matches, 2))
+      )
+    ])
+  )
+).
+
+tail(nativeList, [b, c]).
+why(
+  tail(nativeList, [b, c]),
+  proof(
+    goal(tail(nativeList, [b, c])),
+    by(rule("aliases-and-namespaces.pl", clause(8))),
+    bindings([binding("Tail", [b, c])]),
+    uses([
+      proof(
+        goal(rest([a, b, c], [b, c])),
+        by(builtin(rest, 2))
+      )
+    ])
+  )
+).
+
+label(vocabularyExample, "vocabulary names are ordinary predicate names").
+why(
+  label(vocabularyExample, "vocabulary names are ordinary predicate names"),
+  proof(
+    goal(label(vocabularyExample, "vocabulary names are ordinary predicate names")),
+    by(rule("aliases-and-namespaces.pl", clause(10))),
+    bindings([binding("Text", "vocabulary names are ordinary predicate names")]),
+    uses([
+      proof(
+        goal(example_label(vocabularyExample, "vocabulary names are ordinary predicate names")),
+        by(fact("aliases-and-namespaces.pl", clause(9)))
+      )
+    ])
+  )
+).
+

package/examples/eyelang/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/eyelang/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)))
+      )
+    ])
+  )
+).
+