eyeling 1.22.4 → 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.
 
 ---
 
@@ -3131,29 +3135,69 @@ Sometimes that means recomputing a quantity from another angle. Sometimes it mea
 
 The point is not to make checks large. The point is to make them real.
 
-### F.6 Examples in `examples/` that read well in ARC style
+### F.6 ARC and the Insight Economy
+
+One reason ARC matters beyond pedagogy is that it matches a broader way of thinking about data and computation that Ruben Verborgh has called the **Insight Economy**.
+
+The basic claim is simple: raw data is usually the wrong thing to exchange directly. A better system refines source data into a **specific, purpose-limited, time-bound insight** that is useful in one context, loses much of its value when copied without that context, and can be governed more safely than an unrestricted dump of the original data.
+
+That fits Eyeling remarkably well. Eyeling can derive narrow conclusions explicitly, show why they follow, and attach checks that make sure a decision still respects policy, scope, thresholds, or consistency constraints. In other words, an Eyeling program can act as a small governed insight refinery rather than as a black box that merely emits a verdict.
+
+This is also why ARC is a good mental model here. The **Answer** is the bounded insight. The **Reason Why** makes the governing basis visible. The **Check** ensures the result can be trusted for the stated purpose instead of silently drifting beyond it.
+
+### F.7 ARC-style examples in `examples/`
+
+The following examples are especially useful if you want to see Eyeling files that derive an answer, expose the key reason, and include meaningful checks. Each entry links to both the source example and the corresponding generated output file in `examples/output/`.
+
+#### Insight Economy and governed-data cases
+
+- [`examples/auroracare.n3`](examples/auroracare.n3) · [`examples/output/auroracare.txt`](examples/output/auroracare.txt) — purpose-based medical data exchange with explicit allow/deny reasoning and checks around role, purpose, and conditions.
+- [`examples/calidor.n3`](examples/calidor.n3) · [`examples/output/calidor.txt`](examples/output/calidor.txt) — heatwave-response case where private household signals become a narrow, expiring cooling-support insight.
+- [`examples/delfour.n3`](examples/delfour.n3) · [`examples/output/delfour.txt`](examples/output/delfour.txt) — shopping-assistance case where a private condition becomes a bounded “prefer lower-sugar products” insight.
+- [`examples/flandor.n3`](examples/flandor.n3) · [`examples/output/flandor.txt`](examples/output/flandor.txt) — macro-economic coordination case for Flanders that turns sensitive local signals into a regional retooling insight.
+- [`examples/medior.n3`](examples/medior.n3) · [`examples/output/medior.txt`](examples/output/medior.txt) — post-discharge care-coordination case that derives a minimal continuity-bundle insight without sharing the full record.
+- [`examples/parcellocker.n3`](examples/parcellocker.n3) · [`examples/output/parcellocker.txt`](examples/output/parcellocker.txt) — one-time parcel pickup authorization with a clear permit decision, justification, and misuse checks.
+
+#### Core ARC-style walkthroughs
+
+- [`examples/bmi.n3`](examples/bmi.n3) · [`examples/output/bmi.txt`](examples/output/bmi.txt) — Body Mass Index calculation with normalization, WHO category assignment, and boundary checks.
+- [`examples/control-system.n3`](examples/control-system.n3) · [`examples/output/control-system.txt`](examples/output/control-system.txt) — small control-system example that derives actuator commands and explains feedforward and feedback contributions.
+- [`examples/easter.n3`](examples/easter.n3) · [`examples/output/easter.txt`](examples/output/easter.txt) — Gregorian Easter computus with a readable explanation and date-window checks.
+- [`examples/french-cities.n3`](examples/french-cities.n3) · [`examples/output/french-cities.txt`](examples/output/french-cities.txt) — graph reachability over French cities with explicit path reasoning.
+- [`examples/gps.n3`](examples/gps.n3) · [`examples/output/gps.txt`](examples/output/gps.txt) — tiny route-planning example for western Belgium with route comparison and metric checks.
+- [`examples/resto.n3`](examples/resto.n3) · [`examples/output/resto.txt`](examples/output/resto.txt) — RESTdesc-style service composition from person and date to a concrete restaurant reservation.
+- [`examples/sudoku.n3`](examples/sudoku.n3) · [`examples/output/sudoku.txt`](examples/output/sudoku.txt) — Sudoku solver and report generator with consistency checks over the solved grid.
+- [`examples/wind-turbine.n3`](examples/wind-turbine.n3) · [`examples/output/wind-turbine.txt`](examples/output/wind-turbine.txt) — predictive-maintenance example that turns sensor readings into an auditable inspection decision.
+
+#### Technical and scientific ARC demos
+
+- [`examples/matrix-mechanics.n3`](examples/matrix-mechanics.n3) · [`examples/output/matrix-mechanics.txt`](examples/output/matrix-mechanics.txt) — small 2×2 matrix example deriving trace, determinant, products, and a non-zero commutator.
+- [`examples/pn-junction-tunneling.n3`](examples/pn-junction-tunneling.n3) · [`examples/output/pn-junction-tunneling.txt`](examples/output/pn-junction-tunneling.txt) — semiconductor toy model that explains current-proxy behavior across bias points.
+- [`examples/transistor-switch.n3`](examples/transistor-switch.n3) · [`examples/output/transistor-switch.txt`](examples/output/transistor-switch.txt) — NPN low-side switch model with exact arithmetic and cutoff-versus-saturation checks.
+
+#### Deep-classification stress tests
 
