eyeprolog 1.5.105 → 1.5.107

package/examples/clpz-n-queens.pl

@@ -5,14 +5,19 @@
 % distinctness, and delayed diagonal constraints describe the puzzle before
 % labeling searches the remaining finite alternatives.
 %
-% The checked eight-queens goal verifies a known witness with the same relational
-% model. A smaller four-queens query exercises actual search and multiple-solution
-% enumeration without making the default example suite a CLP(Z) benchmark.
+% queens8_witness/1 does NOT search: it unifies Rows with a known witness
+% FIRST and only then calls queens/2, so every position is already ground
+% before labeling/2 ever runs. It is a fast constraint check against a
+% known-good answer, not a demonstration of solving the puzzle -- the name
+% says so, so it cannot be mistaken for one. A smaller four-queens query
+% below is the routine, honestly-searched default: it exercises actual
+% search and multiple-solution enumeration, small enough to stay fast
+% without making the default example suite a CLP(Z) benchmark.
 
-%% goal: queens8_solution(X0)
+%% goal: queens8_witness(X0)
 %% goal: queens(4, X0)
 
-queens8_solution(Rows) :-
+queens8_witness(Rows) :-
   Rows = [1, 5, 8, 6, 3, 7, 2, 4],
   queens(8, Rows).
 

package/examples/clpz-sudoku-9x9.pl

@@ -2,13 +2,43 @@
 
 % AI Escargot is a well-known difficult 9-by-9 Sudoku. sudoku9/1 is the
 % declarative search relation: every row, column, and 3-by-3 block is
-% all-distinct and first-fail labeling searches the remaining cells. The default
-% golden goal verifies the known full-size solution so routine tests exercise
-% the complete model without turning the example suite into a search benchmark.
+% all-distinct and first-fail labeling searches the remaining cells.
+%
+% sudoku9_witness/1 below does NOT search. It unifies Rows with the
+% well-known published AI Escargot answer FIRST and only then calls
+% sudoku9/1, so every cell is already ground before labeling/2 ever runs --
+% it is a fast constraint check on a known-good grid, not a demonstration of
+% solving the puzzle, and it must never be read as one. Actually searching
+% sudoku9/1 from the blanks with the labeling strategy below does not finish
+% within minutes, because library(clpz)'s all_distinct/1 propagation is not
+% yet strong enough for a puzzle this constrained at 9-by-9 (tracked
+% separately as a propagation-strength issue). Until that is improved,
+% sudoku4_solution/1 is the routine,
+% honestly-searched default: a 4-by-4 "Shidoku" (2-by-2 blocks, digits 1-4)
+% built from the identical relational model, actually solved from its
+% blanks by the same labeling call, so the example suite still exercises
+% real search on every run. Readers who want to watch the real, currently
+% very slow 9-by-9 search can still call sudoku9(Rows) directly with an
+% unbound Rows.
 
-%% goal: sudoku9_solution(X0)
+%% goal: sudoku4_solution(X0)
+%% goal: sudoku9_witness(X0)
 
-sudoku9_solution(Rows) :-
+sudoku4_solution(Rows) :-
+  Rows = [
+    [_, _, 3, _],
+    [_, 4, _, 2],
+    [2, 1, _, _],
+    [_, _, 2, _]
+  ],
+  sudoku4_rows(Rows),
+  sudoku4_transpose(Rows, Columns),
+  sudoku4_rows_distinct(Columns),
+  sudoku4_blocks(Rows),
+  sudoku4_flatten(Rows, Cells),
+  labeling([ff], Cells).
+
+sudoku9_witness(Rows) :-
   sudoku9_known_solution(Rows),
   sudoku9(Rows).
 
@@ -80,3 +110,45 @@ sudoku9_flatten([Row|Rows], Cells) :-
 
 sudoku9_append([], Ys, Ys).
 sudoku9_append([X|Xs], Ys, [X|Zs]) :- sudoku9_append(Xs, Ys, Zs).
