eyelang 1.7.9 → 1.7.11

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/docs/language-reference.md

@@ -123,7 +123,7 @@ A colon outside `:-` is not part of the language. Namespace-like names SHOULD be
 
 ### 3.4 Variables
 
-A variable starts with `?` followed by an ASCII letter or underscore and then zero or more ASCII letters, digits, or underscores. This N3/SPARQL-style spelling is the only source-level variable spelling in eyelang.
+A variable is either the bare anonymous variable `?`, or starts with `?` followed by an ASCII letter or underscore and then zero or more ASCII letters, digits, or underscores. This N3/SPARQL-style spelling is the only source-level variable spelling in eyelang.
 
 Examples:
 
@@ -131,10 +131,10 @@ Examples:
 ?x
 ?person
 ?_thing
-?_
+?
 ```
 
-Each `?_` anonymous variable occurrence is fresh. A bare `_` is not a variable in eyelang source.
+Each bare `?` anonymous variable occurrence is fresh. A bare `_` is not a variable in eyelang source.
 
 ### 3.5 Atom constants
 
@@ -171,7 +171,7 @@ A quoted atom constant is enclosed in single quotes. A single quote inside a quo
 A graphic atom constant is one or more graphic characters from this set:
 
 ```text
-#$&*+-/<=>?@^~\
+#$&*+-/<=>@^~\
 ```
 
 Angle-bracket IRI syntax is recognized only for absolute IRI-like contents. Graphic atoms such as `<=>`, `<`, and `>=` remain graphic atoms.

package/examples/animal.eye

@@ -18,4 +18,4 @@ animal(?x) :- human(?x).
 type(joe, human) :- human(joe).
 type(joe, animal) :- animal(joe).
 subclassOf(human, animal) :- animal(human).
-succeeds(animalExample, true) :- animal(?_).
+succeeds(animalExample, true) :- animal(?).

package/examples/dairy-energy-balance.eye

@@ -17,15 +17,15 @@ cow(grazing, 540, 18, 5.8, 21).
 
 % Maintenance scales with body weight; milk requirement scales with daily milk.
 maintenance(?c, ?m) :-
-  cow(?c, ?weight, ?_, ?_, ?_),
+  cow(?c, ?weight, ?, ?, ?),
   mul(?weight, 0.08, ?m).
 
 milk_requirement(?c, ?r) :-
-  cow(?c, ?_, ?milk, ?_, ?_),
+  cow(?c, ?, ?milk, ?, ?),
   mul(?milk, 5.0, ?r).
 
 ration_supply(?c, ?s) :-
-  cow(?c, ?_, ?_, ?density, ?intake),
+  cow(?c, ?, ?, ?density, ?intake),
   mul(?density, ?intake, ?s).
 
 total_requirement(?c, ?r) :-

package/examples/dijkstra-risk-path.eye

@@ -41,7 +41,7 @@ candidate(pathRelay, [depotA, relay, labD]).
 candidate(pathDirectC, [depotA, labD]).
 candidate(pathViaC, [depotA, depotC, depotB, labD]).
 
-route_cost([?_], 0.0, 0.0, 0).
+route_cost([?], 0.0, 0.0, 0).
 route_cost([?from, ?to|?rest], ?raw, ?risk, ?edges) :-
   route_segment(?from, ?to, ?stepraw, ?steprisk),
   route_cost([?to|?rest], ?restraw, ?restrisk, ?restedges),

package/examples/ev-range-worlds.eye

@@ -24,18 +24,18 @@ trip_data(cold_commute, 120, 90, -8, 100, 35, 0.19).
 
 % Each world adds a different combination of speed, temperature, payload, and
 % reserve factors before comparing required energy with usable battery.
-speed_factor(?t, 1.20) :- trip_data(?t, ?_, ?s, ?_, ?_, ?_, ?_), gt(?s, 100).
-speed_factor(?t, 1.00) :- trip_data(?t, ?_, ?s, ?_, ?_, ?_, ?_), le(?s, 100).
+speed_factor(?t, 1.20) :- trip_data(?t, ?, ?s, ?, ?, ?, ?), gt(?s, 100).
+speed_factor(?t, 1.00) :- trip_data(?t, ?, ?s, ?, ?, ?, ?), le(?s, 100).
 
-temperature_factor(?t, 1.15) :- trip_data(?t, ?_, ?_, ?temp, ?_, ?_, ?_), lt(?temp, 0).
-temperature_factor(?t, 1.00) :- trip_data(?t, ?_, ?_, ?temp, ?_, ?_, ?_), ge(?temp, 0).
+temperature_factor(?t, 1.15) :- trip_data(?t, ?, ?, ?temp, ?, ?, ?), lt(?temp, 0).
+temperature_factor(?t, 1.00) :- trip_data(?t, ?, ?, ?temp, ?, ?, ?), ge(?temp, 0).
 
-payload_factor(?t, 1.15) :- trip_data(?t, ?_, ?_, ?_, ?p, ?_, ?_), gt(?p, 500).
-payload_factor(?t, 1.08) :- trip_data(?t, ?_, ?_, ?_, ?p, ?_, ?_), gt(?p, 250), le(?p, 500).
-payload_factor(?t, 1.00) :- trip_data(?t, ?_, ?_, ?_, ?p, ?_, ?_), le(?p, 250).
+payload_factor(?t, 1.15) :- trip_data(?t, ?, ?, ?, ?p, ?, ?), gt(?p, 500).
+payload_factor(?t, 1.08) :- trip_data(?t, ?, ?, ?, ?p, ?, ?), gt(?p, 250), le(?p, 500).
+payload_factor(?t, 1.00) :- trip_data(?t, ?, ?, ?, ?p, ?, ?), le(?p, 250).
 
 base_energy(?t, ?e) :-
-  trip_data(?t, ?d, ?_, ?_, ?_, ?_, ?b),
+  trip_data(?t, ?d, ?, ?, ?, ?, ?b),
   mul(?d, ?b, ?e).
 
 required_energy(?t, w1, ?e) :-
@@ -61,12 +61,12 @@ required_energy(?t, w3, ?e) :-
 
 % safe_in_world/2 compares required trip energy with usable battery capacity.
 safe_in_world(?t, ?w) :-
-  trip_data(?t, ?_, ?_, ?_, ?_, ?battery, ?_),
+  trip_data(?t, ?, ?, ?, ?, ?battery, ?),
   required_energy(?t, ?w, ?required),
   le(?required, ?battery).
 
 risky_in_world(?t, ?w) :-
-  trip_data(?t, ?_, ?_, ?_, ?_, ?battery, ?_),
+  trip_data(?t, ?, ?, ?, ?, ?battery, ?),
   required_energy(?t, ?w, ?required),
   gt(?required, ?battery).
 

package/examples/fft8-numeric.eye

@@ -82,4 +82,4 @@ fft(?wave, ?spectrum) :-
 
 dcComponent(?wave, ?dc) :-
   wave(?wave, ?samples),
-  fft8(?samples, [?dc|?_]).
+  fft8(?samples, [?dc|?]).

package/examples/field-nitrogen-balance.eye

@@ -21,41 +21,41 @@ field(clay_surplus, 70, 90, 0.08, 120).
 % total_n/2 and available_n/2 build the nutrient budget; surplus/deficit and
 % leaching rules then explain the resulting field status.
 total_n(?f, ?total) :-
-  field(?f, ?soil, ?fert, ?_, ?_),
+  field(?f, ?soil, ?fert, ?, ?),
   add(?soil, ?fert, ?total).
 
 available_n(?f, ?avail) :-
   total_n(?f, ?total),
-  field(?f, ?_, ?_, ?loss, ?_),
+  field(?f, ?, ?, ?loss, ?),
   sub(1.0, ?loss, ?retained),
   mul(?total, ?retained, ?avail).
 
 % surplus_n/2 and deficit_n/2 split the signed balance into reportable quantities.
 surplus_n(?f, ?surplus) :-
   available_n(?f, ?avail),
-  field(?f, ?_, ?_, ?_, ?demand),
+  field(?f, ?, ?, ?, ?demand),
   gt(?avail, ?demand),
   sub(?avail, ?demand, ?surplus).
 
 surplus_n(?f, 0.0) :-
   available_n(?f, ?avail),
-  field(?f, ?_, ?_, ?_, ?demand),
+  field(?f, ?, ?, ?, ?demand),
   le(?avail, ?demand).
 
 deficit_n(?f, ?deficit) :-
   available_n(?f, ?avail),
-  field(?f, ?_, ?_, ?_, ?demand),
+  field(?f, ?, ?, ?, ?demand),
   lt(?avail, ?demand),
   sub(?demand, ?avail, ?deficit).
 
 deficit_n(?f, 0.0) :-
   available_n(?f, ?avail),
-  field(?f, ?_, ?_, ?_, ?demand),
+  field(?f, ?, ?, ?, ?demand),
   ge(?avail, ?demand).
 
 leaching_index(?f, ?index) :-
   surplus_n(?f, ?surplus),
-  field(?f, ?_, ?_, ?loss, ?_),
+  field(?f, ?, ?, ?loss, ?),
   mul(?surplus, ?loss, ?index).
 
 status(?f, under_supplied) :- deficit_n(?f, ?d), gt(?d, 10.0).

package/examples/fundamental-theorem-arithmetic.eye

@@ -112,8 +112,8 @@ distinctPrimeCount(case, 4) :-
 
 smallestPrimeFactor(case, 3) :-
   case(fta, ?n),
-  factor_smallest(?n, [3|?_]).
+  factor_smallest(?n, [3|?]).
 
 largestPrimeFactor(case, 3881) :-
   case(fta, ?n),
-  factor_largest(?n, [3881|?_]).
+  factor_largest(?n, [3881|?]).

package/examples/gps.eye

@@ -78,24 +78,24 @@ outcome(routeDirect, "Take the direct route via Brugge.").
 
 % Verification checks, analogous to the false-producing guards in gps.n3.
 check(c1, true) :-
-  traveller_path(i1, [drive_gent_brugge, drive_brugge_oostende], ?_, ?_, ?_, ?_).
+  traveller_path(i1, [drive_gent_brugge, drive_brugge_oostende], ?, ?, ?, ?).
 
 check(c2, true) :-
-  traveller_path(i1, [drive_gent_kortrijk, drive_kortrijk_brugge, drive_brugge_oostende], ?_, ?_, ?_, ?_).
+  traveller_path(i1, [drive_gent_kortrijk, drive_kortrijk_brugge, drive_brugge_oostende], ?, ?, ?, ?).
 
 check(c3, true) :-
-  route_metrics(routeDirect, ?d1, ?_, ?_, ?_),
-  route_metrics(routeViaKortrijk, ?d2, ?_, ?_, ?_),
+  route_metrics(routeDirect, ?d1, ?, ?, ?),
+  route_metrics(routeViaKortrijk, ?d2, ?, ?, ?),
   lt(?d1, ?d2).
 
 check(c4, true) :-
-  route_metrics(routeDirect, ?_, ?c1, ?_, ?_),
-  route_metrics(routeViaKortrijk, ?_, ?c2, ?_, ?_),
+  route_metrics(routeDirect, ?, ?c1, ?, ?),
+  route_metrics(routeViaKortrijk, ?, ?c2, ?, ?),
   lt(?c1, ?c2).
 
 check(c5, true) :-
-  route_metrics(routeDirect, ?_, ?_, ?b1, ?f1),
-  route_metrics(routeViaKortrijk, ?_, ?_, ?b2, ?f2),
+  route_metrics(routeDirect, ?, ?, ?b1, ?f1),
+  route_metrics(routeViaKortrijk, ?, ?, ?b2, ?f2),
   gt(?b1, ?b2),
   gt(?f1, ?f2).
 

package/examples/illegitimate-reasoning.eye

@@ -67,22 +67,22 @@ fallacy(?a, hasty_generalization) :-
   sample_size(?a, ?n),
   required_sample_size(?a, ?min),
   lt(?n, ?min),
-  concludes(?a, all(?_, ?_)).
+  concludes(?a, all(?, ?)).
 
 fallacy(?a, false_dilemma) :-
   argument(?a),
-  presented_alternatives(?a, ?_),
-  omitted_alternative(?a, ?_),
-  concludes(?a, ?_).
+  presented_alternatives(?a, ?),
+  omitted_alternative(?a, ?),
+  concludes(?a, ?).
 
 reason(arg_affirming_consequent, "observing the consequent does not prove the antecedent").
 reason(arg_denying_antecedent, "denying the antecedent does not disprove the consequent").
 reason(arg_hasty_generalization, "sample size is below the threshold for a universal conclusion").
 reason(arg_false_dilemma, "a relevant alternative is omitted").
 
-type(?a, illegitimate_reasoning) :- fallacy(?a, ?_).
-conclusion(?a, ?c) :- fallacy(?a, ?_), concludes(?a, ?c).
-reason(?a, ?r) :- fallacy(?a, ?_), reason(?a, ?r).
+type(?a, illegitimate_reasoning) :- fallacy(?a, ?).
+conclusion(?a, ?c) :- fallacy(?a, ?), concludes(?a, ?c).
+reason(?a, ?r) :- fallacy(?a, ?), reason(?a, ?r).
 sampleSize(?a, ?n) :- fallacy(?a, hasty_generalization), sample_size(?a, ?n).
 requiredSampleSize(?a, ?min) :- fallacy(?a, hasty_generalization), required_sample_size(?a, ?min).
 omittedAlternative(?a, ?alt) :- fallacy(?a, false_dilemma), omitted_alternative(?a, ?alt).

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/monkey-bananas.eye

@@ -19,9 +19,9 @@ plan(?moves) :-
   goal_state(?g),
   reachable(?i, ?moves, ?g).
 
-candidate_plan([?_, ?_, ?_]).
-candidate_plan([?_, ?_, ?_, ?_]).
-candidate_plan([?_, ?_, ?_, ?_, ?_]).
+candidate_plan([?, ?, ?]).
+candidate_plan([?, ?, ?, ?]).
+candidate_plan([?, ?, ?, ?, ?]).
 
 reachable(?s, [], ?s).
 reachable(?s1, [?m|?l], ?s3) :-
@@ -29,7 +29,7 @@ reachable(?s1, [?m|?l], ?s3) :-
   reachable(?s2, ?l, ?s3).
 
 initial_state([loc1, loc2, loc3, n, n]).
-goal_state([?_, ?_, ?_, ?_, y]).
+goal_state([?, ?, ?, ?, y]).
 
 legal_move([?b, ?m, ?m, n, ?h], climb_on, [?b, ?m, ?m, y, ?h]).
 legal_move([?b, ?m, ?m, y, ?h], climb_off, [?b, ?m, ?m, n, ?h]).

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/wolf-goat-cabbage.eye

@@ -46,8 +46,8 @@ safe([?man, ?wolf, ?goat, ?cabbage]) :-
   one_eq(?man, ?goat, ?wolf),
   one_eq(?man, ?goat, ?cabbage).
 
-one_eq(?x, ?x, ?_).
-one_eq(?x, ?_, ?x).
+one_eq(?x, ?x, ?).
+one_eq(?x, ?, ?x).
 
 solution(puzzle, ?moves) :-
   solution(?moves).

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/examples/zebra.eye

@@ -12,33 +12,33 @@ materialize(solved, 2).
 
 % The single zebra/2 rule is a finite constraint model over the five house slots.
 zebra(?waterdrinker, ?zebraowner) :-
-  eq(?houses, [?_, ?_, ?_, ?_, ?_]),
-  first(?houses, house(?_, norwegian, ?_, ?_, ?_)),
-  third(?houses, house(?_, ?_, ?_, milk, ?_)),
-  adjacent(house(?_, norwegian, ?_, ?_, ?_), house(blue, ?_, ?_, ?_, ?_), ?houses),
-  next_to(house(ivory, ?_, ?_, ?_, ?_), house(green, ?_, ?_, ?_, ?_), ?houses),
-  member(house(red, english, ?_, ?_, ?_), ?houses),
-  member(house(green, ?_, ?_, coffee, ?_), ?houses),
-  member(house(yellow, ?_, ?_, ?_, kools), ?houses),
-  member(house(?_, spanish, dog, ?_, ?_), ?houses),
-  member(house(?_, ukrainian, ?_, tea, ?_), ?houses),
-  member(house(?_, ?_, snail, ?_, old_gold), ?houses),
-  adjacent(house(?_, ?_, ?_, ?_, chesterfields), house(?_, ?_, fox, ?_, ?_), ?houses),
-  adjacent(house(?_, ?_, ?_, ?_, kools), house(?_, ?_, horse, ?_, ?_), ?houses),
-  member(house(?_, ?_, ?_, orange_juice, lucky_strike), ?houses),
-  member(house(?_, japanese, ?_, ?_, parliaments), ?houses),
-  member(house(?_, ?waterdrinker, ?_, water, ?_), ?houses),
-  member(house(?_, ?zebraowner, zebra, ?_, ?_), ?houses).
+  eq(?houses, [?, ?, ?, ?, ?]),
+  first(?houses, house(?, norwegian, ?, ?, ?)),
+  third(?houses, house(?, ?, ?, milk, ?)),
+  adjacent(house(?, norwegian, ?, ?, ?), house(blue, ?, ?, ?, ?), ?houses),
+  next_to(house(ivory, ?, ?, ?, ?), house(green, ?, ?, ?, ?), ?houses),
+  member(house(red, english, ?, ?, ?), ?houses),
+  member(house(green, ?, ?, coffee, ?), ?houses),
+  member(house(yellow, ?, ?, ?, kools), ?houses),
+  member(house(?, spanish, dog, ?, ?), ?houses),
+  member(house(?, ukrainian, ?, tea, ?), ?houses),
+  member(house(?, ?, snail, ?, old_gold), ?houses),
+  adjacent(house(?, ?, ?, ?, chesterfields), house(?, ?, fox, ?, ?), ?houses),
+  adjacent(house(?, ?, ?, ?, kools), house(?, ?, horse, ?, ?), ?houses),
+  member(house(?, ?, ?, orange_juice, lucky_strike), ?houses),
+  member(house(?, japanese, ?, ?, parliaments), ?houses),
+  member(house(?, ?waterdrinker, ?, water, ?), ?houses),
+  member(house(?, ?zebraowner, zebra, ?, ?), ?houses).
 
 % Positional and neighborhood helpers keep the clue encoding readable.
-first([?x|?_], ?x).
-third([?_, ?_, ?x|?_], ?x).
+first([?x|?], ?x).
+third([?, ?, ?x|?], ?x).
 
 adjacent(?a, ?b, ?list) :- next_to(?a, ?b, ?list).
 adjacent(?a, ?b, ?list) :- next_to(?b, ?a, ?list).
 
-next_to(?x, ?y, [?x, ?y|?_]).
-next_to(?x, ?y, [?_|?zs]) :- next_to(?x, ?y, ?zs).
+next_to(?x, ?y, [?x, ?y|?]).
+next_to(?x, ?y, [?|?zs]) :- next_to(?x, ?y, ?zs).
 
 waterDrinker(zebraPuzzle, ?waterdrinker) :- zebra(?waterdrinker, ?_zebraowner).
 zebraOwner(zebraPuzzle, ?zebraowner) :- zebra(?_waterdrinker, ?zebraowner).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.7.9",
+  "version": "1.7.11",
   "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).
@@ -861,9 +869,12 @@ answer(ok) :- eq(ok, ok).
           while (j < text.length && /[\d.]/.test(text[j])) j++;
           out += span('number', text.slice(i, j));
           i = j;
-        } else if (ch === '?' && /[A-Za-z_]/.test(text[i + 1] || '')) {
-          let j = i + 2;
-          while (j < text.length && /[A-Za-z0-9_]/.test(text[j])) j++;
+        } else if (ch === '?') {
+          let j = i + 1;
+          if (/[A-Za-z_]/.test(text[j] || '')) {
+            j++;
+            while (j < text.length && /[A-Za-z0-9_]/.test(text[j])) j++;
+          }
           out += span('variable', text.slice(i, j));
           i = j;
         } else if (/[a-z]/.test(ch)) {

package/src/parser.js

@@ -43,14 +43,14 @@ function isNameContinueCode(code) {
 function isQuestionVariableStart(source, pos) {
   if (source[pos] !== '?') return false;
   const code = (source[pos + 1] ?? '').charCodeAt(0);
-  return code === 95 || isAsciiLetterCode(code);
+  return !source[pos + 1] || code === 95 || isAsciiLetterCode(code) || !isNameContinueCode(code);
 }
 
 function isPlainAtomStartCode(code) {
   return code >= 97 && code <= 122;
 }
 
-const graphicAtomChars = '#$&*+-/<=>?@^~\\';
+const graphicAtomChars = '#$&*+-/<=>@^~\\';
 
 function isGraphicAtomCode(code) {
   return graphicAtomChars.includes(String.fromCharCode(code));
@@ -172,10 +172,9 @@ class Parser {
     if (isQuestionVariableStart(this.source, this.pos)) {
       const start = this.pos;
       this.take(); // ?
-      this.take();
+      if (isNameContinueCode(this.peek().charCodeAt(0))) this.take();
       while (isNameContinueCode(this.peek().charCodeAt(0))) this.take();
-      let text = this.source.slice(start, this.pos);
-      if (text === '?_') text = `__anon${this.anonymous++}`;
+      const text = this.source.slice(start, this.pos);
       return { type: TOK.VAR, text, line };
     }
 
@@ -259,6 +258,7 @@ class Parser {
     if (this.token.type === TOK.VAR) {
       const name = this.token.text;
       this.advance();
+      if (name === '?') return variable(`__anon${this.anonymous++}`);
       return variable(name);
     }
     if (this.token.type === TOK.STRING) {
@@ -346,9 +346,9 @@ function isSimpleName(text) {
 const SIMPLE_NUMBER = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
 const FAST_BINARY_FACT = /^([a-z][A-Za-z0-9_]*)\(\s*([^,\s()[\]|"']+)\s*,\s*([^,\s()[\]|"']+)\s*\)\.$/;
 const FAST_BINARY_RULE = /^([a-z][A-Za-z0-9_]*)\(\s*([^,\s()[\]|"']+)\s*,\s*([^,\s()[\]|"']+)\s*\)\s*:-\s*([a-z][A-Za-z0-9_]*)\(\s*([^,\s()[\]|"']+)\s*,\s*([^,\s()[\]|"']+)\s*\)\.$/;
-const SIMPLE_VARIABLE = /^\?[A-Za-z_][A-Za-z0-9_]*$/;
+const SIMPLE_VARIABLE = /^\?(?:[A-Za-z_][A-Za-z0-9_]*)?$/;
 const SIMPLE_ATOM = /^[a-z][A-Za-z0-9_]*$/;
-const GRAPHIC_ATOM = /^[#$&*+\-\/<=>?@^~\\]+$/;
+const GRAPHIC_ATOM = /^[#$&*+\-\/<=>@^~\\]+$/;
 
 function parseClausesFastNoSource(source) {
   source = String(source ?? '');
@@ -370,7 +370,7 @@ function parseClausesFastNoSource(source) {
   const scalarOrVariableFast = (text) => {
     if (!text || !isFastScalarToken(text)) throw new Error('bad simple term');
     const first = text.charCodeAt(0);
-    if (text === '?_') return variable(`__anon${anonymous++}`);
+    if (text === '?') return variable(`__anon${anonymous++}`);
     if (SIMPLE_VARIABLE.test(text)) {
       const existing = variableCache.get(text);
       if (existing) return existing;

package/src/term.js

@@ -136,7 +136,7 @@ export function termIsGround(term, env = new Env()) {
   return resolved.args.every((arg) => termIsGround(arg, env));
 }
 
-const graphicAtomChars = new Set('#$&*+-/<=>?@^~\\'.split(''));
+const graphicAtomChars = new Set('#$&*+-/<=>@^~\\'.split(''));
 
 function isAbsoluteIriText(text) {
   return /^[A-Za-z][A-Za-z0-9+.-]*:[^\s<>"'{}|\\^`]*$/.test(text);

