eyelang 1.7.9 → 1.7.10

package/docs/guide.md

@@ -360,9 +360,9 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`derived-backward-rule.eye`](../examples/derived-backward-rule.eye) | Derives an inverse-property backward rule from rule data. | [`output/derived-backward-rule.eye`](../examples/output/derived-backward-rule.eye) |
 | [`derived-rule.eye`](../examples/derived-rule.eye) | Derives conclusions from rule data. | [`output/derived-rule.eye`](../examples/output/derived-rule.eye) |
 | [`diamond-property.eye`](../examples/diamond-property.eye) | Checks the diamond property of a relation. | [`output/diamond-property.eye`](../examples/output/diamond-property.eye) |
-| [`dijkstra.eye`](../examples/dijkstra.eye) | Enumerates weighted simple paths. | [`output/dijkstra.eye`](../examples/output/dijkstra.eye) |
 | [`dijkstra-findall-sort.eye`](../examples/dijkstra-findall-sort.eye) | Finds shortest paths using collected candidates. | [`output/dijkstra-findall-sort.eye`](../examples/output/dijkstra-findall-sort.eye) |
 | [`dijkstra-risk-path.eye`](../examples/dijkstra-risk-path.eye) | Ranks routes by cost and trust. | [`output/dijkstra-risk-path.eye`](../examples/output/dijkstra-risk-path.eye) |
+| [`dijkstra.eye`](../examples/dijkstra.eye) | Enumerates weighted simple paths. | [`output/dijkstra.eye`](../examples/output/dijkstra.eye) |
 | [`dining-philosophers.eye`](../examples/dining-philosophers.eye) | Simulates Chandy-Misra fork exchanges. | [`output/dining-philosophers.eye`](../examples/output/dining-philosophers.eye) |
 | [`dog.eye`](../examples/dog.eye) | Counts dogs and derives when a license is required. | [`output/dog.eye`](../examples/output/dog.eye) |
 | [`dpv-odrl-purpose-mapping.eye`](../examples/dpv-odrl-purpose-mapping.eye) | Maps a DPV process into an ODRL permission view. | [`output/dpv-odrl-purpose-mapping.eye`](../examples/output/dpv-odrl-purpose-mapping.eye) |
@@ -389,8 +389,8 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`gdpr-compliance.eye`](../examples/gdpr-compliance.eye) | Checks GDPR-style processing compliance. | [`output/gdpr-compliance.eye`](../examples/output/gdpr-compliance.eye) |
 | [`good-cobbler.eye`](../examples/good-cobbler.eye) | Demonstrates term-level structure with a good-cobbler statement. | [`output/good-cobbler.eye`](../examples/output/good-cobbler.eye) |
 | [`gps.eye`](../examples/gps.eye) | Finds and verifies route paths. | [`output/gps.eye`](../examples/output/gps.eye) |
-| [`graph.eye`](../examples/graph.eye) | Derives transitive paths over French-city road links while showing the productive recursive rule order. | [`output/graph.eye`](../examples/output/graph.eye) |
 | [`graph-reachability.eye`](../examples/graph-reachability.eye) | Derives reachable nodes in a graph. | [`output/graph-reachability.eye`](../examples/output/graph-reachability.eye) |
+| [`graph.eye`](../examples/graph.eye) | Derives transitive paths over French-city road links while showing the productive recursive rule order. | [`output/graph.eye`](../examples/output/graph.eye) |
 | [`gray-code-counter.eye`](../examples/gray-code-counter.eye) | Generates Gray-code counter states. | [`output/gray-code-counter.eye`](../examples/output/gray-code-counter.eye) |
 | [`greatest-lower-bound-uniqueness.eye`](../examples/greatest-lower-bound-uniqueness.eye) | Shows uniqueness of greatest lower bounds in a finite order instance. | [`output/greatest-lower-bound-uniqueness.eye`](../examples/output/greatest-lower-bound-uniqueness.eye) |
 | [`group-inverse-uniqueness.eye`](../examples/group-inverse-uniqueness.eye) | Shows uniqueness of inverses in a finite group instance. | [`output/group-inverse-uniqueness.eye`](../examples/output/group-inverse-uniqueness.eye) |