+
+% sudoku4_*/N below mirror the sudoku9_*/N relations at 4-by-4 scale (2-by-2
+% blocks instead of 3-by-3), so sudoku4_solution/1 exercises the identical
+% relational model as sudoku9/1, just small enough to search instantly.
+
+sudoku4_rows([]).
+sudoku4_rows([Row|Rows]) :-
+  Row ins 1..4,
+  all_distinct(Row),
+  sudoku4_rows(Rows).
+
+sudoku4_rows_distinct([]).
+sudoku4_rows_distinct([Row|Rows]) :-
+  all_distinct(Row),
+  sudoku4_rows_distinct(Rows).
+
+sudoku4_transpose([[]|_], []).
+sudoku4_transpose(Rows, [Column|Columns]) :-
+  sudoku4_heads_tails(Rows, Column, Tails),
+  sudoku4_transpose(Tails, Columns).
+
+sudoku4_heads_tails([], [], []).
+sudoku4_heads_tails([[Head|Tail]|Rows], [Head|Heads], [Tail|Tails]) :-
+  sudoku4_heads_tails(Rows, Heads, Tails).
+
+sudoku4_blocks([]).
+sudoku4_blocks([A, B|Rows]) :-
+  sudoku4_block_row(A, B),
+  sudoku4_blocks(Rows).
+
+sudoku4_block_row([], []).
+sudoku4_block_row([A, B|As], [C, D|Bs]) :-
+  all_distinct([A, B, C, D]),
+  sudoku4_block_row(As, Bs).
+
+sudoku4_flatten([], []).
+sudoku4_flatten([Row|Rows], Cells) :-
+  sudoku4_append(Row, Rest, Cells),
+  sudoku4_flatten(Rows, Rest).
+
+sudoku4_append([], Ys, Ys).
+sudoku4_append([X|Xs], Ys, [X|Zs]) :- sudoku4_append(Xs, Ys, Zs).

package/examples/output/clpz-n-queens.pl

@@ -1,3 +1,3 @@
-queens8_solution([1, 5, 8, 6, 3, 7, 2, 4]).
+queens8_witness([1, 5, 8, 6, 3, 7, 2, 4]).
 queens(4, [2, 4, 1, 3]).
 queens(4, [3, 1, 4, 2]).

package/examples/output/clpz-sudoku-9x9.pl

@@ -1 +1,2 @@
-sudoku9_solution([[1, 6, 2, 8, 5, 7, 4, 9, 3], [5, 3, 4, 1, 2, 9, 6, 7, 8], [7, 8, 9, 6, 4, 3, 5, 2, 1], [4, 7, 5, 3, 1, 2, 9, 8, 6], [9, 1, 3, 5, 8, 6, 7, 4, 2], [6, 2, 8, 7, 9, 4, 1, 3, 5], [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]]).
+sudoku4_solution([[1, 2, 3, 4], [3, 4, 1, 2], [2, 1, 4, 3], [4, 3, 2, 1]]).
+sudoku9_witness([[1, 6, 2, 8, 5, 7, 4, 9, 3], [5, 3, 4, 1, 2, 9, 6, 7, 8], [7, 8, 9, 6, 4, 3, 5, 2, 1], [4, 7, 5, 3, 1, 2, 9, 8, 6], [9, 1, 3, 5, 8, 6, 7, 4, 2], [6, 2, 8, 7, 9, 4, 1, 3, 5], [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]]).

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.5.105",
+  "version": "1.5.107",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/iso.js

