eyeling 1.34.3 → 1.34.5

package/README.md

@@ -819,20 +819,18 @@ Formula-aware built-ins make Eyeling useful for meta-reasoning. `log:includes`,
 
 ### eyelang built-ins
 
-The eyelang engine has its own built-in registry under `lib/eyelang/builtins/`. These are separate from the N3 namespaces above and are called as ordinary eyelang predicates. See the [eyelang language reference](docs/eyelang-language-reference.md#9-standard-built-in-predicates) for the portable profile. The bundled implementation currently registers 59 name/arity entries across 57 predicate names:
+The eyelang engine has its own built-in registry under `lib/eyelang/builtins/`. These are separate from the N3 namespaces above and are called as ordinary eyelang predicates. See the [eyelang language reference](docs/eyelang-language-reference.md#9-standard-built-in-predicates) for the portable profile. The bundled implementation currently registers 80 name/arity entries across 78 predicate names:
 
 | Family | Count | Built-ins |
 |---|---:|---|
 | Core and host | 4 | `eq/2`, `neq/2`, `local_time/1`, `difference/3` |
-| Arithmetic and comparison | 21 | `neg/2`, `abs/2`, `sin/2`, `cos/2`, `asin/2`, `acos/2`, `rounded/2`, `log/2`, `add/3`, `sub/3`, `mul/3`, `div/3`, `mod/3`, `min/3`, `pow/3`, `lt/2`, `gt/2`, `le/2`, `ge/2`, `between/3`, `smallest_divisor_from/3` |
-| Strings | 5 | `str_concat/3`, `contains/2`, `matches/2`, `matches/3`, `not_matches/2` |
-| Lists | 10 | `append/3`, `nth0/3`, `set_nth0/4`, `rest/2`, `member/2`, `select/3`, `not_member/2`, `reverse/2`, `length/2`, `sort/2` |
+| Arithmetic, comparison, and generators | 29 | `neg/2`, `abs/2`, `sin/2`, `cos/2`, `tan/2`, `asin/2`, `acos/2`, `sqrt/2`, `floor/2`, `ceiling/2`, `trunc/2`, `rounded/2`, `exp/2`, `log/2`, `add/3`, `sub/3`, `mul/3`, `div/3`, `mod/3`, `min/3`, `max/3`, `pow/3`, `atan2/3`, `lt/2`, `gt/2`, `le/2`, `ge/2`, `between/3`, `smallest_divisor_from/3` |
+| Strings and conversions | 15 | `str_concat/3`, `contains/2`, `matches/2`, `matches/3`, `not_matches/2`, `split/3`, `join/3`, `substring/4`, `replace/4`, `lowercase/2`, `uppercase/2`, `trim/2`, `number_string/2`, `atom_string/2`, `term_string/2` |
+| Lists | 19 | `append/3`, `nth0/3`, `set_nth0/4`, `head/2`, `rest/2`, `last/2`, `take/3`, `drop/3`, `slice/4`, `member/2`, `select/3`, `not_member/2`, `reverse/2`, `length/2`, `sum_list/2`, `min_list/2`, `max_list/2`, `list_to_set/2`, `sort/2` |
 | Aggregation | 5 | `findall/3`, `countall/2`, `sumall/3`, `aggregate_min/5`, `aggregate_max/5` |
-| Control | 2 | `not/1`, `once/1` |
-| Context terms | 2 | `holds/2`, `holds/3` |
-| Numeric extension helpers | 4 | `extended_gcd/5`, `collatz_trajectory/2`, `kaprekar_steps/2`, `goldbach_pair/3` |
-| Matrix helpers | 6 | `matrix_sum/2`, `matrix_multiply/2`, `cholesky_decomposition/2`, `determinant/2`, `matrix_inv_triang/2`, `matrix_inversion/2` |
-| **Total** | **59** |  |
+| Control | 3 | `not/1`, `once/1`, `forall/2` |
+| Context and terms | 5 | `holds/2`, `holds/3`, `functor/3`, `arg/3`, `compound_name_arguments/3` |
+| **Total** | **80** |  |
 
 ## Custom built-ins
 

package/docs/eyelang-guide.md

@@ -250,7 +250,7 @@ The playground has matching `--stats` and `--proof` checkboxes, so browser runs
 
 eyelang builtins are registered by name and arity in small modules under [`lib/eyelang/builtins`](../lib/eyelang/builtins). This keeps the runtime portable to Node.js and the browser while giving each builtin family a clear boundary. Builtins are enabled by normal predicate calls.
 
-The builtin families cover unification, arithmetic, comparison, dates, strings, lists, aggregation, context terms, search control, number-theory helpers, and matrix helpers. The previous finite-search helper module has been removed because those predicates were too example-specific to be reusable. Examples that are still practical with ordinary relations and reusable list/arithmetic builtins have been rewritten in that style; only the examples that depended on non-portable shortcuts were dropped. The complete bundled implementation list is kept in the top-level [README built-ins section](../README.md#built-ins-1), and the regression suite checks that table against the actual runtime registry.
+The builtin families cover unification, arithmetic, comparison, dates, strings, lists, aggregation, context terms, term inspection, and search control. Domain-specific number-theory and matrix helper modules were removed from the default registry because those predicates were examples/accelerators rather than a reusable portable surface. New reusable helpers cover common numeric functions, list slicing and summaries, string normalization/conversion, term inspection/construction, and `forall/2`. The complete bundled implementation list is kept in the top-level [README built-ins section](../README.md#built-ins-1), and the regression suite checks that table against the actual runtime registry.
 
 To add a builtin, create or extend a module with `register(registry)` and call `registry.add(name, arity, handler, options)`. The default registry is assembled in [`lib/eyelang/builtins/registry.js`](../lib/eyelang/builtins/registry.js). Builtins that are only safe for specific argument modes should provide a `ready` predicate and `fallbackWhenNotReady: true`, so user-defined clauses remain visible until the builtin is applicable.
 
@@ -321,10 +321,8 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`canary-release.pl`](../examples/eyelang/canary-release.pl) | Decides canary rollout or rollback. | [`output/canary-release.pl`](../examples/eyelang/output/canary-release.pl) |
 | [`cat-koko.pl`](../examples/eyelang/cat-koko.pl) | Demonstrates named existential witnesses from a Cat Koko rule pattern. | [`output/cat-koko.pl`](../examples/eyelang/output/cat-koko.pl) |
 | [`clinical-trial-screening.pl`](../examples/eyelang/clinical-trial-screening.pl) | Screens candidates for a trial. | [`output/clinical-trial-screening.pl`](../examples/eyelang/output/clinical-trial-screening.pl) |
-| [`collatz-1000.pl`](../examples/eyelang/collatz-1000.pl) | Computes shared Collatz trajectories. | [`output/collatz-1000.pl`](../examples/eyelang/output/collatz-1000.pl) |
 | [`combinatorics-findall-sort.pl`](../examples/eyelang/combinatorics-findall-sort.pl) | Collects and sorts finite combinations. | [`output/combinatorics-findall-sort.pl`](../examples/eyelang/output/combinatorics-findall-sort.pl) |
 | [`competitive-enzyme-kinetics.pl`](../examples/eyelang/competitive-enzyme-kinetics.pl) | Computes inhibited enzyme reaction rates. | [`output/competitive-enzyme-kinetics.pl`](../examples/eyelang/output/competitive-enzyme-kinetics.pl) |
-| [`complex-matrix-stability.pl`](../examples/eyelang/complex-matrix-stability.pl) | Checks stability of a 2x2 system. | [`output/complex-matrix-stability.pl`](../examples/eyelang/output/complex-matrix-stability.pl) |
 | [`complex.pl`](../examples/eyelang/complex.pl) | Performs arithmetic on complex pairs. | [`output/complex.pl`](../examples/eyelang/output/complex.pl) |
 | [`composition-of-injective-functions-is-injective.pl`](../examples/eyelang/composition-of-injective-functions-is-injective.pl) | Encodes composition and injectivity of finite functions. | [`output/composition-of-injective-functions-is-injective.pl`](../examples/eyelang/output/composition-of-injective-functions-is-injective.pl) |
 | [`context-association.pl`](../examples/eyelang/context-association.pl) | Associates named contexts with their contents. | [`output/context-association.pl`](../examples/eyelang/output/context-association.pl) |
@@ -344,9 +342,9 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`derived-backward-rule.pl`](../examples/eyelang/derived-backward-rule.pl) | Derives an inverse-property backward rule from rule data. | [`output/derived-backward-rule.pl`](../examples/eyelang/output/derived-backward-rule.pl) |
 | [`derived-rule.pl`](../examples/eyelang/derived-rule.pl) | Derives conclusions from rule data. | [`output/derived-rule.pl`](../examples/eyelang/output/derived-rule.pl) |
 | [`diamond-property.pl`](../examples/eyelang/diamond-property.pl) | Checks the diamond property of a relation. | [`output/diamond-property.pl`](../examples/eyelang/output/diamond-property.pl) |
+| [`dijkstra.pl`](../examples/eyelang/dijkstra.pl) | Enumerates weighted simple paths. | [`output/dijkstra.pl`](../examples/eyelang/output/dijkstra.pl) |
 | [`dijkstra-findall-sort.pl`](../examples/eyelang/dijkstra-findall-sort.pl) | Finds shortest paths using collected candidates. | [`output/dijkstra-findall-sort.pl`](../examples/eyelang/output/dijkstra-findall-sort.pl) |
 | [`dijkstra-risk-path.pl`](../examples/eyelang/dijkstra-risk-path.pl) | Ranks routes by cost and trust. | [`output/dijkstra-risk-path.pl`](../examples/eyelang/output/dijkstra-risk-path.pl) |
-| [`dijkstra.pl`](../examples/eyelang/dijkstra.pl) | Enumerates weighted simple paths. | [`output/dijkstra.pl`](../examples/eyelang/output/dijkstra.pl) |
 | [`dining-philosophers.pl`](../examples/eyelang/dining-philosophers.pl) | Simulates Chandy-Misra fork exchanges. | [`output/dining-philosophers.pl`](../examples/eyelang/output/dining-philosophers.pl) |
 | [`dog.pl`](../examples/eyelang/dog.pl) | Counts dogs and derives when a license is required. | [`output/dog.pl`](../examples/eyelang/output/dog.pl) |
 | [`dpv-odrl-purpose-mapping.pl`](../examples/eyelang/dpv-odrl-purpose-mapping.pl) | Maps a DPV process into an ODRL permission view. | [`output/dpv-odrl-purpose-mapping.pl`](../examples/eyelang/output/dpv-odrl-purpose-mapping.pl) |
@@ -365,14 +363,12 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`fft8-numeric.pl`](../examples/eyelang/fft8-numeric.pl) | Runs an 8-point FFT over complex pairs. | [`output/fft8-numeric.pl`](../examples/eyelang/output/fft8-numeric.pl) |
 | [`fibonacci.pl`](../examples/eyelang/fibonacci.pl) | Computes large Fibonacci numbers by fast doubling. | [`output/fibonacci.pl`](../examples/eyelang/output/fibonacci.pl) |
 | [`field-nitrogen-balance.pl`](../examples/eyelang/field-nitrogen-balance.pl) | Classifies field nitrogen balance. | [`output/field-nitrogen-balance.pl`](../examples/eyelang/output/field-nitrogen-balance.pl) |
-| [`floating-point.pl`](../examples/eyelang/floating-point.pl) | Exercises floating-point arithmetic and comparisons. | [`output/floating-point.pl`](../examples/eyelang/output/floating-point.pl) |
 | [`flandor.pl`](../examples/eyelang/flandor.pl) | Derives a Flanders macro-insight authorization and retooling package. | [`output/flandor.pl`](../examples/eyelang/output/flandor.pl) |
+| [`floating-point.pl`](../examples/eyelang/floating-point.pl) | Exercises floating-point arithmetic and comparisons. | [`output/floating-point.pl`](../examples/eyelang/output/floating-point.pl) |
 | [`four-color-map.pl`](../examples/eyelang/four-color-map.pl) | Checks a four-colour map assignment. | [`output/four-color-map.pl`](../examples/eyelang/output/four-color-map.pl) |
 | [`fundamental-theorem-arithmetic.pl`](../examples/eyelang/fundamental-theorem-arithmetic.pl) | Factors integers and reconstructs products. | [`output/fundamental-theorem-arithmetic.pl`](../examples/eyelang/output/fundamental-theorem-arithmetic.pl) |
-| [`gcd-bezout-identity.pl`](../examples/eyelang/gcd-bezout-identity.pl) | Computes gcd and Bézout coefficients. | [`output/gcd-bezout-identity.pl`](../examples/eyelang/output/gcd-bezout-identity.pl) |
 | [`gd-step-certified.pl`](../examples/eyelang/gd-step-certified.pl) | Certifies a gradient-descent step. | [`output/gd-step-certified.pl`](../examples/eyelang/output/gd-step-certified.pl) |
 | [`gdpr-compliance.pl`](../examples/eyelang/gdpr-compliance.pl) | Checks GDPR-style processing compliance. | [`output/gdpr-compliance.pl`](../examples/eyelang/output/gdpr-compliance.pl) |
-| [`goldbach-1000.pl`](../examples/eyelang/goldbach-1000.pl) | Finds Goldbach prime pairs up to 1000. | [`output/goldbach-1000.pl`](../examples/eyelang/output/goldbach-1000.pl) |
 | [`good-cobbler.pl`](../examples/eyelang/good-cobbler.pl) | Demonstrates term-level structure with a good-cobbler statement. | [`output/good-cobbler.pl`](../examples/eyelang/output/good-cobbler.pl) |
 | [`gps.pl`](../examples/eyelang/gps.pl) | Finds and verifies route paths. | [`output/gps.pl`](../examples/eyelang/output/gps.pl) |
 | [`graph-reachability.pl`](../examples/eyelang/graph-reachability.pl) | Derives reachable nodes in a graph. | [`output/graph-reachability.pl`](../examples/eyelang/output/graph-reachability.pl) |
@@ -386,14 +382,12 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`heron-theorem.pl`](../examples/eyelang/heron-theorem.pl) | Computes triangle area by Heron's theorem. | [`output/heron-theorem.pl`](../examples/eyelang/output/heron-theorem.pl) |
 | [`ideal-gas-law.pl`](../examples/eyelang/ideal-gas-law.pl) | Applies the ideal gas law. | [`output/ideal-gas-law.pl`](../examples/eyelang/output/ideal-gas-law.pl) |
 | [`illegitimate-reasoning.pl`](../examples/eyelang/illegitimate-reasoning.pl) | Detects suspect reasoning patterns. | [`output/illegitimate-reasoning.pl`](../examples/eyelang/output/illegitimate-reasoning.pl) |
