eyelang 1.1.15 → 1.1.16

package/docs/guide.md

@@ -328,6 +328,7 @@ Each example has a checked golden output in `examples/output`.
 | [`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 @@ Each example has a checked golden output in `examples/output`.
 | [`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) |
@@ -400,6 +402,7 @@ Each example has a checked golden output in `examples/output`.
 | [`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) |
@@ -430,17 +433,20 @@ Each example has a checked golden output in `examples/output`.
 | [`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.15",
+  "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

@@ -456,6 +456,7 @@
       "cache-performance",
       "canary-release",
       "cat-koko",
+      "chart-parser",
       "clinical-trial-screening",
       "collatz-1000",
       "combinatorics-findall-sort",
@@ -465,6 +466,7 @@
       "context-association",
       "context-schema-audit",
       "control-system",
+      "critical-path-schedule",
       "cyclic-path",
       "d3-group",
       "dairy-energy-balance",
@@ -528,6 +530,7 @@
       "lldm",
       "manufacturing-quality-control",
       "microgrid-dispatch",
+      "missionaries-cannibals",
       "monkey-bananas",
       "n-queens-8",
       "network-sla",
@@ -558,12 +561,14 @@
       "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"

package/test/run-regression.mjs

@@ -524,6 +524,25 @@ 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: () => {