@@ -398,6 +398,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`hamming-code.eye`](../examples/hamming-code.eye) | Corrects a single-bit Hamming word. | [`output/hamming-code.eye`](../examples/output/hamming-code.eye) |
 | [`hanoi.eye`](../examples/hanoi.eye) | Derives the Towers of Hanoi moves. | [`output/hanoi.eye`](../examples/output/hanoi.eye) |
 | [`heat-loss.eye`](../examples/heat-loss.eye) | Computes conductive heat loss. | [`output/heat-loss.eye`](../examples/output/heat-loss.eye) |
+| [`herbrand-witnesses.eye`](../examples/herbrand-witnesses.eye) | Represents existential-style consequences as stable Herbrand witness terms. | [`output/herbrand-witnesses.eye`](../examples/output/herbrand-witnesses.eye) |
 | [`heron-theorem.eye`](../examples/heron-theorem.eye) | Computes triangle area by Heron's theorem. | [`output/heron-theorem.eye`](../examples/output/heron-theorem.eye) |
 | [`ideal-gas-law.eye`](../examples/ideal-gas-law.eye) | Applies the ideal gas law. | [`output/ideal-gas-law.eye`](../examples/output/ideal-gas-law.eye) |
 | [`illegitimate-reasoning.eye`](../examples/illegitimate-reasoning.eye) | Detects suspect reasoning patterns. | [`output/illegitimate-reasoning.eye`](../examples/output/illegitimate-reasoning.eye) |
@@ -413,7 +414,9 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`list-collection.eye`](../examples/list-collection.eye) | Demonstrates list and collection built-ins. | [`output/list-collection.eye`](../examples/output/list-collection.eye) |
 | [`lldm.eye`](../examples/lldm.eye) | Calculates leg-length discrepancy measurements. | [`output/lldm.eye`](../examples/output/lldm.eye) |
 | [`manufacturing-quality-control.eye`](../examples/manufacturing-quality-control.eye) | Evaluates process capability and quality. | [`output/manufacturing-quality-control.eye`](../examples/output/manufacturing-quality-control.eye) |
+| [`map-four-color-search.eye`](../examples/map-four-color-search.eye) | Searches for a valid four-colouring of the EU neighbour graph. | [`output/map-four-color-search.eye`](../examples/output/map-four-color-search.eye) |
 | [`matrix-chain-order.eye`](../examples/matrix-chain-order.eye) | Finds an optimal matrix-chain multiplication order. | [`output/matrix-chain-order.eye`](../examples/output/matrix-chain-order.eye) |
+| [`matrix-noncommutativity.eye`](../examples/matrix-noncommutativity.eye) | Multiplies 2x2 matrices and shows non-commutativity. | [`output/matrix-noncommutativity.eye`](../examples/output/matrix-noncommutativity.eye) |
 | [`microgrid-dispatch.eye`](../examples/microgrid-dispatch.eye) | Plans microgrid dispatch and reserve. | [`output/microgrid-dispatch.eye`](../examples/output/microgrid-dispatch.eye) |
 | [`missionaries-cannibals.eye`](../examples/missionaries-cannibals.eye) | Solves the missionaries-and-cannibals river crossing puzzle. | [`output/missionaries-cannibals.eye`](../examples/output/missionaries-cannibals.eye) |
 | [`modal-logic-kripke.eye`](../examples/modal-logic-kripke.eye) | Emulates modal box and diamond operators over a finite Kripke frame. | [`output/modal-logic-kripke.eye`](../examples/output/modal-logic-kripke.eye) |
@@ -430,21 +433,24 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`orbital-transfer-design.eye`](../examples/orbital-transfer-design.eye) | Designs a Hohmann orbital transfer. | [`output/orbital-transfer-design.eye`](../examples/output/orbital-transfer-design.eye) |
 | [`path-discovery.eye`](../examples/path-discovery.eye) | Discovers bounded air-route paths. | [`output/path-discovery.eye`](../examples/output/path-discovery.eye) |
 | [`peano-arithmetic.eye`](../examples/peano-arithmetic.eye) | Computes Peano addition, multiplication, and factorial. | [`output/peano-arithmetic.eye`](../examples/output/peano-arithmetic.eye) |
