eyelang 1.7.8 → 1.7.10

package/README.md

@@ -4,7 +4,7 @@
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20761726-blue.svg)](https://doi.org/10.5281/zenodo.20761726)
 
 Eyelang is a small logic programming language for rules, goals, answers, and proofs.
-Its source syntax is Prolog-like Horn-clause syntax with deliberate eyelang choices, including `?x` variables for N3/SPARQL-style readability, explicit `table(path, 2).` declarations for tabled predicates, advisory `mode/3` declarations for host tooling, and stratified-negation diagnostics for portable `not/1` usage.
+Its source syntax is Prolog-like Horn-clause syntax with deliberate eyelang choices, including `?x` variables for N3/SPARQL-style readability, explicit `table(path, 2).` declarations for tabled predicates, advisory `mode/3` declarations for host tooling, explicit Herbrand witness terms for executable existential-style consequences, and stratified-negation diagnostics for portable `not/1` usage.
 It grew out of logic-language experiments in the EYE/N3 reasoning tradition, but is packaged here as its own project.
 
 ## Install and run

package/conformance-report.md

@@ -14,12 +14,12 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | lists | 54 | 3 | 0 | 0 | 57 |
 | materialize | 8 | 0 | 0 | 0 | 8 |
 | negation | 8 | 0 | 19 | 0 | 27 |
-| proofs | 0 | 0 | 0 | 20 | 20 |
+| proofs | 0 | 0 | 0 | 21 | 21 |
 | rules | 12 | 3 | 0 | 0 | 15 |
 | strings | 40 | 0 | 0 | 0 | 40 |
 | syntax | 11 | 28 | 0 | 0 | 39 |
 | table | 6 | 0 | 0 | 0 | 6 |
-| terms | 25 | 3 | 0 | 0 | 28 |
+| terms | 29 | 3 | 0 | 0 | 32 |
 | unification | 16 | 0 | 0 | 0 | 16 |
 | variables | 16 | 11 | 0 | 0 | 27 |
-| **Total** | **317** | **56** | **19** | **20** | **412** |
+| **Total** | **321** | **56** | **19** | **21** | **417** |

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) |
@@ -373,7 +373,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`equivalence-classes-overlap-implies-same-class.eye`](../examples/equivalence-classes-overlap-implies-same-class.eye) | Packages the shared-member proof pattern for equivalence classes. | [`output/equivalence-classes-overlap-implies-same-class.eye`](../examples/output/equivalence-classes-overlap-implies-same-class.eye) |
 | [`eulerian-path.eye`](../examples/eulerian-path.eye) | Finds an Eulerian path using each edge once. | [`output/eulerian-path.eye`](../examples/output/eulerian-path.eye) |
 | [`ev-range-worlds.eye`](../examples/ev-range-worlds.eye) | Estimates electric-vehicle trip feasibility. | [`output/ev-range-worlds.eye`](../examples/output/ev-range-worlds.eye) |
-| [`existential-rule.eye`](../examples/existential-rule.eye) | Represents existential witnesses with explicit Skolem-style terms. | [`output/existential-rule.eye`](../examples/output/existential-rule.eye) |
+| [`existential-rule.eye`](../examples/existential-rule.eye) | Represents existential-style witnesses with explicit Herbrand terms. | [`output/existential-rule.eye`](../examples/output/existential-rule.eye) |
 | [`exoplanet-validation-worlds.eye`](../examples/exoplanet-validation-worlds.eye) | Validates exoplanet candidates across worlds. | [`output/exoplanet-validation-worlds.eye`](../examples/output/exoplanet-validation-worlds.eye) |
 | [`expression-eval.eye`](../examples/expression-eval.eye) | Evaluates a small arithmetic expression tree. | [`output/expression-eval.eye`](../examples/output/expression-eval.eye) |
 | [`family-cousins.eye`](../examples/family-cousins.eye) | Derives cousin and family labels. | [`output/family-cousins.eye`](../examples/output/family-cousins.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,18 +433,22 @@ 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) |
 | [`socket-age.eye`](../examples/socket-age.eye) | Shows socket-declared age reasoning inputs and plugs. | [`output/socket-age.eye`](../examples/output/socket-age.eye) |
@@ -452,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) |
@@ -462,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/docs/language-reference.md

@@ -333,6 +333,18 @@ Equivalently, the least Herbrand model is obtained by repeatedly applying the im
 
 Variables do not range over external objects, records, pointers, or host-language values. In the logical reading, variables range over Herbrand terms. A rule is implicitly universally quantified over its variables. A selected goal is existential in the usual logic-programming sense: eyelang searches for substitutions of its variables by Herbrand terms that make the goal true with respect to the program.
 