package/test/conformance/cases/arithmetic/extra_division_by_zero_fails.eye

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(division_by_zero_fails) :- div(1, 0, ?_).
+answer(division_by_zero_fails) :- div(1, 0, ?).

package/test/conformance/cases/atoms/103_angle_iri_atoms.eye

@@ -3,5 +3,5 @@ materialize(iri_subject, 1).
 materialize(iri_object, 1).
 triple(<https://example.org/alice>, <https://schema.org/name>, "Alice").
 triple(<urn:example:bob>, <https://schema.org/knows>, <https://example.org/alice>).
-iri_subject(?iri) :- triple(?iri, ?_, ?_).
-iri_object(?iri) :- triple(?_, <https://schema.org/knows>, ?iri).
+iri_subject(?iri) :- triple(?iri, ?, ?).
+iri_object(?iri) :- triple(?, <https://schema.org/knows>, ?iri).

package/test/conformance/cases/builtins/extra_difference_end_before_start_fails.eye

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(difference_end_before_start_fails) :- difference("2024-01-01", "2024-01-02", ?_).
+answer(difference_end_before_start_fails) :- difference("2024-01-01", "2024-01-02", ?).

package/test/conformance/cases/builtins/extra_difference_invalid_date_fails.eye

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(difference_invalid_date_fails) :- difference("2024-02-30", "2024-02-01", ?_).
+answer(difference_invalid_date_fails) :- difference("2024-02-30", "2024-02-01", ?).

package/test/conformance/cases/context/extra_holds_ignores_string_parts.eye

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(holds_ignores_string_parts) :- holds("not a term", ?_, ?_).
+answer(holds_ignores_string_parts) :- holds("not a term", ?, ?).

package/test/conformance/cases/lists/020_nested_list_terms.eye

@@ -1,5 +1,5 @@
 % Reference 5.3, 5.4: lists may contain structured terms that unify positionally.
 node([pair(a, b), pair(c, d)]).
-answer(first_key, ?x) :- node([pair(?x, ?_), pair(c, d)]).
+answer(first_key, ?x) :- node([pair(?x, ?), pair(c, d)]).
 answer(second_key, ?x) :- node([pair(a, b), pair(?x, d)]).
 materialize(answer, 2).

package/test/conformance/cases/lists/extra_length_improper_fails.eye

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(length_improper_fails) :- length([a | b], ?_).
+answer(length_improper_fails) :- length([a | b], ?).

package/test/conformance/cases/rules/022_rule_head_structure.eye

@@ -1,5 +1,5 @@
 % Reference 5.3, 6, 7.1: structured rule heads destructure matching goals.
 unpack(pair(?x, ?y), ?x, ?y).
-answer(first, ?a) :- unpack(pair(alpha, beta), ?a, ?_).
-answer(second, ?b) :- unpack(pair(alpha, beta), ?_, ?b).
+answer(first, ?a) :- unpack(pair(alpha, beta), ?a, ?).
+answer(second, ?b) :- unpack(pair(alpha, beta), ?, ?b).
 materialize(answer, 2).

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

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(arg_atom_fails) :- arg(1, atom, ?_).
+answer(arg_atom_fails) :- arg(1, atom, ?).

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

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(arg_zero_fails) :- arg(0, pair(a, b), ?_).
+answer(arg_zero_fails) :- arg(0, pair(a, b), ?).

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

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(compound_name_arguments_bad_args_fails) :- compound_name_arguments(?_, pair, not_a_list).
+answer(compound_name_arguments_bad_args_fails) :- compound_name_arguments(?, pair, not_a_list).

package/test/conformance/cases/variables/007_anonymous_variables.eye

@@ -1,5 +1,5 @@
 % Reference 3.4, 5.1, 7.1: each anonymous variable occurrence is fresh.
 pair(a, one).
 pair(b, two).
-answer(fresh, yes) :- pair(a, ?_), pair(b, ?_).
+answer(fresh, yes) :- pair(a, ?), pair(b, ?).
 materialize(answer, 2).

package/test/conformance/cases/variables/026_question_underscore_named_variable_reuse.eye

@@ -1,4 +1,4 @@
-% Reference 3.4, 5.1: `?_name` variables are named variables; only exactly `?_` is anonymous.
+% Reference 3.4, 5.1: `?_name` variables are named variables; only exactly `?` is anonymous.
 pair(a, a).
 pair(a, b).
 answer(shared, ?_value) :- pair(?_value, ?_value).

package/test/conformance/cases/variables/anonymous_in_two_goals.eye

@@ -1,4 +1,4 @@
-% Each ?_ occurrence is fresh, so these two goals do not have to agree.
+% Each ? occurrence is fresh, so these two goals do not have to agree.
 materialize(answer, 1).
 pair(a, b).
-answer(ok) :- pair(?_, ?_).
+answer(ok) :- pair(?, ?).

package/test/conformance/cases/variables/extra_anonymous_not_reused.eye

@@ -1,2 +1,2 @@
 materialize(answer, 1).
-answer(anonymous_not_reused) :- eq(pair(?_, ?_), pair(a, b)).
+answer(anonymous_not_reused) :- eq(pair(?, ?), pair(a, b)).

package/test/conformance/cases/variables/question_anonymous_not_reused.eye

@@ -1,6 +1,6 @@
-% Each `?_` occurrence is anonymous and independent.
+% Each `?` occurrence is anonymous and independent.
 materialize(answer, 1).
 pair(a, b).
 pair(c, d).
-answer(left(?x)) :- pair(?x, ?_).
-answer(right(?y)) :- pair(?_, ?y).
+answer(left(?x)) :- pair(?x, ?).
+answer(right(?y)) :- pair(?, ?y).

package/test/conformance/expected-errors/syntax/bad_question_digit_variable.txt

@@ -1 +1 @@
-parse line 1: expected ), got 1
+parse line 1: bad character "?"

package/test/conformance/expected-errors/variables/question_digit_rejected.txt

@@ -1 +1 @@
-parse line 1: expected ), got 1
+parse line 1: bad character "?"

package/test/run-regression.mjs

@@ -639,9 +639,9 @@ function whiteBoxCases() {
       },
     },
     {
-      name: 'parser treats question-mark underscore as anonymous',
+      name: 'parser treats bare question mark as anonymous',
       run: () => {
-        const clauses = parseProgramText('p(?_, ?_).\n');
+        const clauses = parseProgramText('p(?, ?).\n');
         const left = clauses[0].head.args[0].name;
         const right = clauses[0].head.args[1].name;
         assertEqual(left.startsWith('__anon'), true, 'left anonymous');