eyelang 1.7.14 → 1.7.15

package/docs/guide.md

@@ -335,6 +335,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`canary-release.eye`](../examples/canary-release.eye) | Decides canary rollout or rollback. | [`output/canary-release.eye`](../examples/output/canary-release.eye) |
 | [`cat-koko.eye`](../examples/cat-koko.eye) | Demonstrates named existential witnesses from a Cat Koko rule pattern. | [`output/cat-koko.eye`](../examples/output/cat-koko.eye) |
 | [`catalan-convolution.eye`](../examples/catalan-convolution.eye) | Computes Catalan numbers by tabled convolution. | [`output/catalan-convolution.eye`](../examples/output/catalan-convolution.eye) |
+| [`cdcl-sat-solver.eye`](../examples/cdcl-sat-solver.eye) | Simulates one CDCL conflict-analysis step with a learned clause and backjumped model. | [`output/cdcl-sat-solver.eye`](../examples/output/cdcl-sat-solver.eye) |
 | [`chart-parser.eye`](../examples/chart-parser.eye) | Parses small sentences with a tabled chart parser. | [`output/chart-parser.eye`](../examples/output/chart-parser.eye) |
 | [`clinical-trial-screening.eye`](../examples/clinical-trial-screening.eye) | Screens candidates for a trial. | [`output/clinical-trial-screening.eye`](../examples/output/clinical-trial-screening.eye) |
 | [`collatz-1000.eye`](../examples/collatz-1000.eye) | Materializes Collatz trajectories for starts 1000 down to 1. | [`output/collatz-1000.eye`](../examples/output/collatz-1000.eye) |
@@ -370,6 +371,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`drone-corridor-planner.eye`](../examples/drone-corridor-planner.eye) | Plans bounded drone corridor routes. | [`output/drone-corridor-planner.eye`](../examples/output/drone-corridor-planner.eye) |
 | [`easter-computus.eye`](../examples/easter-computus.eye) | Computes Gregorian Easter dates. | [`output/easter-computus.eye`](../examples/output/easter-computus.eye) |
 | [`electrical-rc-filter.eye`](../examples/electrical-rc-filter.eye) | Sizes an RC low-pass filter. | [`output/electrical-rc-filter.eye`](../examples/output/electrical-rc-filter.eye) |
+| [`equality-saturation.eye`](../examples/equality-saturation.eye) | Performs bounded equality saturation and extracts the cheapest equivalent expression. | [`output/equality-saturation.eye`](../examples/output/equality-saturation.eye) |
 | [`epidemic-policy.eye`](../examples/epidemic-policy.eye) | Chooses policies from risk and social cost. | [`output/epidemic-policy.eye`](../examples/output/epidemic-policy.eye) |
 | [`equivalence-classes-overlap-implies-same-class.eye`](../examples/equivalence-classes-overlap-implies-same-class.eye) | Packages the shared-member proof pattern for equivalence classes. | [`output/equivalence-classes-overlap-implies-same-class.eye`](../examples/output/equivalence-classes-overlap-implies-same-class.eye) |
 | [`eulerian-path.eye`](../examples/eulerian-path.eye) | Finds an Eulerian path using each edge once. | [`output/eulerian-path.eye`](../examples/output/eulerian-path.eye) |
@@ -407,6 +409,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`intuitionistic-logic-kripke.eye`](../examples/intuitionistic-logic-kripke.eye) | Emulates intuitionistic Kripke forcing and constructive implication. | [`output/intuitionistic-logic-kripke.eye`](../examples/output/intuitionistic-logic-kripke.eye) |
 | [`job-shop-scheduling.eye`](../examples/job-shop-scheduling.eye) | Searches a small job-shop schedule and minimizes makespan. | [`output/job-shop-scheduling.eye`](../examples/output/job-shop-scheduling.eye) |
 | [`knapsack-optimization.eye`](../examples/knapsack-optimization.eye) | Optimizes a finite 0/1 knapsack pack with aggregation. | [`output/knapsack-optimization.eye`](../examples/output/knapsack-optimization.eye) |
