eyelang 1.7.8 → 1.7.9

package/README.md

@@ -4,7 +4,7 @@
 [![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20761726-blue.svg)](https://doi.org/10.5281/zenodo.20761726)
 
 Eyelang is a small logic programming language for rules, goals, answers, and proofs.
-Its source syntax is Prolog-like Horn-clause syntax with deliberate eyelang choices, including `?x` variables for N3/SPARQL-style readability, explicit `table(path, 2).` declarations for tabled predicates, advisory `mode/3` declarations for host tooling, and stratified-negation diagnostics for portable `not/1` usage.
+Its source syntax is Prolog-like Horn-clause syntax with deliberate eyelang choices, including `?x` variables for N3/SPARQL-style readability, explicit `table(path, 2).` declarations for tabled predicates, advisory `mode/3` declarations for host tooling, explicit Herbrand witness terms for executable existential-style consequences, and stratified-negation diagnostics for portable `not/1` usage.
 It grew out of logic-language experiments in the EYE/N3 reasoning tradition, but is packaged here as its own project.
 
 ## Install and run

package/conformance-report.md

@@ -14,12 +14,12 @@ This report summarizes the file-based conformance corpus under `test/conformance
 | lists | 54 | 3 | 0 | 0 | 57 |
 | materialize | 8 | 0 | 0 | 0 | 8 |
 | negation | 8 | 0 | 19 | 0 | 27 |
-| proofs | 0 | 0 | 0 | 20 | 20 |
+| proofs | 0 | 0 | 0 | 21 | 21 |
 | rules | 12 | 3 | 0 | 0 | 15 |
 | strings | 40 | 0 | 0 | 0 | 40 |
 | syntax | 11 | 28 | 0 | 0 | 39 |
 | table | 6 | 0 | 0 | 0 | 6 |
-| terms | 25 | 3 | 0 | 0 | 28 |
+| terms | 29 | 3 | 0 | 0 | 32 |
 | unification | 16 | 0 | 0 | 0 | 16 |
 | variables | 16 | 11 | 0 | 0 | 27 |
-| **Total** | **317** | **56** | **19** | **20** | **412** |
+| **Total** | **321** | **56** | **19** | **21** | **417** |

package/docs/guide.md

@@ -373,7 +373,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`equivalence-classes-overlap-implies-same-class.eye`](../examples/equivalence-classes-overlap-implies-same-class.eye) | Packages the shared-member proof pattern for equivalence classes. | [`output/equivalence-classes-overlap-implies-same-class.eye`](../examples/output/equivalence-classes-overlap-implies-same-class.eye) |
 | [`eulerian-path.eye`](../examples/eulerian-path.eye) | Finds an Eulerian path using each edge once. | [`output/eulerian-path.eye`](../examples/output/eulerian-path.eye) |
 | [`ev-range-worlds.eye`](../examples/ev-range-worlds.eye) | Estimates electric-vehicle trip feasibility. | [`output/ev-range-worlds.eye`](../examples/output/ev-range-worlds.eye) |
-| [`existential-rule.eye`](../examples/existential-rule.eye) | Represents existential witnesses with explicit Skolem-style terms. | [`output/existential-rule.eye`](../examples/output/existential-rule.eye) |
+| [`existential-rule.eye`](../examples/existential-rule.eye) | Represents existential-style witnesses with explicit Herbrand terms. | [`output/existential-rule.eye`](../examples/output/existential-rule.eye) |
 | [`exoplanet-validation-worlds.eye`](../examples/exoplanet-validation-worlds.eye) | Validates exoplanet candidates across worlds. | [`output/exoplanet-validation-worlds.eye`](../examples/output/exoplanet-validation-worlds.eye) |
 | [`expression-eval.eye`](../examples/expression-eval.eye) | Evaluates a small arithmetic expression tree. | [`output/expression-eval.eye`](../examples/output/expression-eval.eye) |
 | [`family-cousins.eye`](../examples/family-cousins.eye) | Derives cousin and family labels. | [`output/family-cousins.eye`](../examples/output/family-cousins.eye) |
@@ -444,6 +444,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`service-impact.eye`](../examples/service-impact.eye) | Analyzes service impact over cyclic dependencies. | [`output/service-impact.eye`](../examples/output/service-impact.eye) |
 | [`sieve.eye`](../examples/sieve.eye) | Enumerates primes with a sieve-style program. | [`output/sieve.eye`](../examples/output/sieve.eye) |
 | [`skolem-functions.eye`](../examples/skolem-functions.eye) | Generates deterministic functional terms. | [`output/skolem-functions.eye`](../examples/output/skolem-functions.eye) |
+| [`herbrand-witnesses.eye`](../examples/herbrand-witnesses.eye) | Represents existential-style consequences as stable Herbrand witness terms. | [`output/herbrand-witnesses.eye`](../examples/output/herbrand-witnesses.eye) |
 | [`socket-age.eye`](../examples/socket-age.eye) | Shows socket-declared age reasoning inputs and plugs. | [`output/socket-age.eye`](../examples/output/socket-age.eye) |
 | [`socket-family.eye`](../examples/socket-family.eye) | Shows socket-declared family-source inputs and ancestry rules. | [`output/socket-family.eye`](../examples/output/socket-family.eye) |
 | [`socrates.eye`](../examples/socrates.eye) | Derives that Socrates is mortal. | [`output/socrates.eye`](../examples/output/socrates.eye) |

package/docs/language-reference.md

@@ -333,6 +333,18 @@ Equivalently, the least Herbrand model is obtained by repeatedly applying the im
 
 Variables do not range over external objects, records, pointers, or host-language values. In the logical reading, variables range over Herbrand terms. A rule is implicitly universally quantified over its variables. A selected goal is existential in the usual logic-programming sense: eyelang searches for substitutions of its variables by Herbrand terms that make the goal true with respect to the program.
 
+eyelang has no blank nodes and no existential variables in rule heads. Existential-style consequences SHOULD be represented by explicit Herbrand witness terms written directly in rule heads:
+
+```eyelang
+has_parent(?child, parent_of(?child)) :-
+  person(?child).
+
+registration(?student, ?course, registration_of(?student, ?course)) :-
+  takes(?student, ?course).
+```
+
+These rules may derive `parent_of(alice)` or `registration_of(alice, logic)` as ordinary visible Herbrand terms. The witness is deterministic: the same functor and inputs produce the same term, while different inputs produce different terms by normal syntactic identity. This is the practical executable form of existential-style consequences in Eyelang; it does not introduce hidden blank nodes or special quantifier syntax.
+
 ### 8.2 Equality, identity, and unification
 
 Because the domain is Herbrand, equality in the pure language is syntactic identity of terms after substitution. Two distinct atom constants are distinct. Two compound terms are equal only when they have the same functor, the same arity, and pairwise equal arguments. Lists follow the same rule through their `[]` and `./2` representation.

package/examples/existential-rule.eye

@@ -1,21 +1,14 @@
-% Existential introduction with explicit witnesses.
-% Eyeling's original N3 rule creates existential blank nodes; in Eyelang the
-% same idea is represented by deterministic Skolem-style witness terms so the
-% generated individual is visible in ordinary output.
+% Existential-style introduction with explicit Herbrand witnesses.
 %
-% The materialized is/2 facts show the person-to-witness relation.
-materialize(is, 2).
+% Eyelang has no blank nodes and no existential variables in rule heads.  A
+% rule can still express the practical executable shape of an existential
+% consequence by putting a named functional term directly in the head.
 
-% Source data says which people are humans and which witness term belongs to
-% each human.  The single rule below is the existential-style introduction step.
+materialize(is, 2).
 
 type(socrates, human).
 type(plato, human).
 
-witness(socrates, sk_0).
-witness(plato, sk_1).
-
-% In proof output this rule is the step that explains why each witness exists.
-is(?person, ?witness) :-
-  type(?person, human),
-  witness(?person, ?witness).
+% In proof output this rule is the step that explains each visible witness.
+is(?person, human_witness(?person)) :-
+  type(?person, human).

package/examples/herbrand-witnesses.eye

@@ -0,0 +1,31 @@
+% Existential-style consequences as explicit Herbrand witness terms.
+%
+% Eyelang has no blank nodes and no existential variables in rule heads.  The
+% practical executable form is to put a named functional term directly in the
+% rule head.  The term is ordinary data: stable, visible, and proof-friendly.
+
+materialize(has_parent, 2).
+materialize(registration, 3).
+materialize(same_witness, 2).
+materialize(distinct_witnesses, 2).
+
+person(alice).
+person(bob).
+
+takes(alice, logic).
+takes(alice, math).
+takes(bob, logic).
+
+% One variable: every person has a deterministic parent witness.
+has_parent(?child, parent_of(?child)) :-
+  person(?child).
+
+% Two variables: every student/course pair has its own registration witness.
+registration(?student, ?course, registration_of(?student, ?course)) :-
+  takes(?student, ?course).
+
+same_witness(parent_of_alice, true) :-
+  eq(parent_of(alice), parent_of(alice)).
+
+distinct_witnesses(alice_logic_vs_alice_math, true) :-
+  neq(registration_of(alice, logic), registration_of(alice, math)).

package/examples/output/existential-rule.eye

@@ -1,2 +1,2 @@
-is(socrates, sk_0).
-is(plato, sk_1).
+is(socrates, human_witness(socrates)).
+is(plato, human_witness(plato)).

package/examples/output/herbrand-witnesses.eye

@@ -0,0 +1,7 @@
+has_parent(alice, parent_of(alice)).
+has_parent(bob, parent_of(bob)).
+registration(alice, logic, registration_of(alice, logic)).
+registration(alice, math, registration_of(alice, math)).
+registration(bob, logic, registration_of(bob, logic)).
+same_witness(parent_of_alice, true).
+distinct_witnesses(alice_logic_vs_alice_math, true).

package/examples/proof/existential-rule.eye

@@ -1,38 +1,30 @@
-is(socrates, sk_0).
+is(socrates, human_witness(socrates)).
 why(
-  is(socrates, sk_0),
+  is(socrates, human_witness(socrates)),
   proof(
-    goal(is(socrates, sk_0)),
-    by(rule("existential-rule.eye", clause(6))),
-    bindings([binding("?person", socrates), binding("?witness", sk_0)]),
+    goal(is(socrates, human_witness(socrates))),
+    by(rule("existential-rule.eye", clause(4))),
+    bindings([binding("?person", socrates)]),
     uses([
       proof(
         goal(type(socrates, human)),
         by(fact("existential-rule.eye", clause(2)))
-      ),
-      proof(
-        goal(witness(socrates, sk_0)),
-        by(fact("existential-rule.eye", clause(4)))
       )
     ])
   )
 ).
 
-is(plato, sk_1).
+is(plato, human_witness(plato)).
 why(
-  is(plato, sk_1),
+  is(plato, human_witness(plato)),
   proof(
-    goal(is(plato, sk_1)),
-    by(rule("existential-rule.eye", clause(6))),
-    bindings([binding("?person", plato), binding("?witness", sk_1)]),
+    goal(is(plato, human_witness(plato))),
+    by(rule("existential-rule.eye", clause(4))),
+    bindings([binding("?person", plato)]),
     uses([
       proof(
         goal(type(plato, human)),
         by(fact("existential-rule.eye", clause(3)))
-      ),
-      proof(
-        goal(witness(plato, sk_1)),
-        by(fact("existential-rule.eye", clause(5)))
       )
     ])
   )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyelang",
-  "version": "1.7.8",
+  "version": "1.7.9",
   "description": "A small Prolog-like logic programming language for rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",

package/playground.html

@@ -568,6 +568,7 @@
           "service-impact",
           "sieve",
           "skolem-functions",
+          "herbrand-witnesses",
           "socket-age",
           "socket-family",
           "socrates",

package/src/builtins/terms.js

@@ -61,6 +61,7 @@ function* compoundNameArguments({ goal, env }) {
   if (unify(goal.args[0], built, next)) yield next;
 }
 
+
 function scalarNameTerm(term) {
   if (term.type === 'atom') return atom(term.name);
   if (term.type === 'number') return numberTerm(term.name);

package/test/conformance/cases/terms/herbrand_witness_different_inputs_distinct.eye

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(true) :- neq(registration_of(alice, logic), registration_of(alice, math)).

package/test/conformance/cases/terms/herbrand_witness_one_input.eye

@@ -0,0 +1,5 @@
+% Existential-style consequence with one universal variable represented as a Herbrand term.
+materialize(answer, 2).
+person(alice).
+person(bob).
+answer(?child, parent_of(?child)) :- person(?child).

package/test/conformance/cases/terms/herbrand_witness_same_inputs_same_term.eye

@@ -0,0 +1,2 @@
+materialize(answer, 1).
+answer(true) :- eq(parent_of(alice), parent_of(alice)).

package/test/conformance/cases/terms/herbrand_witness_two_inputs.eye

@@ -0,0 +1,5 @@
+% Existential-style consequence with two universal variables represented as a Herbrand term.
+materialize(answer, 3).
+takes(alice, logic).
+takes(alice, math).
+answer(?student, ?course, registration_of(?student, ?course)) :- takes(?student, ?course).

package/test/conformance/expected/terms/herbrand_witness_different_inputs_distinct.eye

@@ -0,0 +1 @@
+answer(true).

package/test/conformance/expected/terms/herbrand_witness_one_input.eye

@@ -0,0 +1,2 @@
+answer(alice, parent_of(alice)).
+answer(bob, parent_of(bob)).

package/test/conformance/expected/terms/herbrand_witness_same_inputs_same_term.eye

@@ -0,0 +1 @@
+answer(true).

package/test/conformance/expected/terms/herbrand_witness_two_inputs.eye

@@ -0,0 +1,2 @@
+answer(alice, logic, registration_of(alice, logic)).
+answer(alice, math, registration_of(alice, math)).

package/test/conformance/expected-proofs/proofs/herbrand_witness.eye

@@ -0,0 +1,16 @@
+has_parent(alice, parent_of(alice)).
+why(
+  has_parent(alice, parent_of(alice)),
+  proof(
+    goal(has_parent(alice, parent_of(alice))),
+    by(rule("<stdin>", clause(2))),
+    bindings([binding("?child", alice)]),
+    uses([
+      proof(
+        goal(person(alice)),
+        by(fact("<stdin>", clause(1)))
+      )
+    ])
+  )
+).
+

package/test/conformance/proofs/proofs/herbrand_witness.eye

@@ -0,0 +1,3 @@
+person(alice).
+has_parent(?child, parent_of(?child)) :- person(?child).
+materialize(has_parent, 2).