eyeling 1.5.41 → 1.5.42

package/examples/saffron-slopeworks.n3

@@ -0,0 +1,216 @@
+# ================================================================
+# Heavy-Math N3 Demo: "Saffron Slopeworks"
+# ------------------------------------------------
+# A math-stress N3 ruleset focused on *linear regression* and
+# residual analysis, intended for testing strict W3C/N3 math
+# builtins implementations.
+#
+# What it does:
+#  1) Computes least-squares line: y = a + b x
+#     - slope b, intercept a
+#  2) Computes Pearson correlation r and r^2
+#  3) Computes SSE + RMSE
+#  4) Flags points whose |residual| > 2*RMSE (as high-residual outliers)
+#  5) Predicts y at a given x
+#
+# Notes:
+#  - Uses only: math:, list:, log:
+#  - Head blank nodes are used to create connected result structures.
+# ================================================================
+
+@prefix :     <http://example.org/saffron-slopeworks#> .
+@prefix math: <http://www.w3.org/2000/10/swap/math#> .
+@prefix list: <http://www.w3.org/2000/10/swap/list#> .
+@prefix log:  <http://www.w3.org/2000/10/swap/log#> .
+
+############
+# DATA
+############
+
+:Reg1
+  :points (
+    [ :x 1.0 ; :y 2.1  ]
+    [ :x 2.0 ; :y 2.9  ]
+    [ :x 3.0 ; :y 3.8  ]
+    [ :x 4.0 ; :y 4.2  ]
+    [ :x 5.0 ; :y 5.1  ]
+    [ :x 6.0 ; :y 5.9  ]
+    [ :x 7.0 ; :y 7.0  ]
+    [ :x 8.0 ; :y 15.0 ]   # an obvious high-residual outlier
+  ) ;
+  :predictX 8.5 .
+
+############
+# (1) COLLECT SUMS: Σx, Σy, Σx², Σy², Σxy
+############
+
+{
+  :Reg1 :points ?pts .
+  ?pts list:length ?n .
+
+  ( ?x { ?pts list:member ?p . ?p :x ?x . } ?xs ) log:collectAllIn _:s1 .
+  ( ?y { ?pts list:member ?p . ?p :y ?y . } ?ys ) log:collectAllIn _:s1 .
+
+  ?xs math:sum ?sumX .
+  ?ys math:sum ?sumY .
+
+  ( ?x2 {
+      ?pts list:member ?p .
+      ?p :x ?x .
+      (?x 2.0) math:exponentiation ?x2 .
+    } ?x2s ) log:collectAllIn _:s1 .
+  ?x2s math:sum ?sumXX .
+
+  ( ?y2 {
+      ?pts list:member ?p .
+      ?p :y ?y .
+      (?y 2.0) math:exponentiation ?y2 .
+    } ?y2s ) log:collectAllIn _:s1 .
+  ?y2s math:sum ?sumYY .
+
+  ( ?xy {
+      ?pts list:member ?p .
+      ?p :x ?x ; :y ?y .
+      (?x ?y) math:product ?xy .
+    } ?xys ) log:collectAllIn _:s1 .
+  ?xys math:sum ?sumXY .
+}
+=>
+{
+  :Reg1 :n ?n ;
+        :sumX ?sumX ; :sumY ?sumY ;
+        :sumXX ?sumXX ; :sumYY ?sumYY ;
+        :sumXY ?sumXY .
+} .
+
+############
+# (2) REGRESSION + CORRELATION
+#
+# b = ( n*Σxy - (Σx)(Σy) ) / ( n*Σx² - (Σx)² )
+# a = ( Σy - b*Σx ) / n
+#
+# r = ( n*Σxy - (Σx)(Σy) ) / sqrt( (n*Σx²-(Σx)²)(n*Σy²-(Σy)²) )
+# r² = r^2
+############
+
+{
+  :Reg1 :n ?n ;
+        :sumX ?sx ; :sumY ?sy ;
+        :sumXX ?sxx ; :sumYY ?syy ;
+        :sumXY ?sxy .
+
+  # numerator = n*sxy - sx*sy
+  (?n ?sxy) math:product ?n_sxy .
+  (?sx ?sy) math:product ?sx_sy .
+  (?n_sxy ?sx_sy) math:difference ?num .
+
+  # denX = n*sxx - sx^2
+  (?n ?sxx) math:product ?n_sxx .
+  (?sx 2.0) math:exponentiation ?sx2 .
+  (?n_sxx ?sx2) math:difference ?denX .
+
+  # slope b
+  (?num ?denX) math:quotient ?b .
+
+  # intercept a = (sy - b*sx) / n
+  (?b ?sx) math:product ?b_sx .
+  (?sy ?b_sx) math:difference ?tmpA .
+  (?tmpA ?n) math:quotient ?a .
+
+  # denY = n*syy - sy^2
+  (?n ?syy) math:product ?n_syy .
+  (?sy 2.0) math:exponentiation ?sy2 .
+  (?n_syy ?sy2) math:difference ?denY .
+
+  # r = num / sqrt(denX*denY)
+  (?denX ?denY) math:product ?denXY .
+  (?denXY 0.5) math:exponentiation ?sqrtDen .
+  (?num ?sqrtDen) math:quotient ?r .
+  (?r 2.0) math:exponentiation ?r2 .
+}
+=>
+{
+  :Reg1 :slope ?b ;
+        :intercept ?a ;
+        :pearsonR ?r ;
+        :rSquared ?r2 .
+} .
+
+############
+# (3) SSE + RMSE (root mean squared error)
+# residual e = y - (a + b x)
+# SSE = Σ e^2
+# RMSE = sqrt(SSE / n)
+############
+
+{
+  :Reg1 :points ?pts ; :slope ?b ; :intercept ?a .
+  ?pts list:length ?n .
+
+  ( ?e2 {
+      ?pts list:member ?p .
+      ?p :x ?x ; :y ?y .
+
+      (?b ?x) math:product ?bx .
+      (?a ?bx) math:sum ?yhat .
+      (?y ?yhat) math:difference ?e .
+      (?e 2.0) math:exponentiation ?e2 .
+    } ?e2s ) log:collectAllIn _:s2 .
+
+  ?e2s math:sum ?sse .
+  (?sse ?n) math:quotient ?mse .
+  (?mse 0.5) math:exponentiation ?rmse .
+}
+=>
+{
+  :Reg1 :sse ?sse ;
+        :rmse ?rmse .
+} .
+
+############
+# (4) FLAG HIGH-RESIDUAL POINTS: |e| > 2*RMSE
+############
+
+{
+  :Reg1 :points ?pts ; :slope ?b ; :intercept ?a ; :rmse ?rmse .
+  ?pts list:member ?p .
+  ?p :x ?x ; :y ?y .
+
+  (?b ?x) math:product ?bx .
+  (?a ?bx) math:sum ?yhat .
+  (?y ?yhat) math:difference ?e .
+  ?e math:absoluteValue ?ae .
+
+  (2.0 ?rmse) math:product ?thr .
+  ?ae math:greaterThan ?thr .
+}
+=>
+{
+  :Reg1 :highResidual
+    [ :point ?p ;
+      :x ?x ; :y ?y ;
+      :yhat ?yhat ;
+      :residual ?e ] .
+} .
+
+############
+# (5) PREDICTION: y = a + b*x0
+############
+
+{
+  :Reg1 :predictX ?x0 ; :slope ?b ; :intercept ?a .
+  (?b ?x0) math:product ?bx0 .
+  (?a ?bx0) math:sum ?y0 .
+}
+=>
+{
+  :Reg1 :prediction [ :x ?x0 ; :y ?y0 ] .
+} .
+
+############
+# STRICTNESS REGRESSION HOOK (should fail in strict math)
+############
+# {
+#   "2"^^<http://example.org/not-a-number> math:product "3"^^<http://example.org/nope> .
+# } => { :bad :datatype :accepted . } .
+

