eyelang 1.7.13 → 1.7.15

package/docs/guide.md

@@ -310,6 +310,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 
 | Example | Description | Golden output |
 | --- | --- | --- |
+| [`abstract-interpretation.eye`](../examples/abstract-interpretation.eye) | Performs a sign-domain abstract interpretation and reports a possible divide-by-zero warning. | [`output/abstract-interpretation.eye`](../examples/output/abstract-interpretation.eye) |
 | [`access-control-policy.eye`](../examples/access-control-policy.eye) | Evaluates role and condition based access decisions. | [`output/access-control-policy.eye`](../examples/output/access-control-policy.eye) |
 | [`ackermann.eye`](../examples/ackermann.eye) | Computes Ackermann-style hyperoperation values. | [`output/ackermann.eye`](../examples/output/ackermann.eye) |
 | [`age.eye`](../examples/age.eye) | Checks whether people meet age thresholds. | [`output/age.eye`](../examples/output/age.eye) |
@@ -334,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) |
@@ -369,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) |
@@ -406,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) |
@@ -433,19 +437,23 @@ 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) |
 | [`pell-equation.eye`](../examples/pell-equation.eye) | Generates Pell-equation solutions by recurrence. | [`output/pell-equation.eye`](../examples/output/pell-equation.eye) |
 | [`pendulum-period.eye`](../examples/pendulum-period.eye) | Computes simple pendulum periods. | [`output/pendulum-period.eye`](../examples/output/pendulum-period.eye) |
