eyelang 1.7.11 → 1.7.13

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://img.shields.io/npm/v/eyelang.svg)](https://www.npmjs.com/package/eyelang)
 [![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.
+Eyelang is a small logic programming language for facts, 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, 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.
 

package/docs/guide.md

@@ -1,6 +1,6 @@
 # Eyelang Guide
 
-This guide introduces Eyelang, a small Horn-clause language and engine whose source syntax is Prolog-like but deliberately its own compact language for rules, goals, answers, and proofs. Eyelang works over ordinary terms, lists, arithmetic, strings, and finite search. Run it with the `eyelang` CLI, or use `node bin/eyelang.js` when working directly from a source checkout.
+This guide introduces Eyelang, a small Horn-clause language and engine whose source syntax is Prolog-like but deliberately its own compact language for facts, rules, goals, answers, and proofs. Eyelang works over ordinary terms, lists, arithmetic, strings, and finite search. Run it with the `eyelang` CLI, or use `node bin/eyelang.js` when working directly from a source checkout.
 
 Programs write relations directly, for example `ancestor(pat, emma)` or `status(case1, accepted)`. Absolute IRI atoms can be written explicitly with angle brackets, for example `<https://schema.org/name>`, when a program needs web identifiers without prefix declarations. Eyelang output is ordinary Eyelang syntax: by default, the CLI materializes selected answer facts and prints those facts only. Pass `--proof` (or `-p`) when you also want each answer followed by a `why/2` explanation fact that records the proof. Programs may add `materialize/2` declarations such as `materialize(answer, 2).` to focus output on selected predicates.
 
@@ -414,6 +414,7 @@ Use `holds/2` when you want to match the member term directly, for example `name
 | [`list-collection.eye`](../examples/list-collection.eye) | Demonstrates list and collection built-ins. | [`output/list-collection.eye`](../examples/output/list-collection.eye) |
 | [`lldm.eye`](../examples/lldm.eye) | Calculates leg-length discrepancy measurements. | [`output/lldm.eye`](../examples/output/lldm.eye) |
 | [`manufacturing-quality-control.eye`](../examples/manufacturing-quality-control.eye) | Evaluates process capability and quality. | [`output/manufacturing-quality-control.eye`](../examples/output/manufacturing-quality-control.eye) |
+| [`markov-logic-network.eye`](../examples/markov-logic-network.eye) | Scores finite possible worlds with weighted soft formulas in a Markov Logic Network style. | [`output/markov-logic-network.eye`](../examples/output/markov-logic-network.eye) |
 | [`map-four-color-search.eye`](../examples/map-four-color-search.eye) | Searches for a valid four-colouring of the EU neighbour graph. | [`output/map-four-color-search.eye`](../examples/output/map-four-color-search.eye) |
 | [`matrix-chain-order.eye`](../examples/matrix-chain-order.eye) | Finds an optimal matrix-chain multiplication order. | [`output/matrix-chain-order.eye`](../examples/output/matrix-chain-order.eye) |
 | [`matrix-noncommutativity.eye`](../examples/matrix-noncommutativity.eye) | Multiplies 2x2 matrices and shows non-commutativity. | [`output/matrix-noncommutativity.eye`](../examples/output/matrix-noncommutativity.eye) |

package/examples/markov-logic-network.eye

@@ -0,0 +1,87 @@
+% Markov Logic Network style scoring over a tiny finite domain.
+%
+% Eyelang is deterministic, so this is not a probabilistic MLN engine.  The
+% example encodes the usual MLN MAP idea explicitly: enumerate possible worlds,
+% mark which weighted soft formulas each world satisfies, sum the weights, and
+% choose the highest-scoring world.  Weights are stored as integer tenths of a
+% log weight so the example stays reproducible without floating-point noise.
+
+materialize(mlnWeight, 2).
+materialize(mlnWorld, 2).
+materialize(mlnSatisfied, 2).
+materialize(mlnViolated, 2).
+materialize(mlnContribution, 3).
+materialize(mlnWorldScore, 2).
+materialize(mlnMapWorld, 2).
+materialize(mlnConclusion, 2).
+
+% Evidence and candidate hidden assignments.
+person(alice).
+person(bob).
+friend(alice, bob).
+observed_smokes(alice).
+
+candidate_world(w_bob_not_smokes_not_cancer, no, no).
+candidate_world(w_bob_not_smokes_cancer, no, yes).
+candidate_world(w_bob_smokes_not_cancer, yes, no).
+candidate_world(w_bob_smokes_cancer, yes, yes).
+
+% Soft formulas are weighted log features.
+formula_weight_tenths(friend_smoking, 20).
+formula_weight_tenths(smoking_causes_cancer, 13).
+formula_weight_tenths(cancer_is_rare, 6).
+
+% World interpretation for Bob.  Alice's smoking status is observed evidence.
+smokes_in_world(?world, alice) :-
+  candidate_world(?world, ?, ?),
+  observed_smokes(alice).
+smokes_in_world(?world, bob) :- candidate_world(?world, yes, ?).
+cancer_in_world(?world, bob) :- candidate_world(?world, ?, yes).
+
+% Grounded soft formulas for this tiny domain:
+%   friend_smoking:        friend(alice,bob) and smokes(alice) => smokes(bob)
+%   smoking_causes_cancer: smokes(bob) => cancer(bob)
+%   cancer_is_rare:        not cancer(bob)
+formula_satisfied(?world, friend_smoking) :-
+  friend(alice, bob),
+  smokes_in_world(?world, alice),
+  smokes_in_world(?world, bob).
+
+formula_satisfied(?world, smoking_causes_cancer) :-
+  candidate_world(?world, no, ?).
+formula_satisfied(?world, smoking_causes_cancer) :-
+  smokes_in_world(?world, bob),
+  cancer_in_world(?world, bob).
+
+formula_satisfied(?world, cancer_is_rare) :-
+  candidate_world(?world, ?, no).
+
+formula_violated(?world, ?formula) :-
+  candidate_world(?world, ?, ?),
+  formula_weight_tenths(?formula, ?),
+  not(formula_satisfied(?world, ?formula)).
+
+contribution_tenths(?world, ?formula, ?weight) :-
+  formula_satisfied(?world, ?formula),
+  formula_weight_tenths(?formula, ?weight).
+
+world_score_tenths(?world, ?score) :-
+  candidate_world(?world, ?, ?),
+  sumall(?weight, contribution_tenths(?world, ?formula, ?weight), ?score).
+
+map_world(?world, ?score) :-
+  aggregate_max(?candidate_score, ?candidate_world,
+    world_score_tenths(?candidate_world, ?candidate_score),
+    ?score, ?world).
+
+mlnWeight(?formula, log_weight_tenths(?weight)) :- formula_weight_tenths(?formula, ?weight).
+mlnWorld(?world, world(smokes(bob, ?smokes), cancer(bob, ?cancer))) :-
+  candidate_world(?world, ?smokes, ?cancer).
+mlnSatisfied(?world, ?formula) :- formula_satisfied(?world, ?formula).
+mlnViolated(?world, ?formula) :- formula_violated(?world, ?formula).
+mlnContribution(?world, ?formula, log_weight_tenths(?weight)) :-
+  contribution_tenths(?world, ?formula, ?weight).
+mlnWorldScore(?world, log_weight_tenths(?score)) :- world_score_tenths(?world, ?score).
+mlnMapWorld(?world, log_weight_tenths(?score)) :- map_world(?world, ?score).
+mlnConclusion(case, "MAP world predicts that Bob smokes and has cancer") :-
+  map_world(w_bob_smokes_cancer, ?).

package/examples/output/markov-logic-network.eye

@@ -0,0 +1,32 @@
+mlnWeight(friend_smoking, log_weight_tenths(20)).
+mlnWeight(smoking_causes_cancer, log_weight_tenths(13)).
+mlnWeight(cancer_is_rare, log_weight_tenths(6)).
+mlnWorld(w_bob_not_smokes_not_cancer, world(smokes(bob, no), cancer(bob, no))).
+mlnWorld(w_bob_not_smokes_cancer, world(smokes(bob, no), cancer(bob, yes))).
+mlnWorld(w_bob_smokes_not_cancer, world(smokes(bob, yes), cancer(bob, no))).
+mlnWorld(w_bob_smokes_cancer, world(smokes(bob, yes), cancer(bob, yes))).
+mlnSatisfied(w_bob_smokes_not_cancer, friend_smoking).
+mlnSatisfied(w_bob_smokes_cancer, friend_smoking).
+mlnSatisfied(w_bob_not_smokes_not_cancer, smoking_causes_cancer).
+mlnSatisfied(w_bob_not_smokes_cancer, smoking_causes_cancer).
+mlnSatisfied(w_bob_smokes_cancer, smoking_causes_cancer).
+mlnSatisfied(w_bob_not_smokes_not_cancer, cancer_is_rare).
+mlnSatisfied(w_bob_smokes_not_cancer, cancer_is_rare).
+mlnViolated(w_bob_not_smokes_not_cancer, friend_smoking).
+mlnViolated(w_bob_not_smokes_cancer, friend_smoking).
+mlnViolated(w_bob_not_smokes_cancer, cancer_is_rare).
+mlnViolated(w_bob_smokes_not_cancer, smoking_causes_cancer).
+mlnViolated(w_bob_smokes_cancer, cancer_is_rare).
+mlnContribution(w_bob_smokes_not_cancer, friend_smoking, log_weight_tenths(20)).
+mlnContribution(w_bob_smokes_cancer, friend_smoking, log_weight_tenths(20)).
+mlnContribution(w_bob_not_smokes_not_cancer, smoking_causes_cancer, log_weight_tenths(13)).
+mlnContribution(w_bob_not_smokes_cancer, smoking_causes_cancer, log_weight_tenths(13)).
+mlnContribution(w_bob_smokes_cancer, smoking_causes_cancer, log_weight_tenths(13)).
+mlnContribution(w_bob_not_smokes_not_cancer, cancer_is_rare, log_weight_tenths(6)).
+mlnContribution(w_bob_smokes_not_cancer, cancer_is_rare, log_weight_tenths(6)).
+mlnWorldScore(w_bob_not_smokes_not_cancer, log_weight_tenths(19)).
+mlnWorldScore(w_bob_not_smokes_cancer, log_weight_tenths(13)).
+mlnWorldScore(w_bob_smokes_not_cancer, log_weight_tenths(26)).
+mlnWorldScore(w_bob_smokes_cancer, log_weight_tenths(33)).
+mlnMapWorld(w_bob_smokes_cancer, log_weight_tenths(33)).
+mlnConclusion(case, "MAP world predicts that Bob smokes and has cancer").

package/examples/stirling-bell-numbers.eye

@@ -1,30 +1,67 @@
 % Stirling numbers of the second kind and Bell numbers.
 %
-% stirling2(N, K, Count) counts partitions of N labelled elements into K nonempty blocks.
-% The recurrence either places the newest labelled element into a new singleton block or into
-% one of the K existing blocks.  bell/2 then sums a whole row of Stirling numbers.
-% Memoization turns the overlapping recurrence into a small dynamic-programming table.
+% The Stirling count S(N,K) is computed with the inclusion-exclusion formula
+%   S(N,K) = (1/K!) * sum(I=0..K, (-1)^(K-I) * C(K,I) * I^N)
+% instead of the overlapping two-branch recurrence.  Bell numbers use
+%   B(0) = 1, B(N) = sum(K=0..N-1, C(N-1,K) * B(K)).
+% The table declarations memoize the smaller helper relations used by both formulas.
 materialize(stirling_bell_answer, 2).
 
+table(factorial, 2).
+table(binomial, 3).
 table(stirling2, 3).
+table(bell, 2).
+
+factorial(0, 1).
+factorial(?n, ?value) :-
+  gt(?n, 0),
+  sub(?n, 1, ?n1),
+  factorial(?n1, ?previous),
+  mul(?n, ?previous, ?value).
+
+binomial(0, 0, 1).
+binomial(?n, 0, 1) :- gt(?n, 0).
+binomial(?n, ?n, 1) :- gt(?n, 0).
+binomial(?n, ?k, ?value) :-
+  gt(?n, 0),
+  gt(?k, 0),
+  lt(?k, ?n),
+  sub(?n, 1, ?n1),
+  sub(?k, 1, ?k1),
+  binomial(?n1, ?k1, ?left),
+  binomial(?n1, ?k, ?right),
+  add(?left, ?right, ?value).
+
+signed_term(?n, ?k, ?i, ?term) :-
+  binomial(?k, ?i, ?c),
+  pow(?i, ?n, ?p),
+  mul(?c, ?p, ?unsigned),
+  sub(?k, ?i, ?d),
+  mod(?d, 2, 0),
+  eq(?term, ?unsigned).
+signed_term(?n, ?k, ?i, ?term) :-
+  binomial(?k, ?i, ?c),
+  pow(?i, ?n, ?p),
+  mul(?c, ?p, ?unsigned),
+  sub(?k, ?i, ?d),
+  mod(?d, 2, 1),
+  neg(?unsigned, ?term).
 
-% Boundary cases define the empty partition and the impossible zero-block columns.
 stirling2(0, 0, 1).
 stirling2(?n, 0, 0) :- gt(?n, 0).
 stirling2(0, ?k, 0) :- gt(?k, 0).
 stirling2(?n, ?k, ?count) :-
   gt(?n, 0),
   gt(?k, 0),
-  sub(?n, 1, ?n1),
-  sub(?k, 1, ?k1),
-  stirling2(?n1, ?k1, ?newblock),
-  stirling2(?n1, ?k, ?existingblocks),
-  mul(?k, ?existingblocks, ?extended),
-  add(?newblock, ?extended, ?count).
+  sumall(?term, (between(0, ?k, ?i), signed_term(?n, ?k, ?i, ?term)), ?sum),
+  factorial(?k, ?factorial),
+  div(?sum, ?factorial, ?count).
 
-% Bell(N) is the row sum S(N,0)+...+S(N,N).
+bell(0, 1).
 bell(?n, ?count) :-
-  sumall(?s, (between(0, ?n, ?k), stirling2(?n, ?k, ?s)), ?count).
+  gt(?n, 0),
+  sub(?n, 1, ?n1),
+  sumall(?term, (between(0, ?n1, ?k), binomial(?n1, ?k, ?choose), bell(?k, ?bell), mul(?choose, ?bell, ?term)), ?count).
 
 stirling_bell_answer(stirling_10_4, ?count) :- stirling2(10, 4, ?count).
 stirling_bell_answer(stirling_12_5, ?count) :- stirling2(12, 5, ?count).

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eyelang",
-  "version": "1.7.11",
-  "description": "A small Prolog-like logic programming language for rules, goals, answers, and proofs.",
+  "version": "1.7.13",
+  "description": "A small Prolog-like logic programming language for facts, rules, goals, answers, and proofs.",
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",

package/playground.html

@@ -538,6 +538,7 @@
           "list-collection",
           "lldm",
           "manufacturing-quality-control",
+          "markov-logic-network",
           "map-four-color-search",
           "matrix-chain-order",
           "matrix-noncommutativity",

package/test/run-regression.mjs

@@ -800,7 +800,7 @@ function whiteBoxCases() {
           ['matrix-chain-order.eye', 'cost', 3, false],
           ['modular-exponentiation.eye', 'pow_mod', 4, true],
           ['pell-equation.eye', 'pell', 3, true],
-          ['stirling-bell-numbers.eye', 'stirling2', 3, true],
+          ['stirling-bell-numbers.eye', 'stirling2', 3, false],
           ['totient-summatory.eye', 'gcd', 3, true],
           ['totient-summatory.eye', 'totient', 2, false],
           ['weighted-interval-scheduling.eye', 'best_from', 2, true],