eyelang 1.5.5 → 1.6.0

package/README.md

@@ -20,11 +20,13 @@ For the normative language definition, including lexical syntax, terms, clauses,
 4. [Writing programs](#writing-programs)
 5. [Aggregation helpers](#aggregation-helpers)
 6. [Formula data](#formula-data)
-7. [Example catalog](#example-catalog)
-8. [Golden outputs, tests, and conformance](#golden-outputs-tests-and-conformance)
-9. [Development and release](#development-and-release)
-10. [Performance notes](#performance-notes)
-11. [Implementation limits](#implementation-limits)
+7. [RDF 1.2 and Notation3 compatibility](#rdf-12-and-notation3-compatibility)
+8. [Example catalog](#example-catalog)
+9. [Golden outputs, tests, and conformance](#golden-outputs-tests-and-conformance)
+10. [Development and release](#development-and-release)
+11. [Relationship to Eyeling](#relationship-to-eyeling)
+12. [Performance notes](#performance-notes)
+13. [Implementation limits](#implementation-limits)
 
 ## Quick start
 
@@ -313,6 +315,67 @@ formula_binary((name(alice, "Alice"), knows(alice, bob)), S, P, O).
 
 This can yield `S = alice`, `P = name`, `O = "Alice"` and `S = alice`, `P = knows`, `O = bob`. The utility is useful for quoted formula data, but it does not make those formula members true in the ambient program.
 
+
+## RDF 1.2 and Notation3 compatibility
+
+The core eyelang syntax remains Prolog-like, but `src/rdf.js` adds a compatibility layer for RDF 1.2 Turtle/N-Triples style data and a practical Notation3 rule subset. Use it from the CLI with `--rdf`, `--rdf12`, `--n3`, or `--input-format FORMAT`; file inputs ending in `.ttl`, `.nt`, or `.n3` are recognized when the CLI uses its default `auto` format.
+
+```sh
+bin/eyelang --rdf data.ttl rules.n3
+printf '@prefix : <http://example.com/> .
+{ ?x :parent ?y . } => { ?x :related ?y . } .
+:alice :parent :bob .
+' | bin/eyelang --n3 -
+```
+
+RDF triples are lowered to ordinary `rdf/3` goals:
+
+```prolog
+rdf(Subject, Predicate, Object).
+```
+
+RDF terms are explicit eyelang compound terms:
+
+```prolog
+iri("http://example.com/alice")
+bnode("b0")
+literal("Alice", iri("http://www.w3.org/2001/XMLSchema#string"), "", "")
+triple(Subject, Predicate, Object)
+```
+
+The layer supports `PREFIX`/`@prefix`, `BASE`/`@base`, `VERSION`/`@version`, IRIs, prefixed names, blank nodes, strings, numeric and boolean literals, language-tagged and RDF 1.2 directional language-tagged strings, RDF collections, blank-node property lists, RDF 1.2 triple terms `<<( ... )>>`, reified triple sugar `<< ... >>`, annotation blocks `{| ... |}`, N3 rules of the form `{ antecedent } => { consequent } .`, reverse rules of the form `{ consequent } <= { antecedent } .`, and N3 equality `=` as `owl:sameAs`. Reified triples and annotations are expanded through `rdf:reifies`, so this Turtle fragment:
+
+```turtle
+VERSION "1.2"
+PREFIX : <http://example.com/>
+:alice :name "Alice" ~ :t {| :statedBy :bob |} .
+```
+
+is made available as eyelang facts like:
+
+```prolog
+rdf(iri("http://example.com/alice"), iri("http://example.com/name"), literal("Alice", iri("http://www.w3.org/2001/XMLSchema#string"), "", "")).
+rdf(iri("http://example.com/t"), iri("http://www.w3.org/1999/02/22-rdf-syntax-ns#reifies"), triple(iri("http://example.com/alice"), iri("http://example.com/name"), literal("Alice", iri("http://www.w3.org/2001/XMLSchema#string"), "", ""))).
+rdf(iri("http://example.com/t"), iri("http://example.com/statedBy"), iri("http://example.com/bob")).
+```
+
+From JavaScript, use `parseRdfClauses(source, options)` when you want clause objects, or `rdfToEyelang(source, options)` when you want the lowered eyelang source text.
+
+N3 body triples whose predicates are in the common SWAP namespaces are lowered to eyelang built-ins instead of `rdf/3` goals. The practical bridge covers math comparisons and arithmetic such as `math:sum`, `math:difference`, `math:product`, `math:quotient`, `math:rounded`, and trigonometric functions, with exact BigInt-backed integer paths for large N3 arithmetic examples; string predicates such as `string:contains`, `string:startsWith`, `string:concatenation`, `string:length`, `string:replace`, and `string:scrape`; list predicates such as `list:member`, `list:append`, `list:first`, `list:rest`, `list:length`, `list:reverse`, and `list:sort`; `crypto:sha`, `crypto:md5`, `crypto:sha256`, `crypto:sha512`; simple `time:*` component extraction; and selected `log:*` helpers such as `log:equalTo`, `log:notEqualTo`, `log:uri`, `log:dtlit`, and `log:rawType`. This follows the builtin families used by eyeling while keeping eyelang's execution model small.
+
+RDF/N3 examples now live directly in [`examples/`](examples/), with golden outputs in [`examples/output/`](examples/output/), matching the existing example layout. They include eyeling-inspired `socrates.n3`, `family-cousins.n3`, and `annotation-rdf12.ttl` examples; focused RDF 1.2 triple-term and directional-language examples; `n3-builtins.n3`; and a larger `eyeling-*.n3` set adapted from the eyeling example directory. The added eyeling-style examples cover backward rules, recursive `<=`, equality, collection/list handling, Ackermann-style hyperoperations, Fibonacci numbers, dog-license, witch, Cat Koko, family/cousin, alignment, BMI, and SWAP math/string/list/crypto/time builtins. Run them with auto format detection or force the reader explicitly:
+
+```sh
+bin/eyelang examples/socrates.n3
+bin/eyelang --rdf12 examples/annotation-rdf12.ttl
+bin/eyelang --n3 examples/n3-builtins.n3
+bin/eyelang --n3 examples/eyeling-backward-recursion.n3
+bin/eyelang --n3 examples/eyeling-ackermann.n3
+bin/eyelang --n3 examples/eyeling-fibonacci.n3
+```
+
+This is a compatibility layer, not a validating W3C conformance parser. It intentionally covers the graph-oriented syntax, common RDF 1.2 constructs, and the N3 Horn-rule/builtin patterns that map cleanly to eyelang; it does not implement RDF/XML, full TriG datasets, SPARQL, scoped N3 formula built-ins such as full `log:semantics`, or every Notation3 construct.
+
 ## Example catalog
 
 The repository includes examples for recursion, graph reachability, finite search, arithmetic, list processing, optimization, policies, puzzles, N3-inspired rule chains, and applied scientific calculations. Bundled examples use relation-style output.
@@ -328,6 +391,7 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`ancestor.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/ancestor.pl) | Derives ancestors from parent facts. | [`output/ancestor.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/ancestor.pl) |
 | [`animal.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/animal.pl) | Classifies animals from traits. | [`output/animal.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/animal.pl) |
 | [`annotation.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/annotation.pl) | Derives facts from quoted annotation data. | [`output/annotation.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/annotation.pl) |
+| [`annotation-rdf12.ttl`](https://github.com/eyereasoner/eyelang/blob/main/examples/annotation-rdf12.ttl) | Demonstrates RDF 1.2 annotation syntax lowered through `rdf:reifies`. | [`output/annotation-rdf12.ttl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/annotation-rdf12.ttl) |
 | [`auroracare.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/auroracare.pl) | Evaluates purpose-based medical data access scenarios. | [`output/auroracare.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/auroracare.pl) |
 | [`backward.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/backward.pl) | Shows a backward-rule pattern as a goal-directed numeric rule. | [`output/backward.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/backward.pl) |
 | [`basic-monadic.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/basic-monadic.pl) | Runs a monadic benchmark over generated inputs. | [`output/basic-monadic.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/basic-monadic.pl) |
@@ -435,6 +499,8 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`quadratic-formula.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/quadratic-formula.pl) | Solves sample quadratic equations. | [`output/quadratic-formula.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/quadratic-formula.pl) |
 | [`quine-mccluskey.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/quine-mccluskey.pl) | Minimizes Boolean terms with Quine-McCluskey. | [`output/quine-mccluskey.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/quine-mccluskey.pl) |
 | [`radioactive-decay.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/radioactive-decay.pl) | Computes radioactive decay over time. | [`output/radioactive-decay.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/radioactive-decay.pl) |
+| [`resilient-city-orchestration.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/resilient-city-orchestration.pl) | Orchestrates storm-response missions from signals, policy, routes, teams, and portfolio optimization. | [`output/resilient-city-orchestration.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/resilient-city-orchestration.pl) |
+| [`riemann-hypothesis.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/riemann-hypothesis.pl) | Checks a finite catalogue of non-trivial zeta zeros against the Riemann-hypothesis condition. | [`output/riemann-hypothesis.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/riemann-hypothesis.pl) |
 | [`sat-dpll.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/sat-dpll.pl) | Solves a finite SAT instance. | [`output/sat-dpll.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/sat-dpll.pl) |
 | [`security-incident-correlation.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/security-incident-correlation.pl) | Correlates security incidents across signals. | [`output/security-incident-correlation.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/security-incident-correlation.pl) |
 | [`service-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/service-impact.pl) | Analyzes service impact over cyclic dependencies. | [`output/service-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/service-impact.pl) |
@@ -454,12 +520,17 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`zebra.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/zebra.pl) | Solves the zebra logic puzzle. | [`output/zebra.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/zebra.pl) |
 
 
+| [`directional-language.ttl`](https://github.com/eyereasoner/eyelang/blob/main/examples/directional-language.ttl) | Demonstrates RDF 1.2 directional language-tagged strings. | [`output/directional-language.ttl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/directional-language.ttl) |
+| [`n3-builtins.n3`](https://github.com/eyereasoner/eyelang/blob/main/examples/n3-builtins.n3) | Uses N3 `<=` plus `math:`, `string:`, and `list:` builtins. | [`output/n3-builtins.n3`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/n3-builtins.n3) |
+| [`triple-term.n3`](https://github.com/eyereasoner/eyelang/blob/main/examples/triple-term.n3) | Demonstrates RDF 1.2 triple terms in N3 data and rules. | [`output/triple-term.n3`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/triple-term.n3) |
+
 ## Golden outputs, tests, and conformance
 
-Golden answer outputs live in [`examples/output`](examples/output). A curated proof-output suite lives in [`examples/proof`](examples/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:
+Golden answer outputs live in [`examples/output`](examples/output). `npm run test:examples` covers every top-level runnable example with extension `.pl`, `.n3`, `.ttl`, or `.nt`. A curated proof-output suite for `.pl` examples lives in [`examples/proof`](examples/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:
 
 ```sh
-for f in examples/*.pl; do
+for f in examples/*.pl examples/*.n3 examples/*.ttl examples/*.nt; do
+  [ -e "$f" ] || continue
   b=$(basename "$f")
   EYELANG_LOCAL_TIME=2026-05-30 bin/eyelang "$f" > "examples/output/$b"
 done
@@ -476,7 +547,7 @@ Run the full test suite:
 npm test
 ```
 
-The test suite runs in this order: Conformance, Regression/API/White-box, Examples. Each section prints its own subtotal, followed by a suite-specific grand total. The suite checks the conformance cases derived from `SPEC.md`, supplemental regression/API/white-box checks, and every example against its explanation-rich output golden.
+The test suite runs in this order: Conformance, Regression/API/White-box, Examples. Each section prints its own subtotal, followed by a suite-specific grand total. The suite checks the conformance cases derived from `SPEC.md`, supplemental regression/API/white-box checks, and every runnable example against its golden output.
 
 Run only one suite when you are iterating:
 
@@ -514,6 +585,27 @@ For a release:
 4. run `npm test`;
 5. publish the repository with `playground.html` and `playground-worker.mjs` if publishing the playground. The playground includes controls equivalent to CLI `--stats` and `--proof`.
 
+## Relationship to Eyeling
+
+[Eyeling](https://github.com/eyereasoner/eyeling) and eyelang share the same goal of small, inspectable rule-based reasoning in JavaScript, but they make different language and implementation trade-offs.
+
+Eyeling is the RDF/Notation3 member of the family. It reads N3-style triples, quoted formulas, forward rules written with `=>`, backward rules written with `<=`, RDF terms, RDF-JS data, and RDF-oriented streams. That makes it the better fit when data interchange with RDF/N3 tools is the main requirement.
+
+eyelang is the compact Prolog-style member of the family. It uses ordinary predicate syntax such as `parent(alice, bob).` and `ancestor(X, Z) :- parent(X, Y), ancestor(Y, Z).` This keeps the core syntax close to the ISO-standardized Prolog tradition while deliberately staying much smaller than ISO Prolog. It is a good fit when the problem is naturally relational, goal-directed, finite, and does not need RDF graph interchange.
+
+A useful rule of thumb:
+
+| Use case | Prefer | Why |
+| --- | --- | --- |
+| RDF/N3 data, triples, prefixes, graph terms, RDF-JS, RDF message streams | Eyeling | The surface language and APIs are RDF/Notation3-native. |
+| Compact relational rules over ordinary terms, lists, arithmetic, and finite search | eyelang | The syntax is shorter for non-RDF relation programs and output is ordinary facts. |
+| Human-auditable derivations | Either | Both can emit proof explanations when requested. |
+| Large generated Horn-clause workloads | eyelang | The engine specializes in predicate/arity indexing, scalar argument indexes, fast fact paths, and materialized output goals. |
+
+For the deep taxonomy benchmark, eyelang is substantially faster in current local checks. On one sandbox run, `node bin/eyelang examples/deep-taxonomy-100000.pl > /dev/null` took about `1.60 sec`, while `eyeling` package version `1.28.7` on `examples/deep-taxonomy-100000.n3` took about `4.56 sec` without proof and about `5.04 sec` with proof. Treat those numbers as a smoke comparison rather than a formal benchmark: hardware, Node.js version, package version, and CLI startup all matter.
+
+The projects are therefore complementary rather than replacements for each other: Eyeling optimizes for Semantic Web interoperability and N3 expressiveness; eyelang optimizes for a small standard-looking relational rule language and fast finite goal-directed execution.
+
 ## Performance notes
 
 Use `-s` or `--stats` for a quick sanity check while optimizing solver changes. It prints counters such as `solve_goals_calls`, `unify_calls`, `deterministic_rule_expansions`, `candidate_lists_selected`, `clause_candidates_considered`, `clauses_tried`, `max_depth`, and `max_solver_call_depth` to stderr, leaving normal output stable for golden-file tests. The `max_solver_call_depth` counter is especially useful for browser regressions, where the VM call stack can be tighter than a command-line run.
@@ -536,4 +628,4 @@ For large programs, keep helper predicates selective, bind arguments early, and
 
 ## Implementation limits
 
-eyelang is intentionally smaller than ISO Prolog. It has no operators, cut, modules, dynamic database updates, DCGs, or complete ISO library. Negation is negation-as-failure through `not/1`. Search is goal-directed and expected to be finite for the selected output goals. Output explanations are non-normative proof printouts and do not change answer semantics.
+eyelang is intentionally smaller than ISO Prolog. It has no operators, cut, modules, dynamic database updates, DCGs, or complete ISO library. Negation is negation-as-failure through `not/1`. Search is goal-directed and expected to be finite for the selected output goals. Output explanations are non-normative proof printouts and do not change answer semantics. The RDF 1.2 / Notation3 reader is an implementation compatibility layer over `rdf/3`, not a normative RDF conformance profile.

package/SPEC.md

@@ -470,7 +470,7 @@ 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 Sudoku solving, portfolio selection, number-theory algorithms, graph search, matrix operations, or alphametic puzzles. 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 extension modules for Sudoku solving, portfolio selection, number-theory algorithms, graph search, matrix operations, alphametic puzzles, or a non-normative RDF/Notation3 reader that lowers RDF triples to ordinary eyelang predicates such as `rdf/3` and lowers selected Notation3 built-in predicates to extension built-ins such as `n3_math_sum/2` or `n3_string_contains/2`. Those modules may be valuable and may make example programs much faster, but their predicate names, arities, algorithms, syntax accepted by non-eyelang readers, 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.
 
@@ -680,3 +680,5 @@ status(a, open) :- open(a).
 URL input uses host networking support when available. Hosts SHOULD treat downloaded programs as untrusted code because they can trigger expensive search.
 
 Programs SHOULD be written with finite search in mind. Broad default materialization can be expensive for helper predicates; use `materialize/2` declarations and concise output predicates when needed.
+
+Compatibility readers for external syntaxes such as RDF 1.2 Turtle, N-Triples, or Notation3 SHOULD be treated as front-end translations into eyelang clauses. Such readers may support N3 implication syntaxes such as `=>` and `<=`, empty `true` rule bodies, N3 equality as `owl:sameAs`, and common N3/SWAP built-in namespaces mapped to host extension built-ins, including exact integer arithmetic where the host provides it. Unless a host explicitly claims a separate RDF or N3 conformance profile, such readers are not part of core eyelang conformance and may accept only the subset that maps cleanly to finite Horn-clause reasoning.

package/examples/annotation-rdf12.ttl

@@ -0,0 +1,12 @@
+# Inspired by eyereasoner/eyeling examples/annotation.n3.
+# Demonstrates RDF 1.2 annotation syntax lowered through rdf:reifies.
+VERSION "1.2"
+PREFIX : <http://example.org/annotation#>
+PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+
+:a :name "Alice" ~ :t {| :statedBy :bob ; :recorded "2021-07-07"^^xsd:date |} .
+
+{ ?Statement rdf:reifies <<( ?Person :name ?Name )>> .
+  ?Statement :statedBy ?Agent . }
+=>
+{ ?Person :nameStatementBy ?Agent . } .

package/examples/directional-language.ttl

@@ -0,0 +1,9 @@
+# RDF 1.2 directional language-tagged string example.
+VERSION "1.2"
+PREFIX : <http://example.org/lang#>
+
+:greeting :label "שלום"@he--rtl .
+
+{ ?Thing :label ?Text . }
+=>
+{ ?Thing :hasDirectionalLabel true . } .

package/examples/eyeling-ackermann.n3

@@ -0,0 +1,41 @@
+# Adapted from eyeling/examples/ackermann.n3.
+# Demonstrates <= rules over RDF lists and exact BigInt-capable math builtins.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/ackermann#>.
+
+# ackermann(x, y) = hyper(x, y + 3, 2) - 3.
+{ (?X ?Y) :ackermann ?A } <= {
+  (?Y 3) math:sum ?B.
+  (?X ?B 2) :ackermann ?C.
+  (?C 3) math:difference ?A.
+}.
+
+# Successor, addition, multiplication, and exponentiation levels.
+{ (0 ?Y ?Z) :ackermann ?A } <= { (?Y 1) math:sum ?A }.
+{ (1 ?Y ?Z) :ackermann ?A } <= { (?Y ?Z) math:sum ?A }.
+{ (2 ?Y ?Z) :ackermann ?A } <= { (?Y ?Z) math:product ?A }.
+{ (3 ?Y ?Z) :ackermann ?A } <= { (?Z ?Y) math:exponentiation ?A }.
+
+# Tetration and higher hyperoperations.
+{ (?X 0 ?Z) :ackermann 1 } <= { ?X math:greaterThan 3 }.
+{ (?X ?Y ?Z) :ackermann ?A } <= {
+  ?X math:greaterThan 3.
+  ?Y math:notEqualTo 0.
+  (?Y 1) math:difference ?B.
+  (?X ?B ?Z) :ackermann ?C.
+  (?X 1) math:difference ?D.
+  (?D ?C ?Z) :ackermann ?A.
+}.
+
+{ (0 0) :ackermann ?A } => { :ackermann_0_0 :value ?A }.
+{ (0 6) :ackermann ?A } => { :ackermann_0_6 :value ?A }.
+{ (1 2) :ackermann ?A } => { :ackermann_1_2 :value ?A }.
+{ (1 7) :ackermann ?A } => { :ackermann_1_7 :value ?A }.
+{ (2 2) :ackermann ?A } => { :ackermann_2_2 :value ?A }.
+{ (2 9) :ackermann ?A } => { :ackermann_2_9 :value ?A }.
+{ (3 4) :ackermann ?A } => { :ackermann_3_4 :value ?A }.
+{ (3 1000) :ackermann ?A } => { :ackermann_3_1000 :value ?A }.
+{ (4 0) :ackermann ?A } => { :ackermann_4_0 :value ?A }.
+{ (4 1) :ackermann ?A } => { :ackermann_4_1 :value ?A }.
+{ (4 2) :ackermann ?A } => { :ackermann_4_2 :value ?A }.
+{ (5 0) :ackermann ?A } => { :ackermann_5_0 :value ?A }.

package/examples/eyeling-age-threshold.n3

@@ -0,0 +1,12 @@
+# Adapted from eyeling/examples/age.n3.
+# Classifies people against age thresholds using N3 math builtins.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/age#>.
+
+:alice :age 23.
+:bob :age 17.
+:carol :age 65.
+
+{ ?P :age ?A. ?A math:notLessThan 18. } => { ?P :adult true. }.
+{ ?P :age ?A. ?A math:notLessThan 65. } => { ?P :senior true. }.
+{ ?P :adult true. ?P :senior true. } => { ?P :discount :seniorPass. }.

package/examples/eyeling-alignment-demo.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/alignment-demo.n3.
+# Simple vocabulary alignment using owl:sameAs and an explicit transfer rule.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
+@prefix schema: <https://schema.org/>.
+@prefix ex: <https://example.org/ns#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+ex:label = schema:name.
+:alice ex:label "Alice".
+
+{ ?p owl:sameAs ?q. ?s ?p ?o. } => { ?s ?q ?o. }.

package/examples/eyeling-allen-interval-calculus-small.n3

@@ -0,0 +1,13 @@
+# Adapted from eyeling/examples/allen-interval-calculus.n3.
+# Classifies a few interval relations with math comparisons.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/allen#>.
+
+:a :start 1; :end 3.
+:b :start 3; :end 5.
+:c :start 4; :end 8.
+:d :start 1; :end 8.
+
+{ ?X :end ?XE. ?Y :start ?YS. ?XE math:equalTo ?YS. } => { (?X ?Y) :allen :meets. }.
+{ ?X :start ?XS; :end ?XE. ?Y :start ?YS; :end ?YE. ?XS math:lessThan ?YS. ?XE math:greaterThan ?YS. ?XE math:lessThan ?YE. } => { (?X ?Y) :allen :overlaps. }.
+{ ?X :start ?XS; :end ?XE. ?Y :start ?YS; :end ?YE. ?XS math:equalTo ?YS. ?XE math:lessThan ?YE. } => { (?X ?Y) :allen :starts. }.

package/examples/eyeling-backward-recursion.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/backward-recursion.n3.
+# Demonstrates recursive <= rules.
+@prefix : <urn:example#>.
+
+:a :parent :b.
+:b :parent :c.
+:c :parent :d.
+
+{ ?x :ancestor ?y } <= { ?x :parent ?y }.
+{ ?x :ancestor ?z } <= { ?x :parent ?y. ?y :ancestor ?z }.
+{ :a :ancestor ?who } => { :a :reaches ?who }.

package/examples/eyeling-backward.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling/examples/backward.n3.
+# Backward rule example: <= acts like a :- rule over N3 triples.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+# something is more interesting if it is greater
+{ ?X :moreInterestingThan ?Y. } <= { ?X math:greaterThan ?Y. }.
+
+# derivation (forward)
+{ 5 :moreInterestingThan 3. } => { 5 :isIndeedMoreInterestingThan 3. }.

package/examples/eyeling-basic-monadic-small.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/basic-monadic.n3.
+# A tiny monadic propagation benchmark.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/basic-monadic#>.
+
+:i0 a :N0.
+:i1 a :N0.
+:i2 a :N1.
+
+{ ?X a :N0. } => { ?X a :N1. }.
+{ ?X a :N1. } => { ?X a :N2. }.
+{ ?X a :N2. } => { ?X :accepted true. }.

package/examples/eyeling-bmi.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling/examples/bmi.n3.
+# Computes BMI from mass and squared height using math builtins.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:alice :massKg 72;
+       :heightM 1.8.
+
+{ ?P :heightM ?H. (?H 2) math:exponentiation ?H2. } => { ?P :heightSquared ?H2. }.
+{ ?P :massKg ?M. ?P :heightSquared ?H2. (?M ?H2) math:quotient ?BMI. } => { ?P :bmi ?BMI. }.

package/examples/eyeling-cat-koko.n3

@@ -0,0 +1,15 @@
+# Adapted from eyeling/examples/cat-koko.n3.
+# The original derives nested rules; this version keeps the animal split and log:notEqualTo test.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:Koko a :Animal.
+
+{ :Koko a :Animal. } => {
+  :catKoko a :Cat.
+  :britishKoko a :BritishShortHair.
+}.
+
+{ ?X a :Cat. ?Y a :BritishShortHair. ?X log:notEqualTo ?Y. } => {
+  :test :is true.
+}.

package/examples/eyeling-collatz-small.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/collatz-1000.n3.
+# A small, bounded Collatz step demonstration.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/collatz#>.
+
+:case6 :value 6.
+:case7 :value 7.
+
+{ ?C :value ?N. (?N 2) math:remainder 0. (?N 2) math:integerQuotient ?M. } => { ?C :next ?M. }.
+{ ?C :value ?N. (?N 2) math:remainder 1. (?N 3) math:product ?T. (?T 1) math:sum ?M. } => { ?C :next ?M. }.
+{ ?C :next ?N. ?N math:greaterThan 10. } => { ?C :jumpsAboveTen true. }.

package/examples/eyeling-collection.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/collection.n3.
+# Shows N3/RDF collections in subject and object positions.
+@prefix list: <http://www.w3.org/2000/10/swap/list#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/collection#>.
+
+(1 _:b2 (2)) :p2 :q2.
+_:b2 :p :q.
+
+{ (1 _:b2 (2)) list:length ?Length. } => {
+  :collection :length ?Length.
+}.

package/examples/eyeling-complex-arithmetic.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling/examples/complex.n3.
+# Computes complex addition on pair-shaped RDF collections.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/complex#>.
+
+:z1 :cartesian (3 4).
+:z2 :cartesian (5 -2).
+
+{ ?A :cartesian (?AR ?AI). ?B :cartesian (?BR ?BI). (?AR ?BR) math:sum ?RR. (?AI ?BI) math:sum ?RI. } => { (?A ?B) :sum (?RR ?RI). }.
+{ (:z1 :z2) :sum ?Z. } => { :example :complexSum ?Z. }.

package/examples/eyeling-context-association.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/context-association.n3.
+# Associates named contexts with facts and derives their subjects.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/context-association#>.
+
+:ctx1 :contains :fact1.
+:ctx2 :contains :fact2.
+:fact1 :subject :alice; :predicate :likes; :object :tea.
+:fact2 :subject :bob; :predicate :likes; :object :coffee.
+
+{ ?C :contains ?F. ?F :subject ?S. } => { ?C :mentions ?S. }.
+{ ?C :mentions ?S. } => { ?S :mentionedIn ?C. }.

package/examples/eyeling-control-system-small.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/control-system.n3.
+# Flags control measurements outside a safe envelope.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/control-system#>.
+
+:loop1 :target 100; :actual 103; :tolerance 5.
+:loop2 :target 100; :actual 111; :tolerance 5.
+
+{ ?L :target ?T; :actual ?A. (?A ?T) math:difference ?D. ?D math:absoluteValue ?Abs. } => { ?L :absoluteError ?Abs. }.
+{ ?L :absoluteError ?E; :tolerance ?Tol. ?E math:notGreaterThan ?Tol. } => { ?L :status :ok. }.
+{ ?L :absoluteError ?E; :tolerance ?Tol. ?E math:greaterThan ?Tol. } => { ?L :status :alarm. }.

package/examples/eyeling-crypto-builtins-extra.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling/examples/crypto-builtins-tests.n3.
+# Extra digest checks beyond the compact builtins demo.
+@prefix crypto: <http://www.w3.org/2000/10/swap/crypto#>.
+@prefix string: <http://www.w3.org/2000/10/swap/string#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/crypto-extra#>.
+
+:payload :text "eyelang".
+
+{ :payload :text ?T. ?T crypto:sha256 ?H. ?H string:length ?L. } => { :payload :sha256Length ?L; :sha256 ?H. }.
+{ :payload :sha256Length 64. } => { :payload :hashLooksComplete true. }.

package/examples/eyeling-crypto-builtins.n3

@@ -0,0 +1,8 @@
+# Inspired by eyeling/examples/crypto-builtins-tests.n3.
+@prefix crypto: <http://www.w3.org/2000/10/swap/crypto#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:payload :text "eyelang".
+
+{ :payload :text ?Text. ?Text crypto:sha256 ?Digest. } => { :payload :sha256 ?Digest. }.
+{ :payload :text ?Text. ?Text crypto:md5 ?Digest. } => { :payload :md5 ?Digest. }.

package/examples/eyeling-deep-taxonomy-10.n3

@@ -0,0 +1,18 @@
+# Adapted from eyeling/examples/deep-taxonomy-10.n3.
+# Depth-10 classification chain.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/deep-taxonomy-10#>.
+
+:ind a :N0.
+
+{ ?X a :N0. } => { ?X a :N1, :I1, :J1. }.
+{ ?X a :N1. } => { ?X a :N2, :I2, :J2. }.
+{ ?X a :N2. } => { ?X a :N3, :I3, :J3. }.
+{ ?X a :N3. } => { ?X a :N4, :I4, :J4. }.
+{ ?X a :N4. } => { ?X a :N5, :I5, :J5. }.
+{ ?X a :N5. } => { ?X a :N6, :I6, :J6. }.
+{ ?X a :N6. } => { ?X a :N7, :I7, :J7. }.
+{ ?X a :N7. } => { ?X a :N8, :I8, :J8. }.
+{ ?X a :N8. } => { ?X a :N9, :I9, :J9. }.
+{ ?X a :N9. } => { ?X a :N10, :I10, :J10. }.
+{ ?X a :N10. } => { ?X a :A2. }.
+{ :ind a :A2. } => { :test :is true. }.

package/examples/eyeling-derived-backward-rule-flat.n3

@@ -0,0 +1,10 @@
+# Adapted from eyeling/examples/derived-backward-rule.n3.
+# Demonstrates an inverse-property rule without nested-rule materialization.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/derived-backward-rule#>.
+
+:parentOf :invOf :childOf.
+:alice :parentOf :bob.
+:claire :parentOf :diana.
+
+{ ?P :invOf ?Q. ?Y ?P ?X. } => { ?X ?Q ?Y. }.
+{ ?X :childOf ?Y. } => { ?X :hasParent ?Y. }.

package/examples/eyeling-derived-rule-flat.n3

@@ -0,0 +1,9 @@
+# Adapted from eyeling/examples/derived-rule.n3.
+# eyelang's N3 layer does not materialize nested rules yet, so this is a flat equivalent.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/derived-rule#>.
+
+:Minka a :Cat.
+:Charly a :Dog.
+
+{ ?X a :Cat. ?Y a :Dog. } => { :test :is true. }.
+{ ?X a :Cat. ?Y a :Dog. } => { ?X :compatibleWith ?Y. }.

package/examples/eyeling-digital-product-passport-small.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/digital-product-passport.n3.
+# Simple product passport conformance rules.
+@prefix string: <http://www.w3.org/2000/10/swap/string#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/digital-product-passport#>.
+
+:bike1 :serial "EU-BIKE-001"; :batteryId "BAT-77"; :recycledContent "32%".
+:toy1 :serial "TOY-9"; :batteryId ""; :recycledContent "0%".
+
+{ ?P :serial ?S. ?S string:startsWith "EU-". } => { ?P :hasEuSerial true. }.
+{ ?P :batteryId ?B. ?B string:startsWith "BAT-". } => { ?P :hasBatteryPassport true. }.
+{ ?P :hasEuSerial true. ?P :hasBatteryPassport true. } => { ?P :passportStatus :ready. }.

package/examples/eyeling-dijkstra-tiny.n3

@@ -0,0 +1,14 @@
+# Adapted from eyeling/examples/dijkstra.n3.
+# Tiny weighted path expansion without aggregate minimization.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/dijkstra#>.
+
+:e1 :from :a; :to :b; :cost 2.
+:e2 :from :a; :to :c; :cost 5.
+:e3 :from :b; :to :c; :cost 1.
+:e4 :from :b; :to :d; :cost 4.
+:e5 :from :c; :to :d; :cost 1.
+
+{ ?E :from ?S; :to ?O; :cost ?C. } => { (?S ?O) :pathCost ?C. }.
+{ (?S ?M) :pathCost ?C1. ?E :from ?M; :to ?O; :cost ?C2. (?C1 ?C2) math:sum ?CT. } => { (?S ?O) :pathCost ?CT. }.
+{ (:a :d) :pathCost ?C. ?C math:notGreaterThan 6. } => { :route :candidateCost ?C. }.

package/examples/eyeling-dog-license.n3

@@ -0,0 +1,13 @@
+# Adapted from eyeling/examples/dog.n3.
+# The original uses log:collectAllIn; this compatibility example supplies the count directly.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:alice :hasDog :dog1, :dog2, :dog3, :dog4, :dog5;
+       :dogCount 5.
+:bob :hasDog :dog6, :dog7;
+     :dogCount 2.
+
+{ ?Subject :dogCount ?Count. ?Count math:greaterThan 4. } => {
+  ?Subject :mustHave :dogLicense.
+}.

package/examples/eyeling-drone-corridor-planner-small.n3

@@ -0,0 +1,13 @@
+# Adapted from eyeling/examples/drone-corridor-planner.n3.
+# Finds allowed drone corridor hops under wind limits.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/drone-corridor#>.
+
+:c1 :from :dock; :to :tower; :wind 12.
+:c2 :from :tower; :to :field; :wind 18.
+:c3 :from :dock; :to :field; :wind 25.
+:policy :maxWind 20.
+
+{ ?C :from ?A; :to ?B; :wind ?W. :policy :maxWind ?M. ?W math:notGreaterThan ?M. } => { ?C :allowed true. }.
+{ ?C :allowed true; :from ?A; :to ?B. } => { ?A :canFlyTo ?B. }.
+{ :dock :canFlyTo :tower. :tower :canFlyTo :field. } => { :mission :hasTwoHopRoute true. }.

package/examples/eyeling-equals.n3

@@ -0,0 +1,8 @@
+# Adapted from eyeling/examples/equals.n3.
+# N3 '=' is lowered to owl:sameAs.
+@prefix owl: <http://www.w3.org/2002/07/owl#>.
+@prefix : <http://example.org/socrates#>.
+
+:X = :Y.
+
+{ :X owl:sameAs :Y. } => { :test :is true. }.

package/examples/eyeling-equivalence-classes.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/equivalence-classes-overlap-implies-same-class.n3.
+# If two class sets share a member, they are linked as the same class.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/equivalence-classes#>.
+
+:classA :member :alice, :bob.
+:classB :member :bob, :carol.
+:classC :member :diana.
+
+{ ?C1 :member ?X. ?C2 :member ?X. ?C1 log:notEqualTo ?C2. } => { ?C1 :sameClassAs ?C2. }.
+{ ?C1 :sameClassAs ?C2. } => { ?C2 :sameClassAs ?C1. }.

package/examples/eyeling-euler-identity.n3

@@ -0,0 +1,9 @@
+# Adapted from eyeling/examples/euler-identity.n3.
+# Numeric trigonometric builtins around pi.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/euler-identity#>.
+
+:pi :radians 3.141592653589793.
+
+{ :pi :radians ?P. ?P math:cos ?C. ?P math:sin ?S. } => { :euler :cosPi ?C; :sinPi ?S. }.
+{ :euler :cosPi ?C. ?C math:notGreaterThan -1. } => { :euler :cosPiAtMinusOne true. }.

package/examples/eyeling-existential-rule.n3

@@ -0,0 +1,9 @@
+# Adapted from eyeling/examples/existential-rule.n3.
+# Uses explicit blank-node witnesses in the rule head.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/existential-rule#>.
+
+:Socrates a :Human.
+:Plato a :Human.
+
+{ ?S a :Human. } => { ?S :hasNature _:humanNature. }.
+{ ?S :hasNature _:humanNature. } => { ?S :witnessed true. }.

package/examples/eyeling-expression-eval.n3

@@ -0,0 +1,11 @@
+# Adapted from eyeling/examples/expression-eval.n3.
+# Evaluates a small expression tree using arithmetic builtins.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix : <https://eyereasoner.github.io/eyeling/examples/expression-eval#>.
+
+:e1 :op :add; :left 2; :right 3.
+:e2 :op :mul; :left :e1; :right 4.
+
+{ ?E :op :add; :left ?A; :right ?B. (?A ?B) math:sum ?V. } => { ?E :value ?V. }.
+{ ?E :op :mul; :left ?L; :right ?B. ?L :value ?A. (?A ?B) math:product ?V. } => { ?E :value ?V. }.
+{ :e2 :value ?V. } => { :answer :value ?V. }.

package/examples/eyeling-family-cousins-extended.n3

@@ -0,0 +1,12 @@
+# Adapted from eyeling/examples/family-cousins.n3.
+@prefix log: <http://www.w3.org/2000/10/swap/log#>.
+@prefix : <https://eyereasoner.github.io/ns#>.
+
+:alice :parentOf :bob, :carol.
+:bob :parentOf :dave.
+:carol :parentOf :erin.
+:erin :parentOf :fay.
+
+{ ?p :parentOf ?x. ?p :parentOf ?y. ?x log:notEqualTo ?y. } => { ?x :siblingOf ?y. }.
+{ ?a :parentOf ?x. ?b :parentOf ?y. ?a :siblingOf ?b. ?x log:notEqualTo ?y. } => { ?x :cousinOf ?y. }.
+{ ?x :cousinOf ?y. } => { ?x :relatedTo ?y. }.