package/eyeling.js

@@ -1169,44 +1169,70 @@ function liftBlankRuleVars(premise, conclusion) {
   return [newPremise, conclusion];
 }
 
-function skolemizeTermForHeadBlanks(t, headBlankLabels, mapping, skCounter) {
+// Skolemization for blank nodes that occur explicitly in a rule head.
+//
+// IMPORTANT: we must be *stable per rule firing*, otherwise a rule whose
+// premises stay true would keep generating fresh _:sk_N blank nodes on every
+// outer fixpoint iteration (non-termination once we do strict duplicate checks).
+//
+// We achieve this by optionally keying head-blank allocations by a "firingKey"
+// (usually derived from the instantiated premises and rule index) and caching
+// them in a run-global map.
+function skolemizeTermForHeadBlanks(t, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
   if (t instanceof Blank) {
     const label = t.label;
     // Only skolemize blanks that occur explicitly in the rule head
     if (!headBlankLabels || !headBlankLabels.has(label)) {
       return t; // this is a data blank (e.g. bound via ?X), keep it
     }
+
     if (!mapping.hasOwnProperty(label)) {
-      const idx = skCounter[0];
-      skCounter[0] += 1;
-      mapping[label] = `_:sk_${idx}`;
+      // If we have a global cache keyed by firingKey, use it to ensure
+      // deterministic blank IDs for the same rule+substitution instance.
+      if (globalMap && firingKey) {
+        const gk = `${firingKey}|${label}`;
+        let sk = globalMap.get(gk);
+        if (!sk) {
+          const idx = skCounter[0];
+          skCounter[0] += 1;
+          sk = `_:sk_${idx}`;
+          globalMap.set(gk, sk);
+        }
+        mapping[label] = sk;
+      } else {
+        const idx = skCounter[0];
+        skCounter[0] += 1;
+        mapping[label] = `_:sk_${idx}`;
+      }
     }
     return new Blank(mapping[label]);
   }
 
   if (t instanceof ListTerm) {
-    return new ListTerm(t.elems.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter)));
+    return new ListTerm(t.elems.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter, firingKey, globalMap)));
   }
 
   if (t instanceof OpenListTerm) {
     return new OpenListTerm(
-      t.prefix.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter)),
+      t.prefix.map((e) => skolemizeTermForHeadBlanks(e, headBlankLabels, mapping, skCounter, firingKey, globalMap)),
       t.tailVar,
     );
   }
 
   if (t instanceof FormulaTerm) {
-    return new FormulaTerm(t.triples.map((tr) => skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter)));
+    return new FormulaTerm(
+      t.triples.map((tr) => skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, firingKey, globalMap)),
+    );
   }
 
   return t;
 }
 
