eyeling 1.5.29 → 1.5.31

package/README.md

@@ -98,10 +98,10 @@ npm run test:package
 npm run test:packlist
 ```
 
-* `test:api` runs an independent JS API test suite (does not rely on `examples/`).
-* `test:examples` runs the examples in the `examples` directory and compares against the golden outputs in `examples/output`.
-* `test:package` does a “real consumer” smoke test: `npm pack` → install tarball into a temp project → run API + CLI + examples.
-* `test:packlist` sanity-checks what will be published in the npm tarball (and the CLI shebang/bin wiring).
+- `test:api` runs an independent JS API test suite (does not rely on `examples/`).
+- `test:examples` runs the examples in the `examples` directory and compares against the golden outputs in `examples/output`.
+- `test:package` does a “real consumer” smoke test: `npm pack` → install tarball into a temp project → run API + CLI + examples.
+- `test:packlist` sanity-checks what will be published in the npm tarball (and the CLI shebang/bin wiring).
 
 ### Run a single file
 
@@ -146,14 +146,14 @@ The proof comments are compact “local justifications” per derived triple (no
 
 ### Forward + backward chaining
 
-* **Forward chaining to fixpoint** for forward rules written as `{ P } => { C } .`
-* **Backward chaining (SLD-style)** for backward rules written as `{ H } <= { B } .` and for built-ins.
+- **Forward chaining to fixpoint** for forward rules written as `{ P } => { C } .`
+- **Backward chaining (SLD-style)** for backward rules written as `{ H } <= { B } .` and for built-ins.
 
 Forward rule premises are proved using:
 
-* ground facts (input + derived)
-* backward rules
-* built-ins
+- ground facts (input + derived)
+- backward rules
+- built-ins
 
 The CLI prints only newly derived forward facts.
 
@@ -172,30 +172,28 @@ The CLI prints only newly derived forward facts.
 
 Supported:
 
-* `@prefix` / `@base`
-* triples with `;` and `,`
-* variables `?x`
-* blank nodes:
-
-  * anonymous `[]`
-  * property lists `[ :p :o; :q :r ]`
-* collections `( ... )`
-* quoted formulas `{ ... }`
-* implications:
-
-  * forward rules `{ P } => { C } .`
-  * backward rules `{ H } <= { B } .`
-* datatyped literals with `^^`
-* language-tagged string literals: `"hello"@en`, `"colour"@en-GB`
-* long string literals: `"""..."""` (can contain newlines; can also carry a language tag)
-* inverted predicate sugar: `?x <- :p ?y` (swaps subject/object for that predicate)
-* resource paths (forward `!` and reverse `^`): `:joe!:hasAddress!:hasCity "Metropolis".`
-* `#` line comments
+- `@prefix` / `@base`
+- triples with `;` and `,`
+- variables `?x`
+- blank nodes:
+  - anonymous `[]`
+  - property lists `[ :p :o; :q :r ]`
+- collections `( ... )`
+- quoted formulas `{ ... }`
+- implications:
+  - forward rules `{ P } => { C } .`
+  - backward rules `{ H } <= { B } .`
+- datatyped literals with `^^`
+- language-tagged string literals: `"hello"@en`, `"colour"@en-GB`
+- long string literals: `"""..."""` (can contain newlines; can also carry a language tag)
+- inverted predicate sugar: `?x <- :p ?y` (swaps subject/object for that predicate)
+- resource paths (forward `!` and reverse `^`): `:joe!:hasAddress!:hasCity "Metropolis".`
+- `#` line comments
 
 Non-goals / current limits:
 
-* not a full W3C N3 grammar (some edge cases for identifiers, quantifiers, advanced syntax)
-* proof output is local per derived triple (not a global exported proof tree)
+- not a full W3C N3 grammar (some edge cases for identifiers, quantifiers, advanced syntax)
+- proof output is local per derived triple (not a global exported proof tree)
 
 ## Blank nodes and quantification (pragmatic N3/EYE-style)
 
@@ -213,12 +211,12 @@ Equal facts up to renaming of Skolem IDs are treated as duplicates and are not r
 
 Top level:
 
