eyeprolog 0.5.3

package/examples/peano-arithmetic.pl

@@ -0,0 +1,34 @@
+% 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: host-supplied goals select the relations written to this example's golden output.
+%% goal: factorial(X0, X1)
+
+
+% 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,38 @@
+% 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 EyeProlog term: z, s(z),
+% s(s(z)), and so on.  The rules are relational; the query answers choose
+% a few finite calculations as readable examples.
+
+%% goal: peano_answer(X0, X1)
+
+
+% 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,31 @@
+% 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.
+
+%% goal: prod(X0, X1)
+
+%% goal: pow(X0, X1)
+
+
+% 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]),
+  (C is A * B).
+
+pow([A, B], C) :-
+  want_pow([A, B]),
+  (C is A ^ B).

package/examples/pell-equation.pl

@@ -0,0 +1,34 @@
+% Pell equation x^2 - 2y^2 = 1 by automatically tabled recurrence.
+%
+% The fundamental solution (3,2) induces a linear recurrence for all positive
+% solutions of x^2 - 2y^2 = 1.  The example querys later solutions and also
+% rechecks the Diophantine identity so the generated sequence is auditable.
+%% goal: pell_answer(X0, X1)
+
+
+
+% N=0 is the neutral solution; each recursive step multiplies by 3 + 2*sqrt(2).
+pell(0, 1, 0).
+pell(N, X, Y) :-
+  (N > 0),
+  (N1 is N - 1),
+  pell(N1, X0, Y0),
+  (Ax is 3 * X0),
+  (By is 4 * Y0),
+  (X is Ax + By),
+  (Cx is 2 * X0),
+  (Dy is 3 * Y0),
+  (Y is Cx + Dy).
+
+% Verification is intentionally independent of the recurrence equations above.
+pell_holds(N, true) :-
+  pell(N, X, Y),
+  (X2 is X * X),
+  (Y2 is Y * Y),
+  (Twicey2 is 2 * Y2),
+  (1 is X2 - Twicey2).
+
+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,54 @@
+% 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: host-supplied goals select the relations written to this example's golden output.
+%% goal: period_s(X0, X1)
+
+%% goal: periodError_s(X0, X1)
+
+%% goal: status(X0, X1)
+
+%% goal: reason(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried 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),
+  (Ratio is Length / Gravity),
+  (Root is Ratio ** 0.5),
+  constant(pi, Pi),
+  (Twopi is 2.0 * Pi),
+  (Period is Twopi * Root).
+
+period_error(Experiment, Error) :-
+  period(Experiment, Period),
+  limit(Experiment, target_period_s, Target),
+  (Rawerror is Period - Target),
+  (Error is abs(Rawerror)).
+
+within_period_tolerance(Experiment) :-
+  period_error(Experiment, Error),
+  limit(Experiment, tolerance_s, Tolerance),
+  (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/pi.pl

@@ -0,0 +1,18 @@
+% Calculate pi using Nilakantha series
+% See http://www.wikihow.com/Calculate-Pi
+
+pi(A, B) :-
+    pi(1, A, 0, C, 1),
+    B is 3+4*C.
+
+pi(A, A, B, B, _) :-
+    !.
+pi(A, B, C, D, E) :-
+    F is A+1,
+    L is C+E/(2*A*(2*A+1)*(2*A+2)),
+    M is -E,
+    pi(F, B, L, D, M).
+
+% query
+%% goal: pi(100000, _)
+

package/examples/pointer-analysis.pl

@@ -0,0 +1,52 @@
+% 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.
+
+%% goal: pointsTo(X0, X1)
+
+%% goal: heapField(X0, X1)
+
+%% goal: pointerFlow(X0, X1)
+
+%% goal: pointerConclusion(X0, X1)
+
+
+
+% 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,129 @@
+% Polynomial roots over complex integer candidates, adapted from Eyelet's
+% input/polynomial.pl.
+%
+% Complex numbers are represented as [Real, Imaginary].  This eyeprolog 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: host-supplied goals select the relations written to this example's golden output.
+%% goal: polynomial(X0, X1)
+
+%% goal: root(X0, X1)
+
+%% goal: reconstructedPolynomial(X0, X1)
+
+%% goal: reconstructionMatches(X0, X1)
+
+%% goal: allRootsVerified(X0, X1)
+
+
+% Program structure: facts set up the scenario, and rules derive the queried 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]) :-
+  (E is A + C),
+  (F is B + D).
+
+c_sub([A, B], [C, D], [E, F]) :-
+  (E is A - C),
+  (F is B - D).
+
+c_neg([A, B], [C, D]) :-
+  (C is -(A)),
+  (D is -(B)).
+
+c_mul([A, B], [C, D], [E, F]) :-
+  (Ac is A * C),
+  (Bd is B * D),
+  (E is Ac - Bd),
+  (Ad is A * D),
+  (Bc is B * C),
+  (F is Ad + Bc).
+
+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
+% EyeProlog 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.
+
+%% goal: prime_result(X0, X1)
+
+
+candidate(N) :-
+  between(2, 30, N).
+
+composite(N) :-
+  candidate(N),
+  between(2, N, D),
+  (D < N),
+  (0 is N mod D).
+
+prime(N) :-
+  candidate(N),
+  \+ composite(N).
+
+% Euclid's algorithm, used for the totient calculation.
+gcd(N, 0, N).
+gcd(N, M, G) :-
+  (M > 0),
+  (R is N mod M),
+  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/age.pl

