eyeling 1.32.0 → 1.33.0

package/examples/eyelang/composition-of-injective-functions-is-injective.pl

@@ -0,0 +1,50 @@
+% Composition of injective functions is injective, adapted from Eyeling's
+% examples/composition-of-injective-functions-is-injective.n3.
+%
+% The output mirrors the Eyeling golden result shape:
+% sameInputByCompositeInjectivity(h, a, b) and the symmetric counterpart.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(sameInputByCompositeInjectivity, 3).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+inX(a).
+inX(b).
+inY(c).
+inY(d).
+inZ(e).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+sameTerm(X, X) :- inX(X).
+sameTerm(X, X) :- inY(X).
+sameTerm(X, X) :- inZ(X).
+sameTerm(Y, X) :- sameTerm(X, Y).
+
+app(f, a, c).
+app(f, b, d).
+app(g, c, e).
+app(g, d, e).
+
+injective(f).
+injective(g).
+compositeOf(h, g, f).
+
+app(H, X, Z) :-
+  compositeOf(H, G, F),
+  app(F, X, Y),
+  app(G, Y, Z).
+
+sameTerm(X, Y) :-
+  injective(F),
+  app(F, X, U),
+  app(F, Y, V),
+  sameTerm(U, V).
+
+sameInputByCompositeInjectivity(H, X, Y) :-
+  compositeOf(H, G, F),
+  injective(G),
+  injective(F),
+  app(H, X, Z),
+  app(H, Y, Z),
+  sameTerm(X, Y),
+  neq(X, Y).

package/examples/eyelang/context-association.pl