-The following examples are especially good places to see this style in practice.
+- [`examples/deep-taxonomy-10.n3`](examples/deep-taxonomy-10.n3) · [`examples/output/deep-taxonomy-10.txt`](examples/output/deep-taxonomy-10.txt) — ARC-style deep-taxonomy benchmark at depth 10.
+- [`examples/deep-taxonomy-100.n3`](examples/deep-taxonomy-100.n3) · [`examples/output/deep-taxonomy-100.txt`](examples/output/deep-taxonomy-100.txt) — ARC-style deep-taxonomy benchmark at depth 100.
+- [`examples/deep-taxonomy-1000.n3`](examples/deep-taxonomy-1000.n3) · [`examples/output/deep-taxonomy-1000.txt`](examples/output/deep-taxonomy-1000.txt) — ARC-style deep-taxonomy benchmark at depth 1000.
+- [`examples/deep-taxonomy-10000.n3`](examples/deep-taxonomy-10000.n3) · [`examples/output/deep-taxonomy-10000.txt`](examples/output/deep-taxonomy-10000.txt) — ARC-style deep-taxonomy benchmark at depth 10000.
+- [`examples/deep-taxonomy-100000.n3`](examples/deep-taxonomy-100000.n3) · [`examples/output/deep-taxonomy-100000.txt`](examples/output/deep-taxonomy-100000.txt) — ARC-style deep-taxonomy benchmark at depth 100000.
 
-- [`examples/delfour.n3`](examples/delfour.n3) — privacy-preserving shopping assistance with a concrete recommendation, an explanation, and policy checks. Expected output: [`examples/output/delfour.n3`](examples/output/delfour.n3)
-- [`examples/control-system.n3`](examples/control-system.n3) — derives actuator decisions, explains the control basis, and checks the result. Expected output: [`examples/output/control-system.n3`](examples/output/control-system.n3)
-- [`examples/deep-taxonomy-100000.n3`](examples/deep-taxonomy-100000.n3) — a deep classification stress test whose answer is whether the final goal class is reached. Expected output: [`examples/output/deep-taxonomy-100000.n3`](examples/output/deep-taxonomy-100000.n3)
-- [`examples/gps.n3`](examples/gps.n3) — route planning with readable route output. Expected output: [`examples/output/gps.n3`](examples/output/gps.n3)
-- [`examples/sudoku.n3`](examples/sudoku.n3) — solver output plus legality and consistency checks. Expected output: [`examples/output/sudoku.n3`](examples/output/sudoku.n3)
+These files fit together because they all present reasoning in a recognizably ARC-like way: they derive an answer, make the reason visible in a compact report, and include checks that are meant to catch real mistakes. Some are classical logic or numeric examples; others show how Eyeling can express policy-aware, insight-oriented decision flows without collapsing everything into opaque application code.
 
-### F.7 How to read an ARC-style example
+### F.8 How to read an ARC-style example
 
 A good way to read one of these files is to start with the question in the comments or input facts. Then find the part that gives the answer. Then trace the few rules that explain why that answer follows. Finally, look for the checks: the validation facts, the recomputation, or the `=> false` fuse that would stop the run if something important were wrong.
 
 That reading order keeps the example grounded in observable behavior rather than in source code alone.
 
-### F.8 What ARC is not
+### F.9 What ARC is not
 
 ARC does not mean wrapping every file in ceremony. It does not mean long prose explanations. It does not mean hiding important assumptions in comments while the executable part stays thin. And it does not mean replacing checks with a confident tone.
 
 A file really follows ARC only when the answer, the explanation, and the validation all live in the program itself.
 
