eyeling 1.34.3 → 1.34.4

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:

package/docs/eyelang-language-reference.md

@@ -360,15 +360,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 +407,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 +423,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 +448,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 +457,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,6 +483,7 @@ 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
 

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;
+}

package/lib/eyelang/builtins/lists.js

@@ -1,23 +1,62 @@
-// List builtins for proper lists, selection, membership, sorting, and indexing.
+// List builtins for proper lists, selection, membership, sorting, indexing, slicing, and summaries.
 // Several predicates support both checking and generation, so the argument modes are handled explicitly.
-import { compareTerms, copyResolved, deref, isCons, lexicalValue, listFromItems, numberTerm, properListItems, unify } from '../term.js';
+import {
+  compareTerms,
+  copyResolved,
+  deref,
+  isDecimalInteger,
+  isCons,
+  lexicalValue,
+  listFromItems,
+  numberTerm,
+  numberTextFromDouble,
+  parseFiniteNumber,
+  properListItems,
+  unify,
+} from '../term.js';
 
 export const listBuiltins = {
   register(registry) {
     registry.add('append', 3, append);
     registry.add('nth0', 3, nth0);
     registry.add('set_nth0', 4, setNth0, { deterministic: true });
-    registry.add('rest', 2, rest, { deterministic: true });
+    registry.add('head', 2, head, { deterministic: true, fallbackWhenNotReady: true, ready: firstConsReady });
+    registry.add('rest', 2, rest, { deterministic: true, fallbackWhenNotReady: true, ready: firstConsReady });
+    registry.add('last', 2, last, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('take', 3, take, { deterministic: true, fallbackWhenNotReady: true, ready: countAndListReady });
+    registry.add('drop', 3, drop, { deterministic: true, fallbackWhenNotReady: true, ready: countAndListReady });
+    registry.add('slice', 4, slice, { deterministic: true, fallbackWhenNotReady: true, ready: sliceReady });
     registry.add('member', 2, member);
     registry.add('select', 3, select);
     registry.add('not_member', 2, notMember, { deterministic: true });
     registry.add('reverse', 2, reverse, { deterministic: true });
     registry.add('length', 2, lengthBuiltin, { deterministic: true });
+    registry.add('sum_list', 2, sumList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('min_list', 2, minList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('max_list', 2, maxList, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
+    registry.add('list_to_set', 2, listToSet, { deterministic: true, fallbackWhenNotReady: true, ready: firstProperListReady });
     registry.add('sort', 2, sortBuiltin, { deterministic: true });
   }
 };
 
 
+
+function firstConsReady(goal, env) {
+  return isCons(deref(goal.args[0], env));
+}
+
+function firstProperListReady(goal, env) {
+  return properListItems(goal.args[0], env) !== null;
+}
+
+function countAndListReady(goal, env) {
+  return safeIndex(goal.args[0], env) !== null && properListItems(goal.args[1], env) !== null;
+}
+
+function sliceReady(goal, env) {
+  return safeIndex(goal.args[0], env) !== null && safeIndex(goal.args[1], env) !== null && properListItems(goal.args[2], env) !== null;
+}
+
 function listFromItemsExcept(items, skip) {
   const copy = new Array(items.length - 1);
   for (let i = 0, j = 0; i < items.length; i++) if (i !== skip) copy[j++] = items[i];
@@ -62,10 +101,8 @@ function* nth0({ goal, env }) {
 }
 
 function* setNth0({ goal, env }) {
-  const indexText = lexicalValue(goal.args[0], env);
-  if (!/^-?\d+$/.test(indexText ?? '')) return;
-  const index = Number(indexText);
-  if (!Number.isSafeInteger(index) || index < 0) return;
+  const index = safeIndex(goal.args[0], env);
+  if (index == null) return;
   const items = properListItems(goal.args[1], env);
   if (!items || index >= items.length) return;
   const out = items.slice();
@@ -74,6 +111,13 @@ function* setNth0({ goal, env }) {
   if (unify(goal.args[3], listFromItems(out), next)) yield next;
 }
 
+function* head({ goal, env }) {
+  const list = deref(goal.args[0], env);
+  if (!isCons(list)) return;
+  const next = env.clone();
+  if (unify(goal.args[1], list.args[0], next)) yield next;
+}
+
 function* rest({ goal, env }) {
   const list = deref(goal.args[0], env);
   if (!isCons(list)) return;
@@ -81,6 +125,41 @@ function* rest({ goal, env }) {
   if (unify(goal.args[1], list.args[1], next)) yield next;
 }
 
+function* last({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items || items.length === 0) return;
+  const next = env.clone();
+  if (unify(goal.args[1], items[items.length - 1], next)) yield next;
+}
+
+function* take({ goal, env }) {
+  const count = safeIndex(goal.args[0], env);
+  if (count == null) return;
+  const items = properListItems(goal.args[1], env);
+  if (!items || count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(items, 0, count), next)) yield next;
+}
+
+function* drop({ goal, env }) {
+  const count = safeIndex(goal.args[0], env);
+  if (count == null) return;
+  const items = properListItems(goal.args[1], env);
+  if (!items || count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(items, count, items.length), next)) yield next;
+}
+
+function* slice({ goal, env }) {
+  const start = safeIndex(goal.args[0], env);
+  const count = safeIndex(goal.args[1], env);
+  if (start == null || count == null) return;
+  const items = properListItems(goal.args[2], env);
+  if (!items || start + count > items.length) return;
+  const next = env.clone();
+  if (unify(goal.args[3], listFromItems(items, start, start + count), next)) yield next;
+}
+
 function* member({ goal, env }) {
   const items = properListItems(goal.args[1], env);
   if (!items) return;
@@ -132,6 +211,59 @@ function* lengthBuiltin({ goal, env }) {
   if (unify(goal.args[1], numberTerm(items.length), next)) yield next;
 }
 
+function* sumList({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items) return;
+  let intSum = 0n;
+  let floatMode = false;
+  let floatSum = 0;
+  for (const item of items) {
+    const text = lexicalValue(item, env);
+    if (text == null) return;
+    if (!floatMode && isDecimalInteger(text)) intSum += BigInt(text);
+    else {
+      const value = parseFiniteNumber(text);
+      if (value == null) return;
+      if (!floatMode) { floatSum = Number(intSum); floatMode = true; }
+      floatSum += value;
+    }
+  }
+  const out = floatMode ? numberTextFromDouble(floatSum) : intSum.toString();
+  const next = env.clone();
+  if (unify(goal.args[1], numberTerm(out), next)) yield next;
+}
+
+function* minList({ goal, env }) {
+  yield* minMaxList(goal, env, true);
+}
+
+function* maxList({ goal, env }) {
+  yield* minMaxList(goal, env, false);
+}
+
+function* minMaxList(goal, env, wantMin) {
+  const items = properListItems(goal.args[0], env);
+  if (!items || items.length === 0) return;
+  let best = copyResolved(items[0], env);
+  for (let i = 1; i < items.length; i++) {
+    const item = copyResolved(items[i], env);
+    const cmp = compareTerms(item, best);
+    if ((wantMin && cmp < 0) || (!wantMin && cmp > 0)) best = item;
+  }
+  const next = env.clone();
+  if (unify(goal.args[1], best, next)) yield next;
+}
+
+function* listToSet({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  if (!items) return;
+  const unique = [];
+  for (const item of items.map((entry) => copyResolved(entry, env))) {
+    if (!unique.some((seen) => compareTerms(seen, item) === 0)) unique.push(item);
+  }
+  const next = env.clone();
+  if (unify(goal.args[1], listFromItems(unique), next)) yield next;
+}
 
 function* sortBuiltin({ goal, env }) {
   const items = properListItems(goal.args[0], env);
@@ -142,3 +274,10 @@ function* sortBuiltin({ goal, env }) {
   const next = env.clone();
   if (unify(goal.args[1], listFromItems(unique), next)) yield next;
 }
+
+function safeIndex(term, env) {
+  const text = lexicalValue(term, env);
+  if (!/^-?\d+$/.test(text ?? '')) return null;
+  const index = Number(text);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}