-| [`kaprekar.pl`](../examples/eyelang/kaprekar.pl) | Iterates toward Kaprekar's constant. | [`output/kaprekar.pl`](../examples/eyelang/output/kaprekar.pl) |
 | [`knowledge-engineering-alignment-flow.pl`](../examples/eyelang/knowledge-engineering-alignment-flow.pl) | Specializes reusable alignment rules into a target-shaped flow view. | [`output/knowledge-engineering-alignment-flow.pl`](../examples/eyelang/output/knowledge-engineering-alignment-flow.pl) |
 | [`law-of-cosines.pl`](../examples/eyelang/law-of-cosines.pl) | Computes a triangle side by cosine law. | [`output/law-of-cosines.pl`](../examples/eyelang/output/law-of-cosines.pl) |
 | [`least-squares-regression.pl`](../examples/eyelang/least-squares-regression.pl) | Fits a least-squares regression line. | [`output/least-squares-regression.pl`](../examples/eyelang/output/least-squares-regression.pl) |
 | [`list-collection.pl`](../examples/eyelang/list-collection.pl) | Demonstrates list and collection built-ins. | [`output/list-collection.pl`](../examples/eyelang/output/list-collection.pl) |
 | [`lldm.pl`](../examples/eyelang/lldm.pl) | Calculates leg-length discrepancy measurements. | [`output/lldm.pl`](../examples/eyelang/output/lldm.pl) |
 | [`manufacturing-quality-control.pl`](../examples/eyelang/manufacturing-quality-control.pl) | Evaluates process capability and quality. | [`output/manufacturing-quality-control.pl`](../examples/eyelang/output/manufacturing-quality-control.pl) |