+| [`peano-calculus.eye`](../examples/peano-calculus.eye) | Computes Peano addition, multiplication, and factorial. | [`output/peano-calculus.eye`](../examples/output/peano-calculus.eye) |
 | [`peasant.eye`](../examples/peasant.eye) | Performs peasant multiplication and exponentiation. | [`output/peasant.eye`](../examples/output/peasant.eye) |
 | [`pell-equation.eye`](../examples/pell-equation.eye) | Generates Pell-equation solutions by recurrence. | [`output/pell-equation.eye`](../examples/output/pell-equation.eye) |
 | [`pendulum-period.eye`](../examples/pendulum-period.eye) | Computes simple pendulum periods. | [`output/pendulum-period.eye`](../examples/output/pendulum-period.eye) |
 | [`polynomial.eye`](../examples/polynomial.eye) | Finds complex integer polynomial roots. | [`output/polynomial.eye`](../examples/output/polynomial.eye) |
+| [`prime-range.eye`](../examples/prime-range.eye) | Finds primes in a finite range and computes a totient value. | [`output/prime-range.eye`](../examples/output/prime-range.eye) |
 | [`proof-contrapositive.eye`](../examples/proof-contrapositive.eye) | Models proof by contrapositive. | [`output/proof-contrapositive.eye`](../examples/output/proof-contrapositive.eye) |
 | [`quadratic-formula.eye`](../examples/quadratic-formula.eye) | Solves sample quadratic equations. | [`output/quadratic-formula.eye`](../examples/output/quadratic-formula.eye) |
 | [`radioactive-decay.eye`](../examples/radioactive-decay.eye) | Computes radioactive decay over time. | [`output/radioactive-decay.eye`](../examples/output/radioactive-decay.eye) |
 | [`reusable-builtins.eye`](../examples/reusable-builtins.eye) | Tours reusable numeric, list, and string builtins. | [`output/reusable-builtins.eye`](../examples/output/reusable-builtins.eye) |
 | [`riemann-hypothesis.eye`](../examples/riemann-hypothesis.eye) | Checks a finite catalogue of non-trivial zeta zeros against the Riemann-hypothesis condition. | [`output/riemann-hypothesis.eye`](../examples/output/riemann-hypothesis.eye) |
+| [`route-planning.eye`](../examples/route-planning.eye) | Finds routes and records them as explicit route terms. | [`output/route-planning.eye`](../examples/output/route-planning.eye) |
 | [`security-incident-correlation.eye`](../examples/security-incident-correlation.eye) | Correlates security incidents across signals. | [`output/security-incident-correlation.eye`](../examples/output/security-incident-correlation.eye) |
 | [`send-more-money.eye`](../examples/send-more-money.eye) | Solves the SEND + MORE = MONEY cryptarithm. | [`output/send-more-money.eye`](../examples/output/send-more-money.eye) |
 | [`service-impact.eye`](../examples/service-impact.eye) | Analyzes service impact over cyclic dependencies. | [`output/service-impact.eye`](../examples/output/service-impact.eye) |
+| [`shoelace-polygon-area.eye`](../examples/shoelace-polygon-area.eye) | Computes polygon area with a recursive shoelace calculation. | [`output/shoelace-polygon-area.eye`](../examples/output/shoelace-polygon-area.eye) |
 | [`sieve.eye`](../examples/sieve.eye) | Enumerates primes with a sieve-style program. | [`output/sieve.eye`](../examples/output/sieve.eye) |
 | [`skolem-functions.eye`](../examples/skolem-functions.eye) | Generates deterministic functional terms. | [`output/skolem-functions.eye`](../examples/output/skolem-functions.eye) |
-| [`herbrand-witnesses.eye`](../examples/herbrand-witnesses.eye) | Represents existential-style consequences as stable Herbrand witness terms. | [`output/herbrand-witnesses.eye`](../examples/output/herbrand-witnesses.eye) |
 | [`socket-age.eye`](../examples/socket-age.eye) | Shows socket-declared age reasoning inputs and plugs. | [`output/socket-age.eye`](../examples/output/socket-age.eye) |
 | [`socket-family.eye`](../examples/socket-family.eye) | Shows socket-declared family-source inputs and ancestry rules. | [`output/socket-family.eye`](../examples/output/socket-family.eye) |
 | [`socrates.eye`](../examples/socrates.eye) | Derives that Socrates is mortal. | [`output/socrates.eye`](../examples/output/socrates.eye) |
