eyelang 1.1.15 → 1.1.17

package/docs/guide.md

@@ -197,7 +197,7 @@ The default output is then:
 answer(case1, accepted).
 ```
 
-`materialize/2` is a declaration, not a logical rule to prove. It affects which predicates the CLI prints, not the meaning of the rules themselves.
+`materialize/2` is a declaration, not a logical rule to prove. It affects which predicates the CLI prints, not the meaning of the rules themselves. Materialized output facts are not inserted back into the running program for later goals; if later output predicates reuse the same derived helper relation, eyelang proves it again unless that helper is declared with `memoize/2`. Source facts are indexed and reused normally, and memoized solved goals are reused inside the same solver run.
 
 ## Writing programs
 
@@ -321,6 +321,7 @@ Each example has a checked golden output in `examples/output`.
 | [`bayes-diagnosis.pl`](../examples/bayes-diagnosis.pl) | Computes scaled Bayesian diagnosis posteriors. | [`output/bayes-diagnosis.pl`](../examples/output/bayes-diagnosis.pl) |
 | [`bayes-therapy.pl`](../examples/bayes-therapy.pl) | Ranks therapies using Bayesian disease likelihoods. | [`output/bayes-therapy.pl`](../examples/output/bayes-therapy.pl) |
 | [`beam-deflection.pl`](../examples/beam-deflection.pl) | Computes cantilever beam deflection. | [`output/beam-deflection.pl`](../examples/output/beam-deflection.pl) |
+| [`binomial-vandermonde.pl`](../examples/binomial-vandermonde.pl) | Computes binomial coefficients and checks Vandermonde's identity. | [`output/binomial-vandermonde.pl`](../examples/output/binomial-vandermonde.pl) |
 | [`blocks-world-planning.pl`](../examples/blocks-world-planning.pl) | Searches a finite blocks-world plan. | [`output/blocks-world-planning.pl`](../examples/output/blocks-world-planning.pl) |
 | [`bmi.pl`](../examples/bmi.pl) | Normalizes BMI inputs and classifies weight. | [`output/bmi.pl`](../examples/output/bmi.pl) |
 | [`braking-safety-worlds.pl`](../examples/braking-safety-worlds.pl) | Classifies braking safety under alternative worlds. | [`output/braking-safety-worlds.pl`](../examples/output/braking-safety-worlds.pl) |
@@ -328,6 +329,8 @@ 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) |
+| [`catalan-convolution.pl`](../examples/catalan-convolution.pl) | Computes Catalan numbers by memoized convolution. | [`output/catalan-convolution.pl`](../examples/output/catalan-convolution.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) |
@@ -336,7 +339,9 @@ Each example has a checked golden output in `examples/output`.
 | [`composition-of-injective-functions-is-injective.pl`](../examples/composition-of-injective-functions-is-injective.pl) | Encodes composition and injectivity of finite functions. | [`output/composition-of-injective-functions-is-injective.pl`](../examples/output/composition-of-injective-functions-is-injective.pl) |
 | [`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) |
