eyeprolog 0.5.3

package/examples/enigma1225.pl

@@ -0,0 +1,240 @@
+% New Scientist puzzle Enigma 1225
+% Original code from https://www.sciencedirect.com/science/article/pii/S0898122106002057
+%
+% The maximum is retained in one pass with aggregate_max/5.  The recursive
+% helpers below are deterministic in the modes used by square/5; their cuts
+% make that operational contract explicit and keep automatic tabling for the
+% genuinely generative partition relation only.
+
+enigma1225(Size, [Permutation, Board, Max]) :-
+    aggregate_max(Total, board(M, Perm),
+                  square(Size, M, Total, _, Perm),
+                  Max, board(Board, Permutation)).
+
+var_matrix(Size, M) :-
+    repeat(Size, Size, RowLengths),
+    maplist(var_list, RowLengths, M).
+
+repeat(X, 1, [X]) :-
+    !.
+repeat(X, N, [X|R]) :-
+    !,
+    NewN is N - 1,
+    repeat(X, NewN, R).
+
+var_list(N, L) :-
+    length(L, N).
+
+list_permute([], _, []).
+list_permute([P1|Rest], L, [H|T]) :-
+    nth1(P1, L, H),
+    !,
+    list_permute(Rest, L, T).
+
+snd((_, X), X).
+
+retain_var(_, [], []).
+retain_var(V, [H|T], [H|L]) :-
+    H == V,
+    !,
+    retain_var(V, T, L).
+retain_var(V, [H|T], L) :-
+    H \== V,
+    retain_var(V, T, L).
+
+count_var(VarList, Var, Num) :-
+    retain_var(Var, VarList, List),
+    length(List, Num).
+
+total(IntPairs, Total) :-
+    total(IntPairs, 0, Total).
+
+total([], S, S).
+total([(X, Y)|T], Acc, S) :-
+    !,
+    NewAcc is Acc + X*Y,
+    total(T, NewAcc, S).
+
+zip([], _, []) :-
+    !.
+zip(_, [], []) :-
+    !.
+zip([H1|T1], [H2|T2], [(H1, H2)|T]) :-
+    !,
+    zip(T1, T2, T).
+
+from_to(M, N, L) :-
+    (   var(L)
+    ;   L = []
+    ;   L = [_|_]
+    ),
+    integer(M),
+    integer(N),
+    M =< N,
+    from_to_acc(M, [N], L),
+    !.
+from_to(H, N, [H|T]) :-
+    lastlist([H|T], N),
+    !,
+    H =< N.
+
+from_to_acc(H, [H|T], [H|T]).
+from_to_acc(M, [H|T], L) :-
+    NewHead is H - 1,
+    !,
+    from_to_acc(M, [NewHead, H|T], L).
+
+eval_matrix(Matrix, FreqSorted) :-
+    flatlist(Matrix, Entries),
+    setof(E, member(E, Entries), Set),
+    maplist(count_var(Entries), Set, Multiplicities),
+    zip(Multiplicities, Set, Frequencies),
+    sort(Frequencies, FreqSorted),
+    maplist(snd, FreqSorted, VarsSorted),
+    length(VarsSorted, NVars),
+    from_to(1, NVars, VarsSorted).
+
+distinct([_]).
+distinct([H|T]) :-
+    notin(H, T),
+    !,
+    distinct(T).
+
+notin(_, []).
+notin(E, [H|T]) :-
+    E \== H,
+    !,
+    notin(E, T).
+
+next_partition([(2, 1)|T], [(1, 2)|T]).
+next_partition([(2, AlphaK)|T], [(1, 2), (2, NewAlphaK)|T]) :-
+    AlphaK > 1,
+    NewAlphaK is AlphaK - 1.
+next_partition([(K, 1)|T], [(1, 1), (NewK, 1)|T]) :-
+    K > 2,
+    NewK is K - 1.
+next_partition([(K, AlphaK)|T], [(1, 1), (NewK, 1), (K, NewAlphaK)|T]) :-
+    K > 2,
+    AlphaK > 1,
+    NewK is K - 1,
+    NewAlphaK is AlphaK - 1.
+next_partition([(1, Alpha1), (2, 1)|T], [(1, NewAlpha)|T]) :-
+    NewAlpha is Alpha1 + 2.
+next_partition([(1, Alpha1), (2, Alpha2)|T], [(1, NewAlpha1), (2, NewAlpha2)|T]) :-
+    Alpha2 > 1,
+    NewAlpha1 is Alpha1 + 2,
+    NewAlpha2 is Alpha2 - 1.
+next_partition([(1, Alpha1), (L, 1)|T], [(Rest, 1), (NewL, Ratio)|T]) :-
+    L > 2,
+    NewL is L - 1,
+    Rest is (Alpha1 + L) mod NewL,
+    Rest > 0,
+    Ratio is (Alpha1 + L) // NewL.
+next_partition([(1, Alpha1), (L, 1)|T], [(NewL, Ratio)|T]) :-
+    L > 2,
+    NewL is L - 1,
+    Rest is (Alpha1 + L) mod NewL,
+    Rest =:= 0,
+    Ratio is (Alpha1 + L) // NewL.
+next_partition([(1, Alpha1), (L, AlphaL)|T], [(Rest, 1), (NewL, Ratio), (L, NewAlphaL)|T]) :-
+    L > 2,
+    AlphaL > 1,
+    NewL is L - 1,
+    Rest is (Alpha1 + L) mod NewL,
+    Rest > 0,
+    Ratio is (Alpha1 + L) // NewL,
+    NewAlphaL is AlphaL - 1.
+next_partition([(1, Alpha1), (L, AlphaL)|T], [(NewL, Ratio), (L, NewAlphaL)|T]) :-
+    L > 2,
+    AlphaL > 1,
+    NewL is L - 1,
+    Rest is (Alpha1 + L) mod NewL,
+    Rest =:= 0,
+    Ratio is (Alpha1 + L) // NewL,
+    NewAlphaL is AlphaL - 1.
+
+ad_partition(N, [(K, AlphaK)|T]) :-
+    generator([(N, 1)], [(K, AlphaK)|T]),
+    K > 1.
+
+generator(From, From).
+generator(Last, P) :-
+    next_partition(Last, New),
+    generator(New, P).
+
+splitter(N, Type, S) :-
+    from_to(1, N, L),
+    splitter(L, Type, [], S).
+
+splitter([], [(_, 0)], Acc, S) :-
+    reverse(Acc, S),
+    !.
+splitter(L, [(_, 0)|T], Acc, S) :-
+    !,
+    splitter(L, T, Acc, S).
+splitter(L, [(K, AlphaK)|T], Acc, S) :-
+    AlphaK > 0,
+    append(L1, L2, L),
+    length(L1, K),
+    NewAlphaK is AlphaK - 1,
+    splitter(L2, [(K, NewAlphaK)|T], [L1|Acc], S).
+
+list_rotate([H|T], L) :-
+    append(T, [H], L).
+
+rep_perm(N, Type, Perm) :-
+    splitter(N, Type, S),
+    maplist(list_rotate, S, R),
+    flatlist(R, Perm).
+
+square(Size, M, Total, Frequencies, Permutation) :-
+    var_matrix(Size, M),
+    ad_partition(Size, Partition),
+    rep_perm(Size, Partition, Permutation),
+    list_permute(Permutation, M, P),
+    transpose_matrix(P, M),
+    distinct(M),
+    eval_matrix(M, Frequencies),
+    total(Frequencies, Total).
+
+flatlist(List, FlatList) :-
+    flatlist_(List, [], FlatList0),
+    !,
+    FlatList = FlatList0.
+
+flatlist_(Var, Tl, [Var|Tl]) :-
+    var(Var),
+    !.
+flatlist_([], Tl, Tl) :- !.
+flatlist_([Hd|Tl], Tail, List) :-
+    !,
+    flatlist_(Hd, FlatHeadTail, List),
+    flatlist_(Tl, Tail, FlatHeadTail).
+flatlist_(NonList, Tl, [NonList|Tl]).
+
+lastlist([X|Xs], Last) :-
+    lastlist_(Xs, X, Last).
+
+lastlist_([], Last, Last).
+lastlist_([X|Xs], _, Last) :-
+    !,
+    lastlist_(Xs, X, Last).
+
+transpose_matrix([], []).
+transpose_matrix([A|B], C) :-
+    transpose_matrix(A, [A|B], C).
+
+transpose_matrix([], _, []).
+transpose_matrix([_|A], B, [C|D]) :-
+    !,
+    lists_reform(B, C, E),
+    transpose_matrix(A, E, D).
+
+lists_reform([], [], []).
+lists_reform([[A|B]|C], [A|D], [B|E]) :-
+    !,
+    lists_reform(C, D, E).
+
+% query
+%% goal: enigma1225(8, _)
+