@@ -453,6 +459,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`stirling-bell-numbers.eye`](../examples/stirling-bell-numbers.eye) | Computes Stirling numbers and Bell numbers. | [`output/stirling-bell-numbers.eye`](../examples/output/stirling-bell-numbers.eye) |
 | [`sudoku-4x4.eye`](../examples/sudoku-4x4.eye) | Solves a compact 4x4 Sudoku by finite constraint search. | [`output/sudoku-4x4.eye`](../examples/output/sudoku-4x4.eye) |
 | [`superdense-coding.eye`](../examples/superdense-coding.eye) | Models superdense-coding bit transmission. | [`output/superdense-coding.eye`](../examples/output/superdense-coding.eye) |
+| [`symbolic-derivative.eye`](../examples/symbolic-derivative.eye) | Symbolically differentiates explicit expression terms, including products and logs. | [`output/symbolic-derivative.eye`](../examples/output/symbolic-derivative.eye) |
 | [`term-tools.eye`](../examples/term-tools.eye) | Inspects, builds, renders, and validates terms with reusable term/control builtins. | [`output/term-tools.eye`](../examples/output/term-tools.eye) |
 | [`totient-summatory.eye`](../examples/totient-summatory.eye) | Computes Euler totients and their summatory function. | [`output/totient-summatory.eye`](../examples/output/totient-summatory.eye) |
 | [`trust-flow-provenance-threshold.eye`](../examples/trust-flow-provenance-threshold.eye) | Classifies message trust from provenance confidence scores. | [`output/trust-flow-provenance-threshold.eye`](../examples/output/trust-flow-provenance-threshold.eye) |
@@ -463,6 +470,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`weighted-interval-scheduling.eye`](../examples/weighted-interval-scheduling.eye) | Selects the best non-overlapping weighted intervals with tabled dynamic programming. | [`output/weighted-interval-scheduling.eye`](../examples/output/weighted-interval-scheduling.eye) |
 | [`witch.eye`](../examples/witch.eye) | Derives the classic “burn the witch” rule chain. | [`output/witch.eye`](../examples/output/witch.eye) |
 | [`wolf-goat-cabbage.eye`](../examples/wolf-goat-cabbage.eye) | Solves the wolf-goat-cabbage river crossing. | [`output/wolf-goat-cabbage.eye`](../examples/output/wolf-goat-cabbage.eye) |
+| [`workplace-compliance.eye`](../examples/workplace-compliance.eye) | Classifies workplace compliance from explicit action facts. | [`output/workplace-compliance.eye`](../examples/output/workplace-compliance.eye) |
 | [`zebra.eye`](../examples/zebra.eye) | Solves the zebra logic puzzle. | [`output/zebra.eye`](../examples/output/zebra.eye) |
 
 ## Golden outputs, tests, and conformance

package/examples/map-four-color-search.eye

@@ -0,0 +1,65 @@
+% Four-colour search for the European Union neighbour graph.
+%
+% This is a finite executable version of the source map-colouring example.  The
+% neighbour facts are the EU country graph from the original input, represented
+% with lowercase atom names.  `once/1` asks for one valid colouring rather than
+% enumerating all possible four-colour assignments.
+
+materialize(four_color_answer, 2).
+
+color(red).
+color(green).
+color(blue).
+color(yellow).
+
+place_order([belgium, netherlands, luxemburg, france, germany, italy, denmark, ireland, greece, spain, portugal, austria, sweden, finland, cyprus, malta, poland, hungary, czech_republic, slovakia, slovenia, estonia, latvia, lithuania, bulgaria, romania, croatia]).
+
+neighbours(belgium, [france, netherlands, luxemburg, germany]).
+neighbours(netherlands, [belgium, germany]).
+neighbours(luxemburg, [belgium, france, germany]).
+neighbours(france, [spain, belgium, luxemburg, germany, italy]).
+neighbours(germany, [netherlands, belgium, luxemburg, denmark, france, austria, poland, czech_republic]).
+neighbours(italy, [france, austria, slovenia]).
+neighbours(denmark, [germany]).
+neighbours(ireland, []).
+neighbours(greece, [bulgaria]).
+neighbours(spain, [france, portugal]).
+neighbours(portugal, [spain]).
+neighbours(austria, [czech_republic, germany, hungary, italy, slovenia, slovakia]).
+neighbours(sweden, [finland]).
+neighbours(finland, [sweden]).
+neighbours(cyprus, []).
+neighbours(malta, []).
+neighbours(poland, [germany, czech_republic, slovakia, lithuania]).
+neighbours(hungary, [austria, slovakia, romania, croatia, slovenia]).
+neighbours(czech_republic, [germany, poland, slovakia, austria]).
+neighbours(slovakia, [czech_republic, poland, hungary, austria]).
+neighbours(slovenia, [austria, italy, hungary, croatia]).
+neighbours(estonia, [latvia]).
+neighbours(latvia, [estonia, lithuania]).
+neighbours(lithuania, [latvia, poland]).
+neighbours(bulgaria, [romania, greece]).
+neighbours(romania, [hungary, bulgaria]).
+neighbours(croatia, [slovenia, hungary]).
+
+% Colour the tail first, like the source Prolog program.  That gives each
+% colour choice the already-coloured suffix to check against and avoids
+% generating many doomed prefixes.
+valid_color(?place, ?color, ?assigned) :-
+  neighbours(?place, ?neighbors),
+  not((member([?neighbor, ?color], ?assigned), member(?neighbor, ?neighbors))).
+
+place_pairs([], []).
+place_pairs([?place|?rest], [[?place, ?_]|?pairs]) :-
+  place_pairs(?rest, ?pairs).
+
+color_places([]).
+color_places([[?place, ?color]|?tail]) :-
+  color_places(?tail),
+  color(?color),
+  valid_color(?place, ?color, ?tail).
+
+four_color_answer(european_union, ?coloring) :-
+  place_order(?places),
+  place_pairs(?places, ?coloring),
+  once(color_places(?coloring)).