-| [`matrix.pl`](../examples/eyelang/matrix.pl) | Runs matrix operations over sample inputs. | [`output/matrix.pl`](../examples/eyelang/output/matrix.pl) |
 | [`microgrid-dispatch.pl`](../examples/eyelang/microgrid-dispatch.pl) | Plans microgrid dispatch and reserve. | [`output/microgrid-dispatch.pl`](../examples/eyelang/output/microgrid-dispatch.pl) |
 | [`monkey-bananas.pl`](../examples/eyelang/monkey-bananas.pl) | Solves the monkey-and-bananas puzzle. | [`output/monkey-bananas.pl`](../examples/eyelang/output/monkey-bananas.pl) |
 | [`network-sla.pl`](../examples/eyelang/network-sla.pl) | Checks network path SLA compliance. | [`output/network-sla.pl`](../examples/eyelang/output/network-sla.pl) |
@@ -412,6 +406,7 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`proof-contrapositive.pl`](../examples/eyelang/proof-contrapositive.pl) | Models proof by contrapositive. | [`output/proof-contrapositive.pl`](../examples/eyelang/output/proof-contrapositive.pl) |
 | [`quadratic-formula.pl`](../examples/eyelang/quadratic-formula.pl) | Solves sample quadratic equations. | [`output/quadratic-formula.pl`](../examples/eyelang/output/quadratic-formula.pl) |
 | [`radioactive-decay.pl`](../examples/eyelang/radioactive-decay.pl) | Computes radioactive decay over time. | [`output/radioactive-decay.pl`](../examples/eyelang/output/radioactive-decay.pl) |
