eyeling 1.24.1 → 1.24.3

package/lib/cli.js

@@ -107,6 +107,7 @@ function main() {
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +
       `  -p, --proof-comments         Enable proof explanations.\n` +
+      `  -r, --rdf                    Enable RDF/TriG input/output compatibility.\n` +
       `  -s, --super-restricted       Disable all builtins except => and <=.\n` +
       `  -t, --stream                 Stream derived triples as soon as they are derived.\n` +
       `  -v, --version                Print version and exit.\n`;
@@ -148,6 +149,7 @@ function main() {
 
   const showAst = argv.includes('--ast') || argv.includes('-a');
   const streamMode = argv.includes('--stream') || argv.includes('-t');
+  const rdfMode = argv.includes('--rdf') || argv.includes('-r');
 
   // --enforce-https: rewrite http:// -> https:// for log dereferencing builtins
   if (argv.includes('--enforce-https') || argv.includes('-e')) {
@@ -210,6 +212,7 @@ function main() {
           label: sourceLabel,
           collectUsedPrefixes: true,
           keepSourceArtifacts: false,
+          rdf: rdfMode,
         }),
       );
     } catch (e) {
@@ -322,10 +325,10 @@ function main() {
       (df) => {
         if (engine.getProofCommentsEnabled()) {
           engine.printExplanation(df, outPrefixes);
-          console.log(engine.tripleToN3(df.fact, outPrefixes));
+          console.log(rdfMode ? engine.tripleToRdfCompatible(df.fact, outPrefixes) : engine.tripleToN3(df.fact, outPrefixes));
           console.log();
         } else {
-          console.log(engine.tripleToN3(df.fact, outPrefixes));
+          console.log(rdfMode ? engine.tripleToRdfCompatible(df.fact, outPrefixes) : engine.tripleToN3(df.fact, outPrefixes));
         }
       },
       { captureExplanations: engine.getProofCommentsEnabled(), prefixes: outPrefixes },
@@ -361,7 +364,24 @@ function main() {
     return;
   }
 
-  const usedPrefixes = prefixes.prefixesUsedForOutput(outTriples);
+  let bodyText = '';
+  if (rdfMode && !engine.getProofCommentsEnabled()) {
+    bodyText = outTriples.map((tr) => engine.tripleToRdfCompatible(tr, prefixes)).join('\n');
+  } else if (hasQueries && !engine.getProofCommentsEnabled()) {
+    // In log:query mode, when proof comments are disabled, pretty-print blank-node
+    // shaped outputs as Turtle property lists ("[ ... ] .") for readability.
+    bodyText = engine.prettyPrintQueryTriples(outTriples, prefixes);
+  }
+
+  let usedPrefixes = prefixes.prefixesUsedForOutput(outTriples);
+  if (rdfMode && bodyText) {
+    usedPrefixes = usedPrefixes.filter(([pfx]) => pfx === '' || bodyText.includes(pfx + ':'));
+  }
+
+  if (rdfMode && bodyText.includes('<<(')) {
+    console.log('VERSION "1.2"');
+    console.log();
+  }
 
   for (const [pfx, base] of usedPrefixes) {
     if (pfx === '') console.log(`@prefix : <${base}> .`);
@@ -369,21 +389,18 @@ function main() {
   }
   if (outTriples.length && usedPrefixes.length) console.log();
 
-  // In log:query mode, when proof comments are disabled, pretty-print blank-node
-  // shaped outputs as Turtle property lists ("[ ... ] .") for readability.
-  if (hasQueries && !engine.getProofCommentsEnabled()) {
-    const s = engine.prettyPrintQueryTriples(outTriples, prefixes);
-    if (s) process.stdout.write(String(s).replace(/\s*$/g, '') + '\n');
+  if (bodyText) {
+    process.stdout.write(String(bodyText).replace(/\s*$/g, '') + '\n');
     return;
   }
 
   for (const df of outDerived) {
     if (engine.getProofCommentsEnabled()) {
       engine.printExplanation(df, prefixes);
-      console.log(engine.tripleToN3(df.fact, prefixes));
+      console.log(rdfMode ? engine.tripleToRdfCompatible(df.fact, prefixes) : engine.tripleToN3(df.fact, prefixes));
       console.log();
     } else {
-      console.log(engine.tripleToN3(df.fact, prefixes));
+      console.log(rdfMode ? engine.tripleToRdfCompatible(df.fact, prefixes) : engine.tripleToN3(df.fact, prefixes));
     }
   }
 }

package/lib/engine.js

@@ -61,7 +61,12 @@ const {
 
 const { makeExplain } = require('./explain');
 
-const { termToN3, tripleToN3, prettyPrintQueryTriples } = require('./printing');
+const {
+  termToN3,
+  tripleToN3,
+  prettyPrintQueryTriples,
+  tripleToRdfCompatible,
+} = require('./printing');
 const {
   getDataFactory,
   internalTripleToRdfJsQuad,
@@ -3374,9 +3379,12 @@ function reasonStream(input, opts = {}) {
     dataFactory = null,
     skipUnsupportedRdfJs = false,
     builtinModules = null,
+    rdf = false,
   } = opts;
 
-  const parsedSourceList = parseN3SourceList(input, { baseIri });
+  const useRdfCompatibility = !!rdf;
+
+  const parsedSourceList = parseN3SourceList(input, { baseIri, rdf: useRdfCompatibility });
   const parsedInput = parsedSourceList || normalizeParsedReasonerInputSync(input);
   const rdfFactory = rdfjs ? getDataFactory(dataFactory) : null;
 
@@ -3412,7 +3420,7 @@ function reasonStream(input, opts = {}) {
     if (baseIri) prefixes.setBase(baseIri);
   } else {
     const n3Text = normalizeReasonerInputSync(input);
-    const toks = lex(n3Text);
+    const toks = lex(n3Text, { rdf: useRdfCompatibility });
     const parser = new Parser(toks);
     if (baseIri) parser.prefixes.setBase(baseIri);
 
@@ -3446,7 +3454,7 @@ function reasonStream(input, opts = {}) {
     // query-selected triples (not all derived facts).
     if (typeof onDerived === 'function') {
       for (const qdf of queryDerived) {
-        const payload = { triple: tripleToN3(qdf.fact, prefixes), df: qdf };
+        const payload = { triple: useRdfCompatibility ? tripleToRdfCompatible(qdf.fact, prefixes) : tripleToN3(qdf.fact, prefixes), df: qdf };
         if (rdfFactory) {
           const quad = maybeTripleToRdfJsQuad(qdf.fact, rdfFactory, skipUnsupportedRdfJs);
           if (quad) payload.quad = quad;
@@ -3463,7 +3471,7 @@ function reasonStream(input, opts = {}) {
       (df) => {
         if (typeof onDerived === 'function') {
           const payload = {
-            triple: tripleToN3(df.fact, prefixes),
+            triple: useRdfCompatibility ? tripleToRdfCompatible(df.fact, prefixes) : tripleToN3(df.fact, prefixes),
             df,
           };
           if (rdfFactory) {
@@ -3484,8 +3492,9 @@ function reasonStream(input, opts = {}) {
         ? facts
         : derived.map((d) => d.fact);
 
-  const closureN3 =
-    Array.isArray(logQueryRules) && logQueryRules.length && !proof
+  const closureN3 = useRdfCompatibility
+    ? closureTriples.map((t) => tripleToRdfCompatible(t, prefixes)).join('\n')
+    : Array.isArray(logQueryRules) && logQueryRules.length && !proof
       ? prettyPrintQueryTriples(closureTriples, prefixes)
       : closureTriples.map((t) => tripleToN3(t, prefixes)).join('\n');
 
@@ -3626,6 +3635,7 @@ module.exports = {
   printExplanation,
   // used by demo worker to stringify derived triples with prefixes
   tripleToN3,
+  tripleToRdfCompatible,
   // pretty log:query output (when proof comments are disabled)
   prettyPrintQueryTriples,
   getEnforceHttpsEnabled,

package/lib/lexer.js

@@ -347,7 +347,300 @@ function stripQuotes(lex) {
   return lex;
 }
 
-function lex(inputText) {
+
+// RDF/TriG compatibility is an opt-in syntax-normalization layer, not a new
+// reasoning model. Eyeling remains strict N3 by default and N3 internally:
+//   - RDF 1.2 triple terms <<( s p o )>> become singleton graph terms { s p o }.
+//   - TriG named graph blocks g { ... } become g log:nameOf { ... } .
+//   - A top-level default graph block { ... } is unwrapped into ordinary triples.
+// This mirrors tools/n3gen.js and keeps all downstream parsing/reasoning N3-only.
+const LOG_NAME_OF_IRI = '<http://www.w3.org/2000/10/swap/log#nameOf>';
+
+function normalizeRdfCompatibility(inputText) {
+  let text = String(inputText ?? '');
+
+  // Fast path: most Eyeling inputs are ordinary N3 and do not need RDF/TriG
+  // surface-syntax normalization. Avoid scanning large files character-by-character
+  // unless they actually contain RDF 1.2 triple terms, VERSION directives, or a
+  // plausible top-level TriG named graph block.
+  const hasTripleTerms = text.includes('<<(');
+  const hasVersionDirective = /^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/im.test(text);
+  const hasNamedGraphCandidate = /(?:^|[.\r\n])\s*(?:GRAPH\s+)?(?:<[^>\r\n]*>|_:[A-Za-z][A-Za-z0-9_-]*|[A-Za-z][A-Za-z0-9_-]*:[^\s{};,.()[\]]*)\s*\{/m.test(text);
+
+  if (!hasTripleTerms && !hasVersionDirective && !hasNamedGraphCandidate) return text;
+
+  function isWordChar(ch) {
+    return ch != null && /[A-Za-z0-9_:-]/.test(ch);
+  }
+
+  function startsWordAt(s, word, at) {
+    return s.startsWith(word, at) && !isWordChar(s[at - 1]) && !isWordChar(s[at + word.length]);
+  }
+
+  function readStringAt(s, at) {
+    const quote = s[at];
+    let i = at;
+    let out = quote;
+    const long = s.startsWith(quote.repeat(3), i);
+    if (long) {
+      out = quote.repeat(3);
+      i += 3;
+      while (i < s.length) {
+        if (s.startsWith(quote.repeat(3), i)) {
+          out += quote.repeat(3);
+          i += 3;
+          return { text: out, end: i };
+        }
+        if (s[i] === '\\' && i + 1 < s.length) {
+          out += s.slice(i, i + 2);
+          i += 2;
+        } else {
+          out += s[i++];
+        }
+      }
+      return { text: out, end: i };
+    }
+    i += 1;
+    let escaped = false;
+    while (i < s.length) {
+      const ch = s[i++];
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === '\\') {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+    }
+    return { text: out, end: i };
+  }
+
+  function readIriAt(s, at) {
+    let i = at + 1;
+    let out = '<';
+    while (i < s.length) {
+      const ch = s[i++];
+      out += ch;
+      if (ch === '>') break;
+    }
+    return { text: out, end: i };
+  }
+
+  function convertTripleTerms(s) {
+    let i = 0;
+
+    function startsAt(needle, at = i) {
+      return s.startsWith(needle, at);
+    }
+
+    function convertUntil(stopToken) {
+      let out = '';
+      while (i < s.length) {
+        if (stopToken && startsAt(stopToken)) {
+          i += stopToken.length;
+          return out;
+        }
+        if (startsAt('<<(')) {
+          i += 3;
+          out += '{ ' + convertUntil(')>>').trim() + ' }';
+          continue;
+        }
+        const ch = s[i];
+        if (ch === '"' || ch === "'") {
+          const str = readStringAt(s, i);
+          out += str.text;
+          i = str.end;
+          continue;
+        }
+        if (ch === '<') {
+          const iri = readIriAt(s, i);
+          out += iri.text;
+          i = iri.end;
+          continue;
+        }
+        if (ch === '#') {
+          while (i < s.length) {
+            const c = s[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;
+    }
+
+    return convertUntil(null);
+  }
+
+  function stripVersionDirectives(s) {
+    return s.replace(/^\s*(?:@version|VERSION)\s+(["'])1\.2\1\s*\.?\s*(?:#.*)?$/gim, '');
+  }
+
+  function skipWsAndComments(s, at) {
+    let i = at;
+    while (i < s.length) {
+      if (/\s/.test(s[i])) {
+        i += 1;
+        continue;
+      }
+      if (s[i] === '#') {
+        while (i < s.length && s[i] !== '\n' && s[i] !== '\r') i += 1;
+        continue;
+      }
+      break;
+    }
+    return i;
+  }
+
+  function readTermAt(s, at) {
+    if (s[at] === '<') return readIriAt(s, at);
+    let i = at;
+    while (i < s.length && !/\s/.test(s[i]) && !'{}[](),;.'.includes(s[i])) i += 1;
+    if (i === at) return null;
+    const value = s.slice(at, i);
+    if (!value || value.startsWith('@')) return null;
+    return { text: value, end: i };
+  }
+
+  function readBalancedBlock(s, at) {
+    if (s[at] !== '{') return null;
+    let i = at;
+    let depth = 0;
+    while (i < s.length) {
+      const ch = s[i];
+      if (ch === '"' || ch === "'") {
+        i = readStringAt(s, i).end;
+        continue;
+      }
+      if (ch === '<') {
+        i = readIriAt(s, i).end;
+        continue;
+      }
+      if (ch === '#') {
+        while (i < s.length && s[i] !== '\n' && s[i] !== '\r') i += 1;
+        continue;
+      }
+      if (ch === '{') depth += 1;
+      if (ch === '}') {
+        depth -= 1;
+        i += 1;
+        if (depth === 0) return { text: s.slice(at, i), inner: s.slice(at + 1, i - 1), end: i };
+        continue;
+      }
+      i += 1;
+    }
+    throw new N3SyntaxError('Unterminated RDF/TriG graph block, expected }');
+  }
+
+  function normalizeNamedGraphs(s) {
+    let out = '';
+    let i = 0;
+    let statementStart = true;
+    let braceDepth = 0;
+
+    while (i < s.length) {
+      if (statementStart && braceDepth === 0) {
+        const termStart = skipWsAndComments(s, i);
+        out += s.slice(i, termStart);
+        i = termStart;
+
+        // Top-level TriG default graph block: { ... } .
+        if (s[i] === '{') {
+          const block = readBalancedBlock(s, i);
+          const after = skipWsAndComments(s, block.end);
+          if (after >= s.length || s[after] === '.') {
+            out += block.inner.trim();
+            if (block.inner.trim() && !/\n$/.test(block.inner)) out += '\n';
+            i = after < s.length && s[after] === '.' ? after + 1 : after;
+            statementStart = true;
+            continue;
+          }
+          // It is an ordinary N3 formula subject, not a TriG default graph.
+          out += block.text;
+          i = block.end;
+          statementStart = false;
+          continue;
+        }
+
+        let graphKeyword = false;
+        if (startsWordAt(s, 'GRAPH', i)) {
+          graphKeyword = true;
+          i += 'GRAPH'.length;
+          i = skipWsAndComments(s, i);
+        }
+
+        const term = readTermAt(s, i);
+        if (term && !['@prefix', '@base', 'PREFIX', 'BASE', 'VERSION'].includes(term.text)) {
+          const afterTerm = skipWsAndComments(s, term.end);
+          if (s[afterTerm] === '{') {
+            const block = readBalancedBlock(s, afterTerm);
+            const afterBlock = skipWsAndComments(s, block.end);
+            out += `${term.text} ${LOG_NAME_OF_IRI} ${block.text} .`;
+            i = afterBlock < s.length && s[afterBlock] === '.' ? afterBlock + 1 : block.end;
+            statementStart = true;
+            continue;
+          }
+        }
+
+        // Not TriG named-graph syntax after all; copy the first character and
+        // continue as ordinary N3.
+        if (graphKeyword) {
+          out += 'GRAPH ';
+          statementStart = false;
+        } else if (i < s.length) {
+          const copied = s[i++];
+          out += copied;
+          if (!/\s/.test(copied)) statementStart = false;
+        }
+      } else {
+        const ch = s[i];
+        out += ch;
+        if (ch === '"' || ch === "'") {
+          const str = readStringAt(s, i);
+          out = out.slice(0, -1) + str.text;
+          i = str.end;
+          continue;
+        }
+        if (ch === '<') {
+          const iri = readIriAt(s, i);
+          out = out.slice(0, -1) + iri.text;
+          i = iri.end;
+          continue;
+        }
+        if (ch === '#') {
+          i += 1;
+          while (i < s.length) {
+            const c = s[i++];
+            out += c;
+            if (c === '\n' || c === '\r') break;
+          }
+          continue;
+        }
+        if (ch === '{') braceDepth += 1;
+        else if (ch === '}' && braceDepth > 0) braceDepth -= 1;
+        else if (ch === '.' && braceDepth === 0) statementStart = true;
+        else if (!/\s/.test(ch)) statementStart = false;
+        i += 1;
+      }
+    }
+
+    return out;
+  }
+
+  if (hasTripleTerms) text = convertTripleTerms(text);
+  if (hasVersionDirective) text = stripVersionDirectives(text);
+  if (hasVersionDirective || hasNamedGraphCandidate) text = normalizeNamedGraphs(text);
+  return text;
+}
+
+function lex(inputText, opts = {}) {
+  const rdf = !!(opts && opts.rdf);
+  if (rdf) inputText = normalizeRdfCompatibility(inputText);
   const chars = Array.from(inputText);
   const n = chars.length;
   let i = 0;
@@ -808,4 +1101,4 @@ function lex(inputText) {
   return tokens;
 }
 
-module.exports = { Token, N3SyntaxError, lex, decodeN3StringEscapes };
+module.exports = { Token, N3SyntaxError, lex, normalizeRdfCompatibility, decodeN3StringEscapes };

package/lib/multisource.js

@@ -103,8 +103,14 @@ function prefixesUsedInTokens(tokens, prefEnv) {
 }
 
 function parseN3Text(text, opts = {}) {
-  const { baseIri = '', label = '<input>', keepSourceArtifacts = true, collectUsedPrefixes = false } = opts || {};
-  const tokens = lex(text);
+  const {
+    baseIri = '',
+    label = '<input>',
+    keepSourceArtifacts = true,
+    collectUsedPrefixes = false,
+    rdf = false,
+  } = opts || {};
+  const tokens = lex(text, { rdf });
   const parser = new Parser(tokens);
   if (baseIri) parser.prefixes.setBase(baseIri);
   const [prefixes, triples, frules, brules, logQueryRules] = parser.parseDocument();
@@ -298,6 +304,7 @@ function parseN3SourceList(input, opts = {}) {
       baseIri: source.baseIri || (sources.length === 1 ? defaultBaseIri : ''),
       collectUsedPrefixes: true,
       keepSourceArtifacts: !!opts.keepSourceArtifacts,
+      rdf: !!opts.rdf,
     }),
   );
   return mergeParsedDocuments(parsed, {

package/lib/printing.js

@@ -21,6 +21,7 @@ const {
   isOwlSameAsPred,
   isLogImplies,
   isLogImpliedBy,
+  LOG_NS,
 } = require('./prelude');
 
 function stripQuotes(lex) {
@@ -350,4 +351,108 @@ function prettyPrintQueryTriples(triples, prefixes) {
   return blocks.join('\n');
 }
 
-module.exports = { termToN3, tripleToN3, prettyPrintQueryTriples };
+
+// ---------------------------------------------------------------------------
+// RDF compatibility output
+// ---------------------------------------------------------------------------
+
+function isRdfTripleTermSubject(t) {
+  return t instanceof Iri || t instanceof Blank;
+}
+
+function isRdfTripleTermPredicate(t) {
+  return t instanceof Iri;
+}
+
+function isRdfTripleTermObject(t) {
+  return t instanceof Iri || t instanceof Blank || t instanceof Literal;
+}
+
+function isRdfTripleTermGraph(t) {
+  if (!(t instanceof GraphTerm)) return false;
+  if (!Array.isArray(t.triples) || t.triples.length !== 1) return false;
+  const tr = t.triples[0];
+  return isRdfTripleTermSubject(tr.s) && isRdfTripleTermPredicate(tr.p) && isRdfTripleTermObject(tr.o);
+}
+
+
+function isLogNameOfPred(p) {
+  return p instanceof Iri && p.value === LOG_NS + 'nameOf';
+}
+
+function isRdfNamedGraphLabel(t) {
+  return t instanceof Iri || t instanceof Blank;
+}
+
+function rdfCompatibleGraphBlock(graph, prefixes) {
+  const indent = '    ';
+  const indentBlock = (str) =>
+    str
+      .split(/\r?\n/)
+      .map((ln) => (ln.length ? indent + ln : ln))
+      .join('\n');
+
+  let s = '{\n';
+  for (const inner of graph.triples || []) {
+    const block = tripleToRdfCompatible(inner, prefixes).trimEnd();
+    if (block) s += indentBlock(block) + '\n';
+  }
+  s += '}';
+  return s;
+}
+
+function rdfPredicateToText(p, prefixes) {
+  return isRdfTypePred(p) ? 'a' : termToN3(p, prefixes);
+}
+
+function termToRdfCompatible(t, pref) {
+  if (isRdfTripleTermGraph(t)) {
+    const tr = t.triples[0];
+    const s = termToN3(tr.s, pref);
+    const p = rdfPredicateToText(tr.p, pref);
+    const o = termToN3(tr.o, pref);
+    return `<<( ${s} ${p} ${o} )>>`;
+  }
+  return termToN3(t, pref);
+}
+
+function tripleToRdfCompatible(tr, prefixes) {
+  if (isLogNameOfPred(tr.p) && isRdfNamedGraphLabel(tr.s) && tr.o instanceof GraphTerm) {
+    return `${termToN3(tr.s, prefixes)} ${rdfCompatibleGraphBlock(tr.o, prefixes)}`;
+  }
+
+  if (isLogImplies(tr.p)) {
+    const s = termToRdfCompatible(tr.s, prefixes);
+    const o = termToRdfCompatible(tr.o, prefixes);
+    return `${s} => ${o} .`;
+  }
+
+  if (isLogImpliedBy(tr.p)) {
+    const s = termToRdfCompatible(tr.s, prefixes);
+    const o = termToRdfCompatible(tr.o, prefixes);
+    return `${s} <= ${o} .`;
+  }
+
+  const s = termToRdfCompatible(tr.s, prefixes);
+  const p = isRdfTypePred(tr.p) ? 'a' : isOwlSameAsPred(tr.p) ? '=' : termToN3(tr.p, prefixes);
+  const o = termToRdfCompatible(tr.o, prefixes);
+  return `${s} ${p} ${o} .`;
+}
+
+function prettyPrintQueryTriplesRdfCompatible(triples, prefixes) {
+  return triples.map((tr) => tripleToRdfCompatible(tr, prefixes)).join('\n');
+}
+
+function needsRdf12Version(text) {
+  return typeof text === 'string' && text.includes('<<(');
+}
+
+module.exports = {
+  termToN3,
+  tripleToN3,
+  prettyPrintQueryTriples,
+  termToRdfCompatible,
+  tripleToRdfCompatible,
+  prettyPrintQueryTriplesRdfCompatible,
+  needsRdf12Version,
+};

package/package.json

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

package/see/README.md

@@ -18,6 +18,8 @@ Each example starts from a Notation3 source and is compiled by `see.js` into a s
 
 The trust gate is executable verification. If a required fact is missing, the program fails instead of emitting an unsupported entailment.
 
+The `triple_terms` and `rdf_dataset` examples use RDF 1.2 `<<( ... )>>` triple-term syntax. Eyeling accepts that syntax only with `-r, --rdf`, where it normalizes triple terms to existing N3 singleton graph terms `{ ... }` and prints feasible output graph terms back as RDF 1.2 triple terms. The `rdf_dataset` example also uses an RDF/TriG named graph block, which RDF compatibility mode normalizes to the same `log:nameOf { ... }` graph-term shape emitted by `tools/n3gen` and prints back as a TriG named graph block where feasible; SEE keeps the committed `.trig` input and formal output in RDF 1.2/TriG form.
+
 
 ## Run
 
@@ -136,10 +138,12 @@ The repository currently contains **50 N3-compiled SEE examples**. Each example
 | <a id="example-odrl-dpv-risk-ranking"></a>[ODRL + DPV risk ranking](#example-odrl-dpv-risk-ranking) | compiled from Notation3 by `see.js`; policy and data-protection evidence are ranked by risk level and selected through rule-derived comparisons. | [doc](examples/doc/odrl_dpv_risk_ranked.md), [js](examples/odrl_dpv_risk_ranked.js), [input](examples/input/odrl_dpv_risk_ranked.trig), [output](examples/output/odrl_dpv_risk_ranked.md), [n3](examples/n3/odrl_dpv_risk_ranked.n3) |
 | <a id="example-path-discovery"></a>[Path discovery](#example-path-discovery) | compiled from the upstream path-discovery rules; the runner loads the full 96k-fact airroutes graph from TriG and evaluates the bounded route query with an indexed adjacency list. | [doc](examples/doc/path_discovery.md), [js](examples/path_discovery.js), [input](examples/input/path-discovery.trig), [output](examples/output/path_discovery.md), [n3](examples/n3/path_discovery.n3) |
 | <a id="example-rc-discharge-envelope"></a>[RC discharge envelope](#example-rc-discharge-envelope) | compiled from Notation3 by `see.js`; exponentiation over an upper decay bound certifies the first sampled capacitor step below tolerance. | [doc](examples/doc/rc_discharge_envelope.md), [js](examples/rc_discharge_envelope.js), [input](examples/input/rc_discharge_envelope.trig), [output](examples/output/rc_discharge_envelope.md), [n3](examples/n3/rc_discharge_envelope.n3) |
+| <a id="example-rdf-dataset-compatibility"></a>[RDF dataset compatibility](#example-rdf-dataset-compatibility) | compiled from Notation3 by `see.js`; RDF/TriG named graph input and RDF 1.2 triple terms demonstrate the same N3 graph-term normalization used by Eyeling's explicit RDF compatibility mode. | [doc](examples/doc/rdf_dataset.md), [js](examples/rdf_dataset.js), [input](examples/input/rdf_dataset.trig), [output](examples/output/rdf_dataset.md), [n3](examples/n3/rdf_dataset.n3) |
 | <a id="example-rdf-message-flow"></a>[RDF Message Flow](#example-rdf-message-flow) | compiled from Notation3 by `see.js`; live RDF Messages advance through ingest, validate, interpret, route, and sink stages, with each completed message releasing the next one. | [doc](examples/doc/rdf_message_flow.md), [js](examples/rdf_message_flow.js), [input](examples/input/rdf_message_flow.trig), [output](examples/output/rdf_message_flow.md), [n3](examples/n3/rdf_message_flow.n3) |
 | <a id="example-rdf-messages"></a>[RDF Messages](#example-rdf-messages) | compiled from Notation3 by `see.js`; ordered RDF Message Log example preserving explicit message boundaries, an empty heartbeat, message-local payloads, and reused blank-node labels. | [doc](examples/doc/rdf_messages.md), [js](examples/rdf_messages.js), [input](examples/input/rdf_messages.trig), [output](examples/output/rdf_messages.md), [n3](examples/n3/rdf_messages.n3) |
 | <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 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) |