eyeling 1.32.1 → 1.33.0

package/examples/eyelang/proof/group-inverse-uniqueness.pl

@@ -0,0 +1,84 @@
+sameInverse(x, i, j).
+why(
+  sameInverse(x, i, j),
+  proof(
+    goal(sameInverse(x, i, j)),
+    by(rule("group-inverse-uniqueness.pl", clause(17))),
+    bindings([binding("A", x), binding("B", i), binding("C", j)]),
+    uses([
+      proof(
+        goal(leftInverse(x, i)),
+        by(rule("group-inverse-uniqueness.pl", clause(15))),
+        bindings([binding("A", x), binding("B", i)]),
+        uses([
+          proof(
+            goal(op(i, x, e)),
+            by(fact("group-inverse-uniqueness.pl", clause(8)))
+          )
+        ])
+      ),
+      proof(
+        goal(rightInverse(x, j)),
+        by(rule("group-inverse-uniqueness.pl", clause(16))),
+        bindings([binding("A", x), binding("B", j)]),
+        uses([
+          proof(
+            goal(op(x, j, e)),
+            by(fact("group-inverse-uniqueness.pl", clause(9)))
+          )
+        ])
+      ),
+      proof(
+        goal(sameTerm(i, j)),
+        by(fact("group-inverse-uniqueness.pl", clause(13)))
+      ),
+      proof(
+        goal(neq(i, j)),
+        by(builtin(neq, 2))
+      )
+    ])
+  )
+).
+
+sameInverse(x, j, i).
+why(
+  sameInverse(x, j, i),
+  proof(
+    goal(sameInverse(x, j, i)),
+    by(rule("group-inverse-uniqueness.pl", clause(17))),
+    bindings([binding("A", x), binding("B", j), binding("C", i)]),
+    uses([
+      proof(
+        goal(leftInverse(x, j)),
+        by(rule("group-inverse-uniqueness.pl", clause(15))),
+        bindings([binding("A", x), binding("B", j)]),
+        uses([
+          proof(
+            goal(op(j, x, e)),
+            by(fact("group-inverse-uniqueness.pl", clause(10)))
+          )
+        ])
+      ),
+      proof(
+        goal(rightInverse(x, i)),
+        by(rule("group-inverse-uniqueness.pl", clause(16))),
+        bindings([binding("A", x), binding("B", i)]),
+        uses([
+          proof(
+            goal(op(x, i, e)),
+            by(fact("group-inverse-uniqueness.pl", clause(11)))
+          )
+        ])
+      ),
+      proof(
+        goal(sameTerm(j, i)),
+        by(fact("group-inverse-uniqueness.pl", clause(14)))
+      ),
+      proof(
+        goal(neq(j, i)),
+        by(builtin(neq, 2))
+      )
+    ])
+  )
+).
+

package/examples/eyelang/proof/list-collection.pl

@@ -0,0 +1,52 @@
+append(letters, [a, b, c]).
+why(
+  append(letters, [a, b, c]),
+  proof(
+    goal(append(letters, [a, b, c])),
+    by(rule("list-collection.pl", clause(10))),
+    bindings([binding("Extended", [a, b, c]), binding("List", [a, b])]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.pl", clause(7)))
+      ),
+      proof(
+        goal(append([a, b], [c], [a, b, c])),
+        by(builtin(append, 3))
+      )
+    ])
+  )
+).
+
+head(letters, a).
+why(
+  head(letters, a),
+  proof(
+    goal(head(letters, a)),
+    by(rule("list-collection.pl", clause(11))),
+    bindings([binding("Head", a), binding("_Tail", [b])]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.pl", clause(7)))
+      )
+    ])
+  )
+).
+
+tail(letters, [b]).
+why(
+  tail(letters, [b]),
+  proof(
+    goal(tail(letters, [b])),
+    by(rule("list-collection.pl", clause(12))),
+    bindings([binding("Tail", [b]), binding("_Head", a)]),
+    uses([
+      proof(
+        goal(collection(letters, [a, b])),
+        by(fact("list-collection.pl", clause(7)))
+      )
+    ])
+  )
+).
+

package/examples/eyelang/proof/proof-contrapositive.pl