+| [`knuth-bendix-completion.eye`](../examples/knuth-bendix-completion.eye) | Checks bounded Knuth-Bendix-style critical pairs for joinability. | [`output/knuth-bendix-completion.eye`](../examples/output/knuth-bendix-completion.eye) |
 | [`knowledge-engineering-alignment-flow.eye`](../examples/knowledge-engineering-alignment-flow.eye) | Specializes reusable alignment rules into a target-shaped flow view. | [`output/knowledge-engineering-alignment-flow.eye`](../examples/output/knowledge-engineering-alignment-flow.eye) |
 | [`language.eye`](../examples/language.eye) | Shows the modern Eyelang surface syntax in one compact recursive graph example. | [`output/language.eye`](../examples/output/language.eye) |
 | [`law-of-cosines.eye`](../examples/law-of-cosines.eye) | Computes a triangle side by cosine law. | [`output/law-of-cosines.eye`](../examples/output/law-of-cosines.eye) |
@@ -434,6 +437,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`odrl-dpv-risk-ranked.eye`](../examples/odrl-dpv-risk-ranked.eye) | Ranks data-policy risks and mitigations. | [`output/odrl-dpv-risk-ranked.eye`](../examples/output/odrl-dpv-risk-ranked.eye) |
 | [`orbital-transfer-design.eye`](../examples/orbital-transfer-design.eye) | Designs a Hohmann orbital transfer. | [`output/orbital-transfer-design.eye`](../examples/output/orbital-transfer-design.eye) |
 | [`path-discovery.eye`](../examples/path-discovery.eye) | Discovers bounded air-route paths. | [`output/path-discovery.eye`](../examples/output/path-discovery.eye) |
+| [`partial-evaluator.eye`](../examples/partial-evaluator.eye) | Specializes tiny expression programs by folding static inputs into residual code. | [`output/partial-evaluator.eye`](../examples/output/partial-evaluator.eye) |
 | [`peano-arithmetic.eye`](../examples/peano-arithmetic.eye) | Computes Peano addition, multiplication, and factorial. | [`output/peano-arithmetic.eye`](../examples/output/peano-arithmetic.eye) |
 | [`peano-calculus.eye`](../examples/peano-calculus.eye) | Computes Peano addition, multiplication, and factorial. | [`output/peano-calculus.eye`](../examples/output/peano-calculus.eye) |
 | [`peasant.eye`](../examples/peasant.eye) | Performs peasant multiplication and exponentiation. | [`output/peasant.eye`](../examples/output/peasant.eye) |
@@ -445,6 +449,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`proof-contrapositive.eye`](../examples/proof-contrapositive.eye) | Models proof by contrapositive. | [`output/proof-contrapositive.eye`](../examples/output/proof-contrapositive.eye) |
 | [`quadratic-formula.eye`](../examples/quadratic-formula.eye) | Solves sample quadratic equations. | [`output/quadratic-formula.eye`](../examples/output/quadratic-formula.eye) |
 | [`radioactive-decay.eye`](../examples/radioactive-decay.eye) | Computes radioactive decay over time. | [`output/radioactive-decay.eye`](../examples/output/radioactive-decay.eye) |
+| [`register-allocation.eye`](../examples/register-allocation.eye) | Allocates temporaries to two registers with spilling by bounded graph-coloring search. | [`output/register-allocation.eye`](../examples/output/register-allocation.eye) |
 | [`reusable-builtins.eye`](../examples/reusable-builtins.eye) | Tours reusable numeric, list, and string builtins. | [`output/reusable-builtins.eye`](../examples/output/reusable-builtins.eye) |
 | [`riemann-hypothesis.eye`](../examples/riemann-hypothesis.eye) | Checks a finite catalogue of non-trivial zeta zeros against the Riemann-hypothesis condition. | [`output/riemann-hypothesis.eye`](../examples/output/riemann-hypothesis.eye) |
 | [`route-planning.eye`](../examples/route-planning.eye) | Finds routes and records them as explicit route terms. | [`output/route-planning.eye`](../examples/output/route-planning.eye) |

package/examples/cdcl-sat-solver.eye