@@ -674,22 +674,25 @@ function* termVariablesBuiltin({ goal, env }) {
 }
 
 function validPredicateIndicator(term) {
-  // Each position is checked independently, not "could some single
-  // instantiation satisfy both at once" -- so current_predicate(X/X)
-  // (issue #115) passes this check exactly like current_predicate(X/Y)
-  // does, and is then left to the ordinary group search below, which
-  // unifies goal.args[0] (still X/X, the two positions aliased) against
-  // each candidate Name/Arity in turn. Name and Arity are never the same
-  // type, so that unification always fails and the goal simply finds no
-  // solutions, the same way ISO's own current_op/3 (8.14.4.1) is specified:
-  // its candidate set is built by unifying a triple's priority (an integer)
-  // and specifier (an atom) against Priority and Op-specifier, so aliasing
-  // those two arguments the same way makes every candidate fail to unify
-  // and the set come up empty -- current_op/3's own Errors subclause
-  // (8.14.4.3) has no special case for it, only domain errors for an
-  // argument that is instantiated and outright wrong on its own. A
-  // predicate_indicator type error remains for a term that cannot look
-  // like a Name/Arity pair at all (a bare atom, a negative arity, ...).
+  // ISO 13211-1 8.8.2.3's sole error condition is "PI is neither a variable
+  // nor a predicate indicator -> type_error(predicate_indicator, PI)", and
+  // 8.8.2.4's own worked example -- current_predicate(Name/1) succeeds,
+  // backtracking through every matching Name -- shows that a compound whose
+  // Name is merely a variable already counts as "a predicate indicator" for
+  // this check, not just one whose Name and Arity are already bound to an
+  // atom and a non-negative integer as 7.1.6.6 defines the type. So each
+  // position is checked independently here, not "could some single
+  // instantiation satisfy both at once": current_predicate(X/X) (issue #115)
+  // passes this check exactly like current_predicate(X/Y) does, and is left
+  // to the ordinary group search below (8.8.2.1 a-c), which unifies
+  // goal.args[0] (still X/X, the two positions aliased) against each
+  // candidate Name/Arity in turn. Name and Arity are never the same type, so
+  // that unification always fails for every candidate and the goal simply
+  // finds no solutions -- 8.8.2.1's own procedure gives no other outcome for
+  // an empty candidate set than "the goal fails" (step c), with no separate
+  // provision for an argument that turned out unable to ever unify. A
+  // predicate_indicator type error remains for a term that cannot look like
+  // a Name/Arity pair at all (a bare atom, a negative arity, ...).
   return term.type === COMPOUND && term.name === '/' && term.arity === 2 &&
     (term.args[0].type === VAR || term.args[0].type === ATOM) &&
     (term.args[1].type === VAR ||

package/test/run-iso-strict.mjs

@@ -1592,19 +1592,30 @@ export function runIsoStrict(reporter = new TestReporter()) {
     const current = run('p(a).\nq.\n', { isoStrict: true, goal: 'current_predicate(p/1)' });
     equal(current.stats.completed_goal_lists, 1, 'current_predicate/1 finds a user procedure');
 
-    // The same variable filling both Name and Arity (issue #115, stc#79)
-    // looks valid position-by-position -- each alone accepts an unbound
-    // variable, and current_predicate/1 must support both fully unbound
-    // (current_predicate(X/Y), a generator) -- but no instantiation can
-    // satisfy both positions of one shared variable at once, since binding
-    // it to an atom makes Arity an atom too, not an integer. ISO does not
-    // special-case this for the structurally identical current_op/3
-    // (8.14.4.1): its candidate set is built by unifying a triple's integer
-    // priority and atom specifier against Priority and Op-specifier, so
-    // aliasing those two arguments the same way simply makes every
-    // candidate fail to unify and the set come up empty, and current_op/3's
-    // own Errors subclause (8.14.4.3) has no case for it. current_predicate
-    // /1 follows that precedent: it fails rather than raising an error.
+    // ISO 13211-1 8.8.2.4's own worked example: current_predicate(Name/1)
+    // succeeds with an unbound Name, backtracking through every arity-1
+    // predicate. A compound with an unbound component already counts as "a
+    // predicate indicator" for 8.8.2.3's error check, not only one whose
+    // Name and Arity are already bound to an atom and a non-negative
+    // integer as 7.1.6.6 defines the type.
+    equal(
+      run('elk(a).\ninsect(b).\n', { isoStrict: true, goal: 'current_predicate(Name/1)' }).stats.completed_goal_lists,
+      2,
+      'current_predicate/1 enumerates every matching Name with Arity fixed and Name unbound',
+    );
+
+    // The same variable filling both Name and Arity (issue #115) looks
+    // valid position-by-position by that same per-component check -- each
+    // position alone accepts an unbound variable, and current_predicate/1
+    // must support both fully unbound (current_predicate(X/Y), a generator,
+    // just demonstrated above) -- but no instantiation can satisfy both
+    // positions of one shared variable at once, since binding it to an atom
+    // makes Arity an atom too, not an integer. 8.8.2.3 has only the one
+    // error condition above, and 8.8.2.1's procedure gives no outcome for an
+    // empty candidate set (step a-c) besides "the goal fails" (step c) --
+    // there is no separate provision for an argument that turned out unable
+    // to ever unify with anything. current_predicate/1 follows that: it
+    // fails rather than raising an error.
     for (const [goal, label] of [
       ['current_predicate(X/X)', 'current_predicate/1 aliased name/arity variable fails'],
       ['X = Y, current_predicate(X/Y)', 'current_predicate/1 previously unified name/arity variables fails'],

package/the-art-of-eyeprolog.md

@@ -4237,7 +4237,9 @@ be redundant. If partial choices already violate a constraint, pruning saves
 an entire subtree.
 
 This is why combinatorial examples are not toys. `clpz-n-queens.pl` exposes
-the classic eight-queens search through finite-domain constraints. Together with `send-more-money.pl`,
+the classic N-queens search through finite-domain constraints -- genuinely
+searched at four queens; its eight-queens goal instead checks a known witness
+against the same model, without searching for it. Together with `send-more-money.pl`,
 `integer-partitions.pl`, `stirling-bell-numbers.pl`,
 and `weighted-interval-scheduling.pl`, they show different geometries of
 choice: permutations, digit assignments, recursive decompositions, set
@@ -9617,7 +9619,7 @@ eyeprolog --proof --goal 'type(X, Y)' examples/socrates.pl
 eyeprolog --proof examples/socrates.pl > socrates.why.pl
 eyeprolog --verify-proof socrates.why.pl examples/socrates.pl
 eyeprolog --warnings --goal 'answer(X)' test/conformance/warnings/negation/unstratified_mutual.pl
-eyeprolog --portable --goal 'sudoku9_solution(S)' examples/clpz-sudoku-9x9.pl
+eyeprolog --portable --goal 'sudoku4_solution(S)' examples/clpz-sudoku-9x9.pl
 eyeprolog --stats --goal 'path(a, X)' examples/path-discovery.pl > answers.pl 2> run.stats
 ```
 
@@ -9984,7 +9986,7 @@ mode at a time.
 | [CLP(Z) global constraints](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-global-constraints.pl) | Compatibility tables, lexicographic and serialized schedules, global cardinality with costs, circuits, value counting, and integer comparison. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-global-constraints.pl) |
 | [CLP(Z) N-queens](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-n-queens.pl) | A checked eight-queens witness using finite domains, delayed diagonal constraints, `all_distinct/1`, and first-fail labeling, plus a four-queens multi-solution search. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-n-queens.pl) |
 | [CLP(Z) resource allocation](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-resource-allocation.pl) | Resource assignment using `element/3`, `sum/3`, `scalar_product/4`, reification, labeling options, and domain reflection. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-resource-allocation.pl) |
-| [CLP(Z) Sudoku 9×9](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-sudoku-9x9.pl) | The AI Escargot 9×9 model with finite domains, 27 all-distinct constraints, and first-fail labeling; the default golden verifies its known solution while `sudoku9/1` remains the search relation. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-sudoku-9x9.pl) |
+| [CLP(Z) Sudoku 9×9](https://github.com/eyereasoner/eyeprolog/blob/main/examples/clpz-sudoku-9x9.pl) | The AI Escargot 9×9 model with finite domains, 27 all-distinct constraints, and first-fail labeling; a same-shaped 4×4 Shidoku is genuinely searched from its blanks as the routine default, while `sudoku9_witness/1` only checks the known 9×9 answer against the model (`sudoku9/1` itself remains the real, currently very slow 9×9 search relation). | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/clpz-sudoku-9x9.pl) |
 | [Combinatorics Findall Sort](https://github.com/eyereasoner/eyeprolog/blob/main/examples/combinatorics-findall-sort.pl) | Eyelet-inspired combinations example using `findall/3` and ISO `sort/2`. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/combinatorics-findall-sort.pl) |
 | [Floating Point](https://github.com/eyereasoner/eyeprolog/blob/main/examples/floating-point.pl) | Floating-point arithmetic and comparisons. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/floating-point.pl) · [proof](https://github.com/eyereasoner/eyeprolog/blob/main/examples/proof/floating-point.pl) |
 | [Atomic conversion](https://github.com/eyereasoner/eyeprolog/blob/main/examples/iso-atomic-conversion.pl) | Atom splitting, character atoms, Unicode codes, and numeric parsing. | [answers](https://github.com/eyereasoner/eyeprolog/blob/main/examples/output/iso-atomic-conversion.pl) |