eyeling 1.32.0 → 1.33.0

package/examples/eyelang/dijkstra.pl

@@ -0,0 +1,46 @@
+% Weighted path enumeration adapted from Eyeling dijkstra.n3.
+% The Eyeling source uses collect/sort built-ins for Dijkstra's queue.
+% This eyelang variant enumerates simple paths and keeps the bounded frontier
+% that appears in the Eyeling output for a -> f.
+% The input weighted graph is quoted as ... data and projected locally,
+% so the route network is not asserted as ambient edge facts.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(edge, 2).
+materialize(path, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+weighted_graph(dijkstraGraph, (
+  edge(a, arc(b, 4)),
+  edge(a, arc(c, 2)),
+  edge(b, arc(c, 1)),
+  edge(b, arc(d, 5)),
+  edge(c, arc(d, 8)),
+  edge(c, arc(e, 10)),
+  edge(d, arc(e, 2)),
+  edge(d, arc(f, 6)),
+  edge(e, arc(f, 3))
+)).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+base_link(A, B, Cost) :-
+  weighted_graph(dijkstraGraph, Formula),
+  formula_binary(Formula, A, edge, arc(B, Cost)).
+
+link(A, B, Cost) :- base_link(A, B, Cost).
+link(B, A, Cost) :- base_link(A, B, Cost).
+
+path(Goal, Goal, _Visited, [Goal], 0).
+path(Node, Goal, Visited, [Node|Path], Cost) :-
+  link(Node, Next, StepCost),
+  not_member(Next, Visited),
+  path(Next, Goal, [Next|Visited], Path, RestCost),
+  add(StepCost, RestCost, Cost).
+
+% Derived reverse links, mirroring the rule output in the Eyeling example.
+edge([B, A], Cost) :-
+  base_link(A, B, Cost).
+
+path([a, f], [Path, Cost]) :-
+  path(a, f, [a], Path, Cost),
+  le(Cost, 16).

package/examples/eyelang/dining-philosophers.pl

@@ -0,0 +1,140 @@
+% Chandy-Misra dining philosophers trace adapted from Eyeling dining-philosophers.n3.
+% Requests and sends are derived; KeepFork facts copy forks that are not sent.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(dp_type, 2).
+materialize(dp_in, 2).
+materialize(dp_from, 2).
+materialize(dp_to, 2).
+materialize(dp_fork, 2).
+materialize(dp_philosopher, 2).
+materialize(dp_mealNo, 2).
+materialize(dp_inSlot, 2).
+materialize(dp_usesFork, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+left_fork(dp_P1, dp_F51). right_fork(dp_P1, dp_F12).
+left_fork(dp_P2, dp_F12). right_fork(dp_P2, dp_F23).
+left_fork(dp_P3, dp_F23). right_fork(dp_P3, dp_F34).
+left_fork(dp_P4, dp_F34). right_fork(dp_P4, dp_F45).
+left_fork(dp_P5, dp_F45). right_fork(dp_P5, dp_F51).
+
+slot(dp_C0, dp_s1, 1). after_sends(dp_C0, dp_C1). after_eat(dp_C1, dp_C2).
+slot(dp_C2, dp_s2, 1). after_sends(dp_C2, dp_C3). after_eat(dp_C3, dp_C4).
+slot(dp_C4, dp_s3, 1). after_sends(dp_C4, dp_C5). after_eat(dp_C5, dp_C6).
+slot(dp_C6, dp_s4, 2). after_sends(dp_C6, dp_C7). after_eat(dp_C7, dp_C8).
+slot(dp_C8, dp_s5, 2). after_sends(dp_C8, dp_C9). after_eat(dp_C9, dp_C10).
+slot(dp_C10, dp_s6, 2). after_sends(dp_C10, dp_C11). after_eat(dp_C11, dp_C12).
+slot(dp_C12, dp_s7, 3). after_sends(dp_C12, dp_C13). after_eat(dp_C13, dp_C14).
+slot(dp_C14, dp_s8, 3). after_sends(dp_C14, dp_C15). after_eat(dp_C15, dp_C16).
+slot(dp_C16, dp_s9, 3). after_sends(dp_C16, dp_C17). after_eat(dp_C17, dp_C18).
+
+hungry(dp_C0, dp_P1). hungry(dp_C0, dp_P3).
+hungry(dp_C2, dp_P2). hungry(dp_C2, dp_P4).
+hungry(dp_C4, dp_P5).
+hungry(dp_C6, dp_P1). hungry(dp_C6, dp_P3).
+hungry(dp_C8, dp_P2). hungry(dp_C8, dp_P4).
+hungry(dp_C10, dp_P5).
+hungry(dp_C12, dp_P1). hungry(dp_C12, dp_P3).
+hungry(dp_C14, dp_P2). hungry(dp_C14, dp_P4).
+hungry(dp_C16, dp_P5).
+
+start_state(dp_C0, dp_F12, dp_P1, dp_Dirty).
+start_state(dp_C0, dp_F23, dp_P2, dp_Dirty).
+start_state(dp_C0, dp_F34, dp_P3, dp_Dirty).
+start_state(dp_C0, dp_F45, dp_P4, dp_Dirty).
+start_state(dp_C0, dp_F51, dp_P1, dp_Dirty).
+start_state(dp_C2, dp_F12, dp_P1, dp_Dirty).
+start_state(dp_C2, dp_F23, dp_P3, dp_Dirty).
+start_state(dp_C2, dp_F34, dp_P3, dp_Dirty).
+start_state(dp_C2, dp_F45, dp_P4, dp_Dirty).
+start_state(dp_C2, dp_F51, dp_P1, dp_Dirty).
+start_state(dp_C4, dp_F12, dp_P2, dp_Dirty).
+start_state(dp_C4, dp_F23, dp_P2, dp_Dirty).
+start_state(dp_C4, dp_F34, dp_P4, dp_Dirty).
+start_state(dp_C4, dp_F45, dp_P4, dp_Dirty).
+start_state(dp_C4, dp_F51, dp_P1, dp_Dirty).
+start_state(dp_C6, dp_F12, dp_P2, dp_Dirty).
+start_state(dp_C6, dp_F23, dp_P2, dp_Dirty).
+start_state(dp_C6, dp_F34, dp_P4, dp_Dirty).
+start_state(dp_C6, dp_F45, dp_P5, dp_Dirty).
+start_state(dp_C6, dp_F51, dp_P5, dp_Dirty).
+start_state(dp_C8, dp_F12, dp_P1, dp_Dirty).
+start_state(dp_C8, dp_F23, dp_P3, dp_Dirty).
+start_state(dp_C8, dp_F34, dp_P3, dp_Dirty).
+start_state(dp_C8, dp_F45, dp_P5, dp_Dirty).
+start_state(dp_C8, dp_F51, dp_P1, dp_Dirty).
+start_state(dp_C10, dp_F12, dp_P2, dp_Dirty).
+start_state(dp_C10, dp_F23, dp_P2, dp_Dirty).
+start_state(dp_C10, dp_F34, dp_P4, dp_Dirty).
+start_state(dp_C10, dp_F45, dp_P4, dp_Dirty).
+start_state(dp_C10, dp_F51, dp_P1, dp_Dirty).
+start_state(dp_C12, dp_F12, dp_P2, dp_Dirty).
+start_state(dp_C12, dp_F23, dp_P2, dp_Dirty).
+start_state(dp_C12, dp_F34, dp_P4, dp_Dirty).
+start_state(dp_C12, dp_F45, dp_P5, dp_Dirty).
+start_state(dp_C12, dp_F51, dp_P5, dp_Dirty).
+start_state(dp_C14, dp_F12, dp_P1, dp_Dirty).
+start_state(dp_C14, dp_F23, dp_P3, dp_Dirty).
+start_state(dp_C14, dp_F34, dp_P3, dp_Dirty).
+start_state(dp_C14, dp_F45, dp_P5, dp_Dirty).
+start_state(dp_C14, dp_F51, dp_P1, dp_Dirty).
+start_state(dp_C16, dp_F12, dp_P2, dp_Dirty).
+start_state(dp_C16, dp_F23, dp_P2, dp_Dirty).
+start_state(dp_C16, dp_F34, dp_P4, dp_Dirty).
+start_state(dp_C16, dp_F45, dp_P4, dp_Dirty).
+start_state(dp_C16, dp_F51, dp_P1, dp_Dirty).
+keep(dp_C0, dp_F12). keep(dp_C0, dp_F34). keep(dp_C0, dp_F45). keep(dp_C0, dp_F51).
+keep(dp_C2, dp_F45). keep(dp_C2, dp_F51).
+keep(dp_C4, dp_F12). keep(dp_C4, dp_F23). keep(dp_C4, dp_F34).
+keep(dp_C6, dp_F45).
+keep(dp_C8, dp_F51).
+keep(dp_C10, dp_F12). keep(dp_C10, dp_F23). keep(dp_C10, dp_F34).
+keep(dp_C12, dp_F45).
+keep(dp_C14, dp_F51).
+keep(dp_C16, dp_F12). keep(dp_C16, dp_F23). keep(dp_C16, dp_F34).
+
+meal_handle(dp_P1, 1, dp_mP1_1). meal_handle(dp_P1, 2, dp_mP1_2). meal_handle(dp_P1, 3, dp_mP1_3).
+meal_handle(dp_P2, 1, dp_mP2_1). meal_handle(dp_P2, 2, dp_mP2_2). meal_handle(dp_P2, 3, dp_mP2_3).
+meal_handle(dp_P3, 1, dp_mP3_1). meal_handle(dp_P3, 2, dp_mP3_2). meal_handle(dp_P3, 3, dp_mP3_3).
+meal_handle(dp_P4, 1, dp_mP4_1). meal_handle(dp_P4, 2, dp_mP4_2). meal_handle(dp_P4, 3, dp_mP4_3).
+meal_handle(dp_P5, 1, dp_mP5_1). meal_handle(dp_P5, 2, dp_mP5_2). meal_handle(dp_P5, 3, dp_mP5_3).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+request(C, P, Q, F) :-
+  hungry(C, P), left_fork(P, F), start_state(C, F, Q, _Cleanliness), neq(Q, P).
+request(C, P, Q, F) :-
+  hungry(C, P), right_fork(P, F), start_state(C, F, Q, _Cleanliness), neq(Q, P).
+
+send_fork(C, Q, P, F) :-
+  request(C, P, Q, F), start_state(C, F, Q, dp_Dirty).
+
+after_send_state(CS, F, P, dp_Clean) :-
+  after_sends(C, CS), send_fork(C, _Q, P, F).
+after_send_state(CS, F, H, Cleanliness) :-
+  after_sends(C, CS), keep(C, F), start_state(C, F, H, Cleanliness).
+
+meal(M, P, N, S) :-
+  after_sends(C, CS), slot(C, S, N), hungry(C, P), meal_handle(P, N, M),
+  left_fork(P, LF), right_fork(P, RF),
+  after_send_state(CS, LF, P, _LeftCleanliness),
+  after_send_state(CS, RF, P, _RightCleanliness).
+
+dp_type(request(C, P, Q, F), dp_Request) :- request(C, P, Q, F).
+dp_in(request(C, P, Q, F), C) :- request(C, P, Q, F).
+dp_from(request(C, P, Q, F), P) :- request(C, P, Q, F).
+dp_to(request(C, P, Q, F), Q) :- request(C, P, Q, F).
+dp_fork(request(C, P, Q, F), F) :- request(C, P, Q, F).
+
+dp_type(send(C, Q, P, F), dp_SendFork) :- send_fork(C, Q, P, F).
+dp_in(send(C, Q, P, F), C) :- send_fork(C, Q, P, F).
+dp_from(send(C, Q, P, F), Q) :- send_fork(C, Q, P, F).
+dp_to(send(C, Q, P, F), P) :- send_fork(C, Q, P, F).
+dp_fork(send(C, Q, P, F), F) :- send_fork(C, Q, P, F).
+
+dp_type(M, dp_Meal) :- meal(M, _P, _N, _S).
+dp_philosopher(M, P) :- meal(M, P, _N, _S).
+dp_mealNo(M, N) :- meal(M, _P, N, _S).
+dp_inSlot(M, S) :- meal(M, _P, _N, S).
+dp_usesFork(M, LF) :- meal(M, P, _N, _S), left_fork(P, LF).
+dp_usesFork(M, RF) :- meal(M, P, _N, _S), right_fork(P, RF).

package/examples/eyelang/directional-language.ttl

@@ -0,0 +1,9 @@
+# RDF 1.2 directional language-tagged string example.
+VERSION "1.2"
+PREFIX : <http://example.org/lang#>
+
+:greeting :label "שלום"@he--rtl .
+
+{ ?Thing :label ?Text . }
+=>
+{ ?Thing :hasDirectionalLabel true . } .

package/examples/eyelang/dog.pl

@@ -0,0 +1,25 @@
+% The output reports only the compliance obligation derived below.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(mustHave, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Dog-license example adapted from Eyeling dog.n3.
+% A subject with more than four dogs must have a dog license.
+
+hasDog(alice, dog1).
+hasDog(alice, dog2).
+hasDog(alice, dog3).
+hasDog(alice, dog4).
+hasDog(alice, dog5).
+hasDog(bob, dog6).
+hasDog(bob, dog7).
+
+% countall/2 counts all matching dogs for the same subject.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+dogCount(Subject, Count) :-
+  hasDog(Subject, _Any),
+  countall(hasDog(Subject, _Dog), Count).
+
+mustHave(Subject, dogLicense) :-
+  dogCount(Subject, Count),
+  gt(Count, 4).

package/examples/eyelang/drone-corridor-planner.pl

@@ -0,0 +1,51 @@
+% Memoize bounded paths because surviving-plan metrics reuse route prefixes.
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(gps_plan, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(path, 9).
+
+% Bounded drone corridor planner adapted from Eyeling drone-corridor-planner.n3.
+% A fuel list bounds recursion; duration and cost are summed, belief and comfort
+% are multiplied along the action sequence.
+
+fuel(fuel7, [t, t, t, t, t, t, t]).
+
+step(state(gent, full, P), state(brugge, mid, P), fly_gent_brugge, 1500.0, 0.006, 0.99, 0.99).
+step(state(gent, B, P), state(brugge, B, P), train_gent_brugge, 1700.0, 0.012, 0.999, 0.995).
+step(state(gent, full, P), state(kortrijk, mid, P), fly_gent_kortrijk, 1600.0, 0.007, 0.99, 0.99).
+step(state(kortrijk, mid, P), state(brugge, low, P), fly_kortrijk_brugge, 1600.0, 0.007, 0.99, 0.99).
+step(state(brugge, mid, P), state(kortrijk, low, P), fly_brugge_kortrijk, 1600.0, 0.007, 0.985, 0.98).
+step(state(kortrijk, B, none), state(kortrijk, B, yes), get_zone_permit_kortrijk, 300.0, 0.001, 0.999, 1.0).
+step(state(brugge, B, none), state(brugge, B, yes), buy_permit_brugge, 450.0, 0.002, 0.98, 1.0).
+step(state(brugge, low, P), state(brugge, full, P), quick_charge_brugge, 600.0, 0.004, 0.999, 0.97).
+step(state(brugge, mid, P), state(brugge, full, P), topup_brugge, 400.0, 0.003, 0.999, 0.98).
+step(state(kortrijk, mid, P), state(kortrijk, full, P), emergency_charge_kortrijk, 500.0, 0.003, 0.999, 0.95).
+step(state(brugge, full, yes), state(oostende, mid, yes), cross_corridor_brugge_oostende, 900.0, 0.004, 0.98, 1.0).
+step(state(brugge, mid, P), state(oostende, low, P), public_coastline_brugge_oostende, 1300.0, 0.006, 0.97, 0.96).
+step(state(brugge, full, P), state(oostende, mid, P), public_coastline_brugge_oostende, 1200.0, 0.006, 0.975, 0.96).
+step(state(kortrijk, full, yes), state(oostende, mid, yes), direct_corridor_kortrijk_oostende, 1100.0, 0.009, 0.955, 0.92).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+path(From, To, [Act], Duration, Cost, Belief, Comfort, FuelIn, FuelOut) :-
+  step(From, To, Act, Duration, Cost, Belief, Comfort),
+  rest(FuelIn, FuelOut).
+
+path(From, To, Actions, Duration, Cost, Belief, Comfort, FuelIn, FuelOut) :-
+  step(From, Mid, Act, D1, C1, B1, M1),
+  rest(FuelIn, FuelMid),
+  path(Mid, To, RestActions, D2, C2, B2, M2, FuelMid, FuelOut),
+  append([Act], RestActions, Actions),
+  add(D1, D2, Duration),
+  add(C1, C2, Cost),
+  mul(B1, B2, Belief),
+  mul(M1, M2, Comfort).
+
+surviving_plan(Actions, Duration, Cost, Belief, Comfort, Battery, Permit, FuelLeft) :-
+  fuel(fuel7, Fuel),
+  path(state(gent, full, none), state(oostende, Battery, Permit), Actions, Duration, Cost, Belief, Comfort, Fuel, FuelLeft),
+  gt(Belief, 0.94),
+  lt(Cost, 0.03).
+
+gps_plan(d1, plan(Actions, Duration, Cost, Belief, Comfort, Battery, Permit, FuelLeft)) :-
+  surviving_plan(Actions, Duration, Cost, Belief, Comfort, Battery, Permit, FuelLeft).

package/examples/eyelang/easter-computus.pl

@@ -0,0 +1,89 @@
+% Adapted from Eyeling's easter.n3.
+% Gregorian computus for a sample decade, with independent range/window checks.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(easterDate, 2).
+materialize(computusRemainders, 2).
+materialize(legalGregorianWindow, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Sample years for which the computed Easter date is materialized.
+case(y2026, 2026).
+case(y2027, 2027).
+case(y2028, 2028).
+case(y2029, 2029).
+case(y2030, 2030).
+case(y2031, 2031).
+case(y2032, 2032).
+case(y2033, 2033).
+case(y2034, 2034).
+case(y2035, 2035).
+
+% These checks document the legal ranges of intermediate computus values.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+valid_golden(N) :- between(0, 18, N).
+valid_epact(N) :- between(0, 29, N).
+valid_weekday(N) :- between(0, 6, N).
+legal_easter_date(3, D) :- between(22, 31, D).
+legal_easter_date(4, D) :- between(1, 25, D).
+month_name(3, march).
+month_name(4, april).
+
+% Butcher/Meeus-style integer arithmetic, kept explicit for proof readability.
+computus(Case, Year, Month, Day, J, K, Q, R, V, Z) :-
+  case(Case, Year),
+  mod(Year, 19, J),
+  div(Year, 100, K),
+  mod(Year, 100, H),
+  div(K, 4, M),
+  mod(K, 4, N),
+  add(K, 8, KP8),
+  div(KP8, 25, P),
+  sub(K, P, KminusP),
+  add(KminusP, 1, KminusPplus1),
+  div(KminusPplus1, 3, Q),
+  mul(19, J, NineteenJ),
+  add(NineteenJ, K, T1),
+  sub(T1, M, T2),
+  sub(T2, Q, T3),
+  add(T3, 15, T4),
+  mod(T4, 30, R),
+  div(H, 4, S),
+  mod(H, 4, U),
+  mul(2, N, TwoN),
+  mul(2, S, TwoS),
+  add(32, TwoN, L1),
+  add(L1, TwoS, L2),
+  sub(L2, R, L3),
+  sub(L3, U, L4),
+  mod(L4, 7, V),
+  mul(11, R, ElevenR),
+  mul(22, V, TwentyTwoV),
+  add(J, ElevenR, W1),
+  add(W1, TwentyTwoV, W2),
+  div(W2, 451, W),
+  mul(7, W, SevenW),
+  add(R, V, X1),
+  sub(X1, SevenW, X2),
+  add(X2, 114, X3),
+  div(X3, 31, Month),
+  mod(X3, 31, Z),
+  add(Z, 1, Day).
+
+checks_pass(Case) :-
+  computus(Case, _Year, Month, Day, J, _K, _Q, R, V, _Z),
+  valid_golden(J),
+  valid_epact(R),
+  valid_weekday(V),
+  month_name(Month, _Name),
+  legal_easter_date(Month, Day).
+
+easterDate(Case, date(Year, MonthName, Day)) :-
+  computus(Case, Year, Month, Day, _J, _K, _Q, _R, _V, _Z),
+  month_name(Month, MonthName).
+
+computusRemainders(Case, remainders(J, R, V)) :-
+  computus(Case, _Year, _Month, _Day, J, _K, _Q, R, V, _Z).
+
+legalGregorianWindow(Case, true) :-
+  checks_pass(Case).

package/examples/eyelang/electrical-rc-filter.pl

@@ -0,0 +1,36 @@
+% Engineering example: RC low-pass filter sizing.
+%
+% The cutoff frequency is 1 / (2*pi*R*C).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(timeConstant_s, 2).
+materialize(cutoffFrequency_Hz, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+component(filter1, resistor_ohm, 10000.0).
+component(filter1, capacitor_f, 0.000001).
+constant(pi, 3.141592653589793).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+time_constant(Filter, Tau) :-
+  component(Filter, resistor_ohm, R),
+  component(Filter, capacitor_f, C),
+  mul(R, C, Tau).
+
+cutoff_frequency(Filter, Frequency) :-
+  time_constant(Filter, Tau),
+  constant(pi, Pi),
+  mul(2.0, Pi, TwoPi),
+  mul(TwoPi, Tau, Denominator),
+  div(1.0, Denominator, Frequency).
+
+type(Filter, first_order_low_pass) :-
+  component(Filter, resistor_ohm, _R),
+  component(Filter, capacitor_f, _C).
+
+timeConstant_s(Filter, Tau) :-
+  time_constant(Filter, Tau).
+
+cutoffFrequency_Hz(Filter, Frequency) :-
+  cutoff_frequency(Filter, Frequency).

package/examples/eyelang/epidemic-policy.pl

@@ -0,0 +1,67 @@
+% EYE-inspired epidemic policy choice.
+% Policies are evaluated by estimated reproduction risk and social cost.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(riskScore, 2).
+materialize(cost, 2).
+materialize(status, 2).
+materialize(recommendedPolicy, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Candidate interventions combine vaccination and mask factors.
+policy(no_mandate).
+policy(vaccination_campaign).
+policy(indoor_masks).
+policy(vaccination_and_masks).
+
+base_risk(1.40).
+
+vaccination_factor(no_mandate, 1.00).
+vaccination_factor(vaccination_campaign, 0.55).
+vaccination_factor(indoor_masks, 1.00).
+vaccination_factor(vaccination_and_masks, 0.55).
+
+mask_factor(no_mandate, 1.00).
+mask_factor(vaccination_campaign, 1.00).
+mask_factor(indoor_masks, 0.65).
+mask_factor(vaccination_and_masks, 0.65).
+
+policy_cost(no_mandate, 0).
+policy_cost(vaccination_campaign, 3).
+policy_cost(indoor_masks, 2).
+policy_cost(vaccination_and_masks, 5).
+
+% Risk multiplies the base reproduction estimate by policy-specific factors.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+risk_score(P, R) :-
+  base_risk(Base),
+  vaccination_factor(P, VF),
+  mask_factor(P, MF),
+  mul(Base, VF, A),
+  mul(A, MF, R).
+
+acceptable(P) :-
+  risk_score(P, R),
+  le(R, 0.75).
+
+status(P, insufficient_control) :-
+  policy(P),
+  risk_score(P, R),
+  gt(R, 0.75).
+
+status(P, acceptable_control) :-
+  acceptable(P).
+
+% The recommendation is the only candidate below the outbreak threshold.
+recommended(vaccination_and_masks) :-
+  acceptable(vaccination_and_masks),
+  status(no_mandate, insufficient_control),
+  status(vaccination_campaign, insufficient_control),
+  status(indoor_masks, insufficient_control).
+
+riskScore(P, R) :- risk_score(P, R).
+cost(P, C) :- policy_cost(P, C).
+recommendedPolicy(epidemic_policy, P) :- recommended(P).
+reason(epidemic_policy, "combined vaccination and indoor masks are the only policy below the outbreak threshold") :-
+  recommended(vaccination_and_masks).

package/examples/eyelang/equivalence-classes-overlap-implies-same-class.pl

@@ -0,0 +1,27 @@
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(sameClassBecauseOfSharedMember, 3).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Equivalence-classes example adapted from Eyeling
+% equivalence-classes-overlap-implies-same-class.n3.
+% The finite class membership facts represent the equivalence closure generated
+% by b~a and b~c; the rule packages every shared-member witness.
+
+classMember(class_abc, a).
+classMember(class_abc, b).
+classMember(class_abc, c).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+inClassOf(U, X) :-
+  classMember(Class, U),
+  classMember(Class, X).
+
+sameClass(X, Y) :-
+  classMember(Class, X),
+  classMember(Class, Y).
+
+sameClassBecauseOfSharedMember(X, Y, Z) :-
+  inClassOf(Z, X),
+  inClassOf(Z, Y),
+  sameClass(X, Y),
+  neq(X, Y).

package/examples/eyelang/eulerian-path.pl

@@ -0,0 +1,85 @@
+% Eyelet-inspired Eulerian path example using findall/3 and sort/2.
+% The graph is undirected; edges are represented by identifiers so each edge is used once.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(oddVertices, 2).
+materialize(path, 2).
+materialize(edgeCount, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Edge identifiers let the search remove each physical edge exactly once.
+edge(e12, v1, v2).
+edge(e13, v1, v3).
+edge(e15, v1, v5).
+edge(e16, v1, v6).
+edge(e23, v2, v3).
+edge(e24, v2, v4).
+edge(e26, v2, v6).
+edge(e34, v3, v4).
+edge(e36, v3, v6).
+edge(e45, v4, v5).
+edge(e46, v4, v6).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+vertex(V) :- edge(_E, V, _U).
+vertex(V) :- edge(_E, _U, V).
+
+incident(V, E) :- edge(E, V, _U).
+incident(V, E) :- edge(E, _U, V).
+
+adjacent_by_edge(V, U, E) :- edge(E, V, U).
+adjacent_by_edge(V, U, E) :- edge(E, U, V).
+
+select(Item, [Item | Rest], Rest).
+select(Item, [Head | Tail], [Head | Rest]) :-
+  select(Item, Tail, Rest).
+
+% Eulerian paths start at an odd-degree vertex when exactly two exist.
+odd_degree(V) :-
+  findall(E, incident(V, E), Edges),
+  length(Edges, Degree),
+  mod(Degree, 2, 1).
+
+odd_vertices(Odds) :-
+  findall(V, odd_degree(V), Raw),
+  sort(Raw, Odds).
+
+all_edges(Edges) :-
+  findall(E, edge(E, _A, _B), Raw),
+  sort(Raw, Edges).
+
+vertices(Vertices) :-
+  findall(V, vertex(V), Raw),
+  sort(Raw, Vertices).
+
+eulerian_start(Start) :-
+  odd_vertices([Start, _End]).
+eulerian_start(Start) :-
+  odd_vertices([]),
+  vertices([Start | _Rest]).
+
+eulerian_path(Path) :-
+  eulerian_start(Start),
+  all_edges(Edges),
+  dfs_euler(Start, [Start], Edges, ReversedPath),
+  reverse(ReversedPath, Path).
+
+% Depth-first search consumes the remaining edge-id list one edge at a time.
+dfs_euler(_Current, Path, [], Path).
+dfs_euler(Current, Visited, Remaining, Path) :-
+  adjacent_by_edge(Current, Next, Edge),
+  select(Edge, Remaining, NewRemaining),
+  dfs_euler(Next, [Next | Visited], NewRemaining, Path).
+
+oddVertices(eulerian_path_case, Odds) :-
+  odd_vertices(Odds).
+
+path(eulerian_path_case, Path) :-
+  once(eulerian_path(Path)).
+
+edgeCount(eulerian_path_case, Count) :-
+  all_edges(Edges),
+  length(Edges, Count).
+
+reason(eulerian_path_case, "findall collects graph structure and sort canonicalizes vertices and edges").

package/examples/eyelang/ev-range-worlds.pl

@@ -0,0 +1,82 @@
+% EYE-inspired electric-vehicle range worlds.
+% Four simple worlds estimate whether trips fit the available battery.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(safeInWorld, 2).
+materialize(riskyInWorld, 2).
+materialize(reason, 2).
+materialize(status, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+trip(city_errand).
+trip(winter_highway).
+trip(heavy_delivery).
+trip(cold_commute).
+
+% trip_data(Trip, DistanceKm, SpeedKmh, TemperatureC, PayloadKg, BatteryKWh, BaseKWhPerKm).
+trip_data(city_errand, 40, 45, 20, 100, 30, 0.18).
+trip_data(winter_highway, 260, 115, -5, 400, 60, 0.20).
+trip_data(heavy_delivery, 180, 80, 15, 700, 55, 0.22).
+trip_data(cold_commute, 120, 90, -8, 100, 35, 0.19).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+speed_factor(T, 1.20) :- trip_data(T, _, S, _, _, _, _), gt(S, 100).
+speed_factor(T, 1.00) :- trip_data(T, _, S, _, _, _, _), le(S, 100).
+
+temperature_factor(T, 1.15) :- trip_data(T, _, _, Temp, _, _, _), lt(Temp, 0).
+temperature_factor(T, 1.00) :- trip_data(T, _, _, Temp, _, _, _), ge(Temp, 0).
+
+payload_factor(T, 1.15) :- trip_data(T, _, _, _, P, _, _), gt(P, 500).
+payload_factor(T, 1.08) :- trip_data(T, _, _, _, P, _, _), gt(P, 250), le(P, 500).
+payload_factor(T, 1.00) :- trip_data(T, _, _, _, P, _, _), le(P, 250).
+
+base_energy(T, E) :-
+  trip_data(T, D, _, _, _, _, B),
+  mul(D, B, E).
+
+required_energy(T, w1, E) :-
+  base_energy(T, E).
+
+required_energy(T, w2, E) :-
+  base_energy(T, Base),
+  speed_factor(T, SF),
+  mul(Base, SF, E).
+
+required_energy(T, w0, E) :-
+  base_energy(T, Base),
+  speed_factor(T, SF),
+  temperature_factor(T, TF),
+  payload_factor(T, PF),
+  mul(Base, SF, A),
+  mul(A, TF, B),
+  mul(B, PF, E).
+
+required_energy(T, w3, E) :-
+  required_energy(T, w0, W0),
+  mul(W0, 1.30, E).
+
+safe_in_world(T, W) :-
+  trip_data(T, _, _, _, _, Battery, _),
+  required_energy(T, W, Required),
+  le(Required, Battery).
+
+risky_in_world(T, W) :-
+  trip_data(T, _, _, _, _, Battery, _),
+  required_energy(T, W, Required),
+  gt(Required, Battery).
+
+safeInWorld(T, W) :- safe_in_world(T, W).
+riskyInWorld(T, W) :- risky_in_world(T, W).
+reason(winter_highway, "cold fast payload trip exceeds battery in physics-aware worlds") :-
+  risky_in_world(winter_highway, w0),
+  risky_in_world(winter_highway, w2),
+  risky_in_world(winter_highway, w3),
+  safe_in_world(winter_highway, w1).
+reason(heavy_delivery, "safety buffer turns a physics-safe delivery into a cautious risk") :-
+  safe_in_world(heavy_delivery, w0),
+  risky_in_world(heavy_delivery, w3).
+status(ev_range_worlds, expected_world_pattern) :-
+  safe_in_world(city_errand, w3),
+  risky_in_world(winter_highway, w0),
+  risky_in_world(heavy_delivery, w3),
+  safe_in_world(cold_commute, w3).