eyeling 1.22.5 → 1.22.6

package/HANDBOOK.md

@@ -2599,19 +2599,23 @@ In that sense, N3 is less a bid to make the web “smarter” than a bid to make
 
 <a id="app-c"></a>
 
-## Appendix C — N3 beyond Prolog: logic for RDF-style graphs
+## Appendix C — N3 beyond Prolog: logic that survives the open web
 
-Notation3 (N3) rule sets often look similar to Prolog at the surface: they use variables, unification, and implication-style rules (“if these patterns match, then these patterns follow”). N3 is typically used in a different setting: instead of a single program operating over a single local database, N3 rules and data are commonly written as documents that can be published, shared, merged, and referenced across systems.
+Notation3 and Prolog resemble each other at first glance. Both use variables, unification, and implication-shaped rules. Both can be used to derive consequences from a set of premises. But they were shaped for different native environments. Prolog was designed around executing logic programs. N3 was designed around expressing logic in the same world as RDF: a world of IRIs, triples, graphs, linked documents, and shared vocabularies. That difference in native setting gives N3 a wider built-in reach for web-scale knowledge work.
 
-In practice, that setting is reflected in several common features of N3-style rule writing:
+The first difference is the data model. In Prolog, the basic units are terms and clauses. In N3, the basic units are RDF-style triples and graphs, extended with variables, lists, graph terms, and logical implication. N3 is explicitly defined as an extension of RDF, not as a separate programming language that merely happens to manipulate graphs. That means identifiers, data, and inferred results all live in one interoperable form. A rule consumes graph patterns and produces graph patterns, so the output of reasoning can be published, merged, quoted, exchanged, and reasoned over again without changing representation.
 
-- **Identifiers are IRIs.** Terms are usually global identifiers rather than local symbols, which supports linking across datasets.
-- **Input and output are graphs.** Rules consume graph patterns and produce additional triples, so the result of inference can be represented in the same form as the input data.
-- **Quoted graphs allow statements-as-data.** N3 can treat a graph (a set of triples) as a term, which makes it possible to represent and reason about assertions (e.g., “this source says …” or “this formula implies …”) as data.
-- **Rules can be distributed as text artifacts.** Rules can live alongside data, be versioned, and be reused without requiring an external host language to “carry” the meaning.
-- **Built-ins cover common computations.** Many N3 workflows rely on built-ins for operations such as string handling, list processing, comparisons, and related utilities; some workflows also use IRIs as pointers to retrievable content.
+The second difference is more profound: N3 can treat graphs as first-class terms. A graph term is a quoted graph. It can appear in subject, predicate, or object position, and it does not automatically assert its contents as true. It is a resource in its own right. This makes it natural to represent claims, reports, beliefs, policies, source snapshots, and provenance. One can say not only “this is true,” but also “this document says this,” “this authority concludes that,” or “this rule applies to that quoted context.” In other words, N3 can reason about statements as statements, not only about the world those statements describe.
 
