eyelang 1.1.14 → 1.1.16

package/docs/guide.md

@@ -302,10 +302,10 @@ Use `holds/2` when you want to match the member term directly, for example `name
 
 ## Example catalog
 
-The repository includes examples for recursion, graph reachability, finite search, arithmetic, list processing, optimization, policies, puzzles, and applied scientific calculations. Bundled examples use relation-style output.
+Each example has a checked golden output in `examples/output`.
 
-| Input | Short description | Output |
-| --- | --- | --- |
+| Example | What it demonstrates | Golden output |
+|---|---|---|
 | [`access-control-policy.pl`](../examples/access-control-policy.pl) | Evaluates role and condition based access decisions. | [`output/access-control-policy.pl`](../examples/output/access-control-policy.pl) |
 | [`ackermann.pl`](../examples/ackermann.pl) | Computes Ackermann-style hyperoperation values. | [`output/ackermann.pl`](../examples/output/ackermann.pl) |
 | [`age.pl`](../examples/age.pl) | Checks whether people meet age thresholds. | [`output/age.pl`](../examples/output/age.pl) |
@@ -328,6 +328,7 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`cache-performance.pl`](../examples/cache-performance.pl) | Summarizes cache latency performance. | [`output/cache-performance.pl`](../examples/output/cache-performance.pl) |
 | [`canary-release.pl`](../examples/canary-release.pl) | Decides canary rollout or rollback. | [`output/canary-release.pl`](../examples/output/canary-release.pl) |
 | [`cat-koko.pl`](../examples/cat-koko.pl) | Demonstrates named existential witnesses from a Cat Koko rule pattern. | [`output/cat-koko.pl`](../examples/output/cat-koko.pl) |
+| [`chart-parser.pl`](../examples/chart-parser.pl) | Parses small sentences with a memoized chart parser. | [`output/chart-parser.pl`](../examples/output/chart-parser.pl) |
 | [`clinical-trial-screening.pl`](../examples/clinical-trial-screening.pl) | Screens candidates for a trial. | [`output/clinical-trial-screening.pl`](../examples/output/clinical-trial-screening.pl) |
 | [`collatz-1000.pl`](../examples/collatz-1000.pl) | Materializes Collatz trajectories for starts 1000 down to 1. | [`output/collatz-1000.pl`](../examples/output/collatz-1000.pl) |
 | [`combinatorics-findall-sort.pl`](../examples/combinatorics-findall-sort.pl) | Collects and sorts finite combinations. | [`output/combinatorics-findall-sort.pl`](../examples/output/combinatorics-findall-sort.pl) |
@@ -337,6 +338,7 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`context-association.pl`](../examples/context-association.pl) | Associates named contexts with their contents. | [`output/context-association.pl`](../examples/output/context-association.pl) |
 | [`context-schema-audit.pl`](../examples/context-schema-audit.pl) | Audits mixed-arity context members with `holds/3`. | [`output/context-schema-audit.pl`](../examples/output/context-schema-audit.pl) |
 | [`control-system.pl`](../examples/control-system.pl) | Evaluates control-system measurements and targets. | [`output/control-system.pl`](../examples/output/control-system.pl) |
+| [`critical-path-schedule.pl`](../examples/critical-path-schedule.pl) | Computes earliest starts and the critical path for a project network. | [`output/critical-path-schedule.pl`](../examples/output/critical-path-schedule.pl) |
 | [`cyclic-path.pl`](../examples/cyclic-path.pl) | Computes paths in a cyclic graph. | [`output/cyclic-path.pl`](../examples/output/cyclic-path.pl) |
 | [`d3-group.pl`](../examples/d3-group.pl) | Enumerates subgroups of the D3 group. | [`output/d3-group.pl`](../examples/output/d3-group.pl) |
 | [`dairy-energy-balance.pl`](../examples/dairy-energy-balance.pl) | Classifies dairy cow energy balance. | [`output/dairy-energy-balance.pl`](../examples/output/dairy-energy-balance.pl) |
@@ -391,6 +393,8 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`heron-theorem.pl`](../examples/heron-theorem.pl) | Computes triangle area by Heron's theorem. | [`output/heron-theorem.pl`](../examples/output/heron-theorem.pl) |
 | [`ideal-gas-law.pl`](../examples/ideal-gas-law.pl) | Applies the ideal gas law. | [`output/ideal-gas-law.pl`](../examples/output/ideal-gas-law.pl) |
 | [`illegitimate-reasoning.pl`](../examples/illegitimate-reasoning.pl) | Detects suspect reasoning patterns. | [`output/illegitimate-reasoning.pl`](../examples/output/illegitimate-reasoning.pl) |
+| [`job-shop-scheduling.pl`](../examples/job-shop-scheduling.pl) | Searches a small job-shop schedule and minimizes makespan. | [`output/job-shop-scheduling.pl`](../examples/output/job-shop-scheduling.pl) |
+| [`knapsack-optimization.pl`](../examples/knapsack-optimization.pl) | Optimizes a finite 0/1 knapsack pack with aggregation. | [`output/knapsack-optimization.pl`](../examples/output/knapsack-optimization.pl) |
 | [`knowledge-engineering-alignment-flow.pl`](../examples/knowledge-engineering-alignment-flow.pl) | Specializes reusable alignment rules into a target-shaped flow view. | [`output/knowledge-engineering-alignment-flow.pl`](../examples/output/knowledge-engineering-alignment-flow.pl) |
 | [`law-of-cosines.pl`](../examples/law-of-cosines.pl) | Computes a triangle side by cosine law. | [`output/law-of-cosines.pl`](../examples/output/law-of-cosines.pl) |
 | [`least-squares-regression.pl`](../examples/least-squares-regression.pl) | Fits a least-squares regression line. | [`output/least-squares-regression.pl`](../examples/output/least-squares-regression.pl) |
@@ -398,7 +402,9 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`lldm.pl`](../examples/lldm.pl) | Calculates leg-length discrepancy measurements. | [`output/lldm.pl`](../examples/output/lldm.pl) |
 | [`manufacturing-quality-control.pl`](../examples/manufacturing-quality-control.pl) | Evaluates process capability and quality. | [`output/manufacturing-quality-control.pl`](../examples/output/manufacturing-quality-control.pl) |
 | [`microgrid-dispatch.pl`](../examples/microgrid-dispatch.pl) | Plans microgrid dispatch and reserve. | [`output/microgrid-dispatch.pl`](../examples/output/microgrid-dispatch.pl) |
+| [`missionaries-cannibals.pl`](../examples/missionaries-cannibals.pl) | Solves the missionaries-and-cannibals river crossing puzzle. | [`output/missionaries-cannibals.pl`](../examples/output/missionaries-cannibals.pl) |
 | [`monkey-bananas.pl`](../examples/monkey-bananas.pl) | Solves the monkey-and-bananas puzzle. | [`output/monkey-bananas.pl`](../examples/output/monkey-bananas.pl) |
+| [`n-queens-8.pl`](../examples/n-queens-8.pl) | Solves the 8-queens search problem with diagonal constraints. | [`output/n-queens-8.pl`](../examples/output/n-queens-8.pl) |
 | [`network-sla.pl`](../examples/network-sla.pl) | Checks network path SLA compliance. | [`output/network-sla.pl`](../examples/output/network-sla.pl) |
 | [`newton-raphson.pl`](../examples/newton-raphson.pl) | Finds roots by Newton-Raphson iteration. | [`output/newton-raphson.pl`](../examples/output/newton-raphson.pl) |
 | [`nixon-diamond.pl`](../examples/nixon-diamond.pl) | Reports the classic Nixon-diamond conflict. | [`output/nixon-diamond.pl`](../examples/output/nixon-diamond.pl) |
@@ -418,24 +424,29 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`reusable-builtins.pl`](../examples/reusable-builtins.pl) | Tours reusable numeric, list, and string builtins. | [`output/reusable-builtins.pl`](../examples/output/reusable-builtins.pl) |
 | [`riemann-hypothesis.pl`](../examples/riemann-hypothesis.pl) | Checks a finite catalogue of non-trivial zeta zeros against the Riemann-hypothesis condition. | [`output/riemann-hypothesis.pl`](../examples/output/riemann-hypothesis.pl) |
 | [`security-incident-correlation.pl`](../examples/security-incident-correlation.pl) | Correlates security incidents across signals. | [`output/security-incident-correlation.pl`](../examples/output/security-incident-correlation.pl) |
+| [`send-more-money.pl`](../examples/send-more-money.pl) | Solves the SEND + MORE = MONEY cryptarithm. | [`output/send-more-money.pl`](../examples/output/send-more-money.pl) |
 | [`service-impact.pl`](../examples/service-impact.pl) | Analyzes service impact over cyclic dependencies. | [`output/service-impact.pl`](../examples/output/service-impact.pl) |
 | [`sieve.pl`](../examples/sieve.pl) | Enumerates primes with a sieve-style program. | [`output/sieve.pl`](../examples/output/sieve.pl) |
 | [`skolem-functions.pl`](../examples/skolem-functions.pl) | Generates deterministic functional terms. | [`output/skolem-functions.pl`](../examples/output/skolem-functions.pl) |
 | [`socket-age.pl`](../examples/socket-age.pl) | Shows socket-declared age reasoning inputs and plugs. | [`output/socket-age.pl`](../examples/output/socket-age.pl) |
 | [`socket-family.pl`](../examples/socket-family.pl) | Shows socket-declared family-source inputs and ancestry rules. | [`output/socket-family.pl`](../examples/output/socket-family.pl) |
 | [`socrates.pl`](../examples/socrates.pl) | Derives that Socrates is mortal. | [`output/socrates.pl`](../examples/output/socrates.pl) |
+| [`stable-marriage.pl`](../examples/stable-marriage.pl) | Finds stable matchings by excluding blocking pairs. | [`output/stable-marriage.pl`](../examples/output/stable-marriage.pl) |
 | [`statistics-summary.pl`](../examples/statistics-summary.pl) | Computes population statistics for a sample. | [`output/statistics-summary.pl`](../examples/output/statistics-summary.pl) |
+| [`sudoku-4x4.pl`](../examples/sudoku-4x4.pl) | Solves a compact 4x4 Sudoku by finite constraint search. | [`output/sudoku-4x4.pl`](../examples/output/sudoku-4x4.pl) |
 | [`superdense-coding.pl`](../examples/superdense-coding.pl) | Models superdense-coding bit transmission. | [`output/superdense-coding.pl`](../examples/output/superdense-coding.pl) |
 | [`term-tools.pl`](../examples/term-tools.pl) | Inspects, builds, renders, and validates terms with reusable term/control builtins. | [`output/term-tools.pl`](../examples/output/term-tools.pl) |
 | [`trust-flow-provenance-threshold.pl`](../examples/trust-flow-provenance-threshold.pl) | Classifies message trust from provenance confidence scores. | [`output/trust-flow-provenance-threshold.pl`](../examples/output/trust-flow-provenance-threshold.pl) |
 | [`turing.pl`](../examples/turing.pl) | Simulates a binary-increment Turing machine. | [`output/turing.pl`](../examples/output/turing.pl) |
 | [`vector-similarity.pl`](../examples/vector-similarity.pl) | Computes dot product, norm, and cosine similarity. | [`output/vector-similarity.pl`](../examples/output/vector-similarity.pl) |
 | [`vulnerability-impact.pl`](../examples/vulnerability-impact.pl) | Analyzes vulnerable transitive dependencies and urgent patch impact. | [`output/vulnerability-impact.pl`](../examples/output/vulnerability-impact.pl) |
+| [`weighted-interval-scheduling.pl`](../examples/weighted-interval-scheduling.pl) | Selects the best non-overlapping weighted intervals with memoized dynamic programming. | [`output/weighted-interval-scheduling.pl`](../examples/output/weighted-interval-scheduling.pl) |
 | [`witch.pl`](../examples/witch.pl) | Derives the classic “burn the witch” rule chain. | [`output/witch.pl`](../examples/output/witch.pl) |
 | [`wolf-goat-cabbage.pl`](../examples/wolf-goat-cabbage.pl) | Solves the wolf-goat-cabbage river crossing. | [`output/wolf-goat-cabbage.pl`](../examples/output/wolf-goat-cabbage.pl) |
 | [`zebra.pl`](../examples/zebra.pl) | Solves the zebra logic puzzle. | [`output/zebra.pl`](../examples/output/zebra.pl) |
 
 
+
 ## Golden outputs, tests, and conformance
 
 Golden answer outputs live in [`examples/output`](../examples/output). `npm run test:eyelang` covers the eyelang integration check, conformance cases, regression checks, runnable examples, and proof-output examples. A curated proof-output suite for `.pl` examples lives in [`examples/proof`](../examples/proof). Example tests pin `local_time/1` to `2026-05-30` so date-dependent examples stay deterministic. Regenerate them after an intentional output or explanation change:

package/examples/chart-parser.pl

@@ -0,0 +1,59 @@
+% A tiny memoized chart parser for a context-free grammar.
+% span/4 is the dynamic-programming chart relation: sentence, category,
+% start index, and end index.
+materialize(chart_parser_answer, 2).
+
+memoize(span, 4).
+
+sentence(command, 5).
+sentence(ambiguous_pp, 8).
+
+word(command, 0, the).
+word(command, 1, robot).
+word(command, 2, moves).
+word(command, 3, the).
+word(command, 4, box).
+
+word(ambiguous_pp, 0, the).
+word(ambiguous_pp, 1, robot).
+word(ambiguous_pp, 2, sees).
+word(ambiguous_pp, 3, the).
+word(ambiguous_pp, 4, box).
+word(ambiguous_pp, 5, with).
+word(ambiguous_pp, 6, the).
+word(ambiguous_pp, 7, telescope).
+
+terminal(det, the).
+terminal(noun, robot).
+terminal(noun, box).
+terminal(noun, telescope).
+terminal(verb, moves).
+terminal(verb, sees).
+terminal(prep, with).
+
+rule(s, np, vp).
+rule(np, det, noun).
+rule(np, np, pp).
+rule(vp, verb, np).
+rule(vp, vp, pp).
+rule(pp, prep, np).
+
+span(Sentence, Category, Start, End) :-
+  word(Sentence, Start, Token),
+  terminal(Category, Token),
+  add(Start, 1, End).
+span(Sentence, Category, Start, End) :-
+  rule(Category, Left, Right),
+  span(Sentence, Left, Start, Middle),
+  span(Sentence, Right, Middle, End).
+
+chart_parser_answer(parsed, Sentence) :-
+  sentence(Sentence, Length),
+  span(Sentence, s, 0, Length).
+chart_parser_answer(parse_count, count(Sentence, Count)) :-
+  sentence(Sentence, Length),
+  countall(span(Sentence, s, 0, Length), Count).
+chart_parser_answer(noun_phrase_count, count(Sentence, Count)) :-
+  sentence(Sentence, Length),
+  countall(span(Sentence, np, _Start, _End), Count),
+  gt(Length, 0).

package/examples/critical-path-schedule.pl

@@ -0,0 +1,77 @@
+% Critical-path scheduling for a small project network.
+% earliest_start/2 and finish_time/2 are memoized because many schedule and
+% critical-path queries reuse the same predecessor subproblems.
+materialize(critical_path_answer, 2).
+
+memoize(earliest_start, 2).
+memoize(finish_time, 2).
+
+task(requirements, 2).
+task(architecture, 3).
+task(api_design, 2).
+task(database, 4).
+task(backend, 6).
+task(frontend, 5).
+task(auth, 3).
+task(integration, 4).
+task(security_review, 3).
+task(load_test, 2).
+task(launch, 1).
+
+depends(architecture, requirements).
+depends(api_design, requirements).
+depends(database, architecture).
+depends(backend, api_design).
+depends(backend, database).
+depends(frontend, api_design).
+depends(auth, architecture).
+depends(integration, backend).
+depends(integration, frontend).
+depends(integration, auth).
+depends(security_review, integration).
+depends(load_test, integration).
+depends(launch, security_review).
+depends(launch, load_test).
+
+earliest_start(Task, 0) :-
+  task(Task, _Duration),
+  not(depends(Task, _Pred)).
+earliest_start(Task, Start) :-
+  depends(Task, _Pred),
+  aggregate_max(Finish, Pred,
+    (depends(Task, Pred), finish_time(Pred, Finish)),
+    Start, _CriticalPred).
+
+finish_time(Task, Finish) :-
+  task(Task, Duration),
+  earliest_start(Task, Start),
+  add(Start, Duration, Finish).
+
+critical_predecessor(Task, Pred) :-
+  depends(Task, _AnyPred),
+  aggregate_max(Finish, P,
+    (depends(Task, P), finish_time(P, Finish)),
+    _BestFinish, Pred).
+
+project_finish(Finish) :-
+  aggregate_max(FinishTime, Task, finish_time(Task, FinishTime), Finish, _LastTask).
+
+final_task(Task) :-
+  project_finish(Finish),
+  finish_time(Task, Finish).
+
+critical_chain(Task, Task).
+critical_chain(Task, Pred) :-
+  critical_predecessor(Task, Parent),
+  critical_chain(Parent, Pred).
+
+critical_task(Task) :-
+  final_task(Final),
+  critical_chain(Final, Task).
+
+critical_path_answer(project_finish, Finish) :- project_finish(Finish).
+critical_path_answer(critical_task, Task) :- critical_task(Task).
+critical_path_answer(schedule, task(Task, Start, Finish)) :-
+  task(Task, _Duration),
+  earliest_start(Task, Start),
+  finish_time(Task, Finish).

package/examples/job-shop-scheduling.pl

@@ -0,0 +1,44 @@
+% Tiny job-shop scheduling benchmark.
+% Three jobs each need one mill operation and one lathe operation; the solver
+% searches start times and minimizes the makespan.
+materialize(job_shop_answer, 2).
+
+nonoverlap(_StartA, EndA, StartB, _EndB) :- le(EndA, StartB).
+nonoverlap(StartA, _EndA, _StartB, EndB) :- le(EndB, StartA).
+
+feasible_schedule(Makespan, [
+  op(j1_mill, J1MillStart, J1MillEnd),
+  op(j1_lathe, J1LatheStart, J1LatheEnd),
+  op(j2_lathe, J2LatheStart, J2LatheEnd),
+  op(j2_mill, J2MillStart, J2MillEnd),
+  op(j3_mill, J3MillStart, J3MillEnd),
+  op(j3_lathe, J3LatheStart, J3LatheEnd)
+]) :-
+  between(0, 6, J1MillStart), add(J1MillStart, 3, J1MillEnd),
+  between(0, 6, J1LatheStart), add(J1LatheStart, 2, J1LatheEnd),
+  le(J1MillEnd, J1LatheStart),
+
+  between(0, 6, J2LatheStart), add(J2LatheStart, 2, J2LatheEnd),
+  between(0, 6, J2MillStart), add(J2MillStart, 4, J2MillEnd),
+  le(J2LatheEnd, J2MillStart),
+
+  between(0, 6, J3MillStart), add(J3MillStart, 2, J3MillEnd),
+  between(0, 6, J3LatheStart), add(J3LatheStart, 3, J3LatheEnd),
+  le(J3MillEnd, J3LatheStart),
+
+  nonoverlap(J1MillStart, J1MillEnd, J2MillStart, J2MillEnd),
+  nonoverlap(J1MillStart, J1MillEnd, J3MillStart, J3MillEnd),
+  nonoverlap(J2MillStart, J2MillEnd, J3MillStart, J3MillEnd),
+  nonoverlap(J1LatheStart, J1LatheEnd, J2LatheStart, J2LatheEnd),
+  nonoverlap(J1LatheStart, J1LatheEnd, J3LatheStart, J3LatheEnd),
+  nonoverlap(J2LatheStart, J2LatheEnd, J3LatheStart, J3LatheEnd),
+
+  max(J1LatheEnd, J2MillEnd, PartialMakespan),
+  max(PartialMakespan, J3LatheEnd, Makespan).
+
+best_schedule(Makespan, Schedule) :-
+  aggregate_min(Makespan, Schedule, feasible_schedule(Makespan, Schedule), Makespan, Schedule).
+
+job_shop_answer(best_makespan, Makespan) :- best_schedule(Makespan, _Schedule).
+job_shop_answer(best_schedule, Schedule) :- best_schedule(_Makespan, Schedule).
+job_shop_answer(feasible_schedule_count, Count) :- countall(feasible_schedule(_Makespan, _Schedule), Count).

package/examples/knapsack-optimization.pl

@@ -0,0 +1,40 @@
+% 0/1 knapsack search with an aggregate maximum over all feasible packs.
+materialize(knapsack_answer, 2).
+
+capacity(15).
+items([atlas, battery, camera, drone, emergency_radio, field_laptop, medkit, sensor]).
+
+item(atlas, 2, 6).
+item(battery, 4, 10).
+item(camera, 3, 8).
+item(drone, 6, 13).
+item(emergency_radio, 5, 11).
+item(field_laptop, 7, 16).
+item(medkit, 4, 9).
+item(sensor, 2, 7).
+
+subset([], []).
+subset([Item|Rest], [Item|Chosen]) :- subset(Rest, Chosen).
+subset([_Item|Rest], Chosen) :- subset(Rest, Chosen).
+
+item_weight(Item, Weight) :- item(Item, Weight, _Value).
+item_value(Item, Value) :- item(Item, _Weight, Value).
+
+total_weight(Items, Weight) :- findall(W, (member(Item, Items), item_weight(Item, W)), Weights), sum_list(Weights, Weight).
+total_value(Items, Value) :- findall(V, (member(Item, Items), item_value(Item, V)), Values), sum_list(Values, Value).
+
+feasible_pack(Pack, Weight, Value) :-
+  items(All),
+  subset(All, Pack),
+  total_weight(Pack, Weight),
+  capacity(Capacity),
+  le(Weight, Capacity),
+  total_value(Pack, Value).
+
+best_pack(Pack, Weight, Value) :-
+  aggregate_max(Value, pack(Pack, Weight), feasible_pack(Pack, Weight, Value), Value, pack(Pack, Weight)).
+
+knapsack_answer(best_pack, Pack) :- best_pack(Pack, _Weight, _Value).
+knapsack_answer(total_weight, Weight) :- best_pack(_Pack, Weight, _Value).
+knapsack_answer(total_value, Value) :- best_pack(_Pack, _Weight, Value).
+knapsack_answer(feasible_pack_count, Count) :- countall(feasible_pack(_Pack, _Weight, _Value), Count).

package/examples/missionaries-cannibals.pl

@@ -0,0 +1,47 @@
+% Missionaries-and-cannibals river crossing as a guarded state-space search.
+materialize(missionaries_cannibals_answer, 2).
+
+move(1, 0).
+move(0, 1).
+move(2, 0).
+move(0, 2).
+move(1, 1).
+
+bank_safe(0, _C).
+bank_safe(M, C) :- gt(M, 0), ge(M, C).
+
+state_safe(state(MLeft, CLeft, _Boat)) :-
+  between(0, 3, MLeft),
+  between(0, 3, CLeft),
+  sub(3, MLeft, MRight),
+  sub(3, CLeft, CRight),
+  bank_safe(MLeft, CLeft),
+  bank_safe(MRight, CRight).
+
+crossing(state(MLeft, CLeft, left), state(NextM, NextC, right), carry(MoveM, MoveC)) :-
+  move(MoveM, MoveC),
+  sub(MLeft, MoveM, NextM),
+  sub(CLeft, MoveC, NextC),
+  state_safe(state(NextM, NextC, right)).
+crossing(state(MLeft, CLeft, right), state(NextM, NextC, left), carry(MoveM, MoveC)) :-
+  move(MoveM, MoveC),
+  add(MLeft, MoveM, NextM),
+  add(CLeft, MoveC, NextC),
+  state_safe(state(NextM, NextC, left)).
+
+journey(Goal, Goal, Visited, Visited).
+journey(State, Goal, Visited, Path) :-
+  crossing(State, Next, _Carry),
+  not_member(Next, Visited),
+  journey(Next, Goal, [Next|Visited], Path).
+
+solution(Path) :-
+  journey(state(3, 3, left), state(0, 0, right), [state(3, 3, left)], ReversePath),
+  reverse(ReversePath, Path).
+
+missionaries_cannibals_answer(first_solution, Path) :- once(solution(Path)).
+missionaries_cannibals_answer(state_count, Count) :- countall(state_safe(state(_M, _C, _Boat)), Count).
+missionaries_cannibals_answer(step_count, Steps) :-
+  once(solution(Path)),
+  length(Path, States),
+  sub(States, 1, Steps).

package/examples/n-queens-8.pl

@@ -0,0 +1,31 @@
+% N-queens search for the 8x8 board.
+% This example enumerates all row permutations and filters diagonal attacks.
+materialize(n_queens_answer, 2).
+
+% Cache diagonal checks; the same row/distance/suffix states recur across
+% many candidate permutations during the 8-queens search.
+memoize(no_diagonal_attack, 3).
+
+perm([], []).
+perm(Items, [X|Rest]) :-
+  select(X, Items, Remaining),
+  perm(Remaining, Rest).
+
+safe_rows([]).
+safe_rows([Row|Rest]) :-
+  no_diagonal_attack(Row, 1, Rest),
+  safe_rows(Rest).
+
+no_diagonal_attack(_Row, _Distance, []).
+no_diagonal_attack(Row, Distance, [Other|Rest]) :-
+  sub(Row, Other, Delta),
+  abs(Delta, AbsDelta),
+  neq(AbsDelta, Distance),
+  add(Distance, 1, NextDistance),
+  no_diagonal_attack(Row, NextDistance, Rest).
+
+queen_solution(Rows) :-
+  perm([1, 2, 3, 4, 5, 6, 7, 8], Rows),
+  safe_rows(Rows).
+
+n_queens_answer(first_solution, Rows) :- once(queen_solution(Rows)).

package/examples/output/chart-parser.pl

@@ -0,0 +1,6 @@
+chart_parser_answer(parsed, command).
+chart_parser_answer(parsed, ambiguous_pp).
+chart_parser_answer(parse_count, count(command, 1)).
+chart_parser_answer(parse_count, count(ambiguous_pp, 1)).
+chart_parser_answer(noun_phrase_count, count(command, 2)).
+chart_parser_answer(noun_phrase_count, count(ambiguous_pp, 3)).

package/examples/output/critical-path-schedule.pl

@@ -0,0 +1,19 @@
+critical_path_answer(project_finish, 23).
+critical_path_answer(critical_task, launch).
+critical_path_answer(critical_task, security_review).
+critical_path_answer(critical_task, integration).
+critical_path_answer(critical_task, backend).
+critical_path_answer(critical_task, database).
+critical_path_answer(critical_task, architecture).
+critical_path_answer(critical_task, requirements).
+critical_path_answer(schedule, task(requirements, 0, 2)).
+critical_path_answer(schedule, task(architecture, 2, 5)).
+critical_path_answer(schedule, task(api_design, 2, 4)).
+critical_path_answer(schedule, task(database, 5, 9)).
+critical_path_answer(schedule, task(backend, 9, 15)).
+critical_path_answer(schedule, task(frontend, 4, 9)).
+critical_path_answer(schedule, task(auth, 5, 8)).
+critical_path_answer(schedule, task(integration, 15, 19)).
+critical_path_answer(schedule, task(security_review, 19, 22)).
+critical_path_answer(schedule, task(load_test, 19, 21)).
+critical_path_answer(schedule, task(launch, 22, 23)).

package/examples/output/job-shop-scheduling.pl

@@ -0,0 +1,3 @@
+job_shop_answer(best_makespan, 9).
+job_shop_answer(best_schedule, [op(j1_mill, 0, 3), op(j1_lathe, 3, 5), op(j2_lathe, 0, 2), op(j2_mill, 5, 9), op(j3_mill, 3, 5), op(j3_lathe, 5, 8)]).
+job_shop_answer(feasible_schedule_count, 35).

package/examples/output/knapsack-optimization.pl

@@ -0,0 +1,4 @@
+knapsack_answer(best_pack, [atlas, battery, camera, medkit, sensor]).
+knapsack_answer(total_weight, 15).
+knapsack_answer(total_value, 40).
+knapsack_answer(feasible_pack_count, 113).

package/examples/output/missionaries-cannibals.pl

@@ -0,0 +1,3 @@
+missionaries_cannibals_answer(first_solution, [state(3, 3, left), state(3, 1, right), state(3, 2, left), state(3, 0, right), state(3, 1, left), state(1, 1, right), state(2, 2, left), state(0, 2, right), state(0, 3, left), state(0, 1, right), state(1, 1, left), state(0, 0, right)]).
+missionaries_cannibals_answer(state_count, 10).
+missionaries_cannibals_answer(step_count, 11).

package/examples/output/n-queens-8.pl

@@ -0,0 +1 @@
+n_queens_answer(first_solution, [1, 5, 8, 6, 3, 7, 2, 4]).

package/examples/output/send-more-money.pl

@@ -0,0 +1,3 @@
+cryptarithm_answer(assignments, solution(9, 5, 6, 7, 1, 0, 8, 2)).
+cryptarithm_answer(equation, equation(9567, 1085, 10652)).
+cryptarithm_answer(solution_count, 1).

package/examples/output/stable-marriage.pl

@@ -0,0 +1,2 @@
+stable_marriage_answer(first_stable_matching, [pair(adam, bea), pair(brian, dana), pair(cole, amy), pair(drew, cora)]).
+stable_marriage_answer(stable_matching_count, 1).

package/examples/output/sudoku-4x4.pl

@@ -0,0 +1,2 @@
+sudoku_answer(solution, [[1, 2, 3, 4], [3, 4, 1, 2], [2, 1, 4, 3], [4, 3, 2, 1]]).
+sudoku_answer(solution_count, 2).

package/examples/output/weighted-interval-scheduling.pl

@@ -0,0 +1,5 @@
+weighted_interval_answer(best_value, 13).
+weighted_interval_answer(chosen_interval, interval(1, 1, 4, 5)).
+weighted_interval_answer(chosen_interval, interval(4, 4, 7, 4)).
+weighted_interval_answer(chosen_interval, interval(8, 8, 11, 4)).
+weighted_interval_answer(candidate_count, 8).

package/examples/send-more-money.pl

@@ -0,0 +1,66 @@
+% Cryptarithm search for SEND + MORE = MONEY.
+% Column constraints prune the digit assignment search.
+materialize(cryptarithm_answer, 2).
+
+all_digits([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).
+
+send_more_money(solution(S, E, N, D, M, O, R, Y)) :-
+  all_digits(Digits),
+  eq(M, 1),
+  eq(O, 0),
+  select(M, Digits, D0),
+  select(O, D0, D1),
+
+  select(D, D1, D2),
+  select(E, D2, D3),
+  add(D, E, OnesSum),
+  mod(OnesSum, 10, Y),
+  div(OnesSum, 10, Carry1),
+  select(Y, D3, D4),
+
+  select(N, D4, D5),
+  select(R, D5, D6),
+  add(N, R, TensPartial),
+  add(TensPartial, Carry1, TensSum),
+  mod(TensSum, 10, E),
+  div(TensSum, 10, Carry2),
+
+  add(E, O, HundredsPartial),
+  add(HundredsPartial, Carry2, HundredsSum),
+  mod(HundredsSum, 10, N),
+  div(HundredsSum, 10, Carry3),
+
+  select(S, D6, _D7),
+  neq(S, 0),
+  add(S, M, ThousandsPartial),
+  add(ThousandsPartial, Carry3, ThousandsSum),
+  mod(ThousandsSum, 10, O),
+  div(ThousandsSum, 10, M).
+
+number4(A, B, C, D, Value) :-
+  mul(A, 1000, APart),
+  mul(B, 100, BPart),
+  mul(C, 10, CPart),
+  add(APart, BPart, AB),
+  add(AB, CPart, ABC),
+  add(ABC, D, Value).
+
+number5(A, B, C, D, E, Value) :-
+  mul(A, 10000, APart),
+  mul(B, 1000, BPart),
+  mul(C, 100, CPart),
+  mul(D, 10, DPart),
+  add(APart, BPart, AB),
+  add(AB, CPart, ABC),
+  add(ABC, DPart, ABCD),
+  add(ABCD, E, Value).
+
+cryptarithm_answer(assignments, solution(S, E, N, D, M, O, R, Y)) :-
+  send_more_money(solution(S, E, N, D, M, O, R, Y)).
+cryptarithm_answer(equation, equation(Send, More, Money)) :-
+  send_more_money(solution(S, E, N, D, M, O, R, Y)),
+  number4(S, E, N, D, Send),
+  number4(M, O, R, E, More),
+  number5(M, O, N, E, Y, Money).
+cryptarithm_answer(solution_count, Count) :-
+  countall(send_more_money(_Solution), Count).

package/examples/stable-marriage.pl

@@ -0,0 +1,86 @@
+% Stable-marriage search with blocking-pair detection.
+materialize(stable_marriage_answer, 2).
+
+man(adam).
+man(brian).
+man(cole).
+man(drew).
+
+woman(amy).
+woman(bea).
+woman(cora).
+woman(dana).
+
+rank_man(adam, bea, 1).
+rank_man(adam, amy, 2).
+rank_man(adam, dana, 3).
+rank_man(adam, cora, 4).
+rank_man(brian, amy, 1).
+rank_man(brian, cora, 2).
+rank_man(brian, bea, 3).
+rank_man(brian, dana, 4).
+rank_man(cole, amy, 1).
+rank_man(cole, bea, 2).
+rank_man(cole, dana, 3).
+rank_man(cole, cora, 4).
+rank_man(drew, cora, 1).
+rank_man(drew, dana, 2).
+rank_man(drew, bea, 3).
+rank_man(drew, amy, 4).
+
+rank_woman(amy, cole, 1).
+rank_woman(amy, adam, 2).
+rank_woman(amy, brian, 3).
+rank_woman(amy, drew, 4).
+rank_woman(bea, adam, 1).
+rank_woman(bea, cole, 2).
+rank_woman(bea, drew, 3).
+rank_woman(bea, brian, 4).
+rank_woman(cora, drew, 1).
+rank_woman(cora, brian, 2).
+rank_woman(cora, adam, 3).
+rank_woman(cora, cole, 4).
+rank_woman(dana, brian, 1).
+rank_woman(dana, drew, 2).
+rank_woman(dana, cole, 3).
+rank_woman(dana, adam, 4).
+
+perm([], []).
+perm(Items, [X|Rest]) :-
+  select(X, Items, Remaining),
+  perm(Remaining, Rest).
+
+matching([
+  pair(adam, W1),
+  pair(brian, W2),
+  pair(cole, W3),
+  pair(drew, W4)
+]) :-
+  perm([amy, bea, cora, dana], [W1, W2, W3, W4]).
+
+assigned(Matching, Man, Woman) :- member(pair(Man, Woman), Matching).
+
+prefers_man(Man, Candidate, Current) :-
+  rank_man(Man, Candidate, CandidateRank),
+  rank_man(Man, Current, CurrentRank),
+  lt(CandidateRank, CurrentRank).
+
+prefers_woman(Woman, Candidate, Current) :-
+  rank_woman(Woman, Candidate, CandidateRank),
+  rank_woman(Woman, Current, CurrentRank),
+  lt(CandidateRank, CurrentRank).
+
+blocking_pair(Matching, Man, Woman) :-
+  assigned(Matching, Man, CurrentWoman),
+  woman(Woman),
+  neq(Woman, CurrentWoman),
+  prefers_man(Man, Woman, CurrentWoman),
+  assigned(Matching, CurrentMan, Woman),
+  prefers_woman(Woman, Man, CurrentMan).
+
+stable_matching(Matching) :-
+  matching(Matching),
+  not(blocking_pair(Matching, _Man, _Woman)).
+
+stable_marriage_answer(first_stable_matching, Matching) :- once(stable_matching(Matching)).
+stable_marriage_answer(stable_matching_count, Count) :- countall(stable_matching(_Matching), Count).

package/examples/sudoku-4x4.pl

@@ -0,0 +1,48 @@
+% A compact 4x4 Sudoku search with row permutations and column/box constraints.
+materialize(sudoku_answer, 2).
+
+perm([], []).
+perm(Items, [X|Rest]) :-
+  select(X, Items, Remaining),
+  perm(Remaining, Rest).
+
+distinct([]).
+distinct([X|Xs]) :-
+  not_member(X, Xs),
+  distinct(Xs).
+
+row1([1, B, C, 4]) :- perm([1, 2, 3, 4], [1, B, C, 4]).
+row2([A, 4, 1, D]) :- perm([1, 2, 3, 4], [A, 4, 1, D]).
+row3([B, 1, 4, C]) :- perm([1, 2, 3, 4], [B, 1, 4, C]).
+row4([4, C, B, 1]) :- perm([1, 2, 3, 4], [4, C, B, 1]).
+
+column([R1, R2, R3, R4], Index, [A, B, C, D]) :-
+  nth0(Index, R1, A),
+  nth0(Index, R2, B),
+  nth0(Index, R3, C),
+  nth0(Index, R4, D).
+
+boxes([R1, R2, R3, R4], [Box1, Box2, Box3, Box4]) :-
+  nth0(0, R1, A), nth0(1, R1, B), nth0(0, R2, C), nth0(1, R2, D),
+  eq(Box1, [A, B, C, D]),
+  nth0(2, R1, E), nth0(3, R1, F), nth0(2, R2, G), nth0(3, R2, H),
+  eq(Box2, [E, F, G, H]),
+  nth0(0, R3, I), nth0(1, R3, J), nth0(0, R4, K), nth0(1, R4, L),
+  eq(Box3, [I, J, K, L]),
+  nth0(2, R3, M), nth0(3, R3, N), nth0(2, R4, O), nth0(3, R4, P),
+  eq(Box4, [M, N, O, P]).
+
+sudoku_solution([R1, R2, R3, R4]) :-
+  row1(R1),
+  row2(R2),
+  row3(R3),
+  row4(R4),
+  column([R1, R2, R3, R4], 0, C0), distinct(C0),
+  column([R1, R2, R3, R4], 1, C1), distinct(C1),
+  column([R1, R2, R3, R4], 2, C2), distinct(C2),
+  column([R1, R2, R3, R4], 3, C3), distinct(C3),
+  boxes([R1, R2, R3, R4], [B1, B2, B3, B4]),
+  distinct(B1), distinct(B2), distinct(B3), distinct(B4).
+
+sudoku_answer(solution, Grid) :- once(sudoku_solution(Grid)).
+sudoku_answer(solution_count, Count) :- countall(sudoku_solution(_Grid), Count).

package/examples/weighted-interval-scheduling.pl

@@ -0,0 +1,76 @@
+% Weighted interval scheduling via memoized dynamic programming.
+% Intervals are already ordered by finish time; best_from/2 chooses take/skip.
+materialize(weighted_interval_answer, 2).
+
+memoize(best_from, 2).
+
+last_interval(8).
+sentinel(9).
+
+interval(1, 1, 4, 5).
+interval(2, 3, 5, 1).
+interval(3, 0, 6, 8).
+interval(4, 4, 7, 4).
+interval(5, 3, 9, 6).
+interval(6, 5, 9, 3).
+interval(7, 6, 10, 2).
+interval(8, 8, 11, 4).
+
+next_compatible(I, J) :-
+  interval(I, _Start, Finish, _Value),
+  aggregate_min(K, K,
+    (interval(K, StartK, _FinishK, _ValueK), gt(K, I), ge(StartK, Finish)),
+    J, J).
+next_compatible(I, 9) :-
+  interval(I, _Start, Finish, _Value),
+  not((interval(K, StartK, _FinishK, _ValueK), gt(K, I), ge(StartK, Finish))).
+
+best_from(9, 0).
+best_from(I, Best) :-
+  last_interval(Last),
+  le(I, Last),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _Start, _Finish, Value),
+  add(Value, Tail, Take),
+  max(Take, Skip, Best).
+
+chosen_from(I, I) :-
+  best_from(I, Best),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _Start, _Finish, Value),
+  add(Value, Tail, Take),
+  eq(Best, Take),
+  ge(Take, Skip).
+chosen_from(I, Chosen) :-
+  best_from(I, Best),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _Start, _Finish, Value),
+  add(Value, Tail, Take),
+  eq(Best, Take),
+  ge(Take, Skip),
+  chosen_from(Compatible, Chosen).
+chosen_from(I, Chosen) :-
+  best_from(I, Best),
+  add(I, 1, Next),
+  best_from(Next, Skip),
+  next_compatible(I, Compatible),
+  best_from(Compatible, Tail),
+  interval(I, _Start, _Finish, Value),
+  add(Value, Tail, Take),
+  gt(Skip, Take),
+  chosen_from(Next, Chosen).
+
+weighted_interval_answer(best_value, Best) :- best_from(1, Best).
+weighted_interval_answer(chosen_interval, interval(I, Start, Finish, Value)) :-
+  chosen_from(1, I),
+  interval(I, Start, Finish, Value).
+weighted_interval_answer(candidate_count, Count) :- countall(interval(_I, _Start, _Finish, _Value), Count).

package/package.json

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

package/playground.html

@@ -434,135 +434,145 @@
 
   <script type="module">
     const EXAMPLES = [
-  "access-control-policy",
-  "ackermann",
-  "age",
-  "aliases-and-namespaces",
-  "alignment-demo",
-  "allen-interval-calculus",
-  "ancestor",
-  "animal",
-  "annotation",
-  "auroracare",
-  "backward",
-  "basic-monadic",
-  "bayes-diagnosis",
-  "bayes-therapy",
-  "beam-deflection",
-  "blocks-world-planning",
-  "bmi",
-  "braking-safety-worlds",
-  "buck-converter-design",
-  "cache-performance",
-  "canary-release",
-  "cat-koko",
-  "clinical-trial-screening",
-  "collatz-1000",
-  "combinatorics-findall-sort",
-  "competitive-enzyme-kinetics",
-  "complex",
-  "composition-of-injective-functions-is-injective",
-  "context-association",
-  "context-schema-audit",
-  "control-system",
-  "cyclic-path",
-  "d3-group",
-  "dairy-energy-balance",
-  "data-negotiation",
-  "deep-taxonomy-10",
-  "deep-taxonomy-100",
-  "deep-taxonomy-1000",
-  "deep-taxonomy-10000",
-  "deep-taxonomy-100000",
-  "delfour",
-  "deontic-logic",
-  "derived-backward-rule",
-  "derived-rule",
-  "diamond-property",
-  "dijkstra-findall-sort",
-  "dijkstra-risk-path",
-  "dijkstra",
-  "dining-philosophers",
-  "dog",
-  "dpv-odrl-purpose-mapping",
-  "drone-corridor-planner",
-  "easter-computus",
-  "electrical-rc-filter",
-  "epidemic-policy",
-  "equivalence-classes-overlap-implies-same-class",
-  "eulerian-path",
-  "ev-range-worlds",
-  "existential-rule",
-  "exoplanet-validation-worlds",
-  "expression-eval",
-  "family-cousins",
-  "fastpow",
-  "fft8-numeric",
-  "fibonacci",
-  "field-nitrogen-balance",
-  "flandor",
-  "floating-point",
-  "four-color-map",
-  "fundamental-theorem-arithmetic",
-  "gd-step-certified",
-  "gdpr-compliance",
-  "good-cobbler",
-  "gps",
-  "graph-reachability",
-  "gray-code-counter",
-  "greatest-lower-bound-uniqueness",
-  "group-inverse-uniqueness",
-  "hamiltonian-path",
-  "hamming-code",
-  "hanoi",
-  "heat-loss",
-  "heron-theorem",
-  "ideal-gas-law",
-  "illegitimate-reasoning",
-  "knowledge-engineering-alignment-flow",
-  "law-of-cosines",
-  "least-squares-regression",
-  "list-collection",
-  "lldm",
-  "manufacturing-quality-control",
-  "microgrid-dispatch",
-  "monkey-bananas",
-  "network-sla",
-  "newton-raphson",
-  "nixon-diamond",
-  "observability-log-correlation",
-  "odrl-dpv-fpv-trust-flow",
-  "odrl-dpv-healthcare-risk-ranked",
-  "odrl-dpv-risk-ranked",
-  "orbital-transfer-design",
-  "path-discovery",
-  "peano-arithmetic",
-  "peasant",
-  "pendulum-period",
-  "polynomial",
-  "proof-contrapositive",
-  "quadratic-formula",
-  "radioactive-decay",
-  "reusable-builtins",
-  "riemann-hypothesis",
-  "security-incident-correlation",
-  "service-impact",
-  "sieve",
-  "skolem-functions",
-  "socket-age",
-  "socket-family",
-  "socrates",
-  "statistics-summary",
-  "superdense-coding",
-  "term-tools",
-  "trust-flow-provenance-threshold",
-  "turing",
-  "vector-similarity",
-  "vulnerability-impact",
-  "witch",
-  "wolf-goat-cabbage",
-  "zebra"
-];
+      "access-control-policy",
+      "ackermann",
+      "age",
+      "aliases-and-namespaces",
+      "alignment-demo",
+      "allen-interval-calculus",
+      "ancestor",
+      "animal",
+      "annotation",
+      "auroracare",
+      "backward",
+      "basic-monadic",
+      "bayes-diagnosis",
+      "bayes-therapy",
+      "beam-deflection",
+      "blocks-world-planning",
+      "bmi",
+      "braking-safety-worlds",
+      "buck-converter-design",
+      "cache-performance",
+      "canary-release",
+      "cat-koko",
+      "chart-parser",
+      "clinical-trial-screening",
+      "collatz-1000",
+      "combinatorics-findall-sort",
+      "competitive-enzyme-kinetics",
+      "complex",
+      "composition-of-injective-functions-is-injective",
+      "context-association",
+      "context-schema-audit",
+      "control-system",
+      "critical-path-schedule",
+      "cyclic-path",
+      "d3-group",
+      "dairy-energy-balance",
+      "data-negotiation",
+      "deep-taxonomy-10",
+      "deep-taxonomy-100",
+      "deep-taxonomy-1000",
+      "deep-taxonomy-10000",
+      "deep-taxonomy-100000",
+      "delfour",
+      "deontic-logic",
+      "derived-backward-rule",
+      "derived-rule",
+      "diamond-property",
+      "dijkstra",
+      "dijkstra-findall-sort",
+      "dijkstra-risk-path",
+      "dining-philosophers",
+      "dog",
+      "dpv-odrl-purpose-mapping",
+      "drone-corridor-planner",
+      "easter-computus",
+      "electrical-rc-filter",
+      "epidemic-policy",
+      "equivalence-classes-overlap-implies-same-class",
+      "eulerian-path",
+      "ev-range-worlds",
+      "existential-rule",
+      "exoplanet-validation-worlds",
+      "expression-eval",
+      "family-cousins",
+      "fastpow",
+      "fft8-numeric",
+      "fibonacci",
+      "field-nitrogen-balance",
+      "flandor",
+      "floating-point",
+      "four-color-map",
+      "fundamental-theorem-arithmetic",
+      "gd-step-certified",
+      "gdpr-compliance",
+      "good-cobbler",
+      "gps",
+      "graph-reachability",
+      "gray-code-counter",
+      "greatest-lower-bound-uniqueness",
+      "group-inverse-uniqueness",
+      "hamiltonian-path",
+      "hamming-code",
+      "hanoi",
+      "heat-loss",
+      "heron-theorem",
+      "ideal-gas-law",
+      "illegitimate-reasoning",
+      "job-shop-scheduling",
+      "knapsack-optimization",
+      "knowledge-engineering-alignment-flow",
+      "law-of-cosines",
+      "least-squares-regression",
+      "list-collection",
+      "lldm",
+      "manufacturing-quality-control",
+      "microgrid-dispatch",
+      "missionaries-cannibals",
+      "monkey-bananas",
+      "n-queens-8",
+      "network-sla",
+      "newton-raphson",
+      "nixon-diamond",
+      "observability-log-correlation",
+      "odrl-dpv-fpv-trust-flow",
+      "odrl-dpv-healthcare-risk-ranked",
+      "odrl-dpv-risk-ranked",
+      "orbital-transfer-design",
+      "path-discovery",
+      "peano-arithmetic",
+      "peasant",
+      "pendulum-period",
+      "polynomial",
+      "proof-contrapositive",
+      "quadratic-formula",
+      "radioactive-decay",
+      "reusable-builtins",
+      "riemann-hypothesis",
+      "security-incident-correlation",
+      "send-more-money",
+      "service-impact",
+      "sieve",
+      "skolem-functions",
+      "socket-age",
+      "socket-family",
+      "socrates",
+      "stable-marriage",
+      "statistics-summary",
+      "sudoku-4x4",
+      "superdense-coding",
+      "term-tools",
+      "trust-flow-provenance-threshold",
+      "turing",
+      "vector-similarity",
+      "vulnerability-impact",
+      "weighted-interval-scheduling",
+      "witch",
+      "wolf-goat-cabbage",
+      "zebra"
+    ];
     const FALLBACK_SOURCE = `materialize(answer, 1).
 answer(ok) :- eq(ok, ok).
 `;
@@ -1015,11 +1025,13 @@ answer(ok) :- eq(ok, ok).
 
     async function copyShareLink() {
       const link = buildShareLink();
-      if (link == null) {
-        setStatus('This program is too large for a reliable URL. Use “Create Gist share” instead.', true);
+      if (link != null) {
+        await copyText(link, 'Share link copied.');
         return;
       }
-      await copyText(link, 'Share link copied.');
+      await createGistShare({
+        reason: 'This program is too large for an inline URL, so Copy share link will create a Gist share instead.',
+      });
     }
 
     function buildShareLink() {
@@ -1043,12 +1055,16 @@ answer(ok) :- eq(ok, ok).
       return `${basePlaygroundUrl()}#${params.toString()}`;
     }
 