package/examples/matrix-noncommutativity.eye

@@ -0,0 +1,43 @@
+% Matrix multiplication and non-commutativity.
+%
+% The original matrix example contains a larger matrix library.  This compact
+% Eyelang case keeps the core operation visible: multiply two 2x2 matrices and
+% show that, in general, A*B is not the same matrix as B*A.
+
+materialize(matrix_result, 2).
+
+matrix_a([[1, 2], [0, 1]]).
+matrix_b([[1, 0], [3, 1]]).
+
+dot2([?x1, ?x2], [?y1, ?y2], ?r) :-
+  mul(?x1, ?y1, ?p1),
+  mul(?x2, ?y2, ?p2),
+  add(?p1, ?p2, ?r).
+
+transpose2([[?a, ?b], [?c, ?d]], [[?a, ?c], [?b, ?d]]).
+
+row_times_matrix(?row, ?matrix, [?r1, ?r2]) :-
+  transpose2(?matrix, [?col1, ?col2]),
+  dot2(?row, ?col1, ?r1),
+  dot2(?row, ?col2, ?r2).
+
+matrix_mul([?row1, ?row2], ?matrix, [?out1, ?out2]) :-
+  row_times_matrix(?row1, ?matrix, ?out1),
+  row_times_matrix(?row2, ?matrix, ?out2).
+
+matrix_result(ab, ?ab) :-
+  matrix_a(?a),
+  matrix_b(?b),
+  matrix_mul(?a, ?b, ?ab).
+
+matrix_result(ba, ?ba) :-
+  matrix_a(?a),
+  matrix_b(?b),
+  matrix_mul(?b, ?a, ?ba).
+
+matrix_result(commutative, false) :-
+  matrix_a(?a),
+  matrix_b(?b),
+  matrix_mul(?a, ?b, ?ab),
+  matrix_mul(?b, ?a, ?ba),
+  neq(?ab, ?ba).

package/examples/output/map-four-color-search.eye

@@ -0,0 +1 @@
+four_color_answer(european_union, [[belgium, yellow], [netherlands, green], [luxemburg, green], [france, blue], [germany, red], [italy, red], [denmark, green], [ireland, red], [greece, red], [spain, green], [portugal, red], [austria, yellow], [sweden, green], [finland, red], [cyprus, red], [malta, red], [poland, blue], [hungary, blue], [czech_republic, green], [slovakia, red], [slovenia, green], [estonia, red], [latvia, green], [lithuania, red], [bulgaria, green], [romania, red], [croatia, red]]).

package/examples/output/matrix-noncommutativity.eye

@@ -0,0 +1,3 @@
+matrix_result(ab, [[7, 2], [3, 1]]).
+matrix_result(ba, [[1, 2], [3, 7]]).
+matrix_result(commutative, false).

package/examples/output/peano-calculus.eye