-### F.9 Why this style is worth using
+### F.10 Why this style is worth using
 
 This style is worth using because it makes an Eyeling file easier to run, easier to inspect, and easier to trust. The result is visible. The key reason is visible. The check is visible. That makes examples better teaching material, makes policy or computation examples easier to audit, and makes the whole file more reusable as a small reasoning artifact instead of an opaque session transcript.
 

package/dist/browser/eyeling.browser.js

@@ -1343,6 +1343,15 @@
       return null;
     }
 
+    function inferDatatypeForShorthandLexical(lex) {
+      if (typeof lex !== 'string' || isQuotedLexical(lex)) return null;
+      if (lex === 'true' || lex === 'false') return XSD_NS + 'boolean';
+      if (/^[+-]?\d+$/.test(lex)) return XSD_NS + 'integer';
+      if (/^[+-]?(?:\d+\.\d*|\.\d+)$/.test(lex)) return XSD_NS + 'decimal';
+      if (/^[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)$/.test(lex)) return XSD_NS + 'double';
+      return null;
+    }
+
     // ===========================================================================
     // Math builtin helpers
     // ===========================================================================
@@ -3864,6 +3873,7 @@
           if (oDt === null) {
             if (literalHasLangTag(g.o.value)) oDt = RDF_NS + 'langString';
             else if (isPlainStringLiteralValue(g.o.value)) oDt = XSD_NS + 'string';
+            else oDt = inferDatatypeForShorthandLexical(oLex);
           }
 
           if (oDt !== null) {
@@ -3978,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;
       }
 
@@ -4007,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/examples/arcling/README.md

@@ -1,57 +1,11 @@
 # ARC-style examples in Eyeling
 
-This page points to the ARC-style examples that currently live in [`examples/`](../). The files themselves are one level up; this folder exists as a convenient index for readers who want to browse Eyeling examples that follow the same presentation pattern.
+This content is now integrated into the handbook:
 