+| [`reusable-builtins.pl`](../examples/eyelang/reusable-builtins.pl) | Tours reusable numeric, list, and string builtins. | [`output/reusable-builtins.pl`](../examples/eyelang/output/reusable-builtins.pl) |
 | [`riemann-hypothesis.pl`](../examples/eyelang/riemann-hypothesis.pl) | Checks a finite catalogue of non-trivial zeta zeros against the Riemann-hypothesis condition. | [`output/riemann-hypothesis.pl`](../examples/eyelang/output/riemann-hypothesis.pl) |
 | [`security-incident-correlation.pl`](../examples/eyelang/security-incident-correlation.pl) | Correlates security incidents across signals. | [`output/security-incident-correlation.pl`](../examples/eyelang/output/security-incident-correlation.pl) |
 | [`service-impact.pl`](../examples/eyelang/service-impact.pl) | Analyzes service impact over cyclic dependencies. | [`output/service-impact.pl`](../examples/eyelang/output/service-impact.pl) |
@@ -422,6 +417,7 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`socrates.pl`](../examples/eyelang/socrates.pl) | Derives that Socrates is mortal. | [`output/socrates.pl`](../examples/eyelang/output/socrates.pl) |
 | [`statistics-summary.pl`](../examples/eyelang/statistics-summary.pl) | Computes population statistics for a sample. | [`output/statistics-summary.pl`](../examples/eyelang/output/statistics-summary.pl) |
 | [`superdense-coding.pl`](../examples/eyelang/superdense-coding.pl) | Models superdense-coding bit transmission. | [`output/superdense-coding.pl`](../examples/eyelang/output/superdense-coding.pl) |
+| [`term-tools.pl`](../examples/eyelang/term-tools.pl) | Inspects, builds, renders, and validates terms with reusable term/control builtins. | [`output/term-tools.pl`](../examples/eyelang/output/term-tools.pl) |
 | [`trust-flow-provenance-threshold.pl`](../examples/eyelang/trust-flow-provenance-threshold.pl) | Classifies message trust from provenance confidence scores. | [`output/trust-flow-provenance-threshold.pl`](../examples/eyelang/output/trust-flow-provenance-threshold.pl) |
 | [`turing.pl`](../examples/eyelang/turing.pl) | Simulates a binary-increment Turing machine. | [`output/turing.pl`](../examples/eyelang/output/turing.pl) |
 | [`vector-similarity.pl`](../examples/eyelang/vector-similarity.pl) | Computes dot product, norm, and cosine similarity. | [`output/vector-similarity.pl`](../examples/eyelang/output/vector-similarity.pl) |
@@ -431,7 +427,6 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`zebra.pl`](../examples/eyelang/zebra.pl) | Solves the zebra logic puzzle. | [`output/zebra.pl`](../examples/eyelang/output/zebra.pl) |
 
 
-
 ## Golden outputs, tests, and conformance
 
 Golden answer outputs live in [`examples/eyelang/output`](../examples/eyelang/output). `npm run test:eyelang` covers the eyelang integration check, conformance cases, regression checks, runnable examples, and proof-output examples. A curated proof-output suite for `.pl` examples lives in [`examples/eyelang/proof`](../examples/eyelang/proof). Example tests pin `local_time/1` to `2026-05-30` so date-dependent examples stay deterministic. Regenerate them after an intentional output or explanation change:
