eyeling 1.34.5 → 1.34.6

package/examples/eyelang/dining-philosophers.pl

@@ -1,140 +0,0 @@
-% 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/dog.pl

@@ -1,25 +0,0 @@
-% 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/dpv-odrl-purpose-mapping.pl

@@ -1,46 +0,0 @@
-% DPV process to ODRL policy view in eyelang.
-
-materialize(type, 2).
-materialize(odrl_permission, 2).
-materialize(odrl_assigner, 2).
-materialize(odrl_assignee, 2).
-materialize(odrl_target, 2).
-materialize(odrl_action, 2).
-materialize(odrl_constraint, 2).
-materialize(odrl_leftOperand, 2).
-materialize(odrl_operator, 2).
-materialize(odrl_rightOperand, 2).
-materialize(derived_from_process, 2).
-
-process(alpha_care_process).
-data_controller(alpha_care_process, hospital_a).
-recipient(alpha_care_process, research_partner).
-personal_data(alpha_care_process, lab_result).
-processing(alpha_care_process, dpv_use).
-purpose(alpha_care_process, dpv_healthcare).
-legal_basis(alpha_care_process, dpv_consent).
-
-represents_process(alpha_policy, alpha_care_process).
-permission_node(alpha_policy, alpha_permission).
-purpose_constraint(alpha_policy, alpha_purpose_constraint).
-basis_constraint(alpha_policy, alpha_basis_constraint).
-
-type(Policy, odrl_policy) :- represents_process(Policy, _Process).
-odrl_permission(Policy, Permission) :- permission_node(Policy, Permission).
-type(Permission, odrl_permission) :- permission_node(_Policy, Permission).
-derived_from_process(Permission, Process) :- represents_process(Policy, Process), permission_node(Policy, Permission).
-odrl_assigner(Permission, Controller) :- represents_process(Policy, Process), permission_node(Policy, Permission), data_controller(Process, Controller).
-odrl_assignee(Permission, Recipient) :- represents_process(Policy, Process), permission_node(Policy, Permission), recipient(Process, Recipient).
-odrl_target(Permission, Data) :- represents_process(Policy, Process), permission_node(Policy, Permission), personal_data(Process, Data).
-odrl_action(Permission, Action) :- represents_process(Policy, Process), permission_node(Policy, Permission), processing(Process, Action).
-
-odrl_constraint(Permission, Constraint) :- permission_node(Policy, Permission), purpose_constraint(Policy, Constraint).
-odrl_constraint(Permission, Constraint) :- permission_node(Policy, Permission), basis_constraint(Policy, Constraint).
-type(Constraint, odrl_constraint) :- purpose_constraint(_Policy, Constraint).
-type(Constraint, odrl_constraint) :- basis_constraint(_Policy, Constraint).
-odrl_leftOperand(Constraint, dpv_odrl_purpose) :- purpose_constraint(_Policy, Constraint).
-odrl_leftOperand(Constraint, dpv_odrl_legal_basis) :- basis_constraint(_Policy, Constraint).
-odrl_operator(Constraint, odrl_isA) :- purpose_constraint(_Policy, Constraint).
-odrl_operator(Constraint, odrl_isA) :- basis_constraint(_Policy, Constraint).
-odrl_rightOperand(Constraint, Purpose) :- represents_process(Policy, Process), purpose_constraint(Policy, Constraint), purpose(Process, Purpose).
-odrl_rightOperand(Constraint, Basis) :- represents_process(Policy, Process), basis_constraint(Policy, Constraint), legal_basis(Process, Basis).

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

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

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

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

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

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

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

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

package/examples/eyelang/existential-rule.pl

@@ -1,18 +0,0 @@
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(is, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-% Existential-rule example adapted from Eyeling existential-rule.n3.
-% Eyeling creates blank-node witnesses.  eyelang has Herbrand terms only, so the
-% witness is represented explicitly by a deterministic Skolem-style term.
-
-type(socrates, human).
-type(plato, human).
-
-witness(socrates, sk_0).
-witness(plato, sk_1).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-is(Person, Witness) :-
-  type(Person, human),
-  witness(Person, Witness).