+eyelang has no blank nodes and no existential variables in rule heads. Existential-style consequences SHOULD be represented by explicit Herbrand witness terms written directly in rule heads:
+
+```eyelang
+has_parent(?child, parent_of(?child)) :-
+  person(?child).
+
+registration(?student, ?course, registration_of(?student, ?course)) :-
+  takes(?student, ?course).
+```
+
+These rules may derive `parent_of(alice)` or `registration_of(alice, logic)` as ordinary visible Herbrand terms. The witness is deterministic: the same functor and inputs produce the same term, while different inputs produce different terms by normal syntactic identity. This is the practical executable form of existential-style consequences in Eyelang; it does not introduce hidden blank nodes or special quantifier syntax.
+
 ### 8.2 Equality, identity, and unification
 
 Because the domain is Herbrand, equality in the pure language is syntactic identity of terms after substitution. Two distinct atom constants are distinct. Two compound terms are equal only when they have the same functor, the same arity, and pairwise equal arguments. Lists follow the same rule through their `[]` and `./2` representation.

package/examples/existential-rule.eye

@@ -1,21 +1,14 @@
-% Existential introduction with explicit witnesses.
-% Eyeling's original N3 rule creates existential blank nodes; in Eyelang the
-% same idea is represented by deterministic Skolem-style witness terms so the
-% generated individual is visible in ordinary output.
+% Existential-style introduction with explicit Herbrand witnesses.
 %
-% The materialized is/2 facts show the person-to-witness relation.
-materialize(is, 2).
+% Eyelang has no blank nodes and no existential variables in rule heads.  A
+% rule can still express the practical executable shape of an existential
+% consequence by putting a named functional term directly in the head.
 
-% Source data says which people are humans and which witness term belongs to
-% each human.  The single rule below is the existential-style introduction step.
+materialize(is, 2).
 
 type(socrates, human).
 type(plato, human).
 
-witness(socrates, sk_0).
-witness(plato, sk_1).
-
-% In proof output this rule is the step that explains why each witness exists.
-is(?person, ?witness) :-
-  type(?person, human),
-  witness(?person, ?witness).
+% In proof output this rule is the step that explains each visible witness.
+is(?person, human_witness(?person)) :-
+  type(?person, human).

package/examples/herbrand-witnesses.eye

@@ -0,0 +1,31 @@
+% Existential-style consequences as explicit Herbrand witness terms.
+%
+% Eyelang has no blank nodes and no existential variables in rule heads.  The
+% practical executable form is to put a named functional term directly in the
+% rule head.  The term is ordinary data: stable, visible, and proof-friendly.
+
+materialize(has_parent, 2).
+materialize(registration, 3).
+materialize(same_witness, 2).
+materialize(distinct_witnesses, 2).
+
+person(alice).
+person(bob).
+
+takes(alice, logic).
+takes(alice, math).
+takes(bob, logic).
+
+% One variable: every person has a deterministic parent witness.
+has_parent(?child, parent_of(?child)) :-
+  person(?child).
+
+% Two variables: every student/course pair has its own registration witness.
+registration(?student, ?course, registration_of(?student, ?course)) :-
+  takes(?student, ?course).
+
+same_witness(parent_of_alice, true) :-
+  eq(parent_of(alice), parent_of(alice)).
+
+distinct_witnesses(alice_logic_vs_alice_math, true) :-
+  neq(registration_of(alice, logic), registration_of(alice, math)).

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/existential-rule.eye

@@ -1,2 +1,2 @@
-is(socrates, sk_0).
-is(plato, sk_1).
+is(socrates, human_witness(socrates)).
+is(plato, human_witness(plato)).

package/examples/output/herbrand-witnesses.eye

@@ -0,0 +1,7 @@
+has_parent(alice, parent_of(alice)).
+has_parent(bob, parent_of(bob)).
+registration(alice, logic, registration_of(alice, logic)).
+registration(alice, math, registration_of(alice, math)).
+registration(bob, logic, registration_of(bob, logic)).
+same_witness(parent_of_alice, true).
+distinct_witnesses(alice_logic_vs_alice_math, true).

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/proof/existential-rule.eye