@@ -0,0 +1,71 @@
+ageAbove(patH, "P80Y").
+why(
+  ageAbove(patH, "P80Y"),
+  proof(
+    goal(ageAbove(patH, "P80Y")),
+    by(rule("age.pl", clause(3))),
+    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(1)))
+      ),
+      proof(
+        goal(duration(check, "P80Y")),
+        by(fact("age.pl", clause(2)))
+      ),
+      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(@>("P81Y9M9D", "P80Y")),
+        by(builtin(@>, 2))
+      )
+    ])
+  )
+).
+
+holds_result(test, true).
+why(
+  holds_result(test, true),
+  proof(
+    goal(holds_result(test, true)),
+    by(rule("age.pl", clause(4))),
+    bindings([binding("S", patH)]),
+    uses([
+      proof(
+        goal(ageAbove(patH, "P80Y")),
+        by(rule("age.pl", clause(3))),
+        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(1)))
+          ),
+          proof(
+            goal(duration(check, "P80Y")),
+            by(fact("age.pl", clause(2)))
+          ),
+          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(@>("P81Y9M9D", "P80Y")),
+            by(builtin(@>, 2))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/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(1))),
+    bindings([binding("X", 1.0)]),
+    uses([
+      proof(
+        goal(is(1.0, '+'(0.125, 0.875))),
+        by(builtin(is, 2))
+      )
+    ])
+  )
+).
+
+ok(nativeCompare, true).
+why(
+  ok(nativeCompare, true),
+  proof(
+    goal(ok(nativeCompare, true)),
+    by(rule("aliases-and-namespaces.pl", clause(2))),
+    uses([
+      proof(
+        goal(<(2, 3)),
+        by(builtin(<, 2))
+      )
+    ])
+  )
+).
+
+ok(nativeString, true).
+why(
+  ok(nativeString, true),
+  proof(
+    goal(ok(nativeString, true)),
+    by(rule("aliases-and-namespaces.pl", clause(3))),
+    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(4))),
+    bindings([binding("Tail", [b, c]), binding("_head", a)]),
+    uses([
+      proof(
+        goal(=([a, b, c], [a, b, c])),
+        by(builtin(=, 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(6))),
+    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(5)))
+      )
+    ])
+  )
+).
+