eyelang 1.7.14 → 1.7.16

package/README.md

@@ -49,6 +49,7 @@ console.log(result.stdout);
 - [Playground](https://eyereasoner.github.io/eyelang/playground)
 - [Guide](docs/guide.md)
 - [Language reference](docs/language-reference.md)
+- [A Compact Reasoning Workbench](docs/compact-reasoning-workbench.md)
 
 For local browser use, serve the checkout first so the playground can load ES modules and example files:
 

package/docs/compact-reasoning-workbench.md

@@ -0,0 +1,35 @@
+# A Compact Reasoning Workbench
+
+Eyelang began as a small thing: a few facts, a few rules, a way to ask a question and get an answer.
+
+At first it solved the familiar problems. Paths through graphs. Ancestors in families. Tiny proofs that fit on one screen. The early examples in `examples/` keep that beginning visible: they show the core idiom before anything becomes exotic. Facts describe a world, rules extend it, goals ask for visible consequences, and answers come back as ordinary terms.
+
+Then the examples started to widen.
+
+Mathematical programs turned recurrence, tabling, aggregation, and finite search into executable relations. Fibonacci numbers, Collatz traces, integer partitions, Catalan numbers, binomial identities, Stirling and Bell numbers, graph paths, and scheduling problems made performance visible without hiding the logic behind a host-language library.
+
+Knowledge-modeling examples pulled the same syntax in a different direction. Policies, GDPR-style compliance, access control, clinical screening, deontic rules, purpose mapping, alignment flows, and context audits were not mainly numerical problems. They were problems of explanation, qualification, exception, and traceability. In those cases Eyelang stayed close to the vocabulary of the domain.
+
+Science and engineering examples stretched the language again. Filters, beams, control systems, kinetics, gas laws, gradients, coding theory, and optimization showed that structured calculation could live inside a larger rule-based argument. The programs remained small enough to read, but substantial enough to test the engine.
+
+Then came examples that looked more like systems research than toy logic programs. Markov Logic Network-style scoring represented weighted possible worlds while keeping the probability model explicit. Type inference, abstract interpretation, pointer analysis, SAT solving, truth maintenance, and register allocation showed that programming-language and analysis problems could be written as compact theories rather than opaque procedures.
+
+At the far edge were the deliberately uncomfortable examples: partial evaluation, Knuth-Bendix completion, CDCL-style SAT solving, and bounded equality saturation. They did not pretend that Eyelang was a mutable union-find library, an industrial optimizer, or a replacement for every specialized solver. They were useful precisely because they marked the boundary. Some problems had to be bounded. Some had to be expressed carefully. Some revealed where a small logic engine ends and another tool should take over.
+
+That made `examples/` more than a gallery. It became executable documentation, regression evidence, and a map of the language's range. Each file was a compact theory with an expected output that could be run, inspected, and kept honest by the test suite.
+
+The surprise was not that every hard problem became easy. They did not.
+
+The surprise was that the same small core kept reaching.
+
+Across mathematics, knowledge modeling, science, program analysis, symbolic reasoning, optimization, explanation, and search, Eyelang stayed recognizable. The programs were not black boxes. They were little theories: readable, testable, and executable. When performance mattered, tabling and careful formulations often carried them farther than expected.
+
+By the end, Eyelang no longer looked like a toy language with a few clever demos.
+
+It looked like a compact reasoning workbench.
+
+Small enough to understand.
+
+Expressive enough to surprise.
+
+Fast enough to take seriously.

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.16",
   "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",