-    async function createGistShare() {
+    async function createGistShare(options = {}) {
       const stateText = JSON.stringify(currentShareState(), null, 2);
-      const token = prompt('Optional GitHub token with gist scope. It is only sent to api.github.com and is not stored. Leave blank to copy Gist-ready state instead.');
-      if (token === null) return;
+      if (options.reason) setStatus(options.reason);
+      const token = prompt(`${options.reason ? `${options.reason}\n\n` : ''}Optional GitHub token with gist scope. It is only sent to api.github.com and is not stored. Leave blank to copy Gist-ready state and open gist.github.com.`);
+      if (token === null) {
+        setStatus('Gist share cancelled.');
+        return;
+      }
       if (!token.trim()) {
-        await copyText(stateText, `Gist-ready state copied. Create a Gist file named ${GIST_STATE_FILENAME}, paste it, then share its raw URL with #state-url=...`);
+        await copyText(stateText, `Gist-ready state copied. Create a Gist file named ${GIST_STATE_FILENAME}, paste it, then copy its raw URL into a playground #state-url link.`);
         window.open('https://gist.github.com/', '_blank', 'noopener');
         return;
       }

package/test/run-regression.mjs

@@ -524,6 +524,36 @@ function whiteBoxCases() {
         assertEqual(termToString(candidates.primary[0].head, new Env(), true), 'edge(a, b)', 'primary head');
       },
     },
+    {
+      name: 'challenging examples keep dynamic-programming predicates memoized',
+      run: () => {
+        const checks = [
+          ['chart-parser.pl', 'span', 4, true],
+          ['critical-path-schedule.pl', 'earliest_start', 2, false],
+          ['critical-path-schedule.pl', 'finish_time', 2, false],
+          ['weighted-interval-scheduling.pl', 'best_from', 2, true],
+        ];
+        for (const [filename, name, arity, recursive] of checks) {
+          const text = fs.readFileSync(path.join(packageRoot, 'examples', filename), 'utf8');
+          const program = Program.parseSources([{ text, filename }]);
+          const group = program.findGroup(name, arity);
+          assertEqual(Boolean(group), true, `${filename} ${name}/${arity} group exists`);
+          assertEqual(group.memoized, true, `${filename} ${name}/${arity} memoized`);
+          assertEqual(group.recursive, recursive, `${filename} ${name}/${arity} recursive`);
+        }
+      },
+    },
+    {
+      name: 'n-queens example keeps diagonal checks memoized',
+      run: () => {
+        const text = fs.readFileSync(path.join(packageRoot, 'examples', 'n-queens-8.pl'), 'utf8');
+        const program = Program.parseSources([{ text, filename: 'n-queens-8.pl' }]);
+        const group = program.findGroup('no_diagonal_attack', 3);
+        assertEqual(Boolean(group), true, 'no_diagonal_attack/3 group exists');
+        assertEqual(group.memoized, true, 'no_diagonal_attack/3 memoized');
+        assertEqual(group.recursive, true, 'no_diagonal_attack/3 recursive');
+      },
+    },
     {
       name: 'collatz example keeps recursive trajectory predicate memoized',
       run: () => {
@@ -684,6 +714,9 @@ function playgroundStaticIssues() {
   if (!html.includes('id="create-gist"') || !html.includes('createGistShare') || !html.includes('GIST_STATE_FILENAME') || !html.includes("fetch('https://api.github.com/gists'")) {
     issues.push('playground must support Gist-backed sharing for large programs');
   }
+  if (!html.includes('await createGistShare({') || html.includes('Use “Create Gist share” instead')) {
+    issues.push('playground Copy share link must automatically fall back to Gist sharing for large programs');
+  }
   if (!html.includes("params.has('state-url')") || !html.includes('#state-url=')) {
     issues.push('playground must restore state from raw Gist state URLs');
   }