eyeling 1.7.13 → 1.7.15

package/README.md

@@ -219,7 +219,7 @@ Commonly used N3/Turtle features:
 - **log**: `log:collectAllIn` `log:content` `log:dtlit` `log:equalTo` `log:forAllIn` `log:impliedBy` `log:implies` `log:includes` `log:langlit` `log:notEqualTo` `log:notIncludes` `log:outputString` `log:parsedAsN3` `log:rawType` `log:semantics` `log:semanticsOrError` `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:jsonPointer` `string:lessThan` `string:matches` `string:notEqualIgnoringCase` `string:notGreaterThan` `string:notLessThan` `string:notMatches` `string:replace` `string:scrape` `string:startsWith`
-- **time**: `time:day` `time:localTime` `time:minute` `time:month` `time:second` `time:timeZone` `time:year`
+- **time**: `time:day` `time:hour` `time:localTime` `time:minute` `time:month` `time:second` `time:timeZone` `time:year`
 
 ## License
 

package/eyeling.js

@@ -3542,7 +3542,7 @@ function parseXsdDatetimeTerm(t) {
 
 function parseXsdDateTimeLexParts(t) {
   // Parse *lexical* components of an xsd:dateTime literal without timezone normalization.
-  // Returns { yearStr, month, day, minute, second, tz } or null.
+  // Returns { yearStr, month, day, hour, minute, second, tz } or null.
   if (!(t instanceof Literal)) return null;
   const [lex, dt] = literalParts(t.value);
   if (dt !== XSD_NS + 'dateTime') return null;
@@ -3555,16 +3555,18 @@ function parseXsdDateTimeLexParts(t) {
   const yearStr = m[1];
   const month = parseInt(m[2], 10);
   const day = parseInt(m[3], 10);
+  const hour = parseInt(m[4], 10);
   const minute = parseInt(m[5], 10);
   const second = parseInt(m[6], 10);
   const tz = m[7] || null;
 
   if (!(month >= 1 && month <= 12)) return null;
   if (!(day >= 1 && day <= 31)) return null;
+  if (!(hour >= 0 && hour <= 23)) return null;
   if (!(minute >= 0 && minute <= 59)) return null;
   if (!(second >= 0 && second <= 59)) return null;
 
-  return { yearStr, month, day, minute, second, tz };
+  return { yearStr, month, day, hour, minute, second, tz };
 }
 
 function parseDatetimeLike(t) {
@@ -4129,7 +4131,7 @@ function evalCryptoHashBuiltin(g, subst, algo) {
 // ===========================================================================
 // Backward proof & builtins mutual recursion — declarations first
 
-function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
+function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   const g = applySubstTriple(goal, subst);
   const pv = iriValue(g.p);
   if (pv === null) return null;
@@ -4689,6 +4691,32 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     return s2 !== null ? [s2] : [];
   }
 
+  // time:hour
+  // Gets as object the integer hour component of the subject xsd:dateTime.
+  // Schema: $s+ time:hour $o-
+  if (pv === TIME_NS + 'hour') {
+    const parts = parseXsdDateTimeLexParts(g.s);
+    if (!parts) return [];
+    const out = internLiteral(String(parts.hour));
+
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = out;
+      return [s2];
+    }
+    if (g.o instanceof Blank) return [{ ...subst }];
+
+    const oi = parseIntLiteral(g.o);
+    if (oi !== null) {
+      try {
+        if (oi === BigInt(parts.hour)) return [{ ...subst }];
+      } catch {}
+    }
+
+    const s2 = unifyTerm(g.o, out, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
   // time:minute
   // Gets as object the integer minutes component of the subject xsd:dateTime.
   // Schema: $s+ time:minute $o-
@@ -5620,7 +5648,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
 
     const visited2 = [];
     // Start from the incoming substitution so bindings flow outward.
-    return proveGoals(Array.from(g.o.triples), { ...subst }, scopeFacts, [], depth + 1, visited2, varGen);
+    return proveGoals(Array.from(g.o.triples), { ...subst }, scopeFacts, [], depth + 1, visited2, varGen, maxResults);
   }
 
   // log:notIncludes
@@ -5641,7 +5669,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen) {
     });
 
     const visited2 = [];
-    const sols = proveGoals(Array.from(g.o.triples), { ...subst }, scopeFacts, [], depth + 1, visited2, varGen);
+    const sols = proveGoals(Array.from(g.o.triples), { ...subst }, scopeFacts, [], depth + 1, visited2, varGen, 1);
     return sols.length ? [] : [{ ...subst }];
   }
 
@@ -6216,10 +6244,11 @@ function maybeCompactSubst(subst, goals, answerVars, depth) {
   return gcCompactForGoals(subst, goals, answerVars);
 }
 