+| [`pointer-analysis.eye`](../examples/pointer-analysis.eye) | Computes Andersen-style inclusion-based points-to facts over address, assign, store, and load constraints. | [`output/pointer-analysis.eye`](../examples/output/pointer-analysis.eye) |
 | [`polynomial.eye`](../examples/polynomial.eye) | Finds complex integer polynomial roots. | [`output/polynomial.eye`](../examples/output/polynomial.eye) |
 | [`prime-range.eye`](../examples/prime-range.eye) | Finds primes in a finite range and computes a totient value. | [`output/prime-range.eye`](../examples/output/prime-range.eye) |
 | [`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) |
+| [`sat-solver-dpll.eye`](../examples/sat-solver-dpll.eye) | Searches a CNF formula with DPLL-style recursive decisions and early contradiction pruning. | [`output/sat-solver-dpll.eye`](../examples/output/sat-solver-dpll.eye) |
 | [`security-incident-correlation.eye`](../examples/security-incident-correlation.eye) | Correlates security incidents across signals. | [`output/security-incident-correlation.eye`](../examples/output/security-incident-correlation.eye) |
 | [`send-more-money.eye`](../examples/send-more-money.eye) | Solves the SEND + MORE = MONEY cryptarithm. | [`output/send-more-money.eye`](../examples/output/send-more-money.eye) |
 | [`service-impact.eye`](../examples/service-impact.eye) | Analyzes service impact over cyclic dependencies. | [`output/service-impact.eye`](../examples/output/service-impact.eye) |
@@ -464,6 +472,8 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`term-tools.eye`](../examples/term-tools.eye) | Inspects, builds, renders, and validates terms with reusable term/control builtins. | [`output/term-tools.eye`](../examples/output/term-tools.eye) |
 | [`totient-summatory.eye`](../examples/totient-summatory.eye) | Computes Euler totients and their summatory function. | [`output/totient-summatory.eye`](../examples/output/totient-summatory.eye) |
 | [`trust-flow-provenance-threshold.eye`](../examples/trust-flow-provenance-threshold.eye) | Classifies message trust from provenance confidence scores. | [`output/trust-flow-provenance-threshold.eye`](../examples/output/trust-flow-provenance-threshold.eye) |
+| [`truth-maintenance-system.eye`](../examples/truth-maintenance-system.eye) | Tracks assumptions, justifications, supported beliefs, and inconsistent environments in a tiny TMS. | [`output/truth-maintenance-system.eye`](../examples/output/truth-maintenance-system.eye) |
+| [`type-inference.eye`](../examples/type-inference.eye) | Infers/checks types for a tiny lambda language using logic unification over expression syntax trees. | [`output/type-inference.eye`](../examples/output/type-inference.eye) |
 | [`turing.eye`](../examples/turing.eye) | Simulates a binary-increment Turing machine. | [`output/turing.eye`](../examples/output/turing.eye) |
 | [`vector-similarity.eye`](../examples/vector-similarity.eye) | Computes dot product, norm, and cosine similarity. | [`output/vector-similarity.eye`](../examples/output/vector-similarity.eye) |
 | [`vulnerability-impact.eye`](../examples/vulnerability-impact.eye) | Analyzes vulnerable transitive dependencies and urgent patch impact. | [`output/vulnerability-impact.eye`](../examples/output/vulnerability-impact.eye) |

package/examples/abstract-interpretation.eye

@@ -0,0 +1,50 @@
+% Abstract interpretation over a tiny imperative program.
+%
+% The concrete program is:
+%
+%   x := input();
+%   if x < 0 then y := -x else y := x;
+%   z := 10 / y;
+%
+% Instead of executing the program for every integer input, this example tracks
+% only the abstract sign of each variable: neg, zero, or pos.  The analysis is
+% deliberately conservative: if the join point can see y = zero on any path, the
+% division is reported as a possible division-by-zero warning.
+
+materialize(absState, 3).
+materialize(absWarning, 2).
+materialize(absConclusion, 2).
+
+table(abs_state, 3).
+
+% The abstract domain.
+input_sign(neg).
+input_sign(zero).
+input_sign(pos).
+
+% The input statement gives x any of the three abstract signs.
+abs_state(input, x, ?sign) :- input_sign(?sign).
+
+% The branch refines the sign of x.  The negative branch only receives neg; the
+% non-negative branch receives zero or pos.
+abs_state(negative_branch, x, neg) :- abs_state(input, x, neg).
+abs_state(nonnegative_branch, x, zero) :- abs_state(input, x, zero).
+abs_state(nonnegative_branch, x, pos) :- abs_state(input, x, pos).
+
+% Transfer functions for assignments.  In the negative branch, y := -x turns a
+% negative x into a positive y.  In the non-negative branch, y := x preserves the
+% zero/positive information.
+abs_state(negative_branch, y, pos) :- abs_state(negative_branch, x, neg).
+abs_state(nonnegative_branch, y, ?sign) :- abs_state(nonnegative_branch, x, ?sign).
+
+% The join point merges abstract states from both branches.
+abs_state(join, ?var, ?sign) :- abs_state(negative_branch, ?var, ?sign).
+abs_state(join, ?var, ?sign) :- abs_state(nonnegative_branch, ?var, ?sign).
+
+% A possible zero denominator is enough to raise a conservative warning.
+possible_division_by_zero(join) :- abs_state(join, y, zero).
+
+absState(?point, ?var, sign(?sign)) :- abs_state(?point, ?var, ?sign).
+absWarning(division_by_zero, ?point) :- possible_division_by_zero(?point).
+absConclusion(case, "abstract interpretation keeps all feasible signs and warns because y may be zero") :-
+  possible_division_by_zero(join).

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/abstract-interpretation.eye

@@ -0,0 +1,16 @@
+absState(input, x, sign(neg)).
+absState(input, x, sign(zero)).
+absState(input, x, sign(pos)).
+absState(negative_branch, x, sign(neg)).
+absState(nonnegative_branch, x, sign(zero)).
+absState(nonnegative_branch, x, sign(pos)).
+absState(negative_branch, y, sign(pos)).
+absState(nonnegative_branch, y, sign(zero)).
+absState(nonnegative_branch, y, sign(pos)).
+absState(join, x, sign(neg)).
+absState(join, y, sign(pos)).
+absState(join, x, sign(zero)).
+absState(join, x, sign(pos)).
+absState(join, y, sign(zero)).
+absWarning(division_by_zero, join).
+absConclusion(case, "abstract interpretation keeps all feasible signs and warns because y may be zero").

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/pointer-analysis.eye

@@ -0,0 +1,8 @@
+pointsTo(x, object_a).
+pointsTo(z, object_b).
+pointsTo(y, object_a).
+pointsTo(r, object_b).
+pointsTo(q, object_b).
+heapField(object_a, object_b).
+pointerFlow(load_q_from_x, object_b).
+pointerConclusion(case, "the load q = *x recovers object_b through the store *y = z and y = x").

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/output/sat-solver-dpll.eye

@@ -0,0 +1,11 @@
+satModel([bind(d, true), bind(c, true), bind(b, true), bind(a, false)]).
+satValue(d, true).
+satValue(c, true).
+satValue(b, true).
+satValue(a, false).
+satClauseStatus(c1, satisfied).
+satClauseStatus(c2, satisfied).
+satClauseStatus(c3, satisfied).
+satClauseStatus(c4, satisfied).
+satClauseStatus(c5, satisfied).
+satConclusion(case, "DPLL finds a satisfying assignment after pruning clauses that become impossible").

package/examples/output/truth-maintenance-system.eye

@@ -0,0 +1,25 @@
+tmsSupport(clear_only, clear_path).
+tmsSupport(conflicting_sensors, clear_path).
+tmsSupport(blocked_only, blocked_path).
+tmsSupport(conflicting_sensors, blocked_path).
+tmsSupport(override_blocked, blocked_path).
+tmsSupport(clear_only, permit_go).
+tmsSupport(conflicting_sensors, permit_go).
+tmsSupport(blocked_only, forbid_go).
+tmsSupport(conflicting_sensors, forbid_go).
+tmsSupport(override_blocked, forbid_go).
+tmsSupport(override_blocked, permit_go).
+tmsJustification(clear_only, j_clear_path, clear_path).
+tmsJustification(conflicting_sensors, j_clear_path, clear_path).
+tmsJustification(blocked_only, j_blocked_path, blocked_path).
+tmsJustification(conflicting_sensors, j_blocked_path, blocked_path).
+tmsJustification(override_blocked, j_blocked_path, blocked_path).
+tmsJustification(clear_only, j_permit_from_clear, permit_go).
+tmsJustification(conflicting_sensors, j_permit_from_clear, permit_go).
+tmsJustification(blocked_only, j_forbid_from_blocked, forbid_go).
+tmsJustification(conflicting_sensors, j_forbid_from_blocked, forbid_go).
+tmsJustification(override_blocked, j_forbid_from_blocked, forbid_go).
+tmsJustification(override_blocked, j_override, permit_go).
+tmsInconsistent(conflicting_sensors).
+tmsInconsistent(override_blocked).
+tmsConclusion(case, "truth maintenance separates support from consistency across assumption environments").

package/examples/output/type-inference.eye

@@ -0,0 +1,8 @@
+type_answer(id, fun(t0, t0)).
+type_answer(const, fun(t0, fun(t1, t0))).
+type_answer(apply_id, int).
+type_answer(compose, fun(fun(t1, t2), fun(fun(t0, t1), fun(t0, t2)))).
+type_answer(branch, int).
+type_answer(first_of_pair, bool).
+type_reason(compose, "application unifies f with t1 -> t2 and g with t0 -> t1").
+type_reason(apply_id, "the identity function's parameter type is unified with int").

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/pointer-analysis.eye

@@ -0,0 +1,50 @@
+% Andersen-style inclusion-based pointer analysis.
+%
+% The program being analyzed has address-taking, assignment, store, and load
+% statements.  The logic rules compute a fixed point of points_to/2 and
+% field_points_to/2 facts.  This is the classic Datalog shape used in scalable
+% pointer-analysis papers, reduced to a small readable instance.
+
+materialize(pointsTo, 2).
+materialize(heapField, 2).
+materialize(pointerFlow, 2).
+materialize(pointerConclusion, 2).
+
+table(points_to, 2).
+table(field_points_to, 2).
+
+% Source-program statements:
+%   x = &object_a
+%   z = &object_b
+%   y = x
+%   *y = z
+%   q = *x
+%   r = q
+addr(x, object_a).
+addr(z, object_b).
+assign(y, x).
+store(y, z).
+load(q, x).
+assign(r, q).
+
+% Address-taking and assignment constraints.
+points_to(?var, ?object) :- addr(?var, ?object).
+points_to(?to, ?object) :- assign(?to, ?from), points_to(?from, ?object).
+
+% Store and load constraints.  If y may point to object_a and z may point to
+% object_b, then object_a's abstract field may point to object_b.  A later load
+% from x therefore gives q the same target.
+field_points_to(?heap_object, ?value_object) :-
+  store(?pointer, ?value),
+  points_to(?pointer, ?heap_object),
+  points_to(?value, ?value_object).
+points_to(?to, ?value_object) :-
+  load(?to, ?pointer),
+  points_to(?pointer, ?heap_object),
+  field_points_to(?heap_object, ?value_object).
+
+pointsTo(?var, ?object) :- points_to(?var, ?object).
+heapField(?heap_object, ?value_object) :- field_points_to(?heap_object, ?value_object).
+pointerFlow(load_q_from_x, ?object) :- points_to(q, ?object).
+pointerConclusion(case, "the load q = *x recovers object_b through the store *y = z and y = x") :-
+  points_to(q, object_b).

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/examples/sat-solver-dpll.eye

@@ -0,0 +1,88 @@
+% DPLL-style SAT solving for a small CNF formula.
+%
+% The example keeps the solver itself in Eyelang.  It recursively assigns
+% variables in a fixed order, prunes a branch as soon as any clause is already
+% impossible, and accepts a complete assignment when every clause is satisfied.
+% aggregate_min/5 is then used only to choose one canonical satisfying model.
+
+materialize(satModel, 1).
+materialize(satValue, 2).
+materialize(satClauseStatus, 2).
+materialize(satConclusion, 2).
+
+% CNF formula:
+%   (a or b)
+%   (not a or c)
+%   (not b or c)
+%   (not c or d)
+%   (c or not d)
+variable_order([a, b, c, d]).
+clause(c1, [pos(a), pos(b)]).
+clause(c2, [neg(a), pos(c)]).
+clause(c3, [neg(b), pos(c)]).
+clause(c4, [neg(c), pos(d)]).
+clause(c5, [pos(c), neg(d)]).
+
+bool(false).
+bool(true).
+bit(false, 0).
+bit(true, 1).
+
+% Look up a variable inside a partial or complete assignment represented as a
+% list of bind(Name, Bool) terms.
+lookup_bool(?name, [bind(?name, ?value) | ?], ?value).
+lookup_bool(?name, [bind(?, ?) | ?rest], ?value) :- lookup_bool(?name, ?rest, ?value).
+
+literal_true(pos(?var), ?assignment) :- lookup_bool(?var, ?assignment, true).
+literal_true(neg(?var), ?assignment) :- lookup_bool(?var, ?assignment, false).
+literal_false(pos(?var), ?assignment) :- lookup_bool(?var, ?assignment, false).
+literal_false(neg(?var), ?assignment) :- lookup_bool(?var, ?assignment, true).
+
+clause_satisfied(?assignment, ?clause_name) :-
+  clause(?clause_name, ?literals),
+  member(?literal, ?literals),
+  literal_true(?literal, ?assignment).
+
+% A partial branch is impossible when every literal in a clause is already false.
+% Unassigned literals keep the branch alive, just as in DPLL.
+clause_impossible(?assignment, ?clause_name) :-
+  clause(?clause_name, ?literals),
+  forall(member(?literal, ?literals), literal_false(?literal, ?assignment)).
+partial_consistent(?assignment) :- not((clause(?name, ?), clause_impossible(?assignment, ?name))).
+complete_model(?assignment) :- forall(clause(?name, ?), clause_satisfied(?assignment, ?name)).
+
+% Recursive DPLL search: choose a truth value, prune if inconsistent, then
+% continue with the remaining variables.
+dpll([], ?assignment, ?assignment) :- complete_model(?assignment).
+dpll([?var | ?rest], ?partial, ?model) :-
+  bool(?value),
+  partial_consistent([bind(?var, ?value) | ?partial]),
+  dpll(?rest, [bind(?var, ?value) | ?partial], ?model).
+
+satisfying_model(?model) :- variable_order(?vars), dpll(?vars, [], ?model).
+
+% Rank models so the materialized output shows one deterministic answer.  The
+% model list is in reverse decision order because each decision is pushed onto
+% the front during recursion.
+model_rank(?model, ?rank) :-
+  lookup_bool(a, ?model, ?a), bit(?a, ?abit),
+  lookup_bool(b, ?model, ?b), bit(?b, ?bbit),
+  lookup_bool(c, ?model, ?c), bit(?c, ?cbit),
+  lookup_bool(d, ?model, ?d), bit(?d, ?dbit),
+  mul(?abit, 8, ?arank),
+  mul(?bbit, 4, ?brank),
+  mul(?cbit, 2, ?crank),
+  add(?arank, ?brank, ?ab),
+  add(?crank, ?dbit, ?cd),
+  add(?ab, ?cd, ?rank).
+
+best_model(?model, ?rank) :-
+  aggregate_min(?candidate_rank, ?candidate_model,
+    (satisfying_model(?candidate_model), model_rank(?candidate_model, ?candidate_rank)),
+    ?rank, ?model).
+
+satModel(?model) :- best_model(?model, ?).
+satValue(?var, ?value) :- best_model(?model, ?), lookup_bool(?var, ?model, ?value).
+satClauseStatus(?clause, satisfied) :- best_model(?model, ?), clause_satisfied(?model, ?clause).
+satConclusion(case, "DPLL finds a satisfying assignment after pruning clauses that become impossible") :-
+  best_model(?, ?).

package/examples/truth-maintenance-system.eye

@@ -0,0 +1,62 @@
+% A tiny assumption-based truth maintenance system.
+%
+% An environment is a set of assumptions.  Justifications derive beliefs from
+% assumptions and from other derived beliefs.  The TMS can therefore explain
+% which environments support a belief and which environments are inconsistent
+% because they support contradictory conclusions.
+
+materialize(tmsSupport, 2).
+materialize(tmsJustification, 3).
+materialize(tmsInconsistent, 1).
+materialize(tmsConclusion, 2).
+
+table(supported, 2).
+
+% Candidate environments.
+environment(clear_only, [sensor_clear]).
+environment(blocked_only, [sensor_blocked]).
+environment(conflicting_sensors, [sensor_clear, sensor_blocked]).
+environment(override_blocked, [sensor_blocked, operator_override]).
+
+assumes(?environment, ?assumption) :-
+  environment(?environment, ?assumptions),
+  member(?assumption, ?assumptions).
+
+% Justifications.  Preconditions are either assumption(Name) or another derived
+% belief.  The last justification says an operator override can permit motion
+% even when the blocked-path belief is also present.
+justification(j_clear_path, [assumption(sensor_clear)], clear_path).
+justification(j_blocked_path, [assumption(sensor_blocked)], blocked_path).
+justification(j_permit_from_clear, [clear_path], permit_go).
+justification(j_forbid_from_blocked, [blocked_path], forbid_go).
+justification(j_override, [assumption(operator_override), blocked_path], permit_go).
+
+all_hold(?, []).
+all_hold(?environment, [assumption(?assumption) | ?rest]) :-
+  assumes(?environment, ?assumption),
+  all_hold(?environment, ?rest).
+all_hold(?environment, [?belief | ?rest]) :-
+  supported(?environment, ?belief),
+  all_hold(?environment, ?rest).
+
+supported(?environment, ?belief) :-
+  justification(?, ?preconditions, ?belief),
+  all_hold(?environment, ?preconditions).
+
+contradicts(permit_go, forbid_go).
+contradicts(forbid_go, permit_go).
+inconsistent(?environment) :-
+  supported(?environment, ?left),
+  supported(?environment, ?right),
+  contradicts(?left, ?right).
+
+% Show the actual justifications that fired, not just the final supported beliefs.
+fires(?environment, ?justification, ?belief) :-
+  justification(?justification, ?preconditions, ?belief),
+  all_hold(?environment, ?preconditions).
+
+tmsSupport(?environment, ?belief) :- supported(?environment, ?belief).
+tmsJustification(?environment, ?justification, ?belief) :- fires(?environment, ?justification, ?belief).
+tmsInconsistent(?environment) :- inconsistent(?environment).
+tmsConclusion(case, "truth maintenance separates support from consistency across assumption environments") :-
+  inconsistent(conflicting_sensors).

package/examples/type-inference.eye

@@ -0,0 +1,58 @@
+% Hindley-Milner-style type inference for a tiny lambda language.
+%
+% The example is intentionally small and deterministic.  Lambda binders carry
+% explicit type variables or annotations, and ordinary logic unification solves
+% the constraints created by application, arithmetic, conditionals, and pairs.
+% The symbolic names t0, t1, and t2 stand for schematic type variables in the
+% displayed answers; concrete examples such as apply_id annotate the argument as
+% int so the application can be checked.
+materialize(type_answer, 2).
+materialize(type_reason, 2).
+
+table(type_expr, 3).
+
+% Tiny expression language: int_lit/1, bool_lit/1, var/1, lam/3, app/2,
+% add/2, if/3, pair/2, fst/1, and snd/1.
+program(id, lam(x, t0, var(x))).
+program(const, lam(x, t0, lam(y, t1, var(x)))).
+program(apply_id, app(lam(x, int, var(x)), int_lit(42))).
+program(compose,
+  lam(f, fun(t1, t2),
+    lam(g, fun(t0, t1),
+      lam(x, t0,
+        app(var(f), app(var(g), var(x))))))).
+program(branch,
+  if(bool_lit(true), add(int_lit(20), int_lit(22)), int_lit(0))).
+program(first_of_pair, fst(pair(bool_lit(true), int_lit(7)))).
+
+lookup(?name, [[?name, ?type] | ?], ?type).
+lookup(?name, [[?, ?] | ?rest], ?type) :- lookup(?name, ?rest, ?type).
+
+type_expr(?, int_lit(?), int).
+type_expr(?, bool_lit(?), bool).
+type_expr(?env, var(?name), ?type) :- lookup(?name, ?env, ?type).
+type_expr(?env, lam(?name, ?arg_type, ?body), fun(?arg_type, ?body_type)) :-
+  type_expr([[?name, ?arg_type] | ?env], ?body, ?body_type).
+type_expr(?env, app(?fn, ?arg), ?result_type) :-
+  type_expr(?env, ?fn, fun(?arg_type, ?result_type)),
+  type_expr(?env, ?arg, ?arg_type).
+type_expr(?env, add(?left, ?right), int) :-
+  type_expr(?env, ?left, int),
+  type_expr(?env, ?right, int).
+type_expr(?env, if(?cond, ?then, ?else), ?type) :-
+  type_expr(?env, ?cond, bool),
+  type_expr(?env, ?then, ?type),
+  type_expr(?env, ?else, ?type).
+type_expr(?env, pair(?left, ?right), pair(?left_type, ?right_type)) :-
+  type_expr(?env, ?left, ?left_type),
+  type_expr(?env, ?right, ?right_type).
+type_expr(?env, fst(?pair), ?left_type) :-
+  type_expr(?env, ?pair, pair(?left_type, ?)).
+type_expr(?env, snd(?pair), ?right_type) :-
+  type_expr(?env, ?pair, pair(?, ?right_type)).
+
+type_answer(?name, ?type) :- program(?name, ?expr), type_expr([], ?expr, ?type).
+type_reason(compose, "application unifies f with t1 -> t2 and g with t0 -> t1") :-
+  type_answer(compose, ?).
+type_reason(apply_id, "the identity function's parameter type is unified with int") :-
+  type_answer(apply_id, int).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.7.13",
+  "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

@@ -434,6 +434,7 @@
 
   <script type="module">
     const EXAMPLES = [
+          "abstract-interpretation",
           "access-control-policy",
           "ackermann",
           "age",
@@ -458,6 +459,7 @@
           "canary-release",
           "cat-koko",
           "catalan-convolution",
+          "cdcl-sat-solver",
           "chart-parser",
           "clinical-trial-screening",
           "collatz-1000",
@@ -493,6 +495,7 @@
           "drone-corridor-planner",
           "easter-computus",
           "electrical-rc-filter",
+          "equality-saturation",
           "epidemic-policy",
           "equivalence-classes-overlap-implies-same-class",
           "eulerian-path",
@@ -530,6 +533,7 @@
           "intuitionistic-logic-kripke",
           "job-shop-scheduling",
           "knapsack-optimization",
+          "knuth-bendix-completion",
           "knowledge-engineering-alignment-flow",
           "language",
           "law-of-cosines",
@@ -557,19 +561,23 @@
           "odrl-dpv-risk-ranked",
           "orbital-transfer-design",
           "path-discovery",
+          "partial-evaluator",
           "peano-arithmetic",
           "peano-calculus",
           "peasant",
           "pell-equation",
           "pendulum-period",
+          "pointer-analysis",
           "polynomial",
           "prime-range",
           "proof-contrapositive",
           "quadratic-formula",
           "radioactive-decay",
+          "register-allocation",
           "reusable-builtins",
           "riemann-hypothesis",
           "route-planning",
+          "sat-solver-dpll",
           "security-incident-correlation",
           "send-more-money",
           "service-impact",
@@ -588,6 +596,8 @@
           "term-tools",
           "totient-summatory",
           "trust-flow-provenance-threshold",
+          "truth-maintenance-system",
+          "type-inference",
           "turing",
           "vector-similarity",
           "vulnerability-impact",