-Engines can combine execution styles in different ways. One common pattern is to use a Prolog-like backward-chaining prover to satisfy rule bodies, while still using forward chaining to add the instantiated conclusions to the fact set until no new facts are produced.
+That leads directly to a third advantage: scope is part of the logic. In N3, implicit universal quantification is global, while implicit existential quantification is local to the graph in which it occurs. Once graphs can be nested and quoted, that distinction matters. It allows a reasoner to keep track of what is asserted here, what is asserted inside a quoted subgraph, and what variables belong to which level. This gives N3 a native way to express context-sensitive reasoning that would feel external or encoded-by-convention in classic Prolog.
+
+A fourth difference is that N3 connects logic to the web inside the language itself. The N3 vocabulary includes `log:semantics` and `log:conclusion` for retrieving and reasoning over local or online sources. It also includes scoped operators such as `log:forAllIn` and `log:notIncludes`, which support scoped universal reasoning and scoped negation-as-failure over a chosen graph or document. So web retrieval, source-bounded reasoning, and reasoning over quoted content are not afterthoughts. They are part of the logic vocabulary. This is one of the clearest senses in which N3 has greater inherent potential: it is not only a language for deriving consequences from facts, but a language for locating, quoting, constraining, and comparing the sources of those facts.
+
+By contrast, classic Prolog is centered on a proof procedure over definite clauses. In the usual operational reading, Prolog applies a restricted form of SLD-resolution, chooses the leftmost goal, tries clauses top-to-bottom, and searches depth-first. Traditional negation is negation-as-failure, described in the SWI-Prolog glossary as a weak negation. This makes Prolog extremely effective as an executable logic language, but it also means that much of its practical power comes from the operational behavior of the engine, not from a web-native knowledge model.
+
+This does not make Prolog inferior. Modern Prolog systems add important capabilities beyond the classic core, including tabling, which improves termination behavior and can make Prolog behave more like a bottom-up theorem prover for some classes of problems. But that actually sharpens the comparison: when Prolog needs to work more comfortably in graph-heavy or knowledge-integration settings, it typically gains that power through extensions, libraries, or host-environment choices. N3 starts there. Graphs, quoted formulas, scoped reasoning, and web-connected semantics are part of its native conceptual center.
+
+So the strongest claim is not that N3 replaces Prolog in every domain. The stronger and more precise claim is this: Prolog is a very strong language for executing logic programs, while N3 has greater inherent potential as a language for publishable, linkable, inspectable, and source-aware logic on the open web. It lets facts, rules, quoted claims, retrieved documents, and derived conclusions all live in one semantic space. For a system like Eyeling, that is not a cosmetic difference. It is the reason the language can scale from local inference to web-shaped reasoning without changing its basic form.
 
 ---
 

package/dist/browser/eyeling.browser.js

@@ -3988,6 +3988,23 @@
           results.push(s2);
         }
 
+        // Also match quoted log:implies triples present as data in the current scope.
+        if (facts && typeof facts.length === 'number') {
+          ensureFactIndexes(facts);
+          const pb = facts.__byPred.get(goal.p.__tid) || [];
+          for (const idx of pb) {
+            const tr = facts[idx];
+
+            let s2 = unifyTerm(goal.s, tr.s, subst);
+            if (s2 === null) continue;
+
+            s2 = unifyTerm(goal.o, tr.o, s2);
+            if (s2 === null) continue;
+
+            results.push(s2);
+          }
+        }
+
         return results;
       }
 
@@ -4017,6 +4034,23 @@
           results.push(s2);
         }
 
+        // Also match quoted log:impliedBy triples present as data in the current scope.
+        if (facts && typeof facts.length === 'number') {
+          ensureFactIndexes(facts);
+          const pb = facts.__byPred.get(goal.p.__tid) || [];
+          for (const idx of pb) {
+            const tr = facts[idx];
+
+            let s2 = unifyTerm(goal.s, tr.s, subst);
+            if (s2 === null) continue;
+
+            s2 = unifyTerm(goal.o, tr.o, s2);
+            if (s2 === null) continue;
+
+            results.push(s2);
+          }
+        }
+
         return results;
       }
 

package/eyeling.js

@@ -3974,6 +3974,23 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       results.push(s2);
     }
 
+    // Also match quoted log:implies triples present as data in the current scope.
+    if (facts && typeof facts.length === 'number') {
+      ensureFactIndexes(facts);
+      const pb = facts.__byPred.get(goal.p.__tid) || [];
+      for (const idx of pb) {
+        const tr = facts[idx];
+
+        let s2 = unifyTerm(goal.s, tr.s, subst);
+        if (s2 === null) continue;
+
+        s2 = unifyTerm(goal.o, tr.o, s2);
+        if (s2 === null) continue;
+
+        results.push(s2);
+      }
+    }
+
     return results;
   }
 
