eyelang 1.2.2 → 1.3.1

package/examples/dining-philosophers.eye

@@ -0,0 +1,147 @@
+% Chandy-Misra dining philosophers trace adapted from Eyeling dining-philosophers.n3.
+%
+% The example does not search for an arbitrary schedule.  Instead, it reasons over
+% a finite trace of configurations and slots, deriving which fork requests are
+% sent, which forks are kept, and which philosopher uses which fork in each meal.
+%
+% It is useful as a larger rule-translation example because many output facts are
+% copied or transformed from state-transition relations.
+% 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).
+
+% The trace is represented as numbered configurations and slots.  Each slot
+% records who is hungry, which forks are held, and how fork ownership changes.
+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).
+
+% Rules derive requests, sends, kept forks, and eating events for each
+% configuration transition, mirroring Chandy-Misra message passing.
+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/dog.eye

@@ -0,0 +1,25 @@
+% Dog-license compliance rule adapted from Eyeling dog.n3.
+%
+% hasDog/2 records individual dogs.  dogCount/2 uses countall/2 to aggregate all
+% dogs per subject, and mustHave/2 derives the license obligation exactly for
+% subjects with more than four registered dogs.
+%
+% The example is intentionally tiny but useful as an aggregate-counting pattern.
+materialize(mustHave, 2).
+
+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.
+dogCount(?subject, ?count) :-
+  hasDog(?subject, ?_any),
+  countall(hasDog(?subject, ?_dog), ?count).
+
+mustHave(?subject, dogLicense) :-
+  dogCount(?subject, ?count),
+  gt(?count, 4).

package/examples/dpv-odrl-purpose-mapping.eye

@@ -0,0 +1,48 @@
+% Translate a DPV-style personal-data processing description into an ODRL-style policy view.
+% The source facts describe one care/research process: controller, recipient, data, action, purpose, and legal basis.
+% The derived predicates materialize the corresponding ODRL policy, permission, target, party, action, and constraints.
+
+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/drone-corridor-planner.eye

@@ -0,0 +1,48 @@
+% Bounded drone corridor planner adapted from Eyeling drone-corridor-planner.n3.
+% States track city, battery level, and corridor permit.  A finite fuel list
+% bounds recursion; path/9 sums duration and cost while multiplying belief and
+% comfort.  Memoization helps because many surviving-plan checks reuse prefixes.
+
+materialize(gps_plan, 2).
+
+table(path, 9).
+
+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).
+
+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/easter-computus.eye

@@ -0,0 +1,88 @@
+% Gregorian Easter computus adapted from Eyeling's easter.n3.
+% Each case is a year in a sample decade.  The rules derive the Meeus/Jones/
+% Butcher remainders, the final month/day, and a separate window check showing
+% that the result lies in the legal Gregorian Easter range.
+
+materialize(easterDate, 2).
+materialize(computusRemainders, 2).
+materialize(legalGregorianWindow, 2).
+
+% 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.
+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/electrical-rc-filter.eye

@@ -0,0 +1,37 @@
+% Engineering example: RC low-pass filter sizing.
+%
+% A resistor and capacitor define the time constant tau = R*C.  The cutoff
+% frequency rule then computes fc = 1/(2*pi*tau).
+%
+% The model uses key/value component facts so the same pattern can be extended to
+% multiple named filters or extra component attributes without changing the rules.
+
+materialize(type, 2).
+materialize(timeConstant_s, 2).
+materialize(cutoffFrequency_Hz, 2).
+
+component(filter1, resistor_ohm, 10000.0).
+component(filter1, capacitor_f, 0.000001).
+constant(pi, 3.141592653589793).
+
+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/epidemic-policy.eye

@@ -0,0 +1,66 @@
+% EYE-inspired epidemic policy choice.
+% Candidate interventions combine vaccination and mask factors against a base
+% reproduction-risk estimate.  The recommended policy is the only candidate
+% that satisfies the outbreak threshold in this simplified model.
+
+materialize(riskScore, 2).
+materialize(cost, 2).
+materialize(status, 2).
+materialize(recommendedPolicy, 2).
+materialize(reason, 2).
+
+% 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.
+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/equivalence-classes-overlap-implies-same-class.eye

@@ -0,0 +1,27 @@
+% Equivalence-class overlap example adapted from Eyeling.
+%
+% The finite classMember/2 facts represent an already-computed equivalence
+% closure.  sameClassBecauseOfSharedMember/3 reports the witness Z proving that
+% X and Y belong to the same class because both contain that shared member.
+%
+% This is useful for proof output: the conclusion is not just that two class
+% labels coincide, but also which element explains the overlap.
+materialize(sameClassBecauseOfSharedMember, 3).
+
+classMember(class_abc, a).
+classMember(class_abc, b).
+classMember(class_abc, c).
+
+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/eulerian-path.eye

@@ -0,0 +1,87 @@
+% Eyelet-inspired Eulerian path example using findall/3 and sort/2.
+%
+% The graph is undirected; edges have identifiers so the trail consumes each
+% physical edge exactly once even when vertices are revisited.  The remaining
+% edge-id list is the explicit search state.
+materialize(oddVertices, 2).
+materialize(path, 2).
+materialize(edgeCount, 2).
+materialize(reason, 2).
+
+% Edge identifiers are part of the search state: the DFS removes ids, not just
+% endpoints, so repeated vertex visits do not accidentally reuse an edge.
+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).
+
+% Degree parity is computed with findall/3.  The Eulerian-start rule then chooses
+% an odd-degree vertex when exactly two exist, or any vertex for an Eulerian cycle.
+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/ev-range-worlds.eye

@@ -0,0 +1,87 @@
+% EYE-inspired electric-vehicle range worlds.
+%
+% The same trips are evaluated under four modelling worlds: base consumption,
+% speed-aware consumption, physics-aware consumption, and physics plus safety
+% reserve.  This makes the output a small possible-worlds comparison.
+materialize(safeInWorld, 2).
+materialize(riskyInWorld, 2).
+materialize(reason, 2).
+materialize(status, 2).
+
+% trip_data/7 stores distance, speed, temperature, payload, battery, and base
+% energy use.  The factors below adjust base consumption rather than duplicating
+% one rule per trip/world pair.
+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).
+
+% Each world adds a different combination of speed, temperature, payload, and
+% reserve factors before comparing required energy with usable battery.
+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/2 compares required trip energy with usable battery capacity.
+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).