@@ -465,7 +460,7 @@ node test/eyelang/run-regression.mjs
 node test/eyelang/run-examples.mjs
 ```
 
-The conformance suite lives in [`test/eyelang/conformance/`](../test/eyelang/conformance/) and is split into `core` and `extension` profiles matching the language reference. Each case is a small program with an exact expected stdout file, and some internal conformance cases also include a goal file for testing the embeddable solver, so other implementations can reuse the same cases. The regression suite lives in [`test/eyelang/run-regression.mjs`](../test/eyelang/run-regression.mjs) and covers CLI regressions, the public JavaScript API, and white-box invariants for parser, unification, and indexing behavior.
+The conformance suite lives in [`test/eyelang/conformance/`](../test/eyelang/conformance/) as one flat eyelang corpus. Each case is a small `.pl` program with an exact expected stdout `.pl` file, and some cases also include a goal file for testing the embeddable solver, so other implementations can reuse the same cases. The suite covers the standard language surface from the language reference, including reusable built-ins. The regression suite lives in [`test/eyelang/run-regression.mjs`](../test/eyelang/run-regression.mjs) and covers CLI regressions, the public JavaScript API, and white-box invariants for parser, unification, and indexing behavior.
 
 ## Development and release
 

package/docs/eyelang-language-reference.md

@@ -41,7 +41,7 @@
   - [9.8 Aggregation and ordering](#98-aggregation-and-ordering)
   - [9.9 Context terms](#99-context-terms)
   - [9.10 Search control](#910-search-control)
-- [10. Extension built-ins](#10-extension-built-ins)
+- [10. Implementation-specific built-ins](#10-implementation-specific-built-ins)
 - [11. Declarations](#11-declarations)
   - [11.1 Memoization](#111-memoization)
   - [11.2 Default-output materialization](#112-default-output-materialization)
@@ -51,10 +51,7 @@
   - [12.3 Sockets and AI agents](#123-sockets-and-ai-agents)
 - [13. Output and read-back profile](#13-output-and-read-back-profile)
   - [13.1 Explanation output](#131-explanation-output)
-- [14. Conformance profiles](#14-conformance-profiles)
-  - [14.1 Core language profile](#141-core-language-profile)
-  - [14.2 Standard built-in profile](#142-standard-built-in-profile)
-  - [14.3 Standard host profile](#143-standard-host-profile)
+- [14. Conformance](#14-conformance)
 - [15. Relationship to ISO Prolog](#15-relationship-to-iso-prolog)
 - [16. Examples](#16-examples)
   - [16.1 Transitive closure](#161-transitive-closure)
@@ -345,7 +342,7 @@ This section specifies the **standard built-ins** of the eyelang language. An im
 
 A built-in call is still written as an atomic formula, but the relation is provided by the host implementation rather than by source clauses. Several built-ins are mode-sensitive: they are intended to run when their input arguments are sufficiently ground, and implementations may leave user-defined clauses visible when that mode is not yet satisfied.
 
-Implementations MAY provide additional built-ins, but such built-ins are extensions and are not part of this normative catalog. Extension built-ins are discussed separately in section 10.
+Implementations MAY provide additional built-ins, but such built-ins are implementation-specific and are not part of this normative catalog. Implementation-specific built-ins are discussed separately in section 10.
 
 ### 9.1 Equality and unification
 
@@ -360,15 +357,18 @@ Implementations MAY provide additional built-ins, but such built-ins are extensi
 |---|---|
 | `neg(A, B)` | `B` is the numeric negation of `A`. |
 | `abs(A, B)` | `B` is the absolute value of `A`. |
-| `sin(A, B)`, `cos(A, B)`, `asin(A, B)`, `acos(A, B)`, `log(A, B)` | Floating functions. |
-| `rounded(A, B)` | `B` is `A` rounded to the nearest integer. |
+| `sin(A, B)`, `cos(A, B)`, `tan(A, B)` | Trigonometric floating functions. |
+| `asin(A, B)`, `acos(A, B)`, `atan2(Y, X, Angle)` | Inverse trigonometric floating functions. |
+| `sqrt(A, B)` | Square root. Fails for negative inputs. |
+| `floor(A, B)`, `ceiling(A, B)`, `trunc(A, B)`, `rounded(A, B)` | Integer-valued numeric rounding functions. |
+| `exp(A, B)`, `log(A, B)` | Natural exponent and logarithm. `log/2` fails for non-positive inputs. |
 | `add(A, B, C)` | `C = A + B`. |
 | `sub(A, B, C)` | `C = A - B`. |
 | `mul(A, B, C)` | `C = A * B`. |
 | `div(A, B, C)` | `C = A / B`; integer inputs use integer division. |
 | `mod(A, B, C)` | Integer remainder. |
 | `pow(A, B, C)` | `C = A^B`. |
-| `min(A, B, C)` | Numeric minimum. |
+| `min(A, B, C)`, `max(A, B, C)` | Numeric minimum and maximum. |
 
 ### 9.3 Comparison
 
@@ -404,6 +404,14 @@ Comparisons interpret numeric-looking terms numerically. Other scalar terms are
 | `matches(Text, Pattern)` | Text matches a simple implementation regex/search pattern. |
 | `matches(Text, Pattern, Context)` | Text matches a JavaScript regular expression with named capture groups; `Context` is a comma context containing one unary term per matched capture group. |
 | `not_matches(Text, Pattern)` | Negation of `matches/2`. |
+| `split(Text, Separator, Parts)` | Splits text into a proper list of strings. |
+| `join(Parts, Separator, Text)` | Joins a proper list of scalar terms into a string. |
+| `substring(Text, Start, Length, Out)` | Extracts a zero-based substring. |
+| `replace(Text, Search, Replacement, Out)` | Replaces all non-empty literal occurrences of `Search`. |
+| `lowercase(Text, Out)`, `uppercase(Text, Out)`, `trim(Text, Out)` | Text normalization helpers. |
+| `number_string(Number, String)` | Converts a number to a string or parses a numeric string into a number. |
+| `atom_string(Atom, String)` | Converts between atom constants and strings. |
+| `term_string(Term, String)` | Renders a ground term as its eyelang source string. |
 
 ### 9.7 Lists
 
@@ -412,12 +420,21 @@ Comparisons interpret numeric-looking terms numerically. Other scalar terms are
 | `append(A, B, C)` | List append/split relation. |
 | `nth0(Index, List, Value)` | Zero-based list lookup. |
 | `set_nth0(Index, List, Value, Out)` | Functional list update. |
+| `head(List, Head)` | Head of a non-empty list. |
 | `rest(List, Tail)` | Tail of a non-empty list. |
+| `last(List, Last)` | Last element of a non-empty proper list. |
+| `take(N, List, Prefix)` | First `N` items of a proper list. |
+| `drop(N, List, Suffix)` | Proper-list suffix after dropping `N` items. |
+| `slice(Start, Length, List, Slice)` | Zero-based proper-list slice. |
 | `member(X, List)` | Member generator. |
 | `select(X, List, Rest)` | Selects one occurrence. |
 | `not_member(X, List)` | Succeeds when `X` is not a member. |
 | `reverse(A, B)` | Reverses a proper list. |
 | `length(List, N)` | Proper-list length. |
+| `sum_list(List, Sum)` | Numeric sum of a proper list; empty lists produce `0`. |
+| `min_list(List, Min)`, `max_list(List, Max)` | Minimum and maximum under standard term ordering. |
+| `list_to_set(List, Set)` | Removes duplicates while preserving the first occurrence order. |
+| `sort(Input, Output)` | Sorts and deduplicates a proper list. |
 
 ### 9.8 Aggregation and ordering
 
@@ -428,9 +445,8 @@ Comparisons interpret numeric-looking terms numerically. Other scalar terms are
 | `sumall(Template, Goal, Sum)` | Sums numeric `Template` values over solutions of `Goal`; empty solution sets produce `0`. |
 | `aggregate_min(Key, Template, Goal, BestKey, BestTemplate)` | Selects the solution of `Goal` with the smallest resolved `Key`, returning that key and the corresponding resolved `Template`. Fails when `Goal` has no solutions. |
 | `aggregate_max(Key, Template, Goal, BestKey, BestTemplate)` | Selects the solution of `Goal` with the largest resolved `Key`, returning that key and the corresponding resolved `Template`. Fails when `Goal` has no solutions. |
-| `sort(Input, Output)` | Sorts and deduplicates a proper list. |
 
-### 9.9 Context terms
+### 9.9 Context and term inspection
 
 Context terms are data representations of atomic formulas and comma conjunctions.
 
@@ -438,12 +454,18 @@ Context terms are data representations of atomic formulas and comma conjunctions
 |---|---|
 | `holds(Context, Term)` | Enumerates member terms inside a context term and unifies each member with `Term`. |
 | `holds(Context, Name, Args)` | Enumerates context members of any arity, exposing each member as atom constant `Name` plus a proper argument list `Args`. |
+| `functor(Term, Name, Arity)` | Decomposes a non-variable term into its name and arity. |
+| `arg(Index, Term, Arg)` | Extracts the 1-based argument of a compound term. |
+| `compound_name_arguments(Term, Name, Args)` | Decomposes a compound term or constructs one from an atom name and proper argument list. |
 
 Example:
 
 ```prolog
 holds((name(alice, "Alice"), knows(alice, bob)), name(S, O)).
 holds((ready, name(alice, "Alice"), route(alice, bob, 7)), Name, Args).