@@ -0,0 +1,65 @@
+% A tiny CDCL-style SAT trace with one learned clause.
+%
+% Industrial CDCL solvers use watched literals, mutable trails, non-chronological
+% backjumping, clause databases, restarts, and activity heuristics.  Eyelang has
+% no mutable state or destructive trail updates, so this example models one small
+% conflict-analysis episode as relations over immutable terms.
+%
+% Formula:
+%   c1: not(a) or c
+%   c2: not(c)
+%   c3: a or b
+%
+% Decision a=true forces c=true by c1, which conflicts with c2.  Resolving the
+% reason c1 with the conflict c2 learns not(a).  After backjumping, learned
+% not(a) forces a=false, c2 gives c=false, and c3 forces b=true.
+
+materialize(cdclAnswer, 2).
+
+clause(c1, [neg(a), pos(c)]).
+clause(c2, [neg(c)]).
+clause(c3, [pos(a), pos(b)]).
+
+% Initial trail before conflict analysis.
+initial_value(a, true, decision(level1)).
+initial_value(c, true, implied_by(c1)).
+
+% The current trail makes a literal true or false.
+lit_true(pos(?var), ?value_rel) :- call_value(?value_rel, ?var, true, ?).
+lit_true(neg(?var), ?value_rel) :- call_value(?value_rel, ?var, false, ?).
+lit_false(pos(?var), ?value_rel) :- call_value(?value_rel, ?var, false, ?).
+lit_false(neg(?var), ?value_rel) :- call_value(?value_rel, ?var, true, ?).
+
+% Eyelang cannot pass predicates as first-class values, so this small dispatcher
+% lets the same literal helpers inspect either the initial or final trail.
+call_value(initial, ?var, ?value, ?reason) :- initial_value(?var, ?value, ?reason).
+call_value(final, ?var, ?value, ?reason) :- final_value(?var, ?value, ?reason).
+
+% A clause is conflicting when all of its literals are false under a trail.
+conflict(?trail, ?clause) :-
+  clause(?clause, ?literals),
+  forall(member(?literal, ?literals), lit_false(?literal, ?trail)).
+
+% The learned clause for this tiny implication graph is obtained by resolving
+% the conflict clause not(c) with c's reason not(a) or c, yielding not(a).
+learned_clause(l1, [neg(a)]).
+learned_from(l1, resolve(c2, c1, pivot(c))).
+
+% After backjumping, the learned unit clause fixes a=false.  Then the original
+% clauses imply c=false and b=true.
+final_value(a, false, learned(l1)).
+final_value(c, false, unit(c2)).
+final_value(b, true, unit(c3)).
+
+model_satisfies_clause(?trail, ?clause) :-
+  clause(?clause, ?literals),
+  member(?literal, ?literals),
+  lit_true(?literal, ?trail).
+
+final_model_ok(ok) :- forall(clause(?name, ?), model_satisfies_clause(final, ?name)).
+
+cdclAnswer(conflict_clause, ?clause) :- conflict(initial, ?clause).
+cdclAnswer(learned_clause, ?literals) :- learned_clause(l1, ?literals).
+cdclAnswer(learned_from, ?reason) :- learned_from(l1, ?reason).
+cdclAnswer(final_value(?var), ?value) :- final_model_ok(ok), final_value(?var, ?value, ?).
+cdclAnswer(note, "one learned clause makes the final model satisfy all original clauses") :- final_model_ok(ok).

package/examples/equality-saturation.eye

@@ -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.  Eyelang 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/knuth-bendix-completion.eye