-function proveGoals(goals, subst, facts, backRules, depth, visited, varGen) {
+function proveGoals(goals, subst, facts, backRules, depth, visited, varGen, maxResults) {
   // Iterative DFS over proof states using an explicit stack.
   // Each state carries its own substitution and remaining goals.
   const results = [];
+  const max = typeof maxResults === 'number' && maxResults > 0 ? maxResults : Infinity;
 
   const initialGoals = Array.isArray(goals) ? goals.slice() : [];
   const initialSubst = subst ? { ...subst } : {};
@@ -6230,6 +6259,8 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen) {
   gcCollectVarsInGoals(initialGoals, answerVars);
   if (!initialGoals.length) {
     results.push(gcCompactForGoals(initialSubst, [], answerVars));
+
+    if (results.length >= max) return results;
     return results;
   }
 
@@ -6247,6 +6278,8 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen) {
 
     if (!state.goals.length) {
       results.push(gcCompactForGoals(state.subst, [], answerVars));
+
+      if (results.length >= max) return results;
       continue;
     }
 
@@ -6256,13 +6289,18 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen) {
 
     // 1) Builtins
     if (isBuiltinPred(goal0.p)) {
-      const deltas = evalBuiltin(goal0, {}, facts, backRules, state.depth, varGen);
+      const remaining = max - results.length;
+      if (remaining <= 0) return results;
+      const builtinMax = Number.isFinite(remaining) && !restGoals.length ? remaining : undefined;
+      const deltas = evalBuiltin(goal0, {}, facts, backRules, state.depth, varGen, builtinMax);
       const nextStates = [];
       for (const delta of deltas) {
         const composed = composeSubst(state.subst, delta);
         if (composed === null) continue;
         if (!restGoals.length) {
           results.push(gcCompactForGoals(composed, [], answerVars));
+
+          if (results.length >= max) return results;
         } else {
           const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           nextStates.push({
@@ -6293,6 +6331,8 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen) {
         if (composed === null) continue;
         if (!restGoals.length) {
           results.push(gcCompactForGoals(composed, [], answerVars));
+
+          if (results.length >= max) return results;
         } else {
           const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           nextStates.push({
@@ -6314,6 +6354,8 @@ function proveGoals(goals, subst, facts, backRules, depth, visited, varGen) {
         if (composed === null) continue;
         if (!restGoals.length) {
           results.push(gcCompactForGoals(composed, [], answerVars));
+
+          if (results.length >= max) return results;
         } else {
           const nextSubst = maybeCompactSubst(composed, restGoals, answerVars, state.depth + 1);
           nextStates.push({
@@ -6426,7 +6468,38 @@ function forwardChain(facts, forwardRules, backRules, onDerived /* optional */)
         const r = forwardRules[i];
         const empty = {};
         const visited = [];
-        const sols = proveGoals(r.premise.slice(), empty, facts, backRules, 0, visited, varGen);
+        // Optimization: if the rule head is **structurally ground** (no vars anywhere, even inside
+        // quoted formulas) and has no head blanks, then the head does not depend on which body
+        // solution we pick. In that case, we only need *one* proof of the body, and once all head
+        // triples are already known we can skip proving the body entirely.
+        function isStrictGroundTerm(t) {
+          if (t instanceof Var) return false;
+          if (t instanceof Blank) return false;
+          if (t instanceof OpenListTerm) return false;
+          if (t instanceof ListTerm) return t.elems.every(isStrictGroundTerm);
+          if (t instanceof GraphTerm) return t.triples.every(isStrictGroundTriple);
+          return true; // Iri/Literal and any other atomic terms
+        }
+        function isStrictGroundTriple(tr) {
+          return isStrictGroundTerm(tr.s) && isStrictGroundTerm(tr.p) && isStrictGroundTerm(tr.o);
+        }
+
+        const headIsStrictGround =
+          !r.isFuse && (!r.headBlankLabels || r.headBlankLabels.size === 0) && r.conclusion.every(isStrictGroundTriple);
+
+        if (headIsStrictGround) {
+          let allKnown = true;
+          for (const tr of r.conclusion) {
+            if (!hasFactIndexed(facts, tr)) {
+              allKnown = false;
+              break;
+            }
+          }
+          if (allKnown) continue;
+        }
+
+        const maxSols = (r.isFuse || headIsStrictGround) ? 1 : undefined;
+        const sols = proveGoals(r.premise.slice(), empty, facts, backRules, 0, visited, varGen, maxSols);
 
         // Inference fuse
         if (r.isFuse && sols.length) {

package/package.json

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