@@ -1,38 +1,30 @@
-is(socrates, sk_0).
+is(socrates, human_witness(socrates)).
 why(
-  is(socrates, sk_0),
+  is(socrates, human_witness(socrates)),
   proof(
-    goal(is(socrates, sk_0)),
-    by(rule("existential-rule.eye", clause(6))),
-    bindings([binding("?person", socrates), binding("?witness", sk_0)]),
+    goal(is(socrates, human_witness(socrates))),
+    by(rule("existential-rule.eye", clause(4))),
+    bindings([binding("?person", socrates)]),
     uses([
       proof(
         goal(type(socrates, human)),
         by(fact("existential-rule.eye", clause(2)))
-      ),
-      proof(
-        goal(witness(socrates, sk_0)),
-        by(fact("existential-rule.eye", clause(4)))
       )
     ])
   )
 ).
 
-is(plato, sk_1).
+is(plato, human_witness(plato)).
 why(
-  is(plato, sk_1),
+  is(plato, human_witness(plato)),
   proof(
-    goal(is(plato, sk_1)),
-    by(rule("existential-rule.eye", clause(6))),
-    bindings([binding("?person", plato), binding("?witness", sk_1)]),
+    goal(is(plato, human_witness(plato))),
+    by(rule("existential-rule.eye", clause(4))),
+    bindings([binding("?person", plato)]),
     uses([
       proof(
         goal(type(plato, human)),
         by(fact("existential-rule.eye", clause(3)))
-      ),
-      proof(
-        goal(witness(plato, sk_1)),
-        by(fact("existential-rule.eye", clause(5)))
       )
     ])
   )

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.8",
+  "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,18 +557,22 @@
           "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",
           "socket-age",
@@ -576,6 +583,7 @@
           "stirling-bell-numbers",
           "sudoku-4x4",
           "superdense-coding",
+          "symbolic-derivative",
           "term-tools",
           "totient-summatory",
           "trust-flow-provenance-threshold",
@@ -586,6 +594,7 @@
           "weighted-interval-scheduling",
           "witch",
           "wolf-goat-cabbage",
+          "workplace-compliance",
           "zebra"
     ];
     const FALLBACK_SOURCE = `materialize(answer, 1).

package/src/builtins/terms.js

@@ -61,6 +61,7 @@ function* compoundNameArguments({ goal, env }) {
   if (unify(goal.args[0], built, next)) yield next;
 }
 
+
 function scalarNameTerm(term) {
   if (term.type === 'atom') return atom(term.name);
   if (term.type === 'number') return numberTerm(term.name);

package/test/conformance/cases/terms/herbrand_witness_different_inputs_distinct.eye

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(true) :- neq(registration_of(alice, logic), registration_of(alice, math)).

package/test/conformance/cases/terms/herbrand_witness_one_input.eye

@@ -0,0 +1,5 @@
+% Existential-style consequence with one universal variable represented as a Herbrand term.
+materialize(answer, 2).
+person(alice).
+person(bob).
+answer(?child, parent_of(?child)) :- person(?child).

package/test/conformance/cases/terms/herbrand_witness_same_inputs_same_term.eye

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(true) :- eq(parent_of(alice), parent_of(alice)).

package/test/conformance/cases/terms/herbrand_witness_two_inputs.eye

@@ -0,0 +1,5 @@
+% Existential-style consequence with two universal variables represented as a Herbrand term.
+materialize(answer, 3).
+takes(alice, logic).
+takes(alice, math).
+answer(?student, ?course, registration_of(?student, ?course)) :- takes(?student, ?course).

package/test/conformance/expected/terms/herbrand_witness_different_inputs_distinct.eye

@@ -0,0 +1 @@
+answer(true).

package/test/conformance/expected/terms/herbrand_witness_one_input.eye

@@ -0,0 +1,2 @@
+answer(alice, parent_of(alice)).
+answer(bob, parent_of(bob)).

package/test/conformance/expected/terms/herbrand_witness_same_inputs_same_term.eye

@@ -0,0 +1 @@
+answer(true).

package/test/conformance/expected/terms/herbrand_witness_two_inputs.eye

@@ -0,0 +1,2 @@
+answer(alice, logic, registration_of(alice, logic)).
+answer(alice, math, registration_of(alice, math)).

package/test/conformance/expected-proofs/proofs/herbrand_witness.eye

@@ -0,0 +1,16 @@
+has_parent(alice, parent_of(alice)).
+why(
+  has_parent(alice, parent_of(alice)),
+  proof(
+    goal(has_parent(alice, parent_of(alice))),
+    by(rule("<stdin>", clause(2))),
+    bindings([binding("?child", alice)]),
+    uses([
+      proof(
+        goal(person(alice)),
+        by(fact("<stdin>", clause(1)))
+      )
+    ])
+  )
+).
+

package/test/conformance/proofs/proofs/herbrand_witness.eye

@@ -0,0 +1,3 @@
+person(alice).
+has_parent(?child, parent_of(?child)) :- person(?child).
+materialize(has_parent, 2).