eyeprolog 0.5.3

package/examples/dining-philosophers.pl

@@ -0,0 +1,156 @@
+% 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: host-supplied goals select the relations written to this example's golden output.
+%% goal: dp_type(X0, X1)
+
+%% goal: dp_in(X0, X1)
+
+%% goal: dp_from(X0, X1)
+
+%% goal: dp_to(X0, X1)
+
+%% goal: dp_fork(X0, X1)
+
+%% goal: dp_philosopher(X0, X1)
+
+%% goal: dp_mealNo(X0, X1)
+
+%% goal: dp_inSlot(X0, X1)
+
+%% goal: dp_usesFork(X0, X1)
+
+
+% 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), (Q \= P).
+request(C, P, Q, F) :-
+  hungry(C, P), right_fork(P, F), start_state(C, F, Q, _cleanliness), (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,26 @@
+% 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.
+%% goal: mustHave(X0, X1)
+
+
+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),
+  (Count > 4).

package/examples/donald-gerald-robert.pl

@@ -0,0 +1,83 @@
+% A pandigital cryptarithm: DONALD + GERALD = ROBERT.
+%
+% Ten distinct letters must use all ten decimal digits. A naive assignment
+% explores 10! permutations; this solver instead propagates carries from right
+% to left and removes each chosen or derived digit from a shrinking domain.
+%% goal: pandigital_cryptarithm_answer(X0, X1)
+
+
+all_digits([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).
+
+pandigital_cryptarithm(solution(D, O, N, A, L, G, E, R, B, T)) :-
+  all_digits(Digits),
+
+  % Units: D + D = T, with carry C1.
+  select(D, Digits, D0),
+  D \= 0,
+  UnitsSum is D + D,
+  T is UnitsSum mod 10,
+  C1 is UnitsSum // 10,
+  select(T, D0, D1),
+
+  % Tens: L + L + C1 = R, with carry C2.
+  select(L, D1, D2),
+  TensSum is L + L + C1,
+  R is TensSum mod 10,
+  C2 is TensSum // 10,
+  R \= 0,
+  select(R, D2, D3),
+
+  % Hundreds: A + A + C2 = E, with carry C3.
+  select(A, D3, D4),
+  HundredsSum is A + A + C2,
+  E is HundredsSum mod 10,
+  C3 is HundredsSum // 10,
+  select(E, D4, D5),
+
+  % Thousands: N + R + C3 = B, with carry C4.
+  select(N, D5, D6),
+  ThousandsSum is N + R + C3,
+  B is ThousandsSum mod 10,
+  C4 is ThousandsSum // 10,
+  select(B, D6, D7),
+
+  % Ten-thousands: O cancels, so E + C4 must be exactly 10 * C5.
+  CarrySum is E + C4,
+  0 is CarrySum mod 10,
+  C5 is CarrySum // 10,
+
+  % Hundred-thousands: D + G + C5 = R, which derives G directly.
+  G is R - D - C5,
+  G > 0,
+  select(G, D7, D8),
+
+  % The sole remaining digit is O; it is also a leading digit.
+  select(O, D8, []),
+  O \= 0.
+
+number6(A, B, C, D, E, F, Value) :-
+  A5 is A * 100000,
+  B4 is B * 10000,
+  C3 is C * 1000,
+  D2 is D * 100,
+  E1 is E * 10,
+  AB is A5 + B4,
+  ABC is AB + C3,
+  ABCD is ABC + D2,
+  ABCDE is ABCD + E1,
+  Value is ABCDE + F.
+
+pandigital_cryptarithm_answer(naive_search_space, permutations(10, 3628800)) :-
+  all_digits(Digits),
+  length(Digits, 10).
+pandigital_cryptarithm_answer(assignments, solution(D, O, N, A, L, G, E, R, B, T)) :-
+  pandigital_cryptarithm(solution(D, O, N, A, L, G, E, R, B, T)).
+pandigital_cryptarithm_answer(equation, equation(Donald, Gerald, Robert)) :-
+  pandigital_cryptarithm(solution(D, O, N, A, L, G, E, R, B, T)),
+  number6(D, O, N, A, L, D, Donald),
+  number6(G, E, R, A, L, D, Gerald),
+  number6(R, O, B, E, R, T, Robert).
+pandigital_cryptarithm_answer(digit_usage, [D, O, N, A, L, G, E, R, B, T]) :-
+  pandigital_cryptarithm(solution(D, O, N, A, L, G, E, R, B, T)).
+pandigital_cryptarithm_answer(solution_count, Count) :-
+  countall(pandigital_cryptarithm(_), Count).

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

@@ -0,0 +1,94 @@
+% Generated by tools/rdf-to-pl.mjs.
+
+% Run with: eyeprolog --goal 'rdf(S, P, O, G)' program.pl.
+
+rdf(iri("https://example.org/alpha_care_process"), iri("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), iri("https://w3id.org/dpv#Process"), default_graph).
+rdf(iri("https://example.org/alpha_care_process"), iri("https://w3id.org/dpv#hasDataController"), iri("https://example.org/hospital_a"), default_graph).
+rdf(iri("https://example.org/alpha_care_process"), iri("https://w3id.org/dpv#hasRecipient"), iri("https://example.org/research_partner"), default_graph).
+rdf(iri("https://example.org/alpha_care_process"), iri("https://w3id.org/dpv#hasPersonalData"), iri("https://example.org/lab_result"), default_graph).
+rdf(iri("https://example.org/alpha_care_process"), iri("https://w3id.org/dpv#hasProcessing"), iri("https://w3id.org/dpv#Use"), default_graph).
+rdf(iri("https://example.org/alpha_care_process"), iri("https://w3id.org/dpv#hasPurpose"), iri("https://w3id.org/dpv#Healthcare"), default_graph).
+rdf(iri("https://example.org/alpha_care_process"), iri("https://w3id.org/dpv#hasLegalBasis"), iri("https://w3id.org/dpv#Consent"), default_graph).
+rdf(iri("https://example.org/alpha_policy"), iri("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), iri("http://www.w3.org/ns/odrl/2/Policy"), default_graph).
+rdf(iri("https://example.org/alpha_policy"), iri("https://example.org/representsProcess"), iri("https://example.org/alpha_care_process"), default_graph).
+rdf(iri("https://example.org/alpha_policy"), iri("http://www.w3.org/ns/odrl/2/permission"), iri("https://example.org/alpha_permission"), default_graph).
+rdf(iri("https://example.org/alpha_permission"), iri("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), iri("http://www.w3.org/ns/odrl/2/Permission"), default_graph).
+rdf(iri("https://example.org/alpha_permission"), iri("http://www.w3.org/ns/odrl/2/assigner"), iri("https://example.org/hospital_a"), default_graph).
+rdf(iri("https://example.org/alpha_permission"), iri("http://www.w3.org/ns/odrl/2/assignee"), iri("https://example.org/research_partner"), default_graph).
+rdf(iri("https://example.org/alpha_permission"), iri("http://www.w3.org/ns/odrl/2/target"), iri("https://example.org/lab_result"), default_graph).
+rdf(iri("https://example.org/alpha_permission"), iri("http://www.w3.org/ns/odrl/2/action"), iri("http://www.w3.org/ns/odrl/2/use"), default_graph).
+rdf(iri("https://example.org/alpha_permission"), iri("http://www.w3.org/ns/odrl/2/constraint"), iri("https://example.org/alpha_purpose_constraint"), default_graph).
+rdf(iri("https://example.org/alpha_permission"), iri("http://www.w3.org/ns/odrl/2/constraint"), iri("https://example.org/alpha_basis_constraint"), default_graph).
+rdf(iri("https://example.org/alpha_purpose_constraint"), iri("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), iri("http://www.w3.org/ns/odrl/2/Constraint"), default_graph).
+rdf(iri("https://example.org/alpha_purpose_constraint"), iri("http://www.w3.org/ns/odrl/2/leftOperand"), iri("http://www.w3.org/ns/odrl/2/purpose"), default_graph).
+rdf(iri("https://example.org/alpha_purpose_constraint"), iri("http://www.w3.org/ns/odrl/2/operator"), iri("http://www.w3.org/ns/odrl/2/isA"), default_graph).
+rdf(iri("https://example.org/alpha_purpose_constraint"), iri("http://www.w3.org/ns/odrl/2/rightOperand"), iri("https://w3id.org/dpv#Healthcare"), default_graph).
+rdf(iri("https://example.org/alpha_basis_constraint"), iri("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), iri("http://www.w3.org/ns/odrl/2/Constraint"), default_graph).
+rdf(iri("https://example.org/alpha_basis_constraint"), iri("http://www.w3.org/ns/odrl/2/leftOperand"), iri("https://example.org/legalBasis"), default_graph).
+rdf(iri("https://example.org/alpha_basis_constraint"), iri("http://www.w3.org/ns/odrl/2/operator"), iri("http://www.w3.org/ns/odrl/2/isA"), default_graph).
+rdf(iri("https://example.org/alpha_basis_constraint"), iri("http://www.w3.org/ns/odrl/2/rightOperand"), iri("https://w3id.org/dpv#Consent"), default_graph).
+
+% Rules
+% Source data: examples/input/dpv-odrl-purpose-mapping.ttl
+% Regenerate with:
+% node tools/rdf-to-pl.mjs --rules examples/input/dpv-odrl-purpose-mapping-rules.pl examples/input/dpv-odrl-purpose-mapping.ttl -o examples/dpv-odrl-purpose-mapping.pl
+%
+% The DPV process and ODRL policy are RDF data. The rules verify the six
+% correspondences and return one deterministic mapping report.
+%% goal: dpv_odrl_purpose_mapping(_)
+
+dpv_odrl_purpose_mapping(Mappings) :-
+  findall(
+    mapping(SourceRole, Value, TargetRole),
+    mapped_role(SourceRole, Value, TargetRole),
+    Mappings
+  ).
+
+mapped_role(data_controller, Controller, assigner) :-
+  rdf_link(ex(alpha_care_process), dpv(hasDataController), ex(Controller)),
+  rdf_link(ex(alpha_permission), odrl(assigner), ex(Controller)).
+
+mapped_role(recipient, Recipient, assignee) :-
+  rdf_link(ex(alpha_care_process), dpv(hasRecipient), ex(Recipient)),
+  rdf_link(ex(alpha_permission), odrl(assignee), ex(Recipient)).
+
+mapped_role(personal_data, Data, target) :-
+  rdf_link(ex(alpha_care_process), dpv(hasPersonalData), ex(Data)),
+  rdf_link(ex(alpha_permission), odrl(target), ex(Data)).
+
+mapped_role(processing, dpv_use, action) :-
+  rdf_link(ex(alpha_care_process), dpv(hasProcessing), dpv('Use')),
+  rdf_link(ex(alpha_permission), odrl(action), odrl(use)).
+
+mapped_role(purpose, dpv_healthcare, constraint(alpha_purpose_constraint)) :-
+  rdf_link(ex(alpha_care_process), dpv(hasPurpose), dpv('Healthcare')),
+  odrl_constraint(alpha_purpose_constraint, odrl(purpose), dpv('Healthcare')).
+
+mapped_role(legal_basis, dpv_consent, constraint(alpha_basis_constraint)) :-
+  rdf_link(ex(alpha_care_process), dpv(hasLegalBasis), dpv('Consent')),
+  odrl_constraint(alpha_basis_constraint, ex(legalBasis), dpv('Consent')).
+
+odrl_constraint(Name, LeftOperand, RightOperand) :-
+  rdf_link(ex(alpha_permission), odrl(constraint), ex(Name)),
+  rdf_link(ex(Name), odrl('leftOperand'), LeftOperand),
+  rdf_link(ex(Name), odrl(operator), odrl('isA')),
+  rdf_link(ex(Name), odrl('rightOperand'), RightOperand).
+
+rdf_link(Subject, Predicate, Object) :-
+  iri_term(Subject, SubjectIri),
+  iri_term(Predicate, PredicateIri),
+  rdf(iri(SubjectIri), iri(PredicateIri), iri(ObjectIri), default_graph),
+  iri_term(Object, ObjectIri).
+
+iri_term(ex(Name), Iri) :- namespace_iri("https://example.org/", Name, Iri).
+iri_term(dpv(Name), Iri) :- namespace_iri("https://w3id.org/dpv#", Name, Iri).
+iri_term(odrl(Name), Iri) :- namespace_iri("http://www.w3.org/ns/odrl/2/", Name, Iri).
+
+namespace_iri(Prefix, Name, Iri) :-
+  atom(Name),
+  !,
+  atom_string(Name, Local),
+  string_concat(Prefix, Local, Iri).
+namespace_iri(Prefix, Name, Iri) :-
+  string_concat(Prefix, Local, Iri),
+  atom_string(Name, Local).

package/examples/drone-corridor-planner.pl

@@ -0,0 +1,46 @@
+% 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.
+
+%% goal: gps_plan(X0, X1)
+
+
+
+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, [_fuel|Fuelout], Fuelout) :-
+  step(From, To, Act, Duration, Cost, Belief, Comfort).
+
+path(From, To, Actions, Duration, Cost, Belief, Comfort, [_fuel|Fuelmid], Fuelout) :-
+  step(From, Mid, Act, D1, C1, B1, M1),
+  path(Mid, To, Restactions, D2, C2, B2, M2, Fuelmid, Fuelout),
+  append([Act], Restactions, Actions),
+  (Duration is D1 + D2),
+  (Cost is C1 + C2),
+  (Belief is B1 * B2),
+  (Comfort is M1 * M2).
+
+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),
+  (Belief > 0.94),
+  (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,91 @@
+% 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.
+
+%% goal: easterDate(X0, X1)
+
+%% goal: computusRemainders(X0, X1)
+
+%% goal: legalGregorianWindow(X0, X1)
+
+
+% Sample years for which the computed Easter date is queried.
+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),
+  (J is Year mod 19),
+  (K is Year // 100),
+  (H is Year mod 100),
+  (M is K // 4),
+  (N is K mod 4),
+  (Kp8 is K + 8),
+  (P is Kp8 // 25),
+  (Kminusp is K - P),
+  (Kminuspplus1 is Kminusp + 1),
+  (Q is Kminuspplus1 // 3),
+  (Nineteenj is 19 * J),
+  (T1 is Nineteenj + K),
+  (T2 is T1 - M),
+  (T3 is T2 - Q),
+  (T4 is T3 + 15),
+  (R is T4 mod 30),
+  (S is H // 4),
+  (U is H mod 4),
+  (Twon is 2 * N),
+  (Twos is 2 * S),
+  (L1 is 32 + Twon),
+  (L2 is L1 + Twos),
+  (L3 is L2 - R),
+  (L4 is L3 - U),
+  (V is L4 mod 7),
+  (Elevenr is 11 * R),
+  (Twentytwov is 22 * V),
+  (W1 is J + Elevenr),
+  (W2 is W1 + Twentytwov),
+  (W is W2 // 451),
+  (Sevenw is 7 * W),
+  (X1 is R + V),
+  (X2 is X1 - Sevenw),
+  (X3 is X2 + 114),
+  (Month is X3 // 31),
+  (Z is X3 mod 31),
+  (Day is Z + 1).
+
+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,40 @@
+% 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.
+
+%% goal: type(X0, X1)
+
+%% goal: timeConstant_s(X0, X1)
+
+%% goal: cutoffFrequency_Hz(X0, X1)
+
+
+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),
+  (Tau is R * C).
+
+cutoff_frequency(Filter, Frequency) :-
+  time_constant(Filter, Tau),
+  constant(pi, Pi),
+  (Twopi is 2.0 * Pi),
+  (Denominator is Twopi * Tau),
+  (Frequency is 1.0 / Denominator).
+
+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).