eyeling 1.24.0 → 1.24.2

package/HANDBOOK.md

@@ -36,6 +36,7 @@
 - [Appendix I — The Eyeling Playground](#app-i)
 - [Appendix J — Formalism Is Fine](#app-j)
 - [Appendix K — Whitehead-inspired becoming examples](#app-k)
+- [Appendix L — SEE: Specialized Eyeling Executables](#app-l)
 
 ---
 
@@ -236,6 +237,20 @@ The lexer turns the input into tokens like:
 
 Parsing becomes dramatically simpler because tokenization already decided where strings end, where numbers are, and so on.
 
+One compatibility wrinkle is handled in the lexer before normal parsing: RDF 1.2 triple terms written as `<<( s p o )>>` are accepted and normalized to Eyeling's existing singleton quoted-formula term `{ s p o }`. A leading `VERSION "1.2"` or `@version "1.2"` directive is ignored for the same reason. This keeps Eyeling's N3 model stable while allowing small RDF 1.2 triple-term inputs to run through the existing `GraphTerm` machinery. For example:
+
+```n3
+:observation rdf:reifies <<( :sensor :reports :overheating )>> .
+```
+
+is treated internally like:
+
+```n3
+:observation rdf:reifies { :sensor :reports :overheating } .
+```
+
+This is intentionally a compatibility translation, not a new full RDF 1.2 parser layer. Nested or more exotic future triple-term forms should be added only if they can be mapped cleanly onto Eyeling's quoted-formula term model.
+
 ### 4.2 Parsing triples, with Turtle-style convenience
 
 The parser supports:
@@ -2561,6 +2576,8 @@ Quoted graphs/formulas use `{ ... }`. Inside a quoted formula, directive scope m
 
 - `@prefix/@base` and `PREFIX/BASE` directives may appear at top level **or inside `{ ... }`**, and apply to the formula they occur in (formula-local scoping).
 
+Eyeling also accepts the RDF 1.2 triple-term surface form `<<( s p o )>>` as a compatibility spelling for a singleton quoted formula `{ s p o }`. This is useful for inputs that use `rdf:reifies` or other predicates whose objects are RDF 1.2 triple terms, while keeping the rest of Eyeling on its N3 formula-term model.
+
 For the formal grammar, see the N3 spec grammar:
 
 - [https://w3c.github.io/N3/spec/#grammar](https://w3c.github.io/N3/spec/#grammar)
@@ -3794,3 +3811,84 @@ The becoming examples should therefore be read as **executable schemata** rather
 For the handbook, these examples matter for two reasons. First, they provide a concrete demonstration that Eyeling can handle a style of reasoning that feels closer to **becoming, development, and transformation** than to static classification. Second, they show how expressive gains can come from modeling choices rather than from adding new machinery to the engine. The same forward-chaining core that proves `:Socrates a :Mortal` can also prove that a lineage becomes evolvable, that a controller becomes approved, or that a wake switch becomes serviceable under a low-bias regime.
 
 That is why this appendix belongs after Appendix J. “Formalism is fine” not only because it supports rigor, but because it can remain flexible enough to describe worlds in motion. The becoming examples are small demonstrations of that claim. They show that a compact N3 reasoner can host process-oriented models without ceasing to be simple, readable, and executable.
+
+---
+
+<a id="app-l"></a>
+
+## Appendix L — SEE: Specialized Eyeling Executables
+
+SEE, **Specialized Eyeling Executables**, is the companion example system under `see/`. It compiles selected Eyeling-style N3 programs into small, standalone JavaScript runners. The goal is not to replace the main reasoner. The goal is to turn a particular reasoning task into an executable artifact that carries its input evidence, derivation logic, entailment, explanation, and reference output together.
+
+The short mental model is:
+
+```text
+N3 source + TriG evidence -> specialized JavaScript -> entailment + explanation
+```
+
+### L.1 Why SEE exists
+
+The normal Eyeling CLI is a general reasoner: it parses an input file, runs the engine, and prints the resulting closure, selected query output, or rendered `log:outputString` report.
+
+SEE is narrower and more packageable. For each committed example, `see.js` generates:
+
+- `see/examples/<name>.js` — a runnable JavaScript derivation program,
+- `see/examples/input/<name>.trig` — the RDF/TriG evidence read by the runner,
+- `see/examples/output/<name>.md` — the expected Markdown result,
+- `see/examples/doc/<name>.md` — a short generated explanation of the compiled example.
+
+That makes each example easier to audit. A reviewer can inspect the source N3, the generated runner, the input evidence, and the expected entailment/explanation without reconstructing the whole test setup.
+
+### L.2 Entailment plus explanation
+
+SEE reports use an **Entailment** section and an **Explanation** section. The entailment is the selected result of the reasoning task. The explanation records how the compiled runner reached it: source facts, rules, selected support trees, and the formal TriG output when relevant.
+
+This vocabulary is deliberately more precise than a generic “result”. It says: the program is not merely presenting a suggestion; it is presenting something that follows from the encoded facts, rules, gates, and query projection.
+
+### L.3 Direct TriG input
+
+Generated SEE runners read their committed `.trig` input directly. Earlier versions used an intermediate `.n3` conversion step, but the current design keeps the evidence in TriG and lets the runner parse that committed input. This matters for examples that are closer to RDF data exchange than to hand-written N3 rule files.
+
+SEE also includes a triple-term example. Its input can contain RDF 1.2 triple terms such as:
+
+```trig
+VERSION "1.2"
+
+:observation rdf:reifies <<( :sensor :reports :overheating )>> .
+```
+
+Eyeling accepts this surface form by translating the triple term to a singleton quoted formula internally:
+
+```n3
+:observation rdf:reifies { :sensor :reports :overheating } .
+```
+
+That is enough for the SEE example to demonstrate RDF 1.2-style triple terms as input and output without forcing Eyeling to implement a separate full RDF 1.2 syntax model.
+
+### L.4 Generation and tests
+
+The root package scripts treat SEE as part of the normal repository workflow:
+
+```bash
+npm run generate
+npm run test:see
+```
+
+`npm run generate` refreshes the generated SEE artifacts from `see/examples/n3/*.n3`. `npm run test:see` runs every generated SEE example and compares its Markdown output with the committed reference output.
+
+In the full test suite, this means SEE is not just documentation. It is executable regression coverage for a broad range of Eyeling behavior: forward rules, backward rules, builtins, fuses, queries, RDF lists, formula-valued terms, generated explanations, and RDF 1.2 triple-term compatibility.
+
+### L.5 When to add a SEE example
+
+A normal Eyeling example is best when you want to demonstrate a language feature or a compact reasoning pattern directly in N3.
+
+A SEE example is best when you want a more self-contained artifact:
+
+- the input evidence matters,
+- the final entailment should be explained in Markdown,
+- the example should be runnable without an external reasoner at runtime,
+- the generated JavaScript itself is worth inspecting,
+- or the example should become stable regression coverage for a specific reasoning workflow.
+
+In that sense, SEE is an executable publication format for selected Eyeling examples: small enough to read, deterministic enough to test, and explicit enough to audit.
+

package/README.md

@@ -14,7 +14,7 @@ echo '@prefix : <http://example.org/> .
 
 ## Read more
 
-- **Handbook:** [eyereasoner.github.io/eyeling/HANDBOOK](https://eyereasoner.github.io/eyeling/HANDBOOK)
-- **Playground:** [eyereasoner.github.io/eyeling/demo](https://eyereasoner.github.io/eyeling/demo)
-- **SEE:** [Specialized Eyeling Executables](see/README.md) — compiled Notation3 examples as standalone JavaScript runners.
-- **Conformance report:** [codeberg.org/phochste/notation3tests/.../report.md](https://codeberg.org/phochste/notation3tests/src/branch/main/reports/report.md)
+- [Handbook](https://eyereasoner.github.io/eyeling/HANDBOOK)
+- [Playground](https://eyereasoner.github.io/eyeling/demo)
+- [SEE: Specialized Eyeling Executables](https://github.com/eyereasoner/eyeling/tree/main/see)
+- [Conformance report](https://codeberg.org/phochste/notation3tests/src/branch/main/reports/report.md)

package/dist/browser/eyeling.browser.js

@@ -9555,7 +9555,110 @@ function stripQuotes(lex) {
   return lex;
 }
 
+
+// RDF 1.2 triple terms use <<( s p o )>>. Eyeling's N3 engine does not
+// implement a new RDF 1.2 term kind; instead, it accepts this syntax as a
+// compatibility surface and normalizes it to the existing N3 singleton quoted
+// graph term { s p o }. This keeps ordinary N3 reasoning unchanged while making
+// RDF 1.2 examples parseable by the current engine.
+function normalizeRdf12TripleTerms(inputText) {
+  const text = String(inputText ?? '');
+  let i = 0;
+
+  function startsAt(needle, at = i) {
+    return text.startsWith(needle, at);
+  }
+
+  function readString() {
+    const quote = text[i];
+    let out = quote;
+    const long = text.startsWith(quote.repeat(3), i);
+    if (long) {
+      out = quote.repeat(3);
+      i += 3;
+      while (i < text.length) {
+        if (text.startsWith(quote.repeat(3), i)) {
+          out += quote.repeat(3);
+          i += 3;
+          return out;
+        }
+        if (text[i] === '\\' && i + 1 < text.length) {
+          out += text.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += text[i++];
+        }
+      }
+      return out;
+    }
+    i += 1;
+    let escaped = false;
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+    }
+    return out;
+  }
+
+  function readIri() {
+    let out = text[i++];
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (ch === '>') break;
+    }
+    return out;
+  }
+
+  function convertUntil(stopToken) {
+    let out = '';
+    while (i < text.length) {
+      if (stopToken && startsAt(stopToken)) {
+        i += stopToken.length;
+        return out;
+      }
+      if (startsAt('<<(')) {
+        i += 3;
+        out += '{ ' + convertUntil(')>>').trim() + ' }';
+        continue;
+      }
+      const ch = text[i];
+      if (ch === '"' || ch === "'") {
+        out += readString();
+        continue;
+      }
+      if (ch === '<') {
+        out += readIri();
+        continue;
+      }
+      if (ch === '#') {
+        while (i < text.length) {
+          const c = text[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        continue;
+      }
+      out += ch;
+      i += 1;
+    }
+    if (stopToken) throw new N3SyntaxError(`Unterminated RDF 1.2 triple term, expected ${stopToken}`);
+    return out;
+  }
+
+  const converted = convertUntil(null);
+  return converted.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+}
+
 function lex(inputText) {
+  inputText = normalizeRdf12TripleTerms(inputText);
   const chars = Array.from(inputText);
   const n = chars.length;
   let i = 0;

package/eyeling.js

@@ -9555,7 +9555,110 @@ function stripQuotes(lex) {
   return lex;
 }
 
+
+// RDF 1.2 triple terms use <<( s p o )>>. Eyeling's N3 engine does not
+// implement a new RDF 1.2 term kind; instead, it accepts this syntax as a
+// compatibility surface and normalizes it to the existing N3 singleton quoted
+// graph term { s p o }. This keeps ordinary N3 reasoning unchanged while making
+// RDF 1.2 examples parseable by the current engine.
+function normalizeRdf12TripleTerms(inputText) {
+  const text = String(inputText ?? '');
+  let i = 0;
+
+  function startsAt(needle, at = i) {
+    return text.startsWith(needle, at);
+  }
+
+  function readString() {
+    const quote = text[i];
+    let out = quote;
+    const long = text.startsWith(quote.repeat(3), i);
+    if (long) {
+      out = quote.repeat(3);
+      i += 3;
+      while (i < text.length) {
+        if (text.startsWith(quote.repeat(3), i)) {
+          out += quote.repeat(3);
+          i += 3;
+          return out;
+        }
+        if (text[i] === '\\' && i + 1 < text.length) {
+          out += text.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += text[i++];
+        }
+      }
+      return out;
+    }
+    i += 1;
+    let escaped = false;
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+    }
+    return out;
+  }
+
+  function readIri() {
+    let out = text[i++];
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (ch === '>') break;
+    }
+    return out;
+  }
+
+  function convertUntil(stopToken) {
+    let out = '';
+    while (i < text.length) {
+      if (stopToken && startsAt(stopToken)) {
+        i += stopToken.length;
+        return out;
+      }
+      if (startsAt('<<(')) {
+        i += 3;
+        out += '{ ' + convertUntil(')>>').trim() + ' }';
+        continue;
+      }
+      const ch = text[i];
+      if (ch === '"' || ch === "'") {
+        out += readString();
+        continue;
+      }
+      if (ch === '<') {
+        out += readIri();
+        continue;
+      }
+      if (ch === '#') {
+        while (i < text.length) {
+          const c = text[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        continue;
+      }
+      out += ch;
+      i += 1;
+    }
+    if (stopToken) throw new N3SyntaxError(`Unterminated RDF 1.2 triple term, expected ${stopToken}`);
+    return out;
+  }
+
+  const converted = convertUntil(null);
+  return converted.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+}
+
 function lex(inputText) {
+  inputText = normalizeRdf12TripleTerms(inputText);
   const chars = Array.from(inputText);
   const n = chars.length;
   let i = 0;

package/lib/lexer.js

@@ -347,7 +347,110 @@ function stripQuotes(lex) {
   return lex;
 }
 
+
+// RDF 1.2 triple terms use <<( s p o )>>. Eyeling's N3 engine does not
+// implement a new RDF 1.2 term kind; instead, it accepts this syntax as a
+// compatibility surface and normalizes it to the existing N3 singleton quoted
+// graph term { s p o }. This keeps ordinary N3 reasoning unchanged while making
+// RDF 1.2 examples parseable by the current engine.
+function normalizeRdf12TripleTerms(inputText) {
+  const text = String(inputText ?? '');
+  let i = 0;
+
+  function startsAt(needle, at = i) {
+    return text.startsWith(needle, at);
+  }
+
+  function readString() {
+    const quote = text[i];
+    let out = quote;
+    const long = text.startsWith(quote.repeat(3), i);
+    if (long) {
+      out = quote.repeat(3);
+      i += 3;
+      while (i < text.length) {
+        if (text.startsWith(quote.repeat(3), i)) {
+          out += quote.repeat(3);
+          i += 3;
+          return out;
+        }
+        if (text[i] === '\\' && i + 1 < text.length) {
+          out += text.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += text[i++];
+        }
+      }
+      return out;
+    }
+    i += 1;
+    let escaped = false;
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+    }
+    return out;
+  }
+
+  function readIri() {
+    let out = text[i++];
+    while (i < text.length) {
+      const ch = text[i++];
+      out += ch;
+      if (ch === '>') break;
+    }
+    return out;
+  }
+
+  function convertUntil(stopToken) {
+    let out = '';
+    while (i < text.length) {
+      if (stopToken && startsAt(stopToken)) {
+        i += stopToken.length;
+        return out;
+      }
+      if (startsAt('<<(')) {
+        i += 3;
+        out += '{ ' + convertUntil(')>>').trim() + ' }';
+        continue;
+      }
+      const ch = text[i];
+      if (ch === '"' || ch === "'") {
+        out += readString();
+        continue;
+      }
+      if (ch === '<') {
+        out += readIri();
+        continue;
+      }
+      if (ch === '#') {
+        while (i < text.length) {
+          const c = text[i++];
+          out += c;
+          if (c === '\n' || c === '\r') break;
+        }
+        continue;
+      }
+      out += ch;
+      i += 1;
+    }
+    if (stopToken) throw new N3SyntaxError(`Unterminated RDF 1.2 triple term, expected ${stopToken}`);
+    return out;
+  }
+
+  const converted = convertUntil(null);
+  return converted.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+}
+
 function lex(inputText) {
+  inputText = normalizeRdf12TripleTerms(inputText);
   const chars = Array.from(inputText);
   const n = chars.length;
   let i = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.24.0",
+  "version": "1.24.2",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/see/README.md

@@ -5,20 +5,21 @@
 SEE (**Specialized Eyeling Executables**) is a small compiler and example suite for turning Eyeling-style Notation3 programs into specialized JavaScript executables with human-readable explanations.
 
 ```text
-input facts -> rules -> trust gate -> insight + explanation
+input facts -> rules -> trust gate -> entailment + explanation
 ```
 
 Each example starts from a Notation3 source and is compiled by `see.js` into a small Node.js program:
 
 - `examples/n3/<name>.n3` contains the N3 facts, rules, gates, and query.
 - `examples/input/<name>.trig` contains the formal RDF 1.2 TriG input evidence read by the runner.
-- `examples/<name>.js` is generated by `see.js` and derives the insight.
+- `examples/<name>.js` is generated by `see.js` and derives the entailment.
 - `examples/output/<name>.md` is the reference Markdown output used by `npm run test:see`.
 - `examples/doc/<name>.md` explains the compiled example.
 
-The trust gate is executable verification. If a required fact is missing, the program fails instead of emitting an unsupported insight.
+The trust gate is executable verification. If a required fact is missing, the program fails instead of emitting an unsupported entailment.
+
+The `triple_terms` example uses RDF 1.2 `<<( ... )>>` triple-term syntax. Eyeling accepts that syntax by normalizing it to the existing N3 singleton graph term `{ ... }`; SEE keeps the committed `.trig` input and formal output in RDF 1.2 triple-term form.
 
-SEE was largely inspired by Prof. Ruben Verborgh's essay [Inside the Insight Economy](https://ruben.verborgh.org/blog/2025/08/12/inside-the-insight-economy/).
 
 ## Run
 
@@ -72,7 +73,7 @@ Validate that the source is inside the supported compiler subset:
 node see/see.js inspect path/to/example.n3
 ```
 
-The compiler currently supports ordinary triples, semicolon/comma property lists, RDF lists, blank nodes, variable predicates, formula-valued conclusions, forward rules, recursive backward rules (`<=`), top-level `log:query`, `=> false` fuses, and a broad native builtin registry for Eyeling-style `math:`, `string:`, `list:`, `crypto:`, `time:`, and `log:` predicates. The compiled JavaScript covers multi-solution predicates such as `list:member`, `list:in`, `list:iterate`, `list:memberAt`, and `list:map`, plus relation-like reverse modes such as `math:exponentiation`, unary trig/degree relations, `list:reverse`, and `list:append` splitting. Offline dereferencing/parsing builtins (`log:content`, `log:semantics`, `log:semanticsOrError`, `log:parsedAsN3`) fail explicitly in compiled SEE examples instead of doing network or parser work at runtime. Unsupported constructs fail rather than jumping directly to a prewritten `log:outputString`. When no authored `log:outputString` report is derived, the compiled runner still emits a SEE-style report with just **Insight** and **Explanation** sections instead of dumping the whole graph; supporting facts are folded into the explanation, including concise support trees that trace selected conclusions back to source facts when the compiler has rule-premise evidence available.
+The compiler currently supports ordinary triples, semicolon/comma property lists, RDF lists, blank nodes, variable predicates, formula-valued conclusions, forward rules, recursive backward rules (`<=`), top-level `log:query`, `=> false` fuses, and a broad native builtin registry for Eyeling-style `math:`, `string:`, `list:`, `crypto:`, `time:`, and `log:` predicates. The compiled JavaScript covers multi-solution predicates such as `list:member`, `list:in`, `list:iterate`, `list:memberAt`, and `list:map`, plus relation-like reverse modes such as `math:exponentiation`, unary trig/degree relations, `list:reverse`, and `list:append` splitting. Offline dereferencing/parsing builtins (`log:content`, `log:semantics`, `log:semanticsOrError`, `log:parsedAsN3`) fail explicitly in compiled SEE examples instead of doing network or parser work at runtime. Unsupported constructs fail rather than jumping directly to a prewritten `log:outputString`. When no authored `log:outputString` report is derived, the compiled runner still emits a SEE-style report with just **Entailment** and **Explanation** sections instead of dumping the whole graph; supporting facts are folded into the explanation, including concise support trees that trace selected entailments back to source facts when the compiler has rule-premise evidence available.
 
 ## Files
 
@@ -81,7 +82,7 @@ examples/
   <name>.js             executable example
   _see.js               shared helper
   input/<name>.trig     formal RDF 1.2 TriG evidence
-  output/<name>.md      reference insight and explanation
+  output/<name>.md      reference entailment and explanation
   doc/<name>.md         guide
   n3/<name>.n3          Notation3 source
 ```
@@ -103,7 +104,7 @@ The repository currently contains **50 N3-compiled SEE examples**. Each example
 | <a id="example-bmi"></a>[BMI](#example-bmi) | compiled from Notation3 by `see.js`; unit normalization, BMI category selection, and healthy-weight range validations are derived from N3 rules. | [doc](examples/doc/bmi.md), [js](examples/bmi.js), [input](examples/input/bmi.trig), [output](examples/output/bmi.md), [n3](examples/n3/bmi.n3) |
 | <a id="example-builtin-coverage-smoke"></a>[Builtin coverage smoke](#example-builtin-coverage-smoke) | compiled from Notation3 by `see.js`; smoke test for compiled math, string, list, crypto, time, and log builtins. | [doc](examples/doc/builtin_coverage.md), [js](examples/builtin_coverage.js), [input](examples/input/builtin_coverage.trig), [output](examples/output/builtin_coverage.md), [n3](examples/n3/builtin_coverage.n3) |
 | <a id="example-collection"></a>[Collection](#example-collection) | compiled from Notation3 by `see.js`; RDF collection/list data with a blank node inside the list. | [doc](examples/doc/collection.md), [js](examples/collection.js), [input](examples/input/collection.trig), [output](examples/output/collection.md), [n3](examples/n3/collection.n3) |
-| <a id="example-complex-numbers"></a>[Complex numbers](#example-complex-numbers) | compiled from Notation3 by `see.js`; complex arithmetic rules and formula-valued conclusion. | [doc](examples/doc/complex.md), [js](examples/complex.js), [input](examples/input/complex.trig), [output](examples/output/complex.md), [n3](examples/n3/complex.n3) |
+| <a id="example-complex-numbers"></a>[Complex numbers](#example-complex-numbers) | compiled from Notation3 by `see.js`; complex arithmetic rules and formula-valued entailment. | [doc](examples/doc/complex.md), [js](examples/complex.js), [input](examples/input/complex.trig), [output](examples/output/complex.md), [n3](examples/n3/complex.n3) |
 | <a id="example-complex-matrix-stability"></a>[Complex matrix stability](#example-complex-matrix-stability) | compiled from Notation3 by `see.js`; diagonal 2x2 complex matrices are classified from squared eigenvalue moduli, with complex product and scaling validations. | [doc](examples/doc/complex_matrix_stability.md), [js](examples/complex_matrix_stability.js), [input](examples/input/complex_matrix_stability.trig), [output](examples/output/complex_matrix_stability.md), [n3](examples/n3/complex_matrix_stability.n3) |
 | <a id="example-composition-of-injective-functions"></a>[Composition of injective functions](#example-composition-of-injective-functions) | compiled from Notation3 by `see.js`; proof-style rules show that the composition of injective functions is injective. | [doc](examples/doc/composition_of_injective_functions_is_injective.md), [js](examples/composition_of_injective_functions_is_injective.js), [input](examples/input/composition_of_injective_functions_is_injective.trig), [output](examples/output/composition_of_injective_functions_is_injective.md), [n3](examples/n3/composition_of_injective_functions_is_injective.n3) |
 | <a id="example-control-system"></a>[Control system](#example-control-system) | compiled from Notation3 by `see.js`; compact EYE-style sensor, disturbance, and target facts derive two actuator commands. | [doc](examples/doc/control_system.md), [js](examples/control_system.js), [input](examples/input/control_system.trig), [output](examples/output/control_system.md), [n3](examples/n3/control_system.n3) |
@@ -111,8 +112,8 @@ The repository currently contains **50 N3-compiled SEE examples**. Each example
 | <a id="example-dijkstra-shortest-path"></a>[Dijkstra shortest path](#example-dijkstra-shortest-path) | compiled from Notation3 by `see.js`; list, collection, sorting, and recursive backward rules derive the shortest path from `:a` to `:f`. | [doc](examples/doc/dijkstra.md), [js](examples/dijkstra.js), [input](examples/input/dijkstra.trig), [output](examples/output/dijkstra.md), [n3](examples/n3/dijkstra.n3) |
 | <a id="example-dijkstra-risk-path"></a>[Dijkstra risk path](#example-dijkstra-risk-path) | compiled from Notation3 by `see.js`; risk-adjusted route selection derives the best path from edge costs, route risk, and threshold rules. | [doc](examples/doc/dijkstra_risk_path.md), [js](examples/dijkstra_risk_path.js), [input](examples/input/dijkstra_risk_path.trig), [output](examples/output/dijkstra_risk_path.md), [n3](examples/n3/dijkstra_risk_path.n3) |
 | <a id="example-dog-license-example"></a>[Dog license example](#example-dog-license-example) | compiled from Notation3 by `see.js`; `log:collectAllIn` and `math:sum` derive that a multi-dog household needs a license. | [doc](examples/doc/dog.md), [js](examples/dog.js), [input](examples/input/dog.trig), [output](examples/output/dog.md), [n3](examples/n3/dog.n3) |
-| <a id="example-eco-route-insight"></a>[Eco route insight](#example-eco-route-insight) | compiled from Notation3 by `see.js`; privacy-preserving route evidence derives an eco-route recommendation with signed-envelope explanation data. | [doc](examples/doc/eco_route_insight.md), [js](examples/eco_route_insight.js), [input](examples/input/eco_route_insight.trig), [output](examples/output/eco_route_insight.md), [n3](examples/n3/eco_route_insight.n3) |
-| <a id="example-delfour"></a>[Delfour](#example-delfour) | compiled from Notation3 by `see.js`; scoped insight-policy facts, cryptographic hash validation, and product rules authorize a lower-sugar scanner recommendation. | [doc](examples/doc/delfour.md), [js](examples/delfour.js), [input](examples/input/delfour.trig), [output](examples/output/delfour.md), [n3](examples/n3/delfour.n3) |
+| <a id="example-eco-route-insight"></a>[Eco route entailment](#example-eco-route-insight) | compiled from Notation3 by `see.js`; privacy-preserving route evidence derives an eco-route recommendation with signed-envelope explanation data. | [doc](examples/doc/eco_route_insight.md), [js](examples/eco_route_insight.js), [input](examples/input/eco_route_insight.trig), [output](examples/output/eco_route_insight.md), [n3](examples/n3/eco_route_insight.n3) |
+| <a id="example-delfour"></a>[Delfour](#example-delfour) | compiled from Notation3 by `see.js`; scoped policy facts, cryptographic hash validation, and product rules authorize a lower-sugar scanner recommendation. | [doc](examples/doc/delfour.md), [js](examples/delfour.js), [input](examples/input/delfour.trig), [output](examples/output/delfour.md), [n3](examples/n3/delfour.n3) |
 | <a id="example-digital-product-passport"></a>[Digital product passport](#example-digital-product-passport) | compiled from Notation3 by `see.js`; component, document, access-policy, and footprint facts fold into a public passport PASS decision. | [doc](examples/doc/digital_product_passport.md), [js](examples/digital_product_passport.js), [input](examples/input/digital_product_passport.trig), [output](examples/output/digital_product_passport.md), [n3](examples/n3/digital_product_passport.n3) |
 | <a id="example-equals-test"></a>[Equals test](#example-equals-test) | compiled from Notation3 by `see.js`; N3 `=` / `owl:sameAs` shorthand compiled into a normal derivation. | [doc](examples/doc/equals.md), [js](examples/equals.js), [input](examples/input/equals.trig), [output](examples/output/equals.md), [n3](examples/n3/equals.n3) |
 | <a id="example-equivalence-class-overlap"></a>[Equivalence class overlap](#example-equivalence-class-overlap) | compiled from Notation3 by `see.js`; equivalence-relation closure proves overlapping equivalence classes are the same class. | [doc](examples/doc/equivalence_classes_overlap_implies_same_class.md), [js](examples/equivalence_classes_overlap_implies_same_class.js), [input](examples/input/equivalence_classes_overlap_implies_same_class.trig), [output](examples/output/equivalence_classes_overlap_implies_same_class.md), [n3](examples/n3/equivalence_classes_overlap_implies_same_class.n3) |
@@ -127,7 +128,7 @@ The repository currently contains **50 N3-compiled SEE examples**. Each example
 | <a id="example-fundamental-theorem-arithmetic"></a>[Fundamental theorem arithmetic](#example-fundamental-theorem-arithmetic) | compiled from Notation3 by `see.js`; primary factorization is validated by product reconstruction, reverse-order sorting, and prime witnesses, with sample summaries retained as data. | [doc](examples/doc/fundamental_theorem_arithmetic.md), [js](examples/fundamental_theorem_arithmetic.js), [input](examples/input/fundamental_theorem_arithmetic.trig), [output](examples/output/fundamental_theorem_arithmetic.md), [n3](examples/n3/fundamental_theorem_arithmetic.n3) |
 | <a id="example-genetic-knapsack-selection"></a>[Genetic knapsack selection](#example-genetic-knapsack-selection) | compiled from Notation3 by `see.js`; deterministic one-bit mutation candidates are scored against knapsack capacity and value constraints. | [doc](examples/doc/genetic_knapsack_selection.md), [js](examples/genetic_knapsack_selection.js), [input](examples/input/genetic_knapsack_selection.trig), [output](examples/output/genetic_knapsack_selection.md), [n3](examples/n3/genetic_knapsack_selection.n3) |
 | <a id="example-goldbach-1000"></a>[Goldbach 1000](#example-goldbach-1000) | compiled from Notation3 by `see.js`; bounded Goldbach run data is validated through representative prime-sum witnesses and a zero-counterexample condition. | [doc](examples/doc/goldbach_1000.md), [js](examples/goldbach_1000.js), [input](examples/input/goldbach_1000.trig), [output](examples/output/goldbach_1000.md), [n3](examples/n3/goldbach_1000.n3) |
-| <a id="example-good-cobbler"></a>[Good cobbler](#example-good-cobbler) | compiled from Notation3 by `see.js`; term-logic-style list pattern and formula-valued conclusion. | [doc](examples/doc/good_cobbler.md), [js](examples/good_cobbler.js), [input](examples/input/good_cobbler.trig), [output](examples/output/good_cobbler.md), [n3](examples/n3/good_cobbler.n3) |
+| <a id="example-good-cobbler"></a>[Good cobbler](#example-good-cobbler) | compiled from Notation3 by `see.js`; term-logic-style list pattern and formula-valued entailment. | [doc](examples/doc/good_cobbler.md), [js](examples/good_cobbler.js), [input](examples/input/good_cobbler.trig), [output](examples/output/good_cobbler.md), [n3](examples/n3/good_cobbler.n3) |
 | <a id="example-gps-route-planning"></a>[GPS route planning](#example-gps-route-planning) | compiled from Notation3 by `see.js`; recursive path rules compare western-Belgium routes by duration, cost, belief, and comfort. | [doc](examples/doc/gps.md), [js](examples/gps.js), [input](examples/input/gps.trig), [output](examples/output/gps.md), [n3](examples/n3/gps.n3) |
 | <a id="example-gray-code-counter"></a>[Gray code counter](#example-gray-code-counter) | compiled from Notation3 by `see.js`; a 4-bit reflected Gray-code cycle is validated as a complete one-bit-transition sequence. | [doc](examples/doc/gray_code_counter.md), [js](examples/gray_code_counter.js), [input](examples/input/gray_code_counter.trig), [output](examples/output/gray_code_counter.md), [n3](examples/n3/gray_code_counter.n3) |
 | <a id="example-greatest-lower-bound-uniqueness"></a>[Greatest lower bound uniqueness](#example-greatest-lower-bound-uniqueness) | compiled from Notation3 by `see.js`; partial-order rules prove two greatest lower bounds of the same pair coincide. | [doc](examples/doc/greatest_lower_bound_uniqueness.md), [js](examples/greatest_lower_bound_uniqueness.js), [input](examples/input/greatest_lower_bound_uniqueness.trig), [output](examples/output/greatest_lower_bound_uniqueness.md), [n3](examples/n3/greatest_lower_bound_uniqueness.n3) |
@@ -142,5 +143,6 @@ The repository currently contains **50 N3-compiled SEE examples**. Each example
 | <a id="example-school-placement-route-audit"></a>[School placement route audit](#example-school-placement-route-audit) | compiled from Notation3 by `see.js`; student, school, distance, and policy facts derive an auditable school-placement route decision. | [doc](examples/doc/school_placement_audit.md), [js](examples/school_placement_audit.js), [input](examples/input/school_placement_audit.trig), [output](examples/output/school_placement_audit.md), [n3](examples/n3/school_placement_audit.n3) |
 | <a id="example-smoke-arithmetic"></a>[Smoke Arithmetic](#example-smoke-arithmetic) | compiled from Notation3 by `see.js`; arithmetic compiler smoke test deriving 6 × 7 through rules and builtins. | [doc](examples/doc/smoke_arithmetic.md), [js](examples/smoke_arithmetic.js), [input](examples/input/smoke_arithmetic.trig), [output](examples/output/smoke_arithmetic.md), [n3](examples/n3/smoke_arithmetic.n3) |
 | <a id="example-socrates-inference"></a>[Socrates inference](#example-socrates-inference) | compiled from Notation3 by `see.js`; subclass closure with top-level `log:query` projection. | [doc](examples/doc/socrates.md), [js](examples/socrates.js), [input](examples/input/socrates.trig), [output](examples/output/socrates.md), [n3](examples/n3/socrates.n3) |
+| <a id="example-triple-terms"></a>[Triple terms](#example-triple-terms) | compiled from Notation3 by `see.js`; RDF 1.2 TriG triple terms are used as input evidence and as a derived entailment. | [doc](examples/doc/triple_terms.md), [js](examples/triple_terms.js), [input](examples/input/triple_terms.trig), [output](examples/output/triple_terms.md), [n3](examples/n3/triple_terms.n3) |
 | <a id="example-wind-turbine-envelope"></a>[Wind turbine envelope](#example-wind-turbine-envelope) | compiled from Notation3 by `see.js`; wind-speed samples are classified against cut-in, rated, and cut-out thresholds and accumulated into energy. | [doc](examples/doc/wind_turbine.md), [js](examples/wind_turbine.js), [input](examples/input/wind_turbine.trig), [output](examples/output/wind_turbine.md), [n3](examples/n3/wind_turbine.n3) |
-| <a id="example-burn-the-witch"></a>[Burn the witch](#example-burn-the-witch) | compiled from Notation3 by `see.js`; rule-chain explanation for the witch conclusion. | [doc](examples/doc/witch.md), [js](examples/witch.js), [input](examples/input/witch.trig), [output](examples/output/witch.md), [n3](examples/n3/witch.n3) |
+| <a id="example-burn-the-witch"></a>[Burn the witch](#example-burn-the-witch) | compiled from Notation3 by `see.js`; rule-chain explanation for the witch entailment. | [doc](examples/doc/witch.md), [js](examples/witch.js), [input](examples/input/witch.trig), [output](examples/output/witch.md), [n3](examples/n3/witch.n3) |

package/see/examples/_see.js

@@ -7,11 +7,31 @@ function lit(value) { return { kind: 'lit', value }; }
 function blank(value) { return { kind: 'blank', value }; }
 function list(items) { return { kind: 'list', items }; }
 function formula(atoms) { return { kind: 'formula', atoms }; }
+function triple(s, p, o) { return { kind: 'triple', s, p, o }; }
 
 function readTermToken(text, start = 0) {
   let i = start;
   while (/\s/.test(text[i])) i += 1;
   const begin = i;
+  if (text.startsWith('<<(', i)) {
+    let depth = 0;
+    while (i < text.length) {
+      if (text[i] === '"') {
+        const [, next] = readTermToken(text, i);
+        i = next;
+        continue;
+      }
+      if (text.startsWith('<<(', i)) { depth += 1; i += 3; continue; }
+      if (text.startsWith(')>>', i)) {
+        depth -= 1;
+        i += 3;
+        if (depth === 0) break;
+        continue;
+      }
+      i += 1;
+    }
+    return [text.slice(begin, i), i];
+  }
   if (text[i] === '"') {
     i += 1;
     let escaped = false;
@@ -60,7 +80,10 @@ function splitListItems(text) {
     while (/\s/.test(text[i])) i += 1;
     if (i >= text.length) break;
     const start = i;
-    if (text[i] === '"') {
+    if (text.startsWith('<<(', i)) {
+      const [, next] = readTermToken(text, i);
+      i = next;
+    } else if (text[i] === '"') {
       i += 1;
       let escaped = false;
       while (i < text.length) {
@@ -83,9 +106,17 @@ function splitListItems(text) {
   }
   return out;
 }
+function parseTripleTermBody(text) {
+  const [s, i1] = readTermToken(text, 0);
+  const [p, i2] = readTermToken(text, i1);
+  const [o, i3] = readTermToken(text, i2);
+  if (!s || !p || !o || text.slice(i3).trim()) throw new Error('bad triple term: ' + text);
+  return triple(parseTerm(s), parseTerm(p), parseTerm(o));
+}
 function parseTerm(text) {
   const t = String(text || '').trim();
   if (!t) throw new Error('empty term');
+  if (t.startsWith('<<(') && t.endsWith(')>>')) return parseTripleTermBody(t.slice(3, -3).trim());
   const first = t[0];
   if (first === '"') return lit(JSON.parse(t));
   if (first === '(' && t[t.length - 1] === ')') return list(splitListItems(t.slice(1, -1)).map(parseTerm));
@@ -112,7 +143,7 @@ function parseInputTrigFast(trig) {
   const lines = String(trig || '').split(/\r?\n/);
   for (let i = 0; i < lines.length; i += 1) {
     const line = lines[i].trim();
-    if (!line || line.startsWith('#') || line.toLowerCase().startsWith('@prefix ')) continue;
+    if (!line || line.startsWith('#') || line.toLowerCase().startsWith('@prefix ') || /^(@version|version)\s+/i.test(line)) continue;
     const graphStart = line.match(/^(\S+)\s*\{\s*$/);
     if (graphStart) {
       const atoms = [];