package/examples/epidemic-policy.pl

@@ -0,0 +1,71 @@
+% 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.
+
+%% goal: riskScore(X0, X1)
+
+%% goal: cost(X0, X1)
+
+%% goal: status(X0, X1)
+
+%% goal: recommendedPolicy(X0, X1)
+
+%% goal: reason(X0, X1)
+
+
+% 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),
+  (A is Base * Vf),
+  (R is A * Mf).
+
+acceptable(P) :-
+  risk_score(P, R),
+  (R =< 0.75).
+
+status(P, insufficient_control) :-
+  policy(P),
+  risk_score(P, R),
+  (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,83 @@
+% 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.  EyeProlog 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.
+
+%% goal: egraphAnswer(X0, X1)
+
+
+
+% 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) :- number(A), number(B), (C is A + B).
+rewrite(mul(A, B), C) :- number(A), number(B), (C is A * B).
+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) :-
+  (Depth > 0),
+  (Previous_depth is Depth - 1),
+  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),
+  (Children is A_cost + B_cost),
+  (Cost is Children + 1).
+expr_cost(mul(A, B), Cost) :-
+  expr_cost(A, A_cost),
+  expr_cost(B, B_cost),
+  (Children is A_cost + B_cost),
+  (Cost is Children + 1).
+
+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,28 @@
+% 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.
+%% goal: sameClassBecauseOfSharedMember(X0, X1, X2)
+
+
+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),
+  (X \= Y).

