eyeling 1.33.2 → 1.33.4

package/examples/eyelang/README.md

@@ -20,13 +20,12 @@ 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. [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)
+7. [Example catalog](#example-catalog)
+8. [Golden outputs, tests, and conformance](#golden-outputs-tests-and-conformance)
+9. [Development and release](#development-and-release)
+10. [Relationship to Eyeling](#relationship-to-eyeling)
+11. [Performance notes](#performance-notes)
+12. [Implementation limits](#implementation-limits)
 
 ## Quick start
 
@@ -316,69 +315,9 @@ 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.
+The repository includes examples for recursion, graph reachability, finite search, arithmetic, list processing, optimization, policies, puzzles, and applied scientific calculations. Bundled examples use relation-style output.
 
 | Input | Short description | Output |
 | --- | --- | --- |
@@ -391,7 +330,6 @@ 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) |
@@ -516,21 +454,18 @@ The repository includes examples for recursion, graph reachability, finite searc
 | [`turing.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/turing.pl) | Simulates a binary-increment Turing machine. | [`output/turing.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/turing.pl) |
 | [`vector-similarity.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/vector-similarity.pl) | Computes dot product, norm, and cosine similarity. | [`output/vector-similarity.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/vector-similarity.pl) |
 | [`vulnerability-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/vulnerability-impact.pl) | Analyzes vulnerable transitive dependencies and urgent patch impact. | [`output/vulnerability-impact.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/vulnerability-impact.pl) |
-| [`witch.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/witch.pl) | Derives the classic “burn the witch” N3 rule chain. | [`output/witch.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/witch.pl) |
+| [`witch.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/witch.pl) | Derives the classic “burn the witch” rule chain. | [`output/witch.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/witch.pl) |
 | [`wolf-goat-cabbage.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/wolf-goat-cabbage.pl) | Solves the wolf-goat-cabbage river crossing. | [`output/wolf-goat-cabbage.pl`](https://github.com/eyereasoner/eyelang/blob/main/examples/output/wolf-goat-cabbage.pl) |
 | [`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). `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:
+Golden answer outputs live in [`examples/output`](examples/output). `npm run test:examples` covers every top-level runnable `.pl` example. 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 examples/*.n3 examples/*.ttl examples/*.nt; do
+for f in examples/*.pl; do
   [ -e "$f" ] || continue
   b=$(basename "$f")
   EYELANG_LOCAL_TIME=2026-05-30 bin/eyelang "$f" > "examples/output/$b"
@@ -629,4 +564,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. The RDF 1.2 / Notation3 reader is an implementation compatibility layer over `rdf/3`, not a normative RDF conformance profile.
+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. 

package/examples/eyelang/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, 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.
+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.
 
 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.
 
@@ -681,4 +681,3 @@ URL input uses host networking support when available. Hosts SHOULD treat downlo
 
 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/eyelang.d.ts

@@ -6,7 +6,6 @@ export interface EyelangRunOptions {
   proof?: boolean;
   why?: boolean;
   explain?: boolean;
-  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
   [key: string]: unknown;
 }
 
@@ -32,14 +31,6 @@ export class Program {
 export function makeProgram(clauses?: unknown[], options?: EyelangRunOptions): Program;
 export function parseClauses(source: string, options?: EyelangRunOptions): unknown[];
 export function parseProgramText(source: string, options?: EyelangRunOptions): unknown[];
-export function parseRdfClauses(source: string, options?: EyelangRunOptions): unknown[];
-export function rdfToEyelang(source: string, options?: EyelangRunOptions): string;
-export function clausesToEyelang(clauses: unknown[]): string;
-export function rdfIri(value: string): unknown;
-export function rdfBlank(value: string): unknown;
-export function rdfLiteral(value: string, datatype?: string, language?: string): unknown;
-export function rdfTripleTerm(subject: unknown, predicate: unknown, object: unknown): unknown;
-export function rdfGoal(subject: unknown, predicate: unknown, object: unknown): unknown;
 
 export class Env {
   constructor(parent?: Env | null);
@@ -79,9 +70,6 @@ declare const eyelang: {
   makeProgram: typeof makeProgram;
   parseClauses: typeof parseClauses;
   parseProgramText: typeof parseProgramText;
-  parseRdfClauses: typeof parseRdfClauses;
-  rdfToEyelang: typeof rdfToEyelang;
-  clausesToEyelang: typeof clausesToEyelang;
   Solver: typeof Solver;
   Env: typeof Env;
   BuiltinRegistry: typeof BuiltinRegistry;

package/index.d.ts

@@ -98,10 +98,6 @@ export interface EyelangRunOptions {
   why?: boolean;
   explain?: boolean;
   stats?: boolean;
-  rdf?: boolean;
-  rdf12?: boolean;
-  n3?: boolean;
-  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
   args?: string[];
   maxBuffer?: number;
   [key: string]: unknown;

package/index.js

@@ -27,8 +27,7 @@ function normalizeEyelangSourceForTempFile(source) {
       typeof source.eyelang === 'string' ? source.eyelang
         : typeof source.prolog === 'string' ? source.prolog
           : typeof source.text === 'string' ? source.text
-            : typeof source.n3 === 'string' ? source.n3
-              : null;
+            : null;
     if (text !== null) return text;
   }
   throw new TypeError('reason({ engine: "eyelang" }, input): each source must be a string or an object with an eyelang/prolog/text field');
@@ -49,9 +48,6 @@ function reasonEyelangSync(opt = {}, input = '') {
 
   if (opt.proof || opt.why || opt.explain) args.push('--proof');
   if (opt.stats) args.push('--stats');
-  if (opt.rdf || opt.rdf12) args.push('--rdf');
-  if (opt.n3) args.push('--n3');
-  if (typeof opt.inputFormat === 'string' && opt.inputFormat) args.push('--input-format', opt.inputFormat);
   if (Array.isArray(opt.args)) args.push(...opt.args);
 
   const maxBuffer = Number.isFinite(opt.maxBuffer) ? opt.maxBuffer : 50 * 1024 * 1024;

package/lib/eyelang/builtins/registry.js

@@ -13,7 +13,6 @@ import { searchBuiltins } from './search.js';
 import { numberTheoryBuiltins } from './number-theory.js';
 import { matrixBuiltins } from './matrix.js';
 import { alphameticBuiltins } from './alphametic.js';
-import { n3Builtins } from './n3.js';
 
 export class BuiltinRegistry {
   constructor() {
@@ -40,7 +39,7 @@ export class BuiltinRegistry {
 
 export function createDefaultRegistry() {
   const registry = new BuiltinRegistry();
-  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, formulaBuiltins, controlBuiltins, sudokuBuiltins, portfolioBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins, alphameticBuiltins, n3Builtins]) {
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, formulaBuiltins, controlBuiltins, sudokuBuiltins, portfolioBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins, alphameticBuiltins]) {
     mod.register(registry);
   }
   return registry;

package/lib/eyelang/builtins/search.js

@@ -230,9 +230,9 @@ function undirectedGraph(program, predicate) {
 }
 
 function* fixedLengthCycle({ solver, goal, env }) {
-  // fixed_length_cycle(EdgePred, Length, Relation, Cycle) is useful for RDF-like
-  // edge(Source, Relation, Target) data. It enumerates closed walks of exactly
-  // Length steps and returns the relation label and node list.
+  // fixed_length_cycle(EdgePred, Length, Relation, Cycle) is useful for
+  // labelled edge(Source, Relation, Target) data. It enumerates closed walks
+  // of exactly Length steps and returns the relation label and node list.
   const predicate = atomKey(deref(goal.args[0], env));
   const length = intTerm(goal.args[1], env);
   if (!predicate || length == null || length < 0) return;

package/lib/eyelang/cli.js

@@ -18,7 +18,6 @@ export async function main(argv) {
     proof: false,
     stats: false,
     version: false,
-    inputFormat: 'auto',
   };
 
   let endOptions = false;
@@ -37,14 +36,6 @@ export async function main(argv) {
       options.proof = true;
     } else if (!endOptions && (arg === '--stats' || arg === '-s')) {
       options.stats = true;
-    } else if (!endOptions && (arg === '--rdf' || arg === '--rdf12')) {
-      options.inputFormat = 'rdf12';
-    } else if (!endOptions && arg === '--n3') {
-      options.inputFormat = 'n3';
-    } else if (!endOptions && arg === '--input-format') {
-      const value = argv[++i];
-      if (!value) throw new Error('--input-format needs a value');
-      options.inputFormat = value;
     } else if (!endOptions && arg.startsWith('-') && arg !== '-') {
       throw new Error(`unknown option: ${arg}`);
     } else {
@@ -79,7 +70,7 @@ export async function main(argv) {
   }
 
   const engine = await loadEngine();
-  const program = engine.Program.parseSources(sourceParts, { sourceMetadata: options.proof, markRecursive: options.proof, inputFormat: options.inputFormat });
+  const program = engine.Program.parseSources(sourceParts, { sourceMetadata: options.proof, markRecursive: options.proof });
 
   await runDefault(engine, program, options);
 }
@@ -152,9 +143,6 @@ Options:
   -h, --help            Show this help text and exit.
   -p, --proof           Enable proof explanations.
   -s, --stats           Print solver statistics to stderr after execution.
-  --rdf, --rdf12        Read input as RDF 1.2 Turtle/N-Triples compatibility syntax.
-  --n3                  Read input as Notation3 rule compatibility syntax.
-  --input-format FORMAT Use eyelang, auto, rdf12, turtle, nt, or n3.
   -v, --version         Show the package version and exit.
   --                    Stop option parsing; following arguments are treated as files.
 `);

package/lib/eyelang/hash.js

@@ -1,6 +1,6 @@
 // Small dependency-free hashing helpers shared by Node and browser builds.
-// They intentionally avoid node:crypto so src/index.js remains importable by the
-// browser playground when the N3 crypto builtins are registered.
+// They intentionally avoid node:crypto so src/index.js remains importable by
+// browser builds that register hashing builtins.
 
 const textEncoder = new TextEncoder();
 

package/lib/eyelang/index.js

@@ -2,7 +2,6 @@
 // The CLI imports the same parser, program, solver, and term primitives from here.
 export { Program, makeProgram } from './program.js';
 export { parseClauses, parseProgramText } from './parser.js';
-export { parseRdfClauses, rdfToEyelang, clausesToEyelang, rdfIri, rdfBlank, rdfLiteral, rdfTripleTerm, rdfGoal } from './rdf.js';
 export { Solver } from './solver.js';
 export * from './term.js';
 export { BuiltinRegistry, createDefaultRegistry, getDefaultRegistry } from './builtins/registry.js';

package/lib/eyelang/program.js

@@ -2,7 +2,6 @@
 // Indexes are deliberately conservative: they speed up common scalar arguments but never replace unification as the final check.
 import { ATOM, COMPOUND, Env, compound, deref, flattenConjunction, isScalar, termToString } from './term.js';
 import { parseClauses } from './parser.js';
-import { filenameLooksRdf, parseRdfClauses } from './rdf.js';
 
 export class Program {
   constructor(clauses = [], options = {}) {
@@ -234,11 +233,5 @@ export function makeProgram(source, options = {}) {
 }
 
 export function parseSourceClauses(source, options = {}) {
-  const inputFormat = (options.inputFormat ?? options.format ?? 'eyelang').toString().toLowerCase();
-  const filename = options.filename ?? '<input>';
-  const autoRdf = inputFormat === 'auto' && filenameLooksRdf(filename);
-  if (inputFormat === 'rdf' || inputFormat === 'rdf12' || inputFormat === 'n3' || inputFormat === 'turtle' || inputFormat === 'ttl' || inputFormat === 'nt' || autoRdf) {
-    return parseRdfClauses(source, options);
-  }
   return parseClauses(source, options);
 }

package/package.json

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

package/test/eyelang/run-examples.mjs

@@ -54,7 +54,7 @@ export function runExamples(reporter = new TestReporter()) {
 
 
 function exampleIsRunnable(name) {
-  return name.endsWith('.pl') || name.endsWith('.n3') || name.endsWith('.ttl') || name.endsWith('.nt');
+  return name.endsWith('.pl');
 }
 
 function runExample(name) {
@@ -79,7 +79,6 @@ function runProgramExample(programFile, filename, options) {
     const program = Program.parseSources([{ text, filename }], {
       sourceMetadata: options.proof,
       markRecursive: options.proof,
-      inputFormat: 'auto',
     });
     return run(program, options).stdout;
   } finally {

package/test/eyelang/run-regression.mjs

@@ -30,7 +30,6 @@ import {
   unify,
   variantTerms,
   parseProgramText,
-  rdfToEyelang,
 } from '../../lib/eyelang/index.js';
 import { parseGoalText } from '../../lib/eyelang/parser.js';
 import { selectClauseCandidates } from '../../lib/eyelang/program.js';
@@ -207,66 +206,6 @@ why(
       },
     },
 
-    {
-      name: 'RDF 1.2 Turtle annotations lower to rdf/3 facts',
-      run: () => {
-        const source = 'VERSION "1.2"\nPREFIX : <http://example.com/>\nPREFIX xsd: <http://www.w3.org/2001/XMLSchema#>\n:alice :name "Alice" ~ :t {| :statedBy :bob ; :recorded "2021-07-07"^^xsd:date |} .\n';
-        const actual = rdfToEyelang(source, { materializeRdf: false });
-        assertEqual(actual, [
-          'rdf(iri("http://example.com/alice"), iri("http://example.com/name"), literal("Alice", iri("http://www.w3.org/2001/XMLSchema#string"), "", "")).\n',
-          '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"), "", ""))).\n',
-          'rdf(iri("http://example.com/t"), iri("http://example.com/statedBy"), iri("http://example.com/bob")).\n',
-          'rdf(iri("http://example.com/t"), iri("http://example.com/recorded"), literal("2021-07-07", iri("http://www.w3.org/2001/XMLSchema#date"), "", "")).\n',
-        ].join(''), 'rdfToEyelang');
-      },
-    },
-    {
-      name: 'Notation3 rules materialize derived RDF triples',
-      run: () => {
-        const source = '@prefix : <http://example.com/> .\n{ ?x :parent ?y . } => { ?x :related ?y . } .\n:alice :parent :bob .\n';
-        const actual = run(source, { inputFormat: 'n3' }).stdout;
-        assertEqual(actual, 'rdf(iri("http://example.com/alice"), iri("http://example.com/related"), iri("http://example.com/bob")).\n', 'stdout');
-      },
-    },
-    {
-      name: '--rdf reads RDF 1.2 / N3 compatibility input',
-      run: () => {
-        const source = '@prefix : <http://example.com/> .\n{ ?x :parent ?y . } => { ?x :related ?y . } .\n:alice :parent :bob .\n';
-        const result = runCli(['--rdf', '-'], { input: source });
-        assertEqual(result.status, 0, 'exit status');
-        assertEqual(result.stdout, 'rdf(iri("http://example.com/alice"), iri("http://example.com/related"), iri("http://example.com/bob")).\n', 'stdout');
-        assertEqual(result.stderr, '', 'stderr');
-      },
-    },
-
-    {
-      name: 'Notation3 <= rules and builtins materialize derived RDF triples',
-      run: () => {
-        const source = '@prefix : <http://example.com/> .\n@prefix math: <http://www.w3.org/2000/10/swap/math#> .\n{ ?x :ok true . } <= { (2 3) math:sum ?n . ?n math:equalTo 5 . ?x :seed true . } .\n:case :seed true .\n';
-        const actual = run(source, { inputFormat: 'n3' }).stdout;
-        assertEqual(actual, 'rdf(iri("http://example.com/case"), iri("http://example.com/ok"), literal("true", iri("http://www.w3.org/2001/XMLSchema#boolean"), "", "")).\n', 'stdout');
-      },
-    },
-
-    {
-      name: 'bundled RDF 1.2 / N3 examples match golden output',
-      run: () => {
-        const dir = path.join(packageRoot, 'examples', 'eyelang');
-        const files = fs.readdirSync(dir)
-          .filter((name) => name.endsWith('.n3') || name.endsWith('.ttl'))
-          .sort();
-        assertEqual(files.length > 0, true, 'rdf example files exist');
-        for (const name of files) {
-          const result = runCli([path.join('examples', 'eyelang', name)]);
-          assertEqual(result.status, 0, `${name} exit status`);
-          assertEqual(result.stderr, '', `${name} stderr`);
-          const expected = fs.readFileSync(path.join(dir, 'output', name), 'utf8');
-          assertEqual(result.stdout, expected, `${name} stdout`);
-        }
-      },
-    },
-
-
     {
       name: '--proof enables materialization explanations',
       run: () => {

package/test/run.js

@@ -126,9 +126,26 @@ function addSectionToAggregate(summary) {
   aggregate.nonconform += failed;
 }
 
-function scoreLine() {
+function scoreColor(score) {
+  if (aggregate.crashed || aggregate.nonconform) return C.r;
+  if (aggregate.incomplete || score < 100) return C.y;
+  return C.g;
+}
+
+function scoreLine(elapsedMs) {
   const score = aggregate.total === 0 ? 0 : (100 * aggregate.ok) / aggregate.total;
-  return `TOTAL [COUNT:${aggregate.total}] OK: ⭐${aggregate.ok}⭐ INCOMPLETE: ⭐${aggregate.incomplete}⭐ NONCONFORM: ⭐${aggregate.nonconform}⭐ CRASHED: ⭐${aggregate.crashed}⭐ => SCORE: ⭐⭐⭐${score.toFixed(1)}⭐⭐⭐`;
+  const scoreC = scoreColor(score);
+  return [
+    `${C.dim}TOTAL${C.n}`,
+    `${C.dim}[COUNT:${aggregate.total}]${C.n}`,
+    `${C.g}OK:${C.n} ${C.y}⭐${aggregate.ok}⭐${C.n}`,
+    `${C.r}INCOMPLETE:${C.n} ${C.y}⭐${aggregate.incomplete}⭐${C.n}`,
+    `${C.r}NONCONFORM:${C.n} ${C.y}⭐${aggregate.nonconform}⭐${C.n}`,
+    `${C.r}CRASHED:${C.n} ${C.y}⭐${aggregate.crashed}⭐${C.n}`,
+    '=>',
+    `${scoreC}SCORE:${C.n} ${C.y}⭐⭐⭐${score.toFixed(1)}⭐⭐⭐${C.n}`,
+    `${C.dim}ELAPSED:${C.n} ${C.y}${formatDuration(elapsedMs)}${C.n}`,
+  ].join(' ');
 }
 
 function childEnv() {
@@ -194,6 +211,7 @@ function runSection(label, cmd, args) {
 }
 
 (async function main() {
+  const suiteStartedAt = Date.now();
   let status = 0;
   for (const [label, cmd, args] of sections) {
     const sectionStatus = await runSection(label, cmd, args);
@@ -204,7 +222,7 @@ function runSection(label, cmd, args) {
   }
 
   console.log('');
-  console.log(scoreLine());
+  console.log(scoreLine(Date.now() - suiteStartedAt));
 
   process.exit(status);
 })();

package/examples/eyelang/annotation-rdf12.ttl

@@ -1,12 +0,0 @@
-# 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/eyelang/directional-language.ttl

@@ -1,9 +0,0 @@
-# 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/eyelang/eyeling-ackermann.n3

@@ -1,41 +0,0 @@
-# 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/eyelang/eyeling-age-threshold.n3

@@ -1,12 +0,0 @@
-# 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/eyelang/eyeling-alignment-demo.n3

@@ -1,11 +0,0 @@
-# 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/eyelang/eyeling-allen-interval-calculus-small.n3

@@ -1,13 +0,0 @@
-# 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/eyelang/eyeling-backward-recursion.n3

@@ -1,11 +0,0 @@
-# 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/eyelang/eyeling-backward.n3

@@ -1,10 +0,0 @@
-# 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/eyelang/eyeling-basic-monadic-small.n3

@@ -1,11 +0,0 @@
-# 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. }.