@@ -0,0 +1,3 @@
+peano_answer(two_plus_three, s(s(s(s(s(z)))))).
+peano_answer(two_times_three, s(s(s(s(s(s(z))))))).
+peano_answer(factorial_four, s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(s(z))))))))))))))))))))))))).

package/examples/output/prime-range.eye

@@ -0,0 +1,3 @@
+prime_result(range_2_30, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]).
+prime_result(count_2_30, 10).
+prime_result(totient_271, 270).

package/examples/output/route-planning.eye

@@ -0,0 +1,4 @@
+route_to_nantes(angers, go(angers, nantes, goal)).
+route_to_nantes(paris, go(paris, chartres, go(chartres, lemans, go(lemans, angers, go(angers, nantes, goal))))).
+route_to_nantes(chartres, go(chartres, lemans, go(lemans, angers, go(angers, nantes, goal)))).
+route_to_nantes(lemans, go(lemans, angers, go(angers, nantes, goal))).

package/examples/output/shoelace-polygon-area.eye

@@ -0,0 +1 @@
+polygon_area(sample, 7.5).

package/examples/output/symbolic-derivative.eye

@@ -0,0 +1,4 @@
+derivative_result(square, add(mul(const(1), var(x)), mul(var(x), const(1)))).
+derivative_result(linear_plus_const, add(const(1), const(0))).
+derivative_result(product, add(mul(add(const(1), const(0)), mul(add(pow(var(x), 2), const(2)), add(pow(var(x), 3), const(3)))), mul(add(var(x), const(1)), add(mul(add(mul(mul(const(2), pow(var(x), 1)), const(1)), const(0)), add(pow(var(x), 3), const(3))), mul(add(pow(var(x), 2), const(2)), add(mul(mul(const(3), pow(var(x), 2)), const(1)), const(0))))))).
+derivative_result(nested_log, divide(divide(const(1), var(x)), log(var(x)))).

package/examples/output/workplace-compliance.eye

@@ -0,0 +1,4 @@
+status(bob, compliant).
+status(alice, compliant).
+status(dave, non_compliant).
+status(carol, non_compliant).

package/examples/peano-calculus.eye

@@ -0,0 +1,40 @@
+% Peano addition, multiplication, and factorial over explicit Herbrand terms.
+%
+% The original logic-programming example uses `0` and `s(...)`.  Here zero is
+% the atom `z`, so every natural number is an ordinary Eyelang term: z, s(z),
+% s(s(z)), and so on.  The rules are relational; the materialized facts choose
+% a few finite calculations as readable examples.
+
+materialize(peano_answer, 2).
+table(padd, 3).
+table(pmul, 3).
+table(pfact, 2).
+
+% Addition.
+padd(?a, z, ?a).
+padd(?a, s(?b), s(?c)) :-
+  padd(?a, ?b, ?c).
+
+% Multiplication by repeated addition.
+pmul(?_a, z, z).
+pmul(?a, s(?b), ?c) :-
+  pmul(?a, ?b, ?d),
+  padd(?a, ?d, ?c).
+
+% Factorial with an accumulator.
+pfact(?n, ?value) :-
+  pfac(?n, s(z), ?value).
+
+pfac(z, ?acc, ?acc).
+pfac(s(?n), ?acc, ?value) :-
+  pmul(?acc, s(?n), ?next),
+  pfac(?n, ?next, ?value).
+
+peano_answer(two_plus_three, ?n) :-
+  padd(s(s(z)), s(s(s(z))), ?n).
+
+peano_answer(two_times_three, ?n) :-
+  pmul(s(s(z)), s(s(s(z))), ?n).
+
+peano_answer(factorial_four, ?n) :-
+  pfact(s(s(s(s(z)))), ?n).

package/examples/prime-range.eye