@@ -0,0 +1,78 @@
+refutes(proof1, raining).
+why(
+  refutes(proof1, raining),
+  proof(
+    goal(refutes(proof1, raining)),
+    by(rule("proof-contrapositive.pl", clause(7))),
+    uses([
+      proof(
+        goal(false(raining)),
+        by(rule("proof-contrapositive.pl", clause(6))),
+        bindings([binding("A", raining), binding("B", wet_ground)]),
+        uses([
+          proof(
+            goal(implies(raining, wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(4)))
+          ),
+          proof(
+            goal(false(wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(5)))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+method(proof1, contrapositive).
+why(
+  method(proof1, contrapositive),
+  proof(
+    goal(method(proof1, contrapositive)),
+    by(rule("proof-contrapositive.pl", clause(8))),
+    uses([
+      proof(
+        goal(false(raining)),
+        by(rule("proof-contrapositive.pl", clause(6))),
+        bindings([binding("A", raining), binding("B", wet_ground)]),
+        uses([
+          proof(
+            goal(implies(raining, wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(4)))
+          ),
+          proof(
+            goal(false(wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(5)))
+          )
+        ])
+      )
+    ])
+  )
+).
+
+reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining").
+why(
+  reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining"),
+  proof(
+    goal(reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining")),
+    by(rule("proof-contrapositive.pl", clause(9))),
+    uses([
+      proof(
+        goal(false(raining)),
+        by(rule("proof-contrapositive.pl", clause(6))),
+        bindings([binding("A", raining), binding("B", wet_ground)]),
+        uses([
+          proof(
+            goal(implies(raining, wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(4)))
+          ),
+          proof(
+            goal(false(wet_ground)),
+            by(fact("proof-contrapositive.pl", clause(5)))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/eyelang/proof/socket-age.pl

@@ -0,0 +1,32 @@
+ageAbove(patH, "P80Y").
+why(
+  ageAbove(patH, "P80Y"),
+  proof(
+    goal(ageAbove(patH, "P80Y")),
+    by(rule("socket-age.pl", clause(11))),
+    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("socket-age.pl", clause(8)))
+      ),
+      proof(
+        goal(duration(check, "P80Y")),
+        by(fact("socket-age.pl", clause(9)))
+      ),
+      proof(
+        goal(today("2026-05-30")),
+        by(fact("socket-age.pl", clause(10)))
+      ),
+      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/socket-family.pl

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

package/examples/eyelang/proof/socrates.pl

@@ -0,0 +1,38 @@
+type(socrates, mortal).
+why(
+  type(socrates, mortal),
+  proof(
+    goal(type(socrates, mortal)),
+    by(rule("socrates.pl", clause(4))),
+    bindings([binding("X", socrates)]),
+    uses([
+      proof(
+        goal(type(socrates, man)),
+        by(fact("socrates.pl", clause(3)))
+      )
+    ])
+  )
+).
+
+is(test, true).
+why(
+  is(test, true),
+  proof(
+    goal(is(test, true)),
+    by(rule("socrates.pl", clause(5))),
+    uses([
+      proof(
+        goal(type(socrates, mortal)),
+        by(rule("socrates.pl", clause(4))),
+        bindings([binding("X", socrates)]),
+        uses([
+          proof(
+            goal(type(socrates, man)),
+            by(fact("socrates.pl", clause(3)))
+          )
+        ])
+      )
+    ])
+  )
+).
+

package/examples/eyelang/proof-contrapositive.pl

@@ -0,0 +1,27 @@
+% Proof by contrapositive example adapted from Eyelet input/proof-by-contrapositive.pl.
+%
+% The implication itself is represented as data with implies/2.  The proof
+% rule remains ordinary eyelang: if A implies B and B is false, then A is false.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(refutes, 2).
+materialize(method, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+implies(raining, wet_ground).
+false(wet_ground).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+false(A) :-
+  implies(A, B),
+  false(B).
+
+refutes(proof1, raining) :-
+  false(raining).
+
+method(proof1, contrapositive) :-
+  false(raining).
+
+reason(proof1, "if rain implies wet ground and the ground is not wet, then it is not raining") :-
+  false(raining).

package/examples/eyelang/quadratic-formula.pl

@@ -0,0 +1,54 @@
+% Quadratic formula over sample equations.
+%
+% Each equation is represented as a*x^2 + b*x + c = 0.  The example uses
+% eyelang arithmetic predicates to derive the discriminant and the two roots.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(discriminant, 2).
+materialize(root, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+equation(eq1, 1.0, -5.0, 6.0).
+equation(eq2, 2.0, -4.0, -6.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+discriminant(Case, D) :-
+  equation(Case, A, B, C),
+  pow(B, 2.0, B2),
+  mul(4.0, A, FourA),
+  mul(FourA, C, FourAC),
+  sub(B2, FourAC, D).
+
+sqrt_discriminant(Case, S) :-
+  discriminant(Case, D),
+  ge(D, 0.0),
+  pow(D, 0.5, S).
+
+negative_b(Case, NB) :-
+  equation(Case, _A, B, _C),
+  neg(B, NB).
+
+denominator(Case, Den) :-
+  equation(Case, A, _B, _C),
+  mul(2.0, A, Den).
+
+root_plus(Case, Root) :-
+  negative_b(Case, NB),
+  sqrt_discriminant(Case, S),
+  denominator(Case, Den),
+  add(NB, S, Numerator),
+  div(Numerator, Den, Root).
+
+root_minus(Case, Root) :-
+  negative_b(Case, NB),
+  sqrt_discriminant(Case, S),
+  denominator(Case, Den),
+  sub(NB, S, Numerator),
+  div(Numerator, Den, Root).
+
+
+root(Case, Root) :-
+  root_plus(Case, Root).
+
+root(Case, Root) :-
+  root_minus(Case, Root).

package/examples/eyelang/quine-mccluskey.pl

@@ -0,0 +1,143 @@
+% Eyelet-inspired Quine-McCluskey minimization using findall/3 and sort/2.
+% Problem: f(A,B,C,D) = Sigma m(1,3,7,11,15) + d(0,2,5).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(primeImplicants, 2).
+materialize(minimalCover, 2).
+materialize(equation, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+minterm(1).
+minterm(3).
+minterm(7).
+minterm(11).
+minterm(15).
+
+dont_care(0).
+dont_care(2).
+dont_care(5).
+
+bits(0, [0, 0, 0, 0]).
+bits(1, [0, 0, 0, 1]).
+bits(2, [0, 0, 1, 0]).
+bits(3, [0, 0, 1, 1]).
+bits(4, [0, 1, 0, 0]).
+bits(5, [0, 1, 0, 1]).
+bits(6, [0, 1, 1, 0]).
+bits(7, [0, 1, 1, 1]).
+bits(8, [1, 0, 0, 0]).
+bits(9, [1, 0, 0, 1]).
+bits(10, [1, 0, 1, 0]).
+bits(11, [1, 0, 1, 1]).
+bits(12, [1, 1, 0, 0]).
+bits(13, [1, 1, 0, 1]).
+bits(14, [1, 1, 1, 0]).
+bits(15, [1, 1, 1, 1]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+initial_pattern(P) :- minterm(M), bits(M, P).
+initial_pattern(P) :- dont_care(D), bits(D, P).
+
+combine(A, B, R) :-
+  diff_count(A, B, 0, 1, [], Rev),
+  reverse(Rev, R).
+
+diff_count([], [], Count, Count, Acc, Acc).
+diff_count([X | A], [X | B], Count, Max, Acc, R) :-
+  diff_count(A, B, Count, Max, [X | Acc], R).
+diff_count([X | A], [Y | B], Count, Max, Acc, R) :-
+  neq(X, Y),
+  add(Count, 1, Next),
+  le(Next, Max),
+  diff_count(A, B, Next, Max, [x | Acc], R).
+
+combined_once(P) :-
+  initial_pattern(A),
+  initial_pattern(B),
+  combine(A, B, P).
+
+combined_twice(P) :-
+  combined_once(A),
+  combined_once(B),
+  combine(A, B, P).
+
+used_initial(P) :-
+  initial_pattern(Q),
+  combine(P, Q, _R).
+
+used_once(P) :-
+  combined_once(Q),
+  combine(P, Q, _R).
+
+prime(P) :-
+  initial_pattern(P),
+  not(used_initial(P)).
+prime(P) :-
+  combined_once(P),
+  not(used_once(P)).
+prime(P) :-
+  combined_twice(P).
+
+prime_implicants(Primes) :-
+  minterms(Minterms),
+  dont_cares(DontCares),
+  bit_table(Bits),
+  qm_prime_implicants(Minterms, DontCares, Bits, Primes).
+
+covers([], []).
+covers([x | Pattern], [_Bit | Bits]) :-
+  covers(Pattern, Bits).
+covers([Bit | Pattern], [Bit | Bits]) :-
+  neq(Bit, x),
+  covers(Pattern, Bits).
+
+covers_int(Pattern, Int) :-
+  bits(Int, Bits),
+  covers(Pattern, Bits).
+
+covers_all(_Cover, []).
+covers_all(Cover, [M | Minterms]) :-
+  member(P, Cover),
+  covers_int(P, M),
+  covers_all(Cover, Minterms).
+
+minterms(Minterms) :-
+  findall(M, minterm(M), Raw),
+  sort(Raw, Minterms).
+
+dont_cares(DontCares) :-
+  findall(D, dont_care(D), Raw),
+  sort(Raw, DontCares).
+
+bit_table(Bits) :-
+  findall(bit(N, Pattern), bits(N, Pattern), Bits).
+
+pair_from([A | Rest], A, B) :-
+  member(B, Rest).
+pair_from([_Head | Rest], A, B) :-
+  pair_from(Rest, A, B).
+
+cover_candidate(Cover) :-
+  prime_implicants(Primes),
+  pair_from(Primes, A, B),
+  sort([A, B], Cover),
+  minterms(Minterms),
+  covers_all(Cover, Minterms).
+
+minimal_cover(Cover) :-
+  minterms(Minterms),
+  dont_cares(DontCares),
+  bit_table(Bits),
+  qm_minimal_cover(Minterms, DontCares, Bits, Cover).
+
+primeImplicants(quine_mccluskey, Primes) :-
+  prime_implicants(Primes).
+
+minimalCover(quine_mccluskey, Cover) :-
+  minimal_cover(Cover).
+
+equation(quine_mccluskey, "f = ~A~B + CD") :-
+  minimal_cover([[0, 0, x, x], [x, x, 1, 1]]).
+
+reason(quine_mccluskey, "findall builds implicant sets and sort removes duplicates before cover selection").

package/examples/eyelang/radioactive-decay.pl

@@ -0,0 +1,56 @@
+% Science example: radioactive decay.
+%
+% Activity remaining after elapsed time is initial_activity * 0.5^(t/half_life).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(halfLivesElapsed, 2).
+materialize(remainingActivity_Bq, 2).
+materialize(decayedActivity_Bq, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+sample(iodine_sample, initial_activity_bq, 80.0).
+sample(iodine_sample, half_life_h, 8.0).
+sample(iodine_sample, elapsed_h, 16.0).
+threshold(iodine_sample, low_activity_bq, 25.0).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+half_lives(Sample, Count) :-
+  sample(Sample, elapsed_h, Elapsed),
+  sample(Sample, half_life_h, HalfLife),
+  div(Elapsed, HalfLife, Count).
+
+remaining_fraction(Sample, Fraction) :-
+  half_lives(Sample, Count),
+  pow(0.5, Count, Fraction).
+
+remaining_activity(Sample, Remaining) :-
+  sample(Sample, initial_activity_bq, Initial),
+  remaining_fraction(Sample, Fraction),
+  mul(Initial, Fraction, Remaining).
+
+decayed_activity(Sample, Decayed) :-
+  sample(Sample, initial_activity_bq, Initial),
+  remaining_activity(Sample, Remaining),
+  sub(Initial, Remaining, Decayed).
+
+low_activity(Sample) :-
+  remaining_activity(Sample, Remaining),
+  threshold(Sample, low_activity_bq, Limit),
+  lt(Remaining, Limit).
+
+halfLivesElapsed(Sample, Count) :-
+  half_lives(Sample, Count).
+
+remainingActivity_Bq(Sample, Remaining) :-
+  remaining_activity(Sample, Remaining).
+
+decayedActivity_Bq(Sample, Decayed) :-
+  decayed_activity(Sample, Decayed).
+
+status(Sample, low_activity) :-
+  low_activity(Sample).
+
+reason(Sample, "two half-lives leave one quarter of the initial activity") :-
+  low_activity(Sample).