-* `{ P } log:implies { C } .` becomes a forward rule `{ P } => { C } .`
-* `{ H } log:impliedBy { B } .` becomes a backward rule `{ H } <= { B } .`
+- `{ P } log:implies { C } .` becomes a forward rule `{ P } => { C } .`
+- `{ H } log:impliedBy { B } .` becomes a backward rule `{ H } <= { B } .`
 
 During reasoning:
 
-* any **derived** `log:implies` / `log:impliedBy` triple with formula subject/object is turned into a new live forward/backward rule.
+- any **derived** `log:implies` / `log:impliedBy` triple with formula subject/object is turned into a new live forward/backward rule.
 
 ## Inference fuse — `{ ... } => false.`
 
@@ -237,12 +235,12 @@ As soon as the premise is provable, `eyeling` exits with status code `2`.
 
 `eyeling` implements a pragmatic subset of common N3 builtin families and evaluates them during backward goal proving:
 
-* **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
-* **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:rest` `list:reverse` `list:sort`
-* **log**: `log:collectAllIn` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:skolem` `log:uri`
-* **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:integerQuotient` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
-* **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
-* **time**: `time:localTime`
+- **crypto**: `crypto:md5` `crypto:sha` `crypto:sha256` `crypto:sha512`
+- **list**: `list:append` `list:first` `list:firstRest` `list:in` `list:iterate` `list:last` `list:length` `list:map` `list:member` `list:memberAt` `list:notMember` `list:remove` `list:rest` `list:reverse` `list:sort`
+- **log**: `log:collectAllIn` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:notEqualTo` `log:notIncludes` `log:skolem` `log:uri`
+- **math**: `math:absoluteValue` `math:acos` `math:asin` `math:atan` `math:cos` `math:cosh` `math:degrees` `math:difference` `math:equalTo` `math:exponentiation` `math:greaterThan` `math:integerQuotient` `math:lessThan` `math:negation` `math:notEqualTo` `math:notGreaterThan` `math:notLessThan` `math:product` `math:quotient` `math:remainder` `math:rounded` `math:sin` `math:sinh` `math:sum` `math:tan` `math:tanh`
+- **string**: `string:concatenation` `string:contains` `string:containsIgnoringCase` `string:endsWith` `string:equalIgnoringCase` `string:format` `string:greaterThan` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
+- **time**: `time:localTime`
 
 ## License
 

package/examples/math-builtins-tests.n3

@@ -242,6 +242,17 @@
     :status   :pass .
 } .
 