@@ -4003,6 +4020,23 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       results.push(s2);
     }
 
+    // Also match quoted log:impliedBy triples present as data in the current scope.
+    if (facts && typeof facts.length === 'number') {
+      ensureFactIndexes(facts);
+      const pb = facts.__byPred.get(goal.p.__tid) || [];
+      for (const idx of pb) {
+        const tr = facts[idx];
+
+        let s2 = unifyTerm(goal.s, tr.s, subst);
+        if (s2 === null) continue;
+
+        s2 = unifyTerm(goal.o, tr.o, s2);
+        if (s2 === null) continue;
+
+        results.push(s2);
+      }
+    }
+
     return results;
   }
 

package/lib/builtins.js

@@ -3495,6 +3495,23 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       results.push(s2);
     }
 
+    // Also match quoted log:implies triples present as data in the current scope.
+    if (facts && typeof facts.length === 'number') {
+      ensureFactIndexes(facts);
+      const pb = facts.__byPred.get(goal.p.__tid) || [];
+      for (const idx of pb) {
+        const tr = facts[idx];
+
+        let s2 = unifyTerm(goal.s, tr.s, subst);
+        if (s2 === null) continue;
+
+        s2 = unifyTerm(goal.o, tr.o, s2);
+        if (s2 === null) continue;
+
+        results.push(s2);
+      }
+    }
+
     return results;
   }
 
@@ -3524,6 +3541,23 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       results.push(s2);
     }
 
+    // Also match quoted log:impliedBy triples present as data in the current scope.
+    if (facts && typeof facts.length === 'number') {
+      ensureFactIndexes(facts);
+      const pb = facts.__byPred.get(goal.p.__tid) || [];
+      for (const idx of pb) {
+        const tr = facts[idx];
+
+        let s2 = unifyTerm(goal.s, tr.s, subst);
+        if (s2 === null) continue;
+
+        s2 = unifyTerm(goal.o, tr.o, s2);
+        if (s2 === null) continue;
+
+        results.push(s2);
+      }
+    }
+
     return results;
   }
 

package/package.json

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

package/test/api.test.js

@@ -2178,6 +2178,64 @@ _:x :hates { _:foo :making :mess }.
       /^"3"\^\^xsd:integer\s+:is\s+\("3"\s+xsd:integer\)\s*\./m,
     ],
   },
+  {
+    name: '245 regression: log:includes sees quoted log:implies triples as data',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+<> :data {
+    {
+        ?A a ?B .
+        ?B rdfs:subClassOf ?C.
+    }
+    =>
+    {
+        ?A a ?C .
+    }.
+}.
+
+{
+    ?W :data ?F.
+    ?F log:includes { ?X log:implies ?Y }.
+}
+=>
+{
+    :result :is ?X .
+}.
+`,
+    expect: [/^:result\s+:is\s+\{[\s\S]*\?A\s+a\s+\?B\s*\.[\s\S]*\?B\s+rdfs:subClassOf\s+\?C\s*\.[\s\S]*\}\s*\./m],
+  },
+  {
+    name: '246 regression: log:includes sees quoted log:impliedBy triples as data',
+    opt: { proofComments: false },
+    input: `@prefix : <http://example.org/> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+<> :data {
+    {
+        ?A a ?C .
+    }
+    <=
+    {
+        ?A a ?B .
+        ?B rdfs:subClassOf ?C.
+    }.
+}.
+
+{
+    ?W :data ?F.
+    ?F log:includes { ?Y <= ?X }.
+}
+=>
+{
+    :result :is ?X .
+}.
+`,
+    expect: [/^:result\s+:is\s+\{[\s\S]*\?A\s+a\s+\?B\s*\.[\s\S]*\?B\s+rdfs:subClassOf\s+\?C\s*\.[\s\S]*\}\s*\./m],
+  },
 ];
 
 let passed = 0;