seam-lang 2.0.0

package/examples/dining-philosophers.pl

@@ -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.pl

@@ -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.pl

@@ -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.pl

@@ -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.pl

@@ -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.pl

@@ -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.pl

@@ -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/equality-saturation.pl

@@ -0,0 +1,84 @@
+% Bounded equality saturation over tiny arithmetic expression terms.
+%
+% Real equality-saturation engines use mutable e-graphs, union-find classes,
+% congruence closure, rewrite scheduling, and cost-based extraction.  Seam has
+% none of those primitives, so this example simulates the idea relationally: it
+% enumerates expressions reachable within a small rewrite-fuel bound, scores the
+% generated terms, and extracts the cheapest equivalent expression.
+%
+% The point is not to be fast.  The point is to show the declarative shape of an
+% e-graph optimizer in a language that was not designed for it.
+
+materialize(egraphAnswer, 2).
+
+table(equivalent_at_depth, 3).
+table(expr_cost, 2).
+
+% Start expression:
+%   ((x + 0) * 1) + 2 * (1 + 2)
+% The best bounded rewrite result should be x + 6.
+expr(start, add(mul(add(x, 0), 1), mul(2, add(1, 2)))).
+fuel(6).
+
+% Directed rewrite rules.  A true e-graph would keep equalities in equivalence
+% classes.  This bounded version uses oriented rewrites so search terminates.
+rewrite(add(X, 0), X).
+rewrite(add(0, X), X).
+rewrite(mul(X, 1), X).
+rewrite(mul(1, X), X).
+rewrite(mul(X, 0), 0).
+rewrite(mul(0, X), 0).
+
+% Constant folding and one distributivity rule make the search space less toyish.
+rewrite(add(A, B), C) :- add(A, B, C).
+rewrite(mul(A, B), C) :- mul(A, B, C).
+rewrite(mul(X, add(Y, Z)), add(mul(X, Y), mul(X, Z))).
+
+% Apply a rewrite at the root or inside one subterm.
+rewrite_anywhere(In, Out) :- rewrite(In, Out).
+rewrite_anywhere(add(A, B), add(New_a, B)) :- rewrite_anywhere(A, New_a).
+rewrite_anywhere(add(A, B), add(A, New_b)) :- rewrite_anywhere(B, New_b).
+rewrite_anywhere(mul(A, B), mul(New_a, B)) :- rewrite_anywhere(A, New_a).
+rewrite_anywhere(mul(A, B), mul(A, New_b)) :- rewrite_anywhere(B, New_b).
+
+% Fuel-bounded closure.  Every depth represents exactly that many rewrite steps;
+% candidate_expression/1 looks across all depths from zero to the fuel limit.
+equivalent_at_depth(0, Expr, Expr).
+equivalent_at_depth(Depth, Expr, Out) :-
+  gt(Depth, 0),
+  sub(Depth, 1, Previous_depth),
+  equivalent_at_depth(Previous_depth, Expr, Mid),
+  rewrite_anywhere(Mid, Out).
+
+candidate_expression(Candidate) :-
+  expr(start, Expr),
+  fuel(Fuel),
+  between(0, Fuel, Depth),
+  equivalent_at_depth(Depth, Expr, Candidate).
+
+% A tiny cost model for extraction.  Leaves cost 1; compound nodes cost 1 plus
+% their children.  The numeric range is deliberately bounded for the generated
+% constants in this example.
+expr_cost(x, 1).
+expr_cost(N, 1) :- between(0, 20, N).
+expr_cost(add(A, B), Cost) :-
+  expr_cost(A, A_cost),
+  expr_cost(B, B_cost),
+  add(A_cost, B_cost, Children),
+  add(Children, 1, Cost).
+expr_cost(mul(A, B), Cost) :-
+  expr_cost(A, A_cost),
+  expr_cost(B, B_cost),
+  add(A_cost, B_cost, Children),
+  add(Children, 1, Cost).
+
+best_expression(Expr, Cost) :-
+  aggregate_min([Candidate_cost, Candidate], Candidate,
+    (candidate_expression(Candidate), expr_cost(Candidate, Candidate_cost)),
+    [Cost, Expr], Expr).
+
+egraphAnswer(start, Expr) :- expr(start, Expr).
+egraphAnswer(best, Expr) :- best_expression(Expr, _).
+egraphAnswer(cost, Cost) :- best_expression(_, Cost).
+egraphAnswer(candidate_count, Count) :- countall(candidate_expression(_), Count).
+egraphAnswer(note, "bounded equality saturation extracts the cheapest term without a real e-graph") :- best_expression(_, _).

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

@@ -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.pl

@@ -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").