@@ -0,0 +1,55 @@
+% Bounded Knuth-Bendix-style completion for append/2 terms.
+%
+% Full Knuth-Bendix completion orients equations, generates all critical pairs,
+% reduces them, and may add new rules until all overlaps are joinable.  That is
+% a difficult global search problem.  This example keeps the recognizable shape
+% but bounds the hard part: the rewrite system is fixed, and a small catalog of
+% critical overlaps is checked for joinability by normalization.
+
+materialize(kbAnswer, 2).
+
+table(normal_form, 2).
+
+% Oriented equations for a monoid-like append constructor.
+%   append(nil, x)       -> x
+%   append(x, nil)       -> x
+%   append(append(x,y),z)-> append(x, append(y,z))
+% The third rule right-associates terms so normalization terminates here.
+oriented_rule(left_identity, append(nil, ?x), ?x).
+oriented_rule(right_identity, append(?x, nil), ?x).
+oriented_rule(associate_right, append(append(?x, ?y), ?z), append(?x, append(?y, ?z))).
+
+% One rewrite at the root or below an append node.
+rewrite_once(?in, ?out, ?rule) :- oriented_rule(?rule, ?in, ?out).
+rewrite_once(append(?a, ?b), append(?new_a, ?b), ?rule) :- rewrite_once(?a, ?new_a, ?rule).
+rewrite_once(append(?a, ?b), append(?a, ?new_b), ?rule) :- rewrite_once(?b, ?new_b, ?rule).
+
+% Normalization by repeated rewriting.  The rules above are oriented so that the
+% recursive search has a normal form for the bounded terms in this example.
+normal_form(?term, ?term) :- not(rewrite_once(?term, ?, ?)).
+normal_form(?term, ?normal) :- rewrite_once(?term, ?next, ?), normal_form(?next, ?normal).
+
+% A few critical pairs that arise from overlapping the three oriented rules.
+% Each pair records the two one-step reducts that must later normalize together.
+critical_pair(left_identity_assoc,
+  append(a, b),
+  append(nil, append(a, b))).
+critical_pair(right_identity_assoc,
+  append(a, b),
+  append(a, append(nil, b))).
+critical_pair(nested_assoc,
+  append(append(a, append(b, c)), d),
+  append(append(a, b), append(c, d))).
+
+joined_pair(?name) :-
+  critical_pair(?name, ?left, ?right),
+  normal_form(?left, ?normal),
+  normal_form(?right, ?normal).
+
+sample_term(append(append(nil, append(a, nil)), append(b, c))).
+
+kbAnswer(sample_normal_form, ?normal) :- sample_term(?term), normal_form(?term, ?normal).
+kbAnswer(joined_critical_pair, ?name) :- joined_pair(?name).
+kbAnswer(oriented_rule_count, ?count) :- countall(oriented_rule(?, ?, ?), ?count).
+kbAnswer(joined_critical_pair_count, ?count) :- countall(joined_pair(?), ?count).
+kbAnswer(note, "a bounded completion check proves the selected critical pairs join") :- joined_pair(nested_assoc).

package/examples/output/cdcl-sat-solver.eye

@@ -0,0 +1,7 @@
+cdclAnswer(conflict_clause, c2).
+cdclAnswer(learned_clause, [neg(a)]).
+cdclAnswer(learned_from, resolve(c2, c1, pivot(c))).
+cdclAnswer(final_value(a), false).
+cdclAnswer(final_value(c), false).
+cdclAnswer(final_value(b), true).
+cdclAnswer(note, "one learned clause makes the final model satisfy all original clauses").

package/examples/output/equality-saturation.eye

@@ -0,0 +1,5 @@
+egraphAnswer(start, add(mul(add(x, 0), 1), mul(2, add(1, 2)))).
+egraphAnswer(best, add(x, 6)).
+egraphAnswer(cost, 3).
+egraphAnswer(candidate_count, 32).
+egraphAnswer(note, "bounded equality saturation extracts the cheapest term without a real e-graph").

package/examples/output/knuth-bendix-completion.eye

@@ -0,0 +1,7 @@
+kbAnswer(sample_normal_form, append(a, append(b, c))).
+kbAnswer(joined_critical_pair, left_identity_assoc).
+kbAnswer(joined_critical_pair, right_identity_assoc).
+kbAnswer(joined_critical_pair, nested_assoc).
+kbAnswer(oriented_rule_count, 3).
+kbAnswer(joined_critical_pair_count, 3).
+kbAnswer(note, "a bounded completion check proves the selected critical pairs join").

package/examples/output/partial-evaluator.eye

@@ -0,0 +1,4 @@
+partialEvalAnswer(residual(poly_y), add(mul(const(10), var(y)), const(13))).
+partialEvalAnswer(residual(static_branch), const(11)).
+partialEvalAnswer(residual(dynamic_branch), if(var(flag), const(11), mul(var(y), const(2)))).
+partialEvalAnswer(note, "static inputs are folded while dynamic variables remain as residual code").

package/examples/output/register-allocation.eye

@@ -0,0 +1,8 @@
+registerAnswer(best_allocation, [bind(a, r1), bind(b, spill), bind(c, r2), bind(d, r1)]).
+registerAnswer(spill_cost, 1).
+registerAnswer(place(a), r1).
+registerAnswer(place(b), spill).
+registerAnswer(place(c), r2).
+registerAnswer(place(d), r1).
+registerAnswer(valid_allocation_count, 33).
+registerAnswer(note, "the cheapest solution spills b to color the a-b-c triangle with two registers").

package/examples/partial-evaluator.eye