-function skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter) {
+function skolemizeTripleForHeadBlanks(tr, headBlankLabels, mapping, skCounter, firingKey, globalMap) {
   return new Triple(
-    skolemizeTermForHeadBlanks(tr.s, headBlankLabels, mapping, skCounter),
-    skolemizeTermForHeadBlanks(tr.p, headBlankLabels, mapping, skCounter),
-    skolemizeTermForHeadBlanks(tr.o, headBlankLabels, mapping, skCounter),
+    skolemizeTermForHeadBlanks(tr.s, headBlankLabels, mapping, skCounter, firingKey, globalMap),
+    skolemizeTermForHeadBlanks(tr.p, headBlankLabels, mapping, skCounter, firingKey, globalMap),
+    skolemizeTermForHeadBlanks(tr.o, headBlankLabels, mapping, skCounter, firingKey, globalMap),
   );
 }
 
@@ -1502,15 +1528,20 @@ function hasFactIndexed(facts, tr) {
       const po = facts.__byPO.get(pk);
       if (po) {
         const pob = po.get(ok) || [];
-        return pob.some((t) => alphaEqTriple(t, tr));
+        // Facts are all in the same graph. Different blank node labels represent
+        // different existentials unless explicitly connected. Do NOT treat
+        // triples as duplicates modulo blank renaming, or you'll incorrectly
+        // drop facts like: _:sk_0 :x 8.0  (because _:b8 :x 8.0 exists).
+        return pob.some((t) => triplesEqual(t, tr));
       }
     }
 
     const pb = facts.__byPred.get(pk) || [];
-    return pb.some((t) => alphaEqTriple(t, tr));
+    return pb.some((t) => triplesEqual(t, tr));
   }
 
-  return hasAlphaEquiv(facts, tr);
+  // Non-IRI predicate: fall back to strict triple equality.
+  return facts.some((t) => triplesEqual(t, tr));
 }
 
 function pushFactIndexed(facts, tr) {
@@ -4162,6 +4193,20 @@ function forwardChain(facts, forwardRules, backRules) {
   const varGen = [0];
   const skCounter = [0];
 
+  // Cache head blank-node skolemization per (rule firing, head blank label).
+  // This prevents repeatedly generating fresh _:sk_N blanks for the *same*
+  // rule+substitution instance across outer fixpoint iterations.
+  const headSkolemCache = new Map();
+
+  function firingKey(ruleIndex, instantiatedPremises) {
+    // Deterministic key derived from the instantiated body (ground per substitution).
+    const parts = [];
+    for (const tr of instantiatedPremises) {
+      parts.push(JSON.stringify([skolemKeyFromTerm(tr.s), skolemKeyFromTerm(tr.p), skolemKeyFromTerm(tr.o)]));
+    }
+    return `R${ruleIndex}|` + parts.join('\\n');
+  }
+
   // Make rules visible to introspection builtins
   backRules.__allForwardRules = forwardRules;
   backRules.__allBackwardRules = backRules;
@@ -4187,6 +4232,7 @@ function forwardChain(facts, forwardRules, backRules) {
         // (e.g., from [ :p ... ; :q ... ]) stay connected across all head triples.
         const skMap = {};
         const instantiatedPremises = r.premise.map((b) => applySubstTriple(b, s));
+        const fireKey = firingKey(i, instantiatedPremises);
 
         for (const cpat of r.conclusion) {
           const instantiated = applySubstTriple(cpat, s);
@@ -4270,7 +4316,7 @@ function forwardChain(facts, forwardRules, backRules) {
           }
 
           // Only skolemize blank nodes that occur explicitly in the rule head
-          const inst = skolemizeTripleForHeadBlanks(instantiated, r.headBlankLabels, skMap, skCounter);
+          const inst = skolemizeTripleForHeadBlanks(instantiated, r.headBlankLabels, skMap, skCounter, fireKey, headSkolemCache);
 
           if (!isGroundTriple(inst)) continue;
           if (hasFactIndexed(facts, inst)) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.5.41",
+  "version": "1.5.42",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [
@@ -34,7 +34,7 @@
     "test:examples": "node test/examples.test.js",
     "test:package": "node test/package.test.js",
     "test": "npm run test:packlist && npm run test:api && npm run test:examples",
-    "preversion": "prettier -w eyeling.js && npm test",
+    "preversion": "npm test",
     "postversion": "git push origin HEAD --follow-tags"
   }
 }