@@ -0,0 +1,45 @@
+% Prime ranges and Euler totient over finite integer domains.
+%
+% The source example combines prime search with Euler's totient function.  This
+% Eyelang version keeps the computation finite and declarative: composite
+% numbers are described by proper divisors, primes are candidates that are not
+% composite, and `totient/2` counts numbers coprime with the input.
+
+materialize(prime_result, 2).
+table(gcd, 3).
+
+candidate(?n) :-
+  between(2, 30, ?n).
+
+composite(?n) :-
+  candidate(?n),
+  between(2, ?n, ?d),
+  lt(?d, ?n),
+  mod(?n, ?d, 0).
+
+prime(?n) :-
+  candidate(?n),
+  not(composite(?n)).
+
+% Euclid's algorithm, used for the totient calculation.
+gcd(?n, 0, ?n).
+gcd(?n, ?m, ?g) :-
+  gt(?m, 0),
+  mod(?n, ?m, ?r),
+  gcd(?m, ?r, ?g).
+
+coprime(?n, ?k) :-
+  between(1, ?n, ?k),
+  gcd(?n, ?k, 1).
+
+totient(?n, ?phi) :-
+  countall(coprime(?n, ?_k), ?phi).
+
+prime_result(range_2_30, ?primes) :-
+  findall(?p, prime(?p), ?primes).
+
+prime_result(count_2_30, ?count) :-
+  countall(prime(?p), ?count).
+
+prime_result(totient_271, ?phi) :-
+  totient(271, ?phi).

package/examples/route-planning.eye

@@ -0,0 +1,33 @@
+% Route planning with explicit route terms.
+%
+% This is the Eyelang version of the classic Paris-to-Nantes path example: the
+% facts describe one-way road links, and `path/2` derives both the endpoint pair
+% and a structured `go(..., ..., ...)` plan.  The plan is ordinary data, so the
+% route can be inspected, stored, or used by later rules.
+
+materialize(route_to_nantes, 2).
+table(path, 2).
+mode(path, 2, [in, out]).
+
+oneway(paris, orleans).
+oneway(paris, chartres).
+oneway(paris, amiens).
+oneway(orleans, blois).
+oneway(orleans, bourges).
+oneway(blois, tours).
+oneway(chartres, lemans).
+oneway(lemans, angers).
+oneway(lemans, tours).
+oneway(angers, nantes).
+
+% A direct edge is a one-step plan.
+path([?a, ?b], go(?a, ?b, goal)) :-
+  oneway(?a, ?b).
+
+% A longer path prepends one edge to the remaining plan.
+path([?a, ?c], go(?a, ?b, ?rest)) :-
+  oneway(?a, ?b),
+  path([?b, ?c], ?rest).
+
+route_to_nantes(?from, ?plan) :-
+  path([?from, nantes], ?plan).

package/examples/shoelace-polygon-area.eye

@@ -0,0 +1,22 @@
+% Polygon area by the shoelace formula.
+%
+% The input polygon is the same closed polygon shape used by the source example:
+% the final point repeats the first point.  Each recursive step consumes one
+% adjacent pair and contributes `(x1*y2 - y1*x2) / 2` to the oriented area.
+
+materialize(polygon_area, 2).
+
+sample_polygon([[3, 2], [6, 2], [7, 6], [4, 6], [5, 5], [5, 3], [3, 2]]).
+
+area([?_point], 0).
+area([[?a, ?b], [?c, ?d]|?rest], ?total) :-
+  area([[?c, ?d]|?rest], ?subtotal),
+  mul(?a, ?d, ?ad),
+  mul(?b, ?c, ?bc),
+  sub(?ad, ?bc, ?cross),
+  div(?cross, 2.0, ?half),
+  add(?half, ?subtotal, ?total).
+
+polygon_area(sample, ?area) :-
+  sample_polygon(?points),
+  area(?points, ?area).

package/examples/symbolic-derivative.eye