@@ -0,0 +1,74 @@
+% A tiny partial evaluator for expression terms.
+%
+% Real partial evaluation can specialize interpreters, control unfolding, avoid
+% code explosion, and even approach self-application.  This bounded Eyelang
+% version specializes a miniature expression language with known static inputs:
+% constants are folded, known variables are substituted, and dynamic variables
+% remain as residual code.
+
+materialize(partialEvalAnswer, 2).
+
+table(pe, 3).
+
+% Expression language: const/1, bool/1, var/1, add/2, mul/2, and if/3.
+% Static environments are lists of bind(Name, ResidualValue) terms.
+program(poly_y,
+  add(mul(var(x), var(y)), add(var(x), const(3))),
+  [bind(x, const(10))]).
+program(static_branch,
+  if(bool(true), add(var(x), const(1)), mul(var(y), const(999))),
+  [bind(x, const(10))]).
+program(dynamic_branch,
+  if(var(flag), add(var(x), const(1)), mul(var(y), const(2))),
+  [bind(x, const(10))]).
+
+lookup(?name, [bind(?name, ?value) | ?], ?value).
+lookup(?name, [bind(?, ?) | ?rest], ?value) :- lookup(?name, ?rest, ?value).
+
+known_var(?env, ?name, ?value) :- lookup(?name, ?env, ?value).
+unknown_var(?env, ?name) :- not(known_var(?env, ?name, ?)).
+
+pe(?, const(?n), const(?n)).
+pe(?, bool(?b), bool(?b)).
+pe(?env, var(?name), ?value) :- known_var(?env, ?name, ?value).
+pe(?env, var(?name), var(?name)) :- unknown_var(?env, ?name).
+
+% Constant folding for arithmetic when both residual operands became constants.
+pe(?env, add(?left, ?right), const(?sum)) :-
+  pe(?env, ?left, const(?a)),
+  pe(?env, ?right, const(?b)),
+  add(?a, ?b, ?sum).
+pe(?env, mul(?left, ?right), const(?product)) :-
+  pe(?env, ?left, const(?a)),
+  pe(?env, ?right, const(?b)),
+  mul(?a, ?b, ?product).
+
+% Residual arithmetic when at least one operand remains dynamic.
+pe(?env, add(?left, ?right), add(?left_residual, ?right_residual)) :-
+  pe(?env, ?left, ?left_residual),
+  pe(?env, ?right, ?right_residual),
+  not((eq(?left_residual, const(?a)), eq(?right_residual, const(?b)))).
+pe(?env, mul(?left, ?right), mul(?left_residual, ?right_residual)) :-
+  pe(?env, ?left, ?left_residual),
+  pe(?env, ?right, ?right_residual),
+  not((eq(?left_residual, const(?a)), eq(?right_residual, const(?b)))).
+
+% Static conditionals choose a branch; dynamic conditionals keep both residual
+% branches after specializing their contents.
+pe(?env, if(?cond, ?then, ?else), ?residual) :-
+  pe(?env, ?cond, bool(true)),
+  pe(?env, ?then, ?residual).
+pe(?env, if(?cond, ?then, ?else), ?residual) :-
+  pe(?env, ?cond, bool(false)),
+  pe(?env, ?else, ?residual).
+pe(?env, if(?cond, ?then, ?else), if(?cond_residual, ?then_residual, ?else_residual)) :-
+  pe(?env, ?cond, ?cond_residual),
+  not(eq(?cond_residual, bool(true))),
+  not(eq(?cond_residual, bool(false))),
+  pe(?env, ?then, ?then_residual),
+  pe(?env, ?else, ?else_residual).
+
+residual_program(?name, ?residual) :- program(?name, ?expr, ?env), pe(?env, ?expr, ?residual).
+
+partialEvalAnswer(residual(?name), ?residual) :- residual_program(?name, ?residual).
+partialEvalAnswer(note, "static inputs are folded while dynamic variables remain as residual code") :- residual_program(poly_y, ?).

package/examples/register-allocation.eye