+| [`continued-fraction-sqrt2.pl`](../examples/continued-fraction-sqrt2.pl) | Computes sqrt(2) continued-fraction convergents and Pell errors. | [`output/continued-fraction-sqrt2.pl`](../examples/output/continued-fraction-sqrt2.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 +396,7 @@ Each example has a checked golden output in `examples/output`.
 | [`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) |
+| [`integer-partitions.pl`](../examples/integer-partitions.pl) | Counts integer partitions with memoized dynamic programming. | [`output/integer-partitions.pl`](../examples/output/integer-partitions.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) |
@@ -399,7 +405,10 @@ Each example has a checked golden output in `examples/output`.
 | [`list-collection.pl`](../examples/list-collection.pl) | Demonstrates list and collection built-ins. | [`output/list-collection.pl`](../examples/output/list-collection.pl) |
 | [`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) |
+| [`matrix-chain-order.pl`](../examples/matrix-chain-order.pl) | Finds an optimal matrix-chain multiplication order. | [`output/matrix-chain-order.pl`](../examples/output/matrix-chain-order.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) |
+| [`modular-exponentiation.pl`](../examples/modular-exponentiation.pl) | Computes modular powers by repeated squaring. | [`output/modular-exponentiation.pl`](../examples/output/modular-exponentiation.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) |
@@ -413,6 +422,7 @@ Each example has a checked golden output in `examples/output`.
 | [`path-discovery.pl`](../examples/path-discovery.pl) | Discovers bounded air-route paths. | [`output/path-discovery.pl`](../examples/output/path-discovery.pl) |
 | [`peano-arithmetic.pl`](../examples/peano-arithmetic.pl) | Computes Peano addition, multiplication, and factorial. | [`output/peano-arithmetic.pl`](../examples/output/peano-arithmetic.pl) |
 | [`peasant.pl`](../examples/peasant.pl) | Performs peasant multiplication and exponentiation. | [`output/peasant.pl`](../examples/output/peasant.pl) |
+| [`pell-equation.pl`](../examples/pell-equation.pl) | Generates Pell-equation solutions by recurrence. | [`output/pell-equation.pl`](../examples/output/pell-equation.pl) |
 | [`pendulum-period.pl`](../examples/pendulum-period.pl) | Computes simple pendulum periods. | [`output/pendulum-period.pl`](../examples/output/pendulum-period.pl) |
 | [`polynomial.pl`](../examples/polynomial.pl) | Finds complex integer polynomial roots. | [`output/polynomial.pl`](../examples/output/polynomial.pl) |
 | [`proof-contrapositive.pl`](../examples/proof-contrapositive.pl) | Models proof by contrapositive. | [`output/proof-contrapositive.pl`](../examples/output/proof-contrapositive.pl) |
@@ -430,17 +440,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) |
+| [`stirling-bell-numbers.pl`](../examples/stirling-bell-numbers.pl) | Computes Stirling numbers and Bell numbers. | [`output/stirling-bell-numbers.pl`](../examples/output/stirling-bell-numbers.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) |
+| [`totient-summatory.pl`](../examples/totient-summatory.pl) | Computes Euler totients and their summatory function. | [`output/totient-summatory.pl`](../examples/output/totient-summatory.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/docs/language-reference.md

@@ -534,7 +534,7 @@ materialize(status, 2).
 materialize(reason, 2).
 ```
 
-`materialize/2` affects host output selection only; it does not change the logical meaning of the program.
+`materialize/2` affects host output selection only; it does not change the logical meaning of the program. Materialized output facts are not asserted as new source facts for subsequent output goals. A host MAY solve several materialized predicates in one solver run, and memoized predicate answers MAY be reused within that run, but this reuse is controlled by `memoize/2`, not by materialization.
 
 ## 12. Eyelang Sockets
 

package/examples/binomial-vandermonde.pl

@@ -0,0 +1,45 @@
+% Binomial coefficients and Vandermonde's identity.
+% choose_step/5 uses the multiplicative recurrence
+%   C(N, I+1) = C(N, I) * (N-I) / (I+1)
+% and is memoized because row sums and identities reuse prefixes.
+materialize(binomial_answer, 2).
+
+memoize(choose_step, 5).
+
+choose(N, K, C) :-
+  ge(K, 0),
+  le(K, N),
+  choose_step(N, K, 0, 1, C).
+
+choose_step(_N, K, K, Acc, Acc).
+choose_step(N, K, I, Acc, C) :-
+  lt(I, K),
+  add(I, 1, I1),
+  sub(N, I, Factor),
+  mul(Acc, Factor, Numerator),
+  div(Numerator, I1, NextAcc),
+  choose_step(N, K, I1, NextAcc, C).
+
+symmetric(N, K) :-
+  choose(N, K, C),
+  sub(N, K, OtherK),
+  choose(N, OtherK, C).
+
+vandermonde_sum(N, M, R, Sum) :-
+  sumall(Product,
+    (between(0, R, K),
+     sub(R, K, RK),
+     choose(N, K, A),
+     choose(M, RK, B),
+     mul(A, B, Product)),
+    Sum).
+
+vandermonde(N, M, R, Sum) :-
+  add(N, M, TotalN),
+  choose(TotalN, R, Sum),
+  vandermonde_sum(N, M, R, Sum).
+
+binomial_answer(choose_24_12, C) :- choose(24, 12, C).
+binomial_answer(symmetry_24_7, true) :- symmetric(24, 7).
+binomial_answer(vandermonde_12_10_8, Sum) :- vandermonde(12, 10, 8, Sum).
+binomial_answer(row_12_sum, Sum) :- sumall(C, (between(0, 12, K), choose(12, K, C)), Sum).

package/examples/catalan-convolution.pl

@@ -0,0 +1,33 @@
+% Catalan numbers by memoized convolution.
+% catalan/2 counts binary tree shapes, parenthesizations, and polygon
+% triangulations with the usual index shifts.
+materialize(catalan_answer, 2).
+
+memoize(catalan, 2).
+
+catalan(0, 1).
+catalan(N, C) :-
+  gt(N, 0),
+  sub(N, 1, N1),
+  sumall(Product,
+    (between(0, N1, I),
+     sub(N1, I, J),
+     catalan(I, A),
+     catalan(J, B),
+     mul(A, B, Product)),
+    C).
+
+polygon_triangulations(Sides, Count) :-
+  ge(Sides, 3),
+  sub(Sides, 2, N),
+  catalan(N, Count).
+
+parenthesizations(Factors, Count) :-
+  ge(Factors, 1),
+  sub(Factors, 1, N),
+  catalan(N, Count).
+
+catalan_answer(catalan_12, C) :- catalan(12, C).
+catalan_answer(triangulations_14_gon, Count) :- polygon_triangulations(14, Count).
+catalan_answer(parenthesizations_13_factors, Count) :- parenthesizations(13, Count).
+catalan_answer(first_ten_sum, Sum) :- sumall(C, (between(0, 9, N), catalan(N, C)), Sum).

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/continued-fraction-sqrt2.pl

@@ -0,0 +1,30 @@
+% Convergents of sqrt(2) by memoized recurrence.
+% conv(N, P, Q) gives the Nth convergent numerator/denominator for [1;2,2,...].
+materialize(convergent_answer, 2).
+
+memoize(conv, 3).
+
+conv(0, 1, 1).
+conv(1, 3, 2).
+conv(N, P, Q) :-
+  gt(N, 1),
+  sub(N, 1, N1),
+  sub(N, 2, N2),
+  conv(N1, P1, Q1),
+  conv(N2, P2, Q2),
+  mul(2, P1, TwiceP1),
+  add(TwiceP1, P2, P),
+  mul(2, Q1, TwiceQ1),
+  add(TwiceQ1, Q2, Q).
+
+pell_error(N, Error) :-
+  conv(N, P, Q),
+  mul(P, P, P2),
+  mul(Q, Q, Q2),
+  mul(2, Q2, TwiceQ2),
+  sub(P2, TwiceQ2, Error).
+
+convergent_answer(convergent_10, fraction(P, Q)) :- conv(10, P, Q).
+convergent_answer(convergent_15, fraction(P, Q)) :- conv(15, P, Q).
+convergent_answer(pell_error_15, Error) :- pell_error(15, Error).
+convergent_answer(numerator_sum_0_to_10, Sum) :- sumall(P, (between(0, 10, N), conv(N, P, _Q)), Sum).

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/integer-partitions.pl

@@ -0,0 +1,30 @@
+% Integer partition counts by memoized dynamic programming.
+% partitions(N, K, Count) counts partitions of N using parts no larger than K.
+materialize(partition_answer, 2).
+
+memoize(partitions, 3).
+
+partitions(0, _K, 1).
+partitions(N, 0, 0) :- gt(N, 0).
+partitions(N, K, Count) :-
+  gt(N, 0),
+  gt(K, 0),
+  gt(K, N),
+  sub(K, 1, K1),
+  partitions(N, K1, Count).
+partitions(N, K, Count) :-
+  gt(N, 0),
+  gt(K, 0),
+  le(K, N),
+  sub(N, K, Remainder),
+  partitions(Remainder, K, WithK),
+  sub(K, 1, K1),
+  partitions(N, K1, WithoutK),
+  add(WithK, WithoutK, Count).
+
+partition_count(N, Count) :- partitions(N, N, Count).
+
+partition_answer(p_12, Count) :- partition_count(12, Count).
+partition_answer(p_15, Count) :- partition_count(15, Count).
+partition_answer(p_16_using_parts_at_most_5, Count) :- partitions(16, 5, Count).
+partition_answer(cumulative_p_1_to_8, Sum) :- sumall(C, (between(1, 8, N), partition_count(N, C)), Sum).

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/matrix-chain-order.pl

@@ -0,0 +1,72 @@
+% Matrix-chain multiplication order by memoized interval dynamic programming.
+% cost(I, J, Cost) is the minimum scalar multiplication cost for matrices I..J.
+materialize(matrix_chain_answer, 2).
+
+memoize(cost, 3).
+
+% Dimensions for the CLRS-style chain: A1 is 30x35, A2 is 35x15, ...
+dim(0, 30).
+dim(1, 35).
+dim(2, 15).
+dim(3, 5).
+dim(4, 10).
+dim(5, 20).
+dim(6, 25).
+
+matrix_count(6).
+
+cost(I, I, 0) :- matrix_count(N), between(1, N, I).
+cost(I, J, Cost) :-
+  lt(I, J),
+  aggregate_min(SplitCost, K,
+    (between(I, J, K),
+     lt(K, J),
+     cost(I, K, Left),
+     add(K, 1, K1),
+     cost(K1, J, Right),
+     sub(I, 1, I0),
+     dim(I0, Rows),
+     dim(K, Shared),
+     dim(J, Cols),
+     mul(Rows, Shared, First),
+     mul(First, Cols, MultCost),
+     add(Left, Right, Partial),
+     add(Partial, MultCost, SplitCost)),
+    Cost, _BestK).
+
+best_split(I, J, K) :-
+  lt(I, J),
+  aggregate_min(SplitCost, K,
+    (between(I, J, K),
+     lt(K, J),
+     cost(I, K, Left),
+     add(K, 1, K1),
+     cost(K1, J, Right),
+     sub(I, 1, I0),
+     dim(I0, Rows),
+     dim(K, Shared),
+     dim(J, Cols),
+     mul(Rows, Shared, First),
+     mul(First, Cols, MultCost),
+     add(Left, Right, Partial),
+     add(Partial, MultCost, SplitCost)),
+    _Cost, K).
+
+parenthesization(I, I, matrix(I)).
+parenthesization(I, J, product(LeftTree, RightTree)) :-
+  lt(I, J),
+  best_split(I, J, K),
+  add(K, 1, K1),
+  parenthesization(I, K, LeftTree),
+  parenthesization(K1, J, RightTree).
+
+matrix_chain_answer(min_cost, Cost) :- cost(1, 6, Cost).
+matrix_chain_answer(best_split_1_6, K) :- best_split(1, 6, K).
+matrix_chain_answer(best_order, Tree) :- parenthesization(1, 6, Tree).
+subproblem(I, J, Cost) :-
+  matrix_count(N),
+  between(1, N, I),
+  between(I, N, J),
+  cost(I, J, Cost).
+
+matrix_chain_answer(subproblem_count, Count) :- countall(subproblem(_I, _J, _Cost), 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/modular-exponentiation.pl

@@ -0,0 +1,31 @@
+% Modular exponentiation by repeated squaring.
+% pow_mod/4 is logarithmic in the exponent and memoized so repeated primality
+% and congruence checks share subproblems.
+materialize(modular_answer, 2).
+
+memoize(pow_mod, 4).
+
+pow_mod(_Base, 0, Mod, Result) :- mod(1, Mod, Result).
+pow_mod(Base, Exp, Modulus, Result) :-
+  gt(Exp, 0),
+  mod(Exp, 2, 0),
+  div(Exp, 2, Half),
+  pow_mod(Base, Half, Modulus, HalfPower),
+  mul(HalfPower, HalfPower, Square),
+  mod(Square, Modulus, Result).
+pow_mod(Base, Exp, Modulus, Result) :-
+  gt(Exp, 0),
+  mod(Exp, 2, 1),
+  sub(Exp, 1, EvenExp),
+  pow_mod(Base, EvenExp, Modulus, EvenPower),
+  mul(Base, EvenPower, Product),
+  mod(Product, Modulus, Result).
+
+fermat_witness(Base, PrimeCandidate) :-
+  sub(PrimeCandidate, 1, Exponent),
+  pow_mod(Base, Exponent, PrimeCandidate, 1).
+
+modular_answer(pow_7_560_mod_561, R) :- pow_mod(7, 560, 561, R).
+modular_answer(pow_2_1000_mod_1009, R) :- pow_mod(2, 1000, 1009, R).
+modular_answer(fermat_2_101, true) :- fermat_witness(2, 101).
+modular_answer(fermat_3_101, true) :- fermat_witness(3, 101).

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/binomial-vandermonde.pl

@@ -0,0 +1,4 @@
+binomial_answer(choose_24_12, 2704156).
+binomial_answer(symmetry_24_7, true).
+binomial_answer(vandermonde_12_10_8, 319770).
+binomial_answer(row_12_sum, 4096).

package/examples/output/catalan-convolution.pl

@@ -0,0 +1,4 @@
+catalan_answer(catalan_12, 208012).
+catalan_answer(triangulations_14_gon, 208012).
+catalan_answer(parenthesizations_13_factors, 208012).
+catalan_answer(first_ten_sum, 6918).

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/continued-fraction-sqrt2.pl

@@ -0,0 +1,4 @@
+convergent_answer(convergent_10, fraction(8119, 5741)).
+convergent_answer(convergent_15, fraction(665857, 470832)).
+convergent_answer(pell_error_15, 1).
+convergent_answer(numerator_sum_0_to_10, 13859).

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/integer-partitions.pl

@@ -0,0 +1,4 @@
+partition_answer(p_12, 77).
+partition_answer(p_15, 176).
+partition_answer(p_16_using_parts_at_most_5, 101).
+partition_answer(cumulative_p_1_to_8, 66).

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/matrix-chain-order.pl

@@ -0,0 +1,4 @@
+matrix_chain_answer(min_cost, 15125).
+matrix_chain_answer(best_split_1_6, 3).
+matrix_chain_answer(best_order, product(product(matrix(1), product(matrix(2), matrix(3))), product(product(matrix(4), matrix(5)), matrix(6)))).
+matrix_chain_answer(subproblem_count, 21).

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/modular-exponentiation.pl

@@ -0,0 +1,4 @@
+modular_answer(pow_7_560_mod_561, 1).
+modular_answer(pow_2_1000_mod_1009, 942).
+modular_answer(fermat_2_101, true).
+modular_answer(fermat_3_101, true).

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/pell-equation.pl

@@ -0,0 +1,4 @@
+pell_answer(solution_5, solution(3363, 2378)).
+pell_answer(solution_8, solution(665857, 470832)).
+pell_answer(check_8, true).
+pell_answer(y_sum_1_to_8, 568344).

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/stirling-bell-numbers.pl

@@ -0,0 +1,4 @@
+stirling_bell_answer(stirling_10_4, 34105).
+stirling_bell_answer(stirling_12_5, 1379400).
+stirling_bell_answer(bell_10, 115975).
+stirling_bell_answer(bell_12, 4213597).

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/totient-summatory.pl

@@ -0,0 +1,4 @@
+totient_answer(phi_36, 12).
+totient_answer(phi_97, 96).
+totient_answer(coprime_count_84, 24).
+totient_answer(summatory_phi_30, 278).

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/pell-equation.pl

@@ -0,0 +1,29 @@
+% Pell equation x^2 - 2 y^2 = 1 by memoized recurrence.
+% The fundamental solution (3,2) generates all positive solutions.
+materialize(pell_answer, 2).
+
+memoize(pell, 3).
+
+pell(0, 1, 0).
+pell(N, X, Y) :-
+  gt(N, 0),
+  sub(N, 1, N1),
+  pell(N1, X0, Y0),
+  mul(3, X0, AX),
+  mul(4, Y0, BY),
+  add(AX, BY, X),
+  mul(2, X0, CX),
+  mul(3, Y0, DY),
+  add(CX, DY, Y).
+
+pell_holds(N, true) :-
+  pell(N, X, Y),
+  mul(X, X, X2),
+  mul(Y, Y, Y2),
+  mul(2, Y2, TwiceY2),
+  sub(X2, TwiceY2, 1).
+
+pell_answer(solution_5, solution(X, Y)) :- pell(5, X, Y).
+pell_answer(solution_8, solution(X, Y)) :- pell(8, X, Y).
+pell_answer(check_8, true) :- pell_holds(8, true).
+pell_answer(y_sum_1_to_8, Sum) :- sumall(Y, (between(1, 8, N), pell(N, _X, Y)), Sum).

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/stirling-bell-numbers.pl

@@ -0,0 +1,26 @@
+% Stirling numbers of the second kind and Bell numbers.
+% stirling2(N, K, Count) partitions N labelled elements into K nonempty blocks.
+materialize(stirling_bell_answer, 2).
+
+memoize(stirling2, 3).
+
+stirling2(0, 0, 1).
+stirling2(N, 0, 0) :- gt(N, 0).
+stirling2(0, K, 0) :- gt(K, 0).
+stirling2(N, K, Count) :-
+  gt(N, 0),
+  gt(K, 0),
+  sub(N, 1, N1),
+  sub(K, 1, K1),
+  stirling2(N1, K1, NewBlock),
+  stirling2(N1, K, ExistingBlocks),
+  mul(K, ExistingBlocks, Extended),
+  add(NewBlock, Extended, Count).
+
+bell(N, Count) :-
+  sumall(S, (between(0, N, K), stirling2(N, K, S)), Count).
+
+stirling_bell_answer(stirling_10_4, Count) :- stirling2(10, 4, Count).
+stirling_bell_answer(stirling_12_5, Count) :- stirling2(12, 5, Count).
+stirling_bell_answer(bell_10, Count) :- bell(10, Count).
+stirling_bell_answer(bell_12, Count) :- bell(12, 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/totient-summatory.pl

@@ -0,0 +1,29 @@
+% Euler totients and coprimality by memoized Euclidean gcd.
+% This is still ordinary Horn-clause search: phi(N) is the count of K <= N
+% with gcd(N, K) = 1.
+materialize(totient_answer, 2).
+
+memoize(gcd, 3).
+memoize(totient, 2).
+
+gcd(A, 0, A) :- ge(A, 0).
+gcd(A, B, G) :-
+  gt(B, 0),
+  mod(A, B, R),
+  gcd(B, R, G).
+
+coprime_upto(N, K) :-
+  between(1, N, K),
+  gcd(N, K, 1).
+
+totient(N, Count) :-
+  gt(N, 0),
+  countall(coprime_upto(N, _K), Count).
+
+summatory_totient(Limit, Sum) :-
+  sumall(Phi, (between(1, Limit, N), totient(N, Phi)), Sum).
+
+totient_answer(phi_36, Phi) :- totient(36, Phi).
+totient_answer(phi_97, Phi) :- totient(97, Phi).
+totient_answer(coprime_count_84, Count) :- totient(84, Count).
+totient_answer(summatory_phi_30, Sum) :- summatory_totient(30, Sum).

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.17",
   "description": "A small Prolog-syntax-subset logic programming language for rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -449,6 +449,7 @@
       "bayes-diagnosis",
       "bayes-therapy",
       "beam-deflection",
+      "binomial-vandermonde",
       "blocks-world-planning",
       "bmi",
       "braking-safety-worlds",
@@ -456,6 +457,8 @@
       "cache-performance",
       "canary-release",
       "cat-koko",
+      "catalan-convolution",
+      "chart-parser",
       "clinical-trial-screening",
       "collatz-1000",
       "combinatorics-findall-sort",
@@ -464,7 +467,9 @@
       "composition-of-injective-functions-is-injective",
       "context-association",
       "context-schema-audit",
+      "continued-fraction-sqrt2",
       "control-system",
+      "critical-path-schedule",
       "cyclic-path",
       "d3-group",
       "dairy-energy-balance",
@@ -519,6 +524,7 @@
       "heron-theorem",
       "ideal-gas-law",
       "illegitimate-reasoning",
+      "integer-partitions",
       "job-shop-scheduling",
       "knapsack-optimization",
       "knowledge-engineering-alignment-flow",
@@ -527,7 +533,10 @@
       "list-collection",
       "lldm",
       "manufacturing-quality-control",
+      "matrix-chain-order",
       "microgrid-dispatch",
+      "missionaries-cannibals",
+      "modular-exponentiation",
       "monkey-bananas",
       "n-queens-8",
       "network-sla",
@@ -541,6 +550,7 @@
       "path-discovery",
       "peano-arithmetic",
       "peasant",
+      "pell-equation",
       "pendulum-period",
       "polynomial",
       "proof-contrapositive",
@@ -558,12 +568,16 @@
       "socrates",
       "stable-marriage",
       "statistics-summary",
+      "stirling-bell-numbers",
+      "sudoku-4x4",
       "superdense-coding",
       "term-tools",
+      "totient-summatory",
       "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,35 @@ 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 = [
+          ['binomial-vandermonde.pl', 'choose_step', 5, true],
+          ['catalan-convolution.pl', 'catalan', 2, false],
+          ['chart-parser.pl', 'span', 4, true],
+          ['continued-fraction-sqrt2.pl', 'conv', 3, true],
+          ['critical-path-schedule.pl', 'earliest_start', 2, false],
+          ['critical-path-schedule.pl', 'finish_time', 2, false],
+          ['integer-partitions.pl', 'partitions', 3, true],
+          ['matrix-chain-order.pl', 'cost', 3, false],
+          ['modular-exponentiation.pl', 'pow_mod', 4, true],
+          ['pell-equation.pl', 'pell', 3, true],
+          ['stirling-bell-numbers.pl', 'stirling2', 3, true],
+          ['totient-summatory.pl', 'gcd', 3, true],
+          ['totient-summatory.pl', 'totient', 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: () => {