-## What ARC is
+- [Appendix F — The ARC approach: Answer • Reason Why • Check](../../HANDBOOK.md#app-f)
 
-[ARC](https://josd.github.io/arc/) stands for **Answer • Reason Why • Check**. The idea is to make a program do three things at once: give the result, explain the small reason that matters, and include a check that can fail loudly when an assumption is wrong. In practice, ARC turns a runnable example into a small, auditable artifact rather than a black box.
+That appendix now includes:
 
-In Eyeling, ARC fits naturally: facts hold the data, rules derive the result, `log:outputString` can render a human-readable report, and `=> false` rules can act as hard validation fuses.
-
-## What the Insight Economy is
-
-Ruben Verborgh’s [Insight Economy](https://ruben.verborgh.org/blog/2025/08/12/inside-the-insight-economy/) argues that raw data is a bad thing to trade directly. Instead of handing over the source data, a system should refine it into a **specific, purpose-limited, time-bound insight** that is useful in one context, loses value when copied, and can be governed more safely.
-
-That makes the examples below especially relevant: Eyeling can derive those narrow insights explicitly, explain why they hold, and check that the resulting decision respects policy, purpose, and consistency constraints.
-
-## ARC-style examples in `examples/`
-
-Each entry links to both the source example and the corresponding generated output in [`examples/output/`](../output/).
-
-### Insight Economy and governed-data cases
-
-- [`../auroracare.n3`](../auroracare.n3) · [`../output/auroracare.txt`](../output/auroracare.txt) — Purpose-based medical data exchange with explicit allow/deny reasoning and checks around role, purpose, and conditions.
-- [`../calidor.n3`](../calidor.n3) · [`../output/calidor.txt`](../output/calidor.txt) — Heatwave-response case where private household signals become a narrow, expiring cooling-support insight.
-- [`../delfour.n3`](../delfour.n3) · [`../output/delfour.txt`](../output/delfour.txt) — Shopping-assistance case where a private condition becomes a bounded “prefer lower-sugar products” insight.
-- [`../flandor.n3`](../flandor.n3) · [`../output/flandor.txt`](../output/flandor.txt) — Macro-economic coordination case for Flanders that turns sensitive local signals into a regional retooling insight.
-- [`../medior.n3`](../medior.n3) · [`../output/medior.txt`](../output/medior.txt) — Post-discharge care-coordination case that derives a minimal continuity-bundle insight without sharing the full record.
-- [`../parcellocker.n3`](../parcellocker.n3) · [`../output/parcellocker.txt`](../output/parcellocker.txt) — One-time parcel pickup authorization with a clear permit decision, justification, and misuse checks.
-
-### Core ARC-style walkthroughs
-
-- [`../bmi.n3`](../bmi.n3) · [`../output/bmi.txt`](../output/bmi.txt) — Body Mass Index calculation with normalization, WHO category assignment, and boundary checks.
-- [`../control-system.n3`](../control-system.n3) · [`../output/control-system.txt`](../output/control-system.txt) — Small control-system example that derives actuator commands and explains feedforward and feedback contributions.
-- [`../easter.n3`](../easter.n3) · [`../output/easter.txt`](../output/easter.txt) — Gregorian Easter computus with a readable explanation and date-window checks.
-- [`../french-cities.n3`](../french-cities.n3) · [`../output/french-cities.txt`](../output/french-cities.txt) — Graph reachability over French cities with explicit path reasoning.
-- [`../gps.n3`](../gps.n3) · [`../output/gps.txt`](../output/gps.txt) — Tiny route-planning example for western Belgium with route comparison and metric checks.
-- [`../resto.n3`](../resto.n3) · [`../output/resto.txt`](../output/resto.txt) — RESTdesc-style service composition from person and date to a concrete restaurant reservation.
-- [`../sudoku.n3`](../sudoku.n3) · [`../output/sudoku.txt`](../output/sudoku.txt) — Sudoku solver and report generator with consistency checks over the solved grid.
-- [`../wind-turbine.n3`](../wind-turbine.n3) · [`../output/wind-turbine.txt`](../output/wind-turbine.txt) — Predictive-maintenance example that turns sensor readings into an auditable inspection decision.
-
-### Technical and scientific ARC demos
-
-- [`../matrix-mechanics.n3`](../matrix-mechanics.n3) · [`../output/matrix-mechanics.txt`](../output/matrix-mechanics.txt) — Small 2×2 matrix example deriving trace, determinant, products, and a non-zero commutator.
-- [`../pn-junction-tunneling.n3`](../pn-junction-tunneling.n3) · [`../output/pn-junction-tunneling.txt`](../output/pn-junction-tunneling.txt) — Semiconductor toy model that explains current-proxy behavior across bias points.
-- [`../transistor-switch.n3`](../transistor-switch.n3) · [`../output/transistor-switch.txt`](../output/transistor-switch.txt) — NPN low-side switch model with exact arithmetic and cutoff-versus-saturation checks.
-
-### Deep-classification stress tests
-
-- [`../deep-taxonomy-10.n3`](../deep-taxonomy-10.n3) · [`../output/deep-taxonomy-10.txt`](../output/deep-taxonomy-10.txt) — ARC-style deep-taxonomy benchmark at depth 10.
-- [`../deep-taxonomy-100.n3`](../deep-taxonomy-100.n3) · [`../output/deep-taxonomy-100.txt`](../output/deep-taxonomy-100.txt) — ARC-style deep-taxonomy benchmark at depth 100.
-- [`../deep-taxonomy-1000.n3`](../deep-taxonomy-1000.n3) · [`../output/deep-taxonomy-1000.txt`](../output/deep-taxonomy-1000.txt) — ARC-style deep-taxonomy benchmark at depth 1000.
-- [`../deep-taxonomy-10000.n3`](../deep-taxonomy-10000.n3) · [`../output/deep-taxonomy-10000.txt`](../output/deep-taxonomy-10000.txt) — ARC-style deep-taxonomy benchmark at depth 10000.
-- [`../deep-taxonomy-100000.n3`](../deep-taxonomy-100000.n3) · [`../output/deep-taxonomy-100000.txt`](../output/deep-taxonomy-100000.txt) — ARC-style deep-taxonomy benchmark at depth 100000.
-
-## Why these examples fit together
-
-These files all present reasoning in a recognizably ARC-like way: they derive an answer, make the reason visible in a compact report, and include checks that are meant to catch real mistakes. Some are classical logic or numeric examples; others show how Eyeling can express policy-aware, insight-oriented decision flows without collapsing everything into opaque application code.
+- a brief explanation of ARC,
+- a brief explanation of the Insight Economy,
+- and links to the ARC-style examples in `examples/` together with their outputs in `examples/output/`.

package/examples/output/sudoku.txt

@@ -28,6 +28,7 @@ Completed grid
 3 5 6 | 4 7 8 | 2 1 9 
 2 4 1 | 9 3 5 | 8 6 7 
 8 9 7 | 2 6 1 | 3 5 4 
+
 === Reason Why ===
 The solver starts from 23 clues and fills the remaining 58 cells by combining constraint propagation with depth-first search. At each step it chooses the empty cell with the fewest legal digits, places forced singles immediately, and only guesses when more than one candidate remains. Across the search it made 213 forced placements and tried 22 guesses, visited 23 search nodes overall, and backtracked 12 times before reaching the completed grid. The solver also confirmed that the solution is unique. Early steps: r2c3=4: guess, r5c3=3: forced, r2c1=5: guess, r2c4=1: guess, r2c6=9: forced, r2c7=6: guess, r2c8=7: forced, r1c7=4: guess, … and 50 more placements
 

package/examples/sudoku.n3

@@ -114,8 +114,8 @@
                      log:outputString ?puzzleText ;
                      log:outputString "\n" ;
                      log:outputString "Completed grid\n" ;
-                     log:outputString ?solutionText ;
-                     log:outputString "\n\n" .
+                     log:outputString ?solutionText .
+         :01b-answer log:outputString "\n" .
          :02-reason log:outputString "=== Reason Why ===\n" ;
                     log:outputString ?reasonText ;
                     log:outputString "\n\n" .

package/eyeling.js

@@ -1338,6 +1338,15 @@ function parseXsdFloatSpecialLex(s) {
   return null;
 }
 
+function inferDatatypeForShorthandLexical(lex) {
+  if (typeof lex !== 'string' || isQuotedLexical(lex)) return null;
+  if (lex === 'true' || lex === 'false') return XSD_NS + 'boolean';
+  if (/^[+-]?\d+$/.test(lex)) return XSD_NS + 'integer';
+  if (/^[+-]?(?:\d+\.\d*|\.\d+)$/.test(lex)) return XSD_NS + 'decimal';
+  if (/^[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)$/.test(lex)) return XSD_NS + 'double';
+  return null;
+}
+
 // ===========================================================================
 // Math builtin helpers
 // ===========================================================================
@@ -3850,6 +3859,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       if (oDt === null) {
         if (literalHasLangTag(g.o.value)) oDt = RDF_NS + 'langString';
         else if (isPlainStringLiteralValue(g.o.value)) oDt = XSD_NS + 'string';
+        else oDt = inferDatatypeForShorthandLexical(oLex);
       }
 
       if (oDt !== null) {
@@ -3964,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;
   }
 
@@ -3993,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

@@ -859,6 +859,15 @@ function parseXsdFloatSpecialLex(s) {
   return null;
 }
 
+function inferDatatypeForShorthandLexical(lex) {
+  if (typeof lex !== 'string' || isQuotedLexical(lex)) return null;
+  if (lex === 'true' || lex === 'false') return XSD_NS + 'boolean';
+  if (/^[+-]?\d+$/.test(lex)) return XSD_NS + 'integer';
+  if (/^[+-]?(?:\d+\.\d*|\.\d+)$/.test(lex)) return XSD_NS + 'decimal';
+  if (/^[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)$/.test(lex)) return XSD_NS + 'double';
+  return null;
+}
+
 // ===========================================================================
 // Math builtin helpers
 // ===========================================================================
@@ -3371,6 +3380,7 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       if (oDt === null) {
         if (literalHasLangTag(g.o.value)) oDt = RDF_NS + 'langString';
         else if (isPlainStringLiteralValue(g.o.value)) oDt = XSD_NS + 'string';
+        else oDt = inferDatatypeForShorthandLexical(oLex);
       }
 
       if (oDt !== null) {
@@ -3485,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;
   }
 
@@ -3514,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.4",
+  "version": "1.22.6",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/api.test.js

@@ -2152,6 +2152,90 @@ _:x :hates { _:foo :making :mess }.
     ],
     notExpect: [/:result\s+:sumX\s+"329"\^\^xsd:decimal\s*\./, /:result\s+:meanX\s+"47"\^\^xsd:decimal\s*\./],
   },
+  {
+    name: '244 regression: log:dtlit recognizes shorthand numeric and boolean literals',
+    opt: { proofComments: false },
+    input: `@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix : <http://example.org#> .
+
+:let :term 4, 2.5, 3e1, true, "3"^^xsd:integer .
+
+{
+  :let :term ?term .
+  (?text ?datatype) log:dtlit ?term .
+}
+=>
+{
+  ?term :is (?text ?datatype) .
+}.
+`,
+    expect: [
+      /^4\s+:is\s+\("4"\s+xsd:integer\)\s*\./m,
+      /^2\.5\s+:is\s+\("2\.5"\s+xsd:decimal\)\s*\./m,
+      /^3e1\s+:is\s+\("3e1"\s+xsd:double\)\s*\./m,
+      /^true\s+:is\s+\("true"\s+xsd:boolean\)\s*\./m,
+      /^"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;