package/examples/eulerian-path.pl

@@ -0,0 +1,91 @@
+% 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.
+%% goal: oddVertices(X0, X1)
+
+%% goal: path(X0, X1)
+
+%% goal: edgeCount(X0, X1)
+
+%% goal: reason(X0, X1)
+
+
+% 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),
+  (1 is Degree mod 2).
+
+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.pl

@@ -0,0 +1,91 @@
+% 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.
+%% goal: safeInWorld(X0, X1)
+
+%% goal: riskyInWorld(X0, X1)
+
+%% goal: reason(X0, X1)
+
+%% goal: status(X0, X1)
+
+
+% 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, _, _, _, _), (S > 100).
+speed_factor(T, 1.00) :- trip_data(T, _, S, _, _, _, _), (S =< 100).
+
+temperature_factor(T, 1.15) :- trip_data(T, _, _, Temp, _, _, _), (Temp < 0).
+temperature_factor(T, 1.00) :- trip_data(T, _, _, Temp, _, _, _), (Temp >= 0).
+
+payload_factor(T, 1.15) :- trip_data(T, _, _, _, P, _, _), (P > 500).
+payload_factor(T, 1.08) :- trip_data(T, _, _, _, P, _, _), (P > 250), (P =< 500).
+payload_factor(T, 1.00) :- trip_data(T, _, _, _, P, _, _), (P =< 250).
+
+base_energy(T, E) :-
+  trip_data(T, D, _, _, _, _, B),
+  (E is D * B).
+
+required_energy(T, w1, E) :-
+  base_energy(T, E).
+
+required_energy(T, w2, E) :-
+  base_energy(T, Base),
+  speed_factor(T, Sf),
+  (E is Base * Sf).
+
+required_energy(T, w0, E) :-
+  base_energy(T, Base),
+  speed_factor(T, Sf),
+  temperature_factor(T, Tf),
+  payload_factor(T, Pf),
+  (A is Base * Sf),
+  (B is A * Tf),
+  (E is B * Pf).
+
+required_energy(T, w3, E) :-
+  required_energy(T, w0, W0),
+  (E is W0 * 1.30).
+
+% 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),
+  (Required =< Battery).
+
+risky_in_world(T, W) :-
+  trip_data(T, _, _, _, _, Battery, _),
+  required_energy(T, W, Required),
+  (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/existential-rule.pl

@@ -0,0 +1,15 @@
+% Existential-style introduction with explicit Herbrand witnesses.
+%
+% EyeProlog has no blank nodes and no existential variables in rule heads.  A
+% rule can still express the practical executable shape of an existential
+% consequence by putting a named functional term directly in the head.
+
+%% goal: holds_result(X0, X1)
+
+
+type(socrates, human).
+type(plato, human).
+
+% In proof output this rule is the step that explains each visible witness.
+holds_result(Person, human_witness(Person)) :-
+  type(Person, human).