+# math:integerQuotient
+{ (10 3) math:integerQuotient ?q . ?q math:equalTo 3 . }
+=> {
+  :test-integerQuotient-1 a :MathBuiltinTest;
+    :builtin math:integerQuotient;
+    :input (10 3);
+    :expected 3;
+    :actual ?q;
+    :status :pass .
+} .
+
 # math:lessThan
 {
   41 math:lessThan 42 .

package/examples/output/math-builtins-tests.n3

@@ -1989,6 +1989,156 @@
 
 :test-greaterThan-1 :status :pass .
 
+# ----------------------------------------------------------------------
+# Proof for derived triple:
+#   :test-integerQuotient-1 a :MathBuiltinTest .
+# It holds because the following instance of the rule body is provable:
+#   (10 3) math:integerQuotient 3 .
+#   3 math:equalTo 3 .
+# via the schematic forward rule:
+#   {
+#     (10 3) math:integerQuotient ?q .
+#     ?q math:equalTo 3 .
+#   } => {
+#     :test-integerQuotient-1 a :MathBuiltinTest .
+#     :test-integerQuotient-1 :builtin math:integerQuotient .
+#     :test-integerQuotient-1 :input (10 3) .
+#     :test-integerQuotient-1 :expected 3 .
+#     :test-integerQuotient-1 :actual ?q .
+#     :test-integerQuotient-1 :status :pass .
+#   } .
+# with substitution (on rule variables):
+#   ?q = 3
+# Therefore the derived triple above is entailed by the rules and facts.
+# ----------------------------------------------------------------------
+
+:test-integerQuotient-1 a :MathBuiltinTest .
+
+# ----------------------------------------------------------------------
+# Proof for derived triple:
+#   :test-integerQuotient-1 :builtin math:integerQuotient .
+# It holds because the following instance of the rule body is provable:
+#   (10 3) math:integerQuotient 3 .
+#   3 math:equalTo 3 .
+# via the schematic forward rule:
+#   {
+#     (10 3) math:integerQuotient ?q .
+#     ?q math:equalTo 3 .
+#   } => {
+#     :test-integerQuotient-1 a :MathBuiltinTest .
+#     :test-integerQuotient-1 :builtin math:integerQuotient .
+#     :test-integerQuotient-1 :input (10 3) .
+#     :test-integerQuotient-1 :expected 3 .
+#     :test-integerQuotient-1 :actual ?q .
+#     :test-integerQuotient-1 :status :pass .
+#   } .
+# with substitution (on rule variables):
+#   ?q = 3
+# Therefore the derived triple above is entailed by the rules and facts.
+# ----------------------------------------------------------------------
+
+:test-integerQuotient-1 :builtin math:integerQuotient .
+
+# ----------------------------------------------------------------------
+# Proof for derived triple:
+#   :test-integerQuotient-1 :input (10 3) .
+# It holds because the following instance of the rule body is provable:
+#   (10 3) math:integerQuotient 3 .
+#   3 math:equalTo 3 .
+# via the schematic forward rule:
+#   {
+#     (10 3) math:integerQuotient ?q .
+#     ?q math:equalTo 3 .
+#   } => {
+#     :test-integerQuotient-1 a :MathBuiltinTest .
+#     :test-integerQuotient-1 :builtin math:integerQuotient .
+#     :test-integerQuotient-1 :input (10 3) .
+#     :test-integerQuotient-1 :expected 3 .
+#     :test-integerQuotient-1 :actual ?q .
+#     :test-integerQuotient-1 :status :pass .
+#   } .
+# with substitution (on rule variables):
+#   ?q = 3
+# Therefore the derived triple above is entailed by the rules and facts.
+# ----------------------------------------------------------------------
+
+:test-integerQuotient-1 :input (10 3) .
+
+# ----------------------------------------------------------------------
+# Proof for derived triple:
+#   :test-integerQuotient-1 :expected 3 .
+# It holds because the following instance of the rule body is provable:
+#   (10 3) math:integerQuotient 3 .
+#   3 math:equalTo 3 .
+# via the schematic forward rule:
+#   {
+#     (10 3) math:integerQuotient ?q .
+#     ?q math:equalTo 3 .
+#   } => {
+#     :test-integerQuotient-1 a :MathBuiltinTest .
+#     :test-integerQuotient-1 :builtin math:integerQuotient .
+#     :test-integerQuotient-1 :input (10 3) .
+#     :test-integerQuotient-1 :expected 3 .
+#     :test-integerQuotient-1 :actual ?q .
+#     :test-integerQuotient-1 :status :pass .
+#   } .
+# with substitution (on rule variables):
+#   ?q = 3
+# Therefore the derived triple above is entailed by the rules and facts.
+# ----------------------------------------------------------------------
+
+:test-integerQuotient-1 :expected 3 .
+
+# ----------------------------------------------------------------------
+# Proof for derived triple:
+#   :test-integerQuotient-1 :actual 3 .
+# It holds because the following instance of the rule body is provable:
+#   (10 3) math:integerQuotient 3 .
+#   3 math:equalTo 3 .
+# via the schematic forward rule:
+#   {
+#     (10 3) math:integerQuotient ?q .
+#     ?q math:equalTo 3 .
+#   } => {
+#     :test-integerQuotient-1 a :MathBuiltinTest .
+#     :test-integerQuotient-1 :builtin math:integerQuotient .
+#     :test-integerQuotient-1 :input (10 3) .
+#     :test-integerQuotient-1 :expected 3 .
+#     :test-integerQuotient-1 :actual ?q .
+#     :test-integerQuotient-1 :status :pass .
+#   } .
+# with substitution (on rule variables):
+#   ?q = 3
+# Therefore the derived triple above is entailed by the rules and facts.
+# ----------------------------------------------------------------------
+
+:test-integerQuotient-1 :actual 3 .
+
+# ----------------------------------------------------------------------
+# Proof for derived triple:
+#   :test-integerQuotient-1 :status :pass .
+# It holds because the following instance of the rule body is provable:
+#   (10 3) math:integerQuotient 3 .
+#   3 math:equalTo 3 .
+# via the schematic forward rule:
+#   {
+#     (10 3) math:integerQuotient ?q .
+#     ?q math:equalTo 3 .
+#   } => {
+#     :test-integerQuotient-1 a :MathBuiltinTest .
+#     :test-integerQuotient-1 :builtin math:integerQuotient .
+#     :test-integerQuotient-1 :input (10 3) .
+#     :test-integerQuotient-1 :expected 3 .
+#     :test-integerQuotient-1 :actual ?q .
+#     :test-integerQuotient-1 :status :pass .
+#   } .
+# with substitution (on rule variables):
+#   ?q = 3
+# Therefore the derived triple above is entailed by the rules and facts.
+# ----------------------------------------------------------------------
+
+:test-integerQuotient-1 :status :pass .
+
 # ----------------------------------------------------------------------
 # Proof for derived triple:
 #   :test-lessThan-1 a :MathBuiltinTest .

package/eyeling.js

@@ -676,8 +676,23 @@ class Parser {
           this.expectDot();
           backwardRules.push(this.makeRule(first, second, false));
         } else {
-          const more = this.parsePredicateObjectList(first);
-          this.expectDot();
+          let more;
+
+          if (this.peek().typ === "Dot") {
+            // Allow a bare blank-node property list statement, e.g. `[ a :Statement ].`
+            const lastTok = this.toks[this.pos - 1];
+            if (this.pendingTriples.length > 0 && lastTok && lastTok.typ === "RBracket") {
+              more = this.pendingTriples;
+              this.pendingTriples = [];
+              this.next(); // consume '.'
+            } else {
+              throw new Error(`Unexpected '.' after term; missing predicate/object list`);
+            }
+          } else {
+            more = this.parsePredicateObjectList(first);
+            this.expectDot();
+          }
+
           // normalize explicit log:implies / log:impliedBy at top-level
           for (const tr of more) {
             if (isLogImplies(tr.p) && tr.s instanceof FormulaTerm && tr.o instanceof FormulaTerm) {
@@ -692,7 +707,6 @@ class Parser {
       }
     }
 
-    // console.log(JSON.stringify([this.prefixes, triples, forwardRules, backwardRules], null, 2));
     return [this.prefixes, triples, forwardRules, backwardRules];
   }
 
@@ -929,6 +943,17 @@ class Parser {
           throw new Error(`Expected '.' or '}', got ${this.peek().toString()}`);
         }
       } else {
+        // Allow a bare blank-node property list statement inside a formula, e.g. `{ [ a :X ]. }`
+        if (this.peek().typ === "Dot" || this.peek().typ === "RBrace") {
+          const lastTok = this.toks[this.pos - 1];
+          if (this.pendingTriples.length > 0 && lastTok && lastTok.typ === "RBracket") {
+            triples.push(...this.pendingTriples);
+            this.pendingTriples = [];
+            if (this.peek().typ === "Dot") this.next();
+            continue;
+          }
+        }
+
         triples.push(...this.parsePredicateObjectList(left));
         if (this.peek().typ === "Dot") this.next();
         else if (this.peek().typ === "RBrace") {
@@ -4187,6 +4212,7 @@ function main() {
   const toks = lex(text);
   const parser = new Parser(toks);
   const [prefixes, triples, frules, brules] = parser.parseDocument();
+  // console.log(JSON.stringify([prefixes, triples, frules, brules], null, 2));
 
   const facts = triples.filter(tr => isGroundTriple(tr));
   const derived = forwardChain(facts, frules, brules);

package/package.json

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