eyeling 1.34.4 → 1.34.6

package/examples/eyelang/context-association.pl

@@ -1,53 +0,0 @@
-% 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(ContextName, Subject, Predicate, Object) :-
-  log_nameOf(ContextName, Context),
-  holds(Context, Predicate, [Subject, 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/context-schema-audit.pl

@@ -1,46 +0,0 @@
-% Context schema audit.
-%
-% This example needs holds/3 rather than holds/2 because the audit rule does
-% not know the predicate names or arities in advance.  It inspects a whole
-% context as data, extracts each member as Name + Args, computes the arity, and
-% checks that shape against an allowed schema.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(context_shape, 3).
-materialize(schema_violation, 3).
-
-% Program structure: each message carries heterogeneous context data.  The
-% members deliberately use different arities: heartbeat/0, source/1,
-% temperature/2, gps/3, and signature/4.
-message_context(msg_ok, (
-  heartbeat,
-  source(sensor17),
-  temperature(sensor17, 38),
-  gps(sensor17, 51, 4),
-  signature(sensor17, sha256, "9f86d081", "2026-06-18T09:30:00Z")
-)).
-
-message_context(msg_bad, (
-  heartbeat,
-  source(sensor18),
-  temperature(sensor18, 99),
-  gps(sensor18, 51),
-  tampered(sensor18)
-)).
-
-allowed_shape(heartbeat, 0).
-allowed_shape(source, 1).
-allowed_shape(temperature, 2).
-allowed_shape(gps, 3).
-allowed_shape(signature, 4).
-
-% Derivation rules: holds/3 exposes arbitrary context members as predicate name
-% plus argument list, so one generic rule can audit mixed-arity data.
-context_shape(Message, Name, Arity) :-
-  message_context(Message, Context),
-  holds(Context, Name, Args),
-  length(Args, Arity).
-
-schema_violation(Message, Name, Arity) :-
-  context_shape(Message, Name, Arity),
-  not(allowed_shape(Name, Arity)).

package/examples/eyelang/control-system.pl

@@ -1,72 +0,0 @@
-% 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/cyclic-path.pl

@@ -1,16 +0,0 @@
-% 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

@@ -1,100 +0,0 @@
-% 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

@@ -1,65 +0,0 @@
-% 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

@@ -1,39 +0,0 @@
-% 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

@@ -1,115 +0,0 @@
-% =============================================================================================================================
-% 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)).