@@ -0,0 +1,77 @@
+% Register allocation as bounded graph coloring with spilling.
+%
+% Production allocators combine liveness analysis, interference graphs, register
+% classes, coalescing, rematerialization, and spill-code insertion.  This Eyelang
+% example reduces the problem to its logical core: enumerate assignments of a
+% few temporaries to two registers or memory, reject register conflicts, and use
+% aggregate_min/5 to choose the cheapest spill plan.
+
+materialize(registerAnswer, 2).
+
+% Two physical registers are available.  The synthetic place spill means the
+% temporary is kept in memory instead of a register.
+register(r1).
+register(r2).
+place(?reg) :- register(?reg).
+place(spill).
+
+% Temporaries and the cost of spilling each one.  The triangle a-b-c cannot be
+% colored with only two registers, so at least one of them must spill.
+temporary(a, 10).
+temporary(b, 1).
+temporary(c, 10).
+temporary(d, 2).
+
+interferes(a, b).
+interferes(b, c).
+interferes(c, a).
+interferes(c, d).
+
+% A candidate allocation is an immutable list of bindings.  This is deliberately
+% brute force: three choices for each of four temporaries.
+candidate_allocation([
+  bind(a, ?a_place),
+  bind(b, ?b_place),
+  bind(c, ?c_place),
+  bind(d, ?d_place)
+]) :-
+  place(?a_place),
+  place(?b_place),
+  place(?c_place),
+  place(?d_place).
+
+assigned(?var, [[?var, ?place] | ?], ?place).
+assigned(?var, [bind(?var, ?place) | ?], ?place).
+assigned(?var, [bind(?, ?) | ?rest], ?place) :- assigned(?var, ?rest, ?place).
+
+% A conflict exists only when both interfering temporaries choose the same real
+% register.  Spilled temporaries do not occupy registers.
+allocation_conflict(?allocation) :-
+  interferes(?left, ?right),
+  assigned(?left, ?allocation, ?reg),
+  assigned(?right, ?allocation, ?reg),
+  register(?reg).
+
+valid_allocation(?allocation) :-
+  candidate_allocation(?allocation),
+  not(allocation_conflict(?allocation)).
+
+spill_cost_of_place(?var, spill, ?cost) :- temporary(?var, ?cost).
+spill_cost_of_place(?var, ?reg, 0) :- temporary(?var, ?), register(?reg).
+
+allocation_cost(?allocation, ?cost) :-
+  findall(?item_cost,
+    (member(bind(?var, ?place), ?allocation), spill_cost_of_place(?var, ?place, ?item_cost)),
+    ?costs),
+  sum_list(?costs, ?cost).
+
+best_allocation(?allocation, ?cost) :-
+  aggregate_min([?candidate_cost, ?candidate], ?candidate,
+    (valid_allocation(?candidate), allocation_cost(?candidate, ?candidate_cost)),
+    [?cost, ?allocation], ?allocation).
+
+registerAnswer(best_allocation, ?allocation) :- best_allocation(?allocation, ?).
+registerAnswer(spill_cost, ?cost) :- best_allocation(?, ?cost).
+registerAnswer(place(?var), ?place) :- best_allocation(?allocation, ?), assigned(?var, ?allocation, ?place).
+registerAnswer(valid_allocation_count, ?count) :- countall(valid_allocation(?), ?count).
+registerAnswer(note, "the cheapest solution spills b to color the a-b-c triangle with two registers") :- best_allocation(?, ?).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.7.14",
+  "version": "1.7.15",
   "description": "A small Prolog-like logic programming language for facts, rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -459,6 +459,7 @@
           "canary-release",
           "cat-koko",
           "catalan-convolution",
+          "cdcl-sat-solver",
           "chart-parser",
           "clinical-trial-screening",
           "collatz-1000",
@@ -494,6 +495,7 @@
           "drone-corridor-planner",
           "easter-computus",
           "electrical-rc-filter",
+          "equality-saturation",
           "epidemic-policy",
           "equivalence-classes-overlap-implies-same-class",
           "eulerian-path",
@@ -531,6 +533,7 @@
           "intuitionistic-logic-kripke",
           "job-shop-scheduling",
           "knapsack-optimization",
+          "knuth-bendix-completion",
           "knowledge-engineering-alignment-flow",
           "language",
           "law-of-cosines",
@@ -558,6 +561,7 @@
           "odrl-dpv-risk-ranked",
           "orbital-transfer-design",
           "path-discovery",
+          "partial-evaluator",
           "peano-arithmetic",
           "peano-calculus",
           "peasant",
@@ -569,6 +573,7 @@
           "proof-contrapositive",
           "quadratic-formula",
           "radioactive-decay",
+          "register-allocation",
           "reusable-builtins",
           "riemann-hypothesis",
           "route-planning",