eyelang 1.7.13 → 1.7.14

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) |
@@ -438,6 +439,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`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) |
@@ -446,6 +448,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`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 +467,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/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/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/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/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/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.14",
   "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",
@@ -562,6 +563,7 @@
           "peasant",
           "pell-equation",
           "pendulum-period",
+          "pointer-analysis",
           "polynomial",
           "prime-range",
           "proof-contrapositive",
@@ -570,6 +572,7 @@
           "reusable-builtins",
           "riemann-hypothesis",
           "route-planning",
+          "sat-solver-dpll",
           "security-incident-correlation",
           "send-more-money",
           "service-impact",
@@ -588,6 +591,8 @@
           "term-tools",
           "totient-summatory",
           "trust-flow-provenance-threshold",
+          "truth-maintenance-system",
+          "type-inference",
           "turing",
           "vector-similarity",
           "vulnerability-impact",