@@ -0,0 +1,39 @@
+% Symbolic differentiation over explicit expression terms.
+%
+% The source derivative example uses Prolog operators such as `+`, `*`, `^`, and
+% cut.  Eyelang keeps expressions as ordinary terms: `add/2`, `mul/2`, `pow/2`,
+% `log/1`, and so on.  The result is intentionally unsimplified so the rule that
+% produced each part remains visible.
+
+materialize(derivative_result, 2).
+
+expr(square, mul(var(x), var(x))).
+expr(linear_plus_const, add(var(x), const(3))).
+expr(product, mul(add(var(x), const(1)), mul(add(pow(var(x), 2), const(2)), add(pow(var(x), 3), const(3))))).
+expr(nested_log, log(log(var(x)))).
+
+d(const(?_c), ?_x, const(0)).
+d(var(?x), ?x, const(1)).
+d(var(?y), ?x, const(0)) :-
+  neq(?x, ?y).
+d(add(?u, ?v), ?x, add(?du, ?dv)) :-
+  d(?u, ?x, ?du),
+  d(?v, ?x, ?dv).
+d(sub(?u, ?v), ?x, sub(?du, ?dv)) :-
+  d(?u, ?x, ?du),
+  d(?v, ?x, ?dv).
+d(mul(?u, ?v), ?x, add(mul(?du, ?v), mul(?u, ?dv))) :-
+  d(?u, ?x, ?du),
+  d(?v, ?x, ?dv).
+d(divide(?u, ?v), ?x, divide(sub(mul(?du, ?v), mul(?u, ?dv)), pow(?v, 2))) :-
+  d(?u, ?x, ?du),
+  d(?v, ?x, ?dv).
+d(pow(?u, ?n), ?x, mul(mul(const(?n), pow(?u, ?n1)), ?du)) :-
+  sub(?n, 1, ?n1),
+  d(?u, ?x, ?du).
+d(log(?u), ?x, divide(?du, ?u)) :-
+  d(?u, ?x, ?du).
+
+derivative_result(?name, ?derivative) :-
+  expr(?name, ?expr),
+  d(?expr, x, ?derivative).

package/examples/workplace-compliance.eye

@@ -0,0 +1,41 @@
+% Workplace compliance from explicit action facts.
+%
+% The source example generated a large dynamic dataset.  Eyelang keeps the data
+% explicit and reproducible: each `does/2` fact records an observed employee
+% action, and the rules classify compliant and non-compliant behaviour.
+
+materialize(status, 2).
+
+employee(alice).
+employee(bob).
+employee(carol).
+employee(dave).
+
+does(alice, log_off_at_end_of_shift).
+does(bob, work_related_task).
+does(bob, log_off_at_end_of_shift).
+does(carol, access_social_media).
+does(dave, work_related_task).
+
+% Work-related activity is compliant when the employee also logs off.
+status(?person, compliant) :-
+  employee(?person),
+  does(?person, work_related_task),
+  does(?person, log_off_at_end_of_shift).
+
+% Logging off is compliant by itself when no work task was observed.
+status(?person, compliant) :-
+  employee(?person),
+  does(?person, log_off_at_end_of_shift),
+  not(does(?person, work_related_task)).
+
+% A work task without the required log-off is non-compliant.
+status(?person, non_compliant) :-
+  employee(?person),
+  does(?person, work_related_task),
+  not(does(?person, log_off_at_end_of_shift)).
+
+% Accessing social media is non-compliant in this policy.
+status(?person, non_compliant) :-
+  employee(?person),
+  does(?person, access_social_media).

package/package.json

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

package/playground.html

@@ -522,6 +522,7 @@
           "hamming-code",
           "hanoi",
           "heat-loss",
+          "herbrand-witnesses",
           "heron-theorem",
           "ideal-gas-law",
           "illegitimate-reasoning",
@@ -537,7 +538,9 @@
           "list-collection",
           "lldm",
           "manufacturing-quality-control",
+          "map-four-color-search",
           "matrix-chain-order",
+          "matrix-noncommutativity",
           "microgrid-dispatch",
           "missionaries-cannibals",
           "modal-logic-kripke",
@@ -554,21 +557,24 @@
           "orbital-transfer-design",
           "path-discovery",
           "peano-arithmetic",
+          "peano-calculus",
           "peasant",
           "pell-equation",
           "pendulum-period",
           "polynomial",
+          "prime-range",
           "proof-contrapositive",
           "quadratic-formula",
           "radioactive-decay",
           "reusable-builtins",
           "riemann-hypothesis",
+          "route-planning",
           "security-incident-correlation",
           "send-more-money",
           "service-impact",
+          "shoelace-polygon-area",
           "sieve",
           "skolem-functions",
-          "herbrand-witnesses",
           "socket-age",
           "socket-family",
           "socrates",
@@ -577,6 +583,7 @@
           "stirling-bell-numbers",
           "sudoku-4x4",
           "superdense-coding",
+          "symbolic-derivative",
           "term-tools",
           "totient-summatory",
           "trust-flow-provenance-threshold",
@@ -587,6 +594,7 @@
           "weighted-interval-scheduling",
           "witch",
           "wolf-goat-cabbage",
+          "workplace-compliance",
           "zebra"
     ];
     const FALLBACK_SOURCE = `materialize(answer, 1).