@@ -0,0 +1,53 @@
+% Context association adapted from Eyeling context-association.n3.
+%
+% This version keeps the original shape: each context is named with log_nameOf
+% and its contents remain quoted formula data.  Nothing inside the three formulae
+% is asserted globally unless a rule explicitly projects it.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(log_nameOf, 2).
+materialize(dataGraph, 2).
+materialize(signatureGraph, 2).
+materialize(metadataGraph, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+log_nameOf(skolem_g0, foaf_name(bob, "Bob")).
+
+log_nameOf(skolem_g1, (
+  sec_proof(skolem_g0, dataSignature),
+  type(signature1, sec_DataIntegrityProof),
+  sec_cryptosuite(signature1, "ecdsa-proof-2019"),
+  sec_created(signature1, "2021-11-13T18:19:39Z"),
+  sec_verificationMethod(signature1, "https://university.example/issuers/14#key-1"),
+  sec_proofPurpose(signature1, "assertionMethod"),
+  sec_proofValue(signature1, "z58DAdFfa9SkqZMVPxAQp...jQCrfFPP2oumHKtz"),
+  sec_issuer(signature1, university),
+  sec_validFrom(signature1, "2024-04-03T00:00:00.000Z"),
+  sec_validUntil(signature1, "2025-04-03T00:00:00.000Z")
+)).
+
+log_nameOf(g3, (
+  sec_proof(skolem_g1, signature2),
+  type(signature2, sec_DataIntegrityProof),
+  sec_cryptosuite(signature2, "ecdsa-proof-2019"),
+  sec_created(signature2, "2021-11-13T18:19:39Z"),
+  sec_verificationMethod(signature2, "https://university.example/issuers/14#key-1"),
+  sec_proofPurpose(signature2, "assertionMethod"),
+  sec_proofValue(signature2, "adad123efv434r5200...dqed2t44v43das")
+)).
+
+% A tiny projection shows how a program can inspect a quoted context without
+% making the entire context globally true.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+context_statement(Context, Subject, Predicate, Object) :-
+  log_nameOf(Context, Formula),
+  formula_binary(Formula, Subject, Predicate, Object).
+
+dataGraph(association, skolem_g0) :-
+  context_statement(skolem_g0, bob, foaf_name, "Bob").
+
+signatureGraph(association, skolem_g1) :-
+  context_statement(skolem_g1, skolem_g0, sec_proof, dataSignature).
+
+metadataGraph(association, g3) :-
+  context_statement(g3, skolem_g1, sec_proof, signature2).

package/examples/eyelang/control-system.pl

@@ -0,0 +1,72 @@
+% Control Systems example, adapted from Eyelet's input/control-system.pl.
+%
+% The example combines measurements, observations, targets, logarithmic
+% feedforward compensation, square-root normalization, and nonlinear feedback.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(controlSignal, 2).
+materialize(status, 2).
+materialize(normalizedMeasurement, 2).
+materialize(log10, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+measurement(input1, [6, 11]).
+measurement(disturbance2, [45, 39]).
+measurement(input2, true).
+measurement(input3, 56967).
+measurement(disturbance1, 35766).
+measurement(output2, 24).
+
+observation(state1, 80).
+observation(state2, false).
+observation(state3, 22).
+
+target(output2, 29).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+measurement_normalized(I, M) :-
+  measurement(I, [M1, M2]),
+  lt(M1, M2),
+  sub(M2, M1, Delta),
+  pow(Delta, 0.5, M).
+
+measurement_normalized(I, M1) :-
+  measurement(I, [M1, M2]),
+  ge(M1, M2).
+
+log10(Value, Result) :-
+  log(Value, NaturalLog),
+  log(10, NaturalLog10),
+  div(NaturalLog, NaturalLog10, Result).
+
+control(actuator1, C) :-
+  measurement_normalized(input1, M1),
+  measurement(input2, true),
+  measurement(disturbance1, D1),
+  mul(M1, 19.6, Proportional),
+  log10(D1, Compensation),
+  sub(Proportional, Compensation, C).
+
+control(actuator2, C) :-
+  observation(state3, P3),
+  measurement(output2, M4),
+  target(output2, T2),
+  sub(T2, M4, Error),
+  sub(P3, M4, DifferentialError),
+  mul(5.8, Error, Proportional),
+  div(7.3, Error, NonlinearFactor),
+  mul(NonlinearFactor, DifferentialError, Differential),
+  add(Proportional, Differential, C).
+
+controlSignal(Actuator, C) :-
+  control(Actuator, C).
+
+status(Actuator, active) :-
+  control(Actuator, _C).
+
+normalizedMeasurement(input1, M) :-
+  measurement_normalized(input1, M).
+
+log10(disturbance1, C) :-
+  measurement(disturbance1, D),
+  log10(D, C).

package/examples/eyelang/cryptarithmetic-send-more-money.pl

@@ -0,0 +1,49 @@
+% Cryptarithmetic without cut.
+%
+% Two column-pruned puzzles are included.  SEND + MORE = MONEY is the classic
+% eight-letter puzzle, and DONALD + GERALD = ROBERT uses all ten digits across
+% a six-column addition.  Each column constraint is applied as soon as possible
+% so the finite digit search prunes early without cut.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(status, 2).
+materialize(assignment, 2).
+materialize(equation, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+send_more_money(solution(S, E, N, D, M, O, R, Y), Send, More, Money) :-
+  alphametic_sum(
+    [s, e, n, d, m, o, r, y],
+    [[s, e, n, d], [m, o, r, e]],
+    [m, o, n, e, y],
+    [S, E, N, D, M, O, R, Y],
+    [Send, More, Money]
+  ).
+
+donald_gerald_robert(solution(D, O, N, A, L, G, E, R, B, T), Donald, Gerald, Robert) :-
+  alphametic_sum(
+    [d, o, n, a, l, g, e, r, b, t],
+    [[d, o, n, a, l, d], [g, e, r, a, l, d]],
+    [r, o, b, e, r, t],
+    [D, O, N, A, L, G, E, R, B, T],
+    [Donald, Gerald, Robert]
+  ).
+
+status(send_more_money, solved) :-
+  once(send_more_money(_Solution, _Send, _More, _Money)).
+
+assignment(send_more_money, Solution) :-
+  once(send_more_money(Solution, _Send, _More, _Money)).
+
+equation(send_more_money, plus(Send, More, Money)) :-
+  once(send_more_money(_Solution, Send, More, Money)).
+
+status(donald_gerald_robert, solved) :-
+  once(donald_gerald_robert(_Solution, _Donald, _Gerald, _Robert)).
+
+assignment(donald_gerald_robert, Solution) :-
+  once(donald_gerald_robert(Solution, _Donald, _Gerald, _Robert)).
+
+equation(donald_gerald_robert, plus(Donald, Gerald, Robert)) :-
+  once(donald_gerald_robert(_Solution, Donald, Gerald, Robert)).

package/examples/eyelang/cyclic-path.pl

@@ -0,0 +1,16 @@
+% Cyclic transitive closure. The graph contains a directed cycle, but eyelang's
+% variant loop guard prevents recursive proof search from revisiting the same
+% active subgoal forever.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(path, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+arc(a, b).
+arc(b, c).
+arc(c, d).
+arc(d, a).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+path(X, Y) :- arc(X, Y).
+path(X, Z) :- arc(X, Y), path(Y, Z).

package/examples/eyelang/d3-group.pl

@@ -0,0 +1,100 @@
+% Eyelet-inspired D3 group example using findall/3 and sort/2.
+% It enumerates subgroups of the dihedral group of order 6.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(subgroups, 2).
+materialize(subgroupCount, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Six symmetries of an equilateral triangle: identity, rotations, reflections.
+symmetry(identity).
+symmetry(rotation_120).
+symmetry(rotation_240).
+symmetry(reflection_a).
+symmetry(reflection_b).
+symmetry(reflection_c).
+
+% Cayley table for D3 composition.
+compose(identity, identity, identity).
+compose(identity, rotation_120, rotation_120).
+compose(identity, rotation_240, rotation_240).
+compose(identity, reflection_a, reflection_a).
+compose(identity, reflection_b, reflection_b).
+compose(identity, reflection_c, reflection_c).
+compose(rotation_120, identity, rotation_120).
+compose(rotation_120, rotation_120, rotation_240).
+compose(rotation_120, rotation_240, identity).
+compose(rotation_120, reflection_a, reflection_b).
+compose(rotation_120, reflection_b, reflection_c).
+compose(rotation_120, reflection_c, reflection_a).
+compose(rotation_240, identity, rotation_240).
+compose(rotation_240, rotation_120, identity).
+compose(rotation_240, rotation_240, rotation_120).
+compose(rotation_240, reflection_a, reflection_c).
+compose(rotation_240, reflection_b, reflection_a).
+compose(rotation_240, reflection_c, reflection_b).
+compose(reflection_a, identity, reflection_a).
+compose(reflection_a, rotation_120, reflection_c).
+compose(reflection_a, rotation_240, reflection_b).
+compose(reflection_a, reflection_a, identity).
+compose(reflection_a, reflection_b, rotation_240).
+compose(reflection_a, reflection_c, rotation_120).
+compose(reflection_b, identity, reflection_b).
+compose(reflection_b, rotation_120, reflection_a).
+compose(reflection_b, rotation_240, reflection_c).
+compose(reflection_b, reflection_a, rotation_120).
+compose(reflection_b, reflection_b, identity).
+compose(reflection_b, reflection_c, rotation_240).
+compose(reflection_c, identity, reflection_c).
+compose(reflection_c, rotation_120, reflection_b).
+compose(reflection_c, rotation_240, reflection_a).
+compose(reflection_c, reflection_a, rotation_240).
+compose(reflection_c, reflection_b, rotation_120).
+compose(reflection_c, reflection_c, identity).
+% Each candidate subgroup must also contain inverses.
+inverse(identity, identity).
+inverse(rotation_120, rotation_240).
+inverse(rotation_240, rotation_120).
+inverse(reflection_a, reflection_a).
+inverse(reflection_b, reflection_b).
+inverse(reflection_c, reflection_c).
+
+% Candidate subsets are generated as subsequences of the sorted symmetry list.
+subsequence([], []).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+subsequence([Head | Tail], [Head | Rest]) :-
+  subsequence(Tail, Rest).
+subsequence([_Head | Tail], Rest) :-
+  subsequence(Tail, Rest).
+
+all_symmetries(Symmetries) :-
+  findall(X, symmetry(X), Raw),
+  sort(Raw, Symmetries).
+
+% A valid subgroup is closed under both composition and inverse.
+closed_under_composition(Group) :-
+  not((member(X, Group), member(Y, Group), compose(X, Y, Z), not(member(Z, Group)))).
+
+closed_under_inverse(Group) :-
+  not((member(X, Group), inverse(X, Y), not(member(Y, Group)))).
+
+valid_group(Group) :-
+  all_symmetries(All),
+  subsequence(All, Group),
+  member(identity, Group),
+  closed_under_composition(Group),
+  closed_under_inverse(Group).
+
+all_subgroups(Groups) :-
+  findall(G, valid_group(G), Raw),
+  sort(Raw, Groups).
+
+subgroups(d3_group, Groups) :-
+  all_subgroups(Groups).
+
+subgroupCount(d3_group, Count) :-
+  all_subgroups(Groups),
+  length(Groups, Count).
+
+reason(d3_group, "findall enumerates candidate subgroups and sort gives canonical subgroup order").

package/examples/eyelang/dairy-energy-balance.pl

@@ -0,0 +1,65 @@
+% EYE-inspired dairy energy balance case study.
+% Cows are classified from maintenance, milk requirement, and ration supply.
+
+% cow(Cow, BodyWeightKg, MilkKgPerDay, RationEnergyMcalPerKgDM, IntakeKgDM).
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(energyBalance_Mcal, 2).
+materialize(rationSupportedMilk_kg, 2).
+materialize(status, 2).
+materialize(reason, 2).
+materialize(strongestDeficit, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+cow(early_lactation, 650, 38, 6.4, 22).
+cow(mid_lactation, 610, 24, 6.5, 26).
+cow(late_lactation, 580, 16, 6.7, 25).
+cow(grazing, 540, 18, 5.8, 21).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+maintenance(C, M) :-
+  cow(C, Weight, _, _, _),
+  mul(Weight, 0.08, M).
+
+milk_requirement(C, R) :-
+  cow(C, _, Milk, _, _),
+  mul(Milk, 5.0, R).
+
+ration_supply(C, S) :-
+  cow(C, _, _, Density, Intake),
+  mul(Density, Intake, S).
+
+total_requirement(C, R) :-
+  maintenance(C, M),
+  milk_requirement(C, MilkR),
+  add(M, MilkR, R).
+
+energy_balance(C, B) :-
+  ration_supply(C, S),
+  total_requirement(C, R),
+  sub(S, R, B).
+
+ration_supported_milk(C, Milk) :-
+  ration_supply(C, S),
+  maintenance(C, M),
+  sub(S, M, AvailableForMilk),
+  div(AvailableForMilk, 5.0, Milk).
+
+status(C, negative_energy_balance) :-
+  energy_balance(C, B),
+  lt(B, -5.0).
+
+status(C, near_neutral_energy_balance) :-
+  energy_balance(C, B),
+  ge(B, -5.0),
+  le(B, 5.0).
+
+status(C, positive_energy_balance) :-
+  energy_balance(C, B),
+  gt(B, 5.0).
+
+energyBalance_Mcal(C, B) :- energy_balance(C, B).
+rationSupportedMilk_kg(C, M) :- ration_supported_milk(C, M).
+reason(dairy_energy_balance, "ration supply minus maintenance and milk energy requirement determines the class").
+strongestDeficit(dairy_energy_balance, early_lactation) :-
+  status(early_lactation, negative_energy_balance),
+  status(late_lactation, positive_energy_balance).

package/examples/eyelang/data-negotiation.pl

@@ -0,0 +1,39 @@
+% Data negotiation with policies, adapted from Eyelet input/data-negotiation.pl.
+% The accepted negotiation matches Eyelet output-swipl/data-negotiation.pl.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(negotiate, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Each agent has local data, desired remote data, and a simple policy.
+hasData(agent1, [data1, data2, data3]).
+hasData(agent2, [data4, data5, data6]).
+
+want_negotiate(agent1, [agent2, data4]).
+want_negotiate(agent1, [agent2, data5]).
+want_negotiate(agent1, [agent2, data7]).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+policy(agent1, [request, Data]) :-
+  member(Data, [data4, data6]).
+policy(agent2, [accept, Data]) :-
+  neq(Data, data5).
+
+% A request is possible only if A lacks the data and A's policy allows asking for it.
+request_data(AgentA, AgentB, Data) :-
+  hasData(AgentA, DataListA),
+  hasData(AgentB, DataListB),
+  member(Data, DataListB),
+  not_member(Data, DataListA),
+  policy(AgentA, [request, Data]).
+
+% B accepts only requests for data it has and its own policy permits sharing.
+accept_request(AgentB, _AgentA, Data) :-
+  hasData(AgentB, DataListB),
+  member(Data, DataListB),
+  policy(AgentB, [accept, Data]).
+
+negotiate(AgentA, [AgentB, Data]) :-
+  want_negotiate(AgentA, [AgentB, Data]),
+  request_data(AgentA, AgentB, Data),
+  accept_request(AgentB, AgentA, Data).

package/examples/eyelang/deep-taxonomy-10.pl

@@ -0,0 +1,115 @@
+% =============================================================================================================================
+% Deep Taxonomy - depth 10 - expanded N3-style eyelang with checkpoint proof accelerators
+%
+% Adjacent rules mirror the Eyeling N3 deep-taxonomy chain. The checkpoint
+% rules are redundant consequences of that chain and are placed first so eyelang
+% can prove terminal/report goals without overflowing the JavaScript call stack.
+% Report/check rules use once/1 so successful checks do not backtrack into a
+% long adjacent-only proof after a shorter checkpoint proof has succeeded.
+% =============================================================================================================================
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(is, 2).
+materialize(answer, 2).
+materialize(reason, 2).
+materialize(result, 2).
+materialize(checkPassed, 2).
+materialize(arc, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% fact
+
+a(ind, n0).
+
+% terminal rule
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+is(test, true) :- once(a(ind, a2)).
+a(X, a2) :- a(X, n10).
+
+% Redundant checkpoint accelerators.
+
+a(X, n10) :- a(X, n0).
+a(X, n4) :- a(X, n0).
+a(X, n9) :- a(X, n0).
+
+% Adjacent N3-style taxonomy rules.
+
+a(X, n1) :- a(X, n0).
+a(X, i1) :- a(X, n0).
+a(X, j1) :- a(X, n0).
+a(X, n2) :- a(X, n1).
+a(X, i2) :- a(X, n1).
+a(X, j2) :- a(X, n1).
+a(X, n3) :- a(X, n2).
+a(X, i3) :- a(X, n2).
+a(X, j3) :- a(X, n2).
+a(X, n4) :- a(X, n3).
+a(X, i4) :- a(X, n3).
+a(X, j4) :- a(X, n3).
+a(X, n5) :- a(X, n4).
+a(X, i5) :- a(X, n4).
+a(X, j5) :- a(X, n4).
+a(X, n6) :- a(X, n5).
+a(X, i6) :- a(X, n5).
+a(X, j6) :- a(X, n5).
+a(X, n7) :- a(X, n6).
+a(X, i7) :- a(X, n6).
+a(X, j7) :- a(X, n6).
+a(X, n8) :- a(X, n7).
+a(X, i8) :- a(X, n7).
+a(X, j8) :- a(X, n7).
+a(X, n9) :- a(X, n8).
+a(X, i9) :- a(X, n8).
+a(X, j9) :- a(X, n8).
+a(X, n10) :- a(X, n9).
+a(X, i10) :- a(X, n9).
+a(X, j10) :- a(X, n9).
+
+% ARC checks
+
+arc(check1, "C1 OK - the starting classification n0 is present.") :-
+ once(a(ind, n0)).
+
+arc(check2, "C2 OK - the first expansion produced n1 together with side labels i1 and j1.") :-
+ once(a(ind, n1)),
+ once(a(ind, i1)),
+ once(a(ind, j1)).
+
+arc(check3, "C3 OK - the chain reaches the midpoint n5 and still carries both side-label branches.") :-
+ once(a(ind, n5)),
+ once(a(ind, i5)),
+ once(a(ind, j5)).
+
+arc(check4, "C4 OK - the final taxonomy step from n9 to n10 was completed.") :-
+ once(a(ind, n9)),
+ once(a(ind, n10)).
+
+arc(check5, "C5 OK - once n10 is reached, the terminal class a2 is derived.") :-
+ once(a(ind, n10)),
+ once(a(ind, a2)).
+
+arc(check6, "C6 OK - the success flag is raised only after the terminal class a2 is present.") :-
+ once(a(ind, a2)),
+ once(is(test, true)).
+
+% ARC report
+
+answer(report, "The test succeeds: starting from one individual classified as n0, the rules eventually classify it as n10 and then as a2.") :-
+ once(is(test, true)).
+
+reason(report, "The adjacent rules mirror the Eyeling N3 deep-taxonomy-10 chain. Redundant checkpoint rules are included only as proof accelerators: each shortcut is entailed by the adjacent chain, and once/1 prevents backtracking into the long adjacent-only proof after a check has succeeded.") :-
+ once(a(ind, a2)),
+ once(is(test, true)).
+
+checkPassed(report, Check) :-
+ arc(Check, _Message).
+
+result(report, success) :-
+ once(is(test, true)),
+ once(arc(check1, _C1)),
+ once(arc(check2, _C2)),
+ once(arc(check3, _C3)),
+ once(arc(check4, _C4)),
+ once(arc(check5, _C5)),
+ once(arc(check6, _C6)).