+functor(route(alice, bob, 7), route, 3).
+arg(2, route(alice, bob, 7), bob).
+compound_name_arguments(Term, route, [alice, bob, 7]).
 ```
 
 The first goal can yield `holds((name(alice, "Alice"), knows(alice, bob)), name(alice, "Alice")).` The second can yield `holds((ready, name(alice, "Alice"), route(alice, bob, 7)), ready, []).`, `holds((ready, name(alice, "Alice"), route(alice, bob, 7)), name, [alice, "Alice"]).`, and `holds((ready, name(alice, "Alice"), route(alice, bob, 7)), route, [alice, bob, 7]).`
@@ -458,14 +480,15 @@ The N3 example [`context-schema-audit.n3`](../examples/context-schema-audit.n3)
 |---|---|
 | `not(Goal)` | Negation as failure. Succeeds when `Goal` has no solution. |
 | `once(Goal)` | Succeeds with at most the first solution of `Goal`. |
+| `forall(Generator, Test)` | Succeeds when every solution of `Generator` also satisfies `Test`; succeeds vacuously when `Generator` has no solutions. |
 
-## 10. Extension built-ins
+## 10. Implementation-specific built-ins
 
-Implementations MAY provide additional built-ins beyond the standard predicates listed above. Such built-ins are **extension built-ins**. They are useful for embedding eyelang in particular host environments, exposing efficient finite-domain solvers, or providing domain-specific relations for examples and applications.
+Implementations MAY provide additional built-ins beyond the standard predicates listed above. Such built-ins are **implementation-specific built-ins**. They are useful for embedding eyelang in particular host environments, exposing efficient finite-domain solvers, or providing domain-specific relations for applications.
 
-Extension built-ins are not required for conformance to this specification. A portable eyelang program SHOULD NOT depend on an extension built-in unless the target implementation explicitly documents that extension.
+Implementation-specific built-ins are not required for conformance to this specification. A portable eyelang program SHOULD NOT depend on one unless the target implementation explicitly documents it.
 
-An extension built-in SHOULD obey the same surface-language discipline as standard built-ins:
+An implementation-specific built-in SHOULD obey the same surface-language discipline as standard built-ins:
 
 - it is called using ordinary atomic-formula syntax, for example `some_extension(A, B)`;
 - its arguments and results are eyelang terms from the Herbrand universe;
@@ -473,9 +496,9 @@ An extension built-in SHOULD obey the same surface-language discipline as standa
 - it SHOULD document its intended modes, especially which arguments must be ground before it runs deterministically;
 - it MUST NOT change the meaning of ordinary facts, rules, unification, or standard built-ins.
 
-For example, an implementation may include extension modules for number-theory algorithms, matrix operations, or host-specific integrations. Those modules may be valuable and may make example programs much faster, but their predicate names, arities, algorithms, and modes are implementation-defined unless they are separately standardized.
+For example, an implementation may include host-specific integrations or domain accelerators. Those modules may be valuable and may make applications much faster, but their predicate names, arities, algorithms, and modes are implementation-defined unless they are separately standardized.
 
-An implementation that provides explanation output SHOULD make extension built-ins explainable at least as opaque successful or failed built-in calls, so that proof traces do not incorrectly report "no clauses" for a host-provided relation.
+An implementation that provides explanation output SHOULD make implementation-specific built-ins explainable at least as opaque successful or failed built-in calls, so that proof traces do not incorrectly report "no clauses" for a host-provided relation.
 
 ## 11. Declarations
 
@@ -597,37 +620,25 @@ Default host output behavior is:
 
 When proof output is enabled, each answer SHOULD be followed by a machine-readable `why/2` fact. Explanation output is ordinary eyelang syntax whose second argument is a nested abstract proof term such as `proof(goal(G), by(Method), bindings(Bindings), uses(Proofs))`; implementations SHOULD print `goal(...)` and `by(...)` on separate lines for readability. A proof term preserves the answer goal, derivation method, relevant bindings, and nested uses while omitting proof IDs. User clauses SHOULD be referenced explicitly as `fact(Filename, clause(N))` or `rule(Filename, clause(N))`, where `N` is the 1-based clause number within that source. Built-ins SHOULD be referenced as `builtin(Name, Arity)` because they do not come from source clauses. Explanation output is outside the logical semantics of the input program and MUST NOT change the set of answers.
 
-## 14. Conformance profiles
-
-### 14.1 Core language profile
+## 14. Conformance
 
-A conforming core language implementation supports:
+A conforming eyelang implementation supports the standard language described above as one conformance surface rather than as separate core and extension profiles. This includes:
 
 - lexical syntax described above;
 - facts and definite clauses;
 - first-order unification without occurs check;
 - left-to-right goal-directed proof search;
 - lists and comma conjunctions;
-- answer printing.
-
-### 14.2 Standard built-in profile
-
-A conforming standard built-in implementation supports the built-ins listed in section 9. These are the portable built-ins independent implementations should implement when they claim standard built-in compatibility.
-
-### 14.3 Standard host profile
-
-A conforming standard host also supports:
-
+- answer printing and read-back formatting;
+- the standard built-ins listed in section 9;
 - `memoize/2` declarations;
 - `materialize/2` declarations;
 - default derived output;
-- explanation output;
-- stdin, file, and URL inputs in the CLI.
-
-Browser execution, package layout, and any extension built-ins described in implementation documentation are outside this specification unless separately standardized.
+- explanation output when the host exposes proof output.
 
+Browser execution, package layout, CLI URL loading, and any implementation-specific built-ins described in host documentation are outside this conformance surface unless separately standardized.
 
-Conformance cases for these profiles live in the repository under `conformance/`. They are run by `npm test` before the example suite, and can be run alone with `npm run test:conformance`. The cases use exact expected standard output files so independent implementations can compare behavior case by case.
+Conformance cases live in the repository under `test/eyelang/conformance/`. They are run by `npm test` before the example suite, and can be run alone with `node test/eyelang/run-conformance.mjs`. Each case has an input program under `conformance/cases/` and an exact expected standard-output file under `conformance/expected/`; both use `.pl` so expected output remains eyelang-readable.
 
 ## 15. Relationship to ISO Prolog
 

package/examples/eyelang/bayes-therapy.pl

@@ -106,9 +106,9 @@ scores_for([Disease|RestDiseases], [Score|RestScores]) :-
   score(Disease, Score),
   scores_for(RestDiseases, RestScores).
 
-sum_list([], 0.0).
-sum_list([Value|Rest], Sum) :-
-  sum_list(Rest, TailSum),
+score_sum([], 0.0).
+score_sum([Value|Rest], Sum) :-
+  score_sum(Rest, TailSum),
   add(Value, TailSum, Sum).
 
 normalize_scores([], _Total, []).
@@ -159,7 +159,7 @@ scores(case, Scores) :-
   scores_for(Diseases, Scores).
 evidenceTotal(case, Total) :-
   scores(case, Scores),
-  sum_list(Scores, Total).
+  score_sum(Scores, Total).
 posteriors(case, Posteriors) :-
   scores(case, Scores),
   evidenceTotal(case, Total),

package/examples/eyelang/output/reusable-builtins.pl

@@ -0,0 +1,5 @@
+report(normalized_name, "ada lovelace").
+report(unique_tags, ["logic", "math", "programming"]).
+report(tag_label, "logic / math / programming").
+report(score_summary, summary(42, 21, 6.4807406984078604)).
+report(window, [13, 21]).

package/examples/eyelang/output/term-tools.pl

@@ -0,0 +1,6 @@
+report(shape, shape(edge, 3)).
+report(second_argument, b).
+report(parts, parts(edge, [a, b, 3])).
+report(rebuilt, edge(c, d, 5)).
+report(rendered, "edge(a, [b, c])").
+report(all_weights_positive, yes).

package/examples/eyelang/reusable-builtins.pl

@@ -0,0 +1,32 @@
+% Reusable builtin tour: normalize text, summarize lists, and compute numeric values.
+materialize(report, 2).
+
+name_raw("  Ada Lovelace  ").
+tag_csv("logic,math,logic,programming").
+scores([8, 13, 21]).
+
+report(normalized_name, Name) :-
+  name_raw(Raw),
+  trim(Raw, Trimmed),
+  lowercase(Trimmed, Name).
+
+report(unique_tags, Tags) :-
+  tag_csv(Csv),
+  split(Csv, ",", Parts),
+  list_to_set(Parts, Tags).
+
+report(tag_label, Label) :-
+  tag_csv(Csv),
+  split(Csv, ",", Parts),
+  list_to_set(Parts, Tags),
+  join(Tags, " / ", Label).
+
+report(score_summary, summary(Total, Peak, RootTotal)) :-
+  scores(Scores),
+  sum_list(Scores, Total),
+  max_list(Scores, Peak),
+  sqrt(Total, RootTotal).
+
+report(window, Slice) :-
+  scores(Scores),
+  slice(1, 2, Scores, Slice).

package/examples/eyelang/term-tools.pl

@@ -0,0 +1,23 @@
+% Term tools: inspect and build structured terms, then validate all facts with forall/2.
+materialize(report, 2).
+
+edge(a, b, 3).
+edge(b, c, 4).
+
+report(shape, shape(Name, Arity)) :-
+  functor(edge(a, b, 3), Name, Arity).
+
+report(second_argument, Node) :-
+  arg(2, edge(a, b, 3), Node).
+
+report(parts, parts(Name, Args)) :-
+  compound_name_arguments(edge(a, b, 3), Name, Args).
+
+report(rebuilt, Term) :-
+  compound_name_arguments(Term, edge, [c, d, 5]).
+
+report(rendered, Text) :-
+  term_string(edge(a, [b, c]), Text).
+
+report(all_weights_positive, yes) :-
+  forall(edge(_From, _To, Weight), gt(Weight, 0)).

package/lib/eyelang/builtins/arithmetic.js

@@ -2,8 +2,8 @@
 // The code keeps BigInt paths where possible so large eyelang integers remain exact.
 import { compareIntegerText, deref, isDecimalInteger, lexicalValue, numberTerm, numberTextFromDouble, parseFiniteNumber, unify } from '../term.js';
 
-const unaryNames = ['neg', 'abs', 'sin', 'cos', 'asin', 'acos', 'rounded', 'log'];
-const binaryNames = ['add', 'sub', 'mul', 'div', 'mod', 'min', 'pow'];
+const unaryNames = ['neg', 'abs', 'sin', 'cos', 'tan', 'asin', 'acos', 'sqrt', 'floor', 'ceiling', 'trunc', 'rounded', 'exp', 'log'];
+const binaryNames = ['add', 'sub', 'mul', 'div', 'mod', 'min', 'max', 'pow', 'atan2'];
 const compareNames = ['lt', 'gt', 'le', 'ge'];
 
 export const arithmeticBuiltins = {
@@ -22,9 +22,11 @@ function unary(name) {
     const text = lexicalValue(goal.args[0], env);
     if (text == null) return;
     let out = null;
-    if ((name === 'neg' || name === 'abs') && isDecimalInteger(text)) {
+    if ((name === 'neg' || name === 'abs' || name === 'floor' || name === 'ceiling' || name === 'trunc' || name === 'rounded') && isDecimalInteger(text)) {
       const value = BigInt(text);
-      out = (name === 'neg' ? -value : value < 0n ? -value : value).toString();
+      if (name === 'neg') out = (-value).toString();
+      else if (name === 'abs') out = (value < 0n ? -value : value).toString();
+      else out = value.toString();
     } else {
       const input = parseFiniteNumber(text);
       if (input == null) return;
@@ -33,14 +35,22 @@ function unary(name) {
       else if (name === 'abs') value = Math.abs(input);
       else if (name === 'sin') value = Math.sin(input);
       else if (name === 'cos') value = Math.cos(input);
+      else if (name === 'tan') value = Math.tan(input);
       else if (name === 'asin') value = Math.asin(input);
       else if (name === 'acos') value = Math.acos(input);
+      else if (name === 'sqrt') { if (input < 0) return; value = Math.sqrt(input); }
+      else if (name === 'floor') value = Math.floor(input);
+      else if (name === 'ceiling') value = Math.ceil(input);
+      else if (name === 'trunc') value = Math.trunc(input);
       else if (name === 'rounded') value = Math.round(input);
+      else if (name === 'exp') value = Math.exp(input);
       else if (name === 'log') {
         if (input <= 0) return;
         value = logCompat(input);
       }
-      out = name === 'rounded' ? String(Math.trunc(value)) : numberTextFromDouble(value);
+      out = (name === 'floor' || name === 'ceiling' || name === 'trunc' || name === 'rounded')
+        ? String(Math.trunc(value))
+        : numberTextFromDouble(value);
     }
     const next = env.clone();
     if (out != null && unify(goal.args[1], numberTerm(out), next)) yield next;
@@ -53,7 +63,7 @@ function binary(name) {
     const rightText = lexicalValue(goal.args[1], env);
     if (leftText == null || rightText == null) return;
     let out = null;
-    if (isDecimalInteger(leftText) && isDecimalInteger(rightText) && name !== 'mod') {
+    if (isDecimalInteger(leftText) && isDecimalInteger(rightText) && name !== 'mod' && name !== 'atan2') {
       const a = BigInt(leftText);
       const b = BigInt(rightText);
       if (name === 'add') out = (a + b).toString();
@@ -61,6 +71,7 @@ function binary(name) {
       else if (name === 'mul') out = (a * b).toString();
       else if (name === 'div') { if (b === 0n) return; out = (a / b).toString(); }
       else if (name === 'min') out = (a <= b ? a : b).toString();
+      else if (name === 'max') out = (a >= b ? a : b).toString();
       else if (name === 'pow') { if (b < 0n) return; out = (a ** b).toString(); }
     } else if (name === 'mod') {
       if (!isDecimalInteger(leftText) || !isDecimalInteger(rightText)) return;
@@ -77,6 +88,8 @@ function binary(name) {
       else if (name === 'div') { if (b === 0) return; value = a / b; }
       else if (name === 'pow') value = Math.pow(a, b);
       else if (name === 'min') value = Math.min(a, b);
+      else if (name === 'max') value = Math.max(a, b);
+      else if (name === 'atan2') value = Math.atan2(a, b);
       out = numberTextFromDouble(value);
     }
     const next = env.clone();

package/lib/eyelang/builtins/control.js

@@ -3,6 +3,7 @@ export const controlBuiltins = {
   register(registry) {
     registry.add('not', 1, notBuiltin);
     registry.add('once', 1, onceBuiltin);
+    registry.add('forall', 2, forallBuiltin);
   }
 };
 
@@ -20,3 +21,14 @@ function* onceBuiltin({ solver, goal, env }) {
     break;
   }
 }
+
+function* forallBuiltin({ solver, goal, env }) {
+  const generator = solver.cloneForInnerGoal(10000000);
+  for (const answerEnv of generator.solve([goal.args[0]], env.clone(), 0)) {
+    const checker = solver.cloneForInnerGoal(1);
+    let ok = false;
+    for (const _ of checker.solve([goal.args[1]], answerEnv.clone(), 0)) { ok = true; break; }
+    if (!ok) return;
+  }
+  yield env;
+}