eyeprolog 1.5.108 → 1.6.0

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

@@ -4,50 +4,10 @@
 % declarative search relation: every row, column, and 3-by-3 block is
 % all-distinct and first-fail labeling searches the remaining cells.
 %
-% sudoku9(Rows), called with an unbound Rows, genuinely searches AI
-% Escargot from its blanks and finds the unique solution -- confirmed by
-% actually running it (~4 minutes of real search on this machine, no
-% known-answer shortcut). It is left out of the default %% goal: examples
-% below purely because 4 minutes per run is too slow for the example
-% suite, which re-runs on every test invocation, not because of any
-% propagation weakness.
-%
-% 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. It exists so the
-% example suite still exercises the sudoku9_* constraint-model code on every
-% run, without paying the multi-minute real-search cost.
-%
-% sudoku4_solution/1 is 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 also exercises real search
-% (just at a size that finishes instantly) on every run.
-%
-% Readers who want to watch the real 9-by-9 search can call sudoku9(Rows)
-% directly with an unbound Rows; expect it to take a few minutes.
-
-%% goal: sudoku4_solution(X0)
-%% goal: sudoku9_witness(X0)
-
-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).
+% The default goal genuinely searches AI Escargot from its clues and finds
+% the unique solution. No known-answer shortcut is used before labeling.
 
-sudoku9_witness(Rows) :-
-  sudoku9_known_solution(Rows),
-  sudoku9(Rows).
+%% goal: sudoku9(X0)
 
 sudoku9(Rows) :-
   Rows = [
@@ -68,18 +28,6 @@ sudoku9(Rows) :-
   sudoku9_flatten(Rows, Cells),
   labeling([ff], Cells).
 
-sudoku9_known_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]
-]).
-
 sudoku9_rows([]).
 sudoku9_rows([Row|Rows]) :-
   Row ins 1..9,
@@ -117,45 +65,3 @@ 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-sudoku-9x9.pl

@@ -1,2 +1 @@
-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]]).
+sudoku9([[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.108",
+  "version": "1.6.0",
   "description": "EyeProlog turns facts and rules into answers and proofs.",
   "type": "module",
   "main": "./index.js",

package/src/ARCHITECTURE.md

@@ -91,9 +91,12 @@ extra dispatch in solver hot paths.  Existing scalar/indexed solver paths stay
 as direct function calls.  Candidate indexing is separated physically but
 retains the same data structures and selection functions.
 
-Large solver fast paths deliberately remain co-located in `solver.js` until a
-split can demonstrate performance parity.  A cleaner file layout is not worth a
-runtime regression.
+Generic solver fast paths remain co-located in `solver.js` until a split can
+demonstrate performance parity. Module-specific acceleration belongs to the
+matching `*-host.js` adapter: `clpz-host.js` and `clpb-host.js`, for example,
+construct native propagation/search plans while their Prolog modules retain
+validation, residual constraints, and portable fallbacks. A cleaner file layout
+is not worth a runtime regression, so such splits must retain benchmark parity.
 
 Performance claims use `npm test`'s own elapsed time across the full corpus,
 not predicate, inference, or host-call counts as a substitute for elapsed

package/src/clpb-host.js

@@ -0,0 +1,48 @@
+// Native search-plan construction for library(clpb). Formula construction and
+// BDD propagation remain in clpb.pl; this adapter replaces its interpreted
+// variable sorting and Boolean enumeration with an equivalent goal tree.
+
+import { COMPOUND, NUMBER, VAR, atom, compound, deref, numberTerm, properListItems } from './term.js';
+
+function conjunction(goals) {
+  if (goals.length === 0) return atom('true');
+  let result = goals[goals.length - 1];
+  for (let index = goals.length - 2; index >= 0; index--) result = compound(',', [goals[index], result]);
+  return result;
+}
+
+function variableIndex(term, env) {
+  const wrapper = env.getPrologAttribute(term.name, 'clpb', 'clpb', 1);
+  const attribute = wrapper == null ? null : deref(wrapper.args[0], env);
+  if (attribute?.type !== COMPOUND || attribute.name !== 'index_root' || attribute.arity !== 2) return 0n;
+  const index = deref(attribute.args[0], env);
+  return index.type === NUMBER ? BigInt(index.name) : 0n;
+}
+
+function expandLabeling({ solver, goal, env }) {
+  const items = properListItems(goal.args[0], env) ?? [];
+  const variables = [];
+  for (let position = 0; position < items.length; position++) {
+    const value = deref(items[position], env);
+    if (value.type === VAR) variables.push({ term: value, index: variableIndex(value, env), position });
+  }
+  variables.sort((left, right) => left.index < right.index ? -1 : left.index > right.index ? 1 : left.position - right.position);
+  solver.stats.clpb_native_labelings++;
+  return conjunction(variables.map(({ term }) => compound(';', [
+    compound('=', [term, numberTerm(0)]),
+    compound('=', [term, numberTerm(1)]),
+  ])));
+}
+
+function* unreachable() {
+  throw new Error('CLP adapter expansion was not applied');
+}
+
+export const clpbHostBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__clpb_labeling', 1, unreachable, {
+      expandGoal: expandLabeling,
+      eyePrologLibrary: true,
+    });
+  },
+};

package/src/clpz-host.js

@@ -0,0 +1,371 @@
+// Native acceleration for the finite all_distinct subset of library(clpz).
+// The public predicates, validation, and general fallbacks remain in clpz.pl;
+// these private adapters only replace the expensive matching and search loops
+// when the live attributed-variable store is completely understood here.
+
+import {
+  ATOM, COMPOUND, NUMBER, VAR, atom, compound, deref, isDecimalInteger,
+  numberTerm, properListItems, variable,
+} from './term.js';
+
+let distinctStateId = 0;
+
+function qualified(name, args) {
+  const goal = compound(name, args);
+  goal.module = 'clpz';
+  return goal;
+}
+
+function conjunction(goals) {
+  if (goals.length === 0) return atom('true');
+  let result = goals[goals.length - 1];
+  for (let index = goals.length - 2; index >= 0; index--) {
+    result = compound(',', [goals[index], result]);
+  }
+  return result;
+}
+
+function finiteDomainValues(domain, env, output) {
+  const resolved = deref(domain, env);
+  if (resolved?.type !== COMPOUND) return false;
+  if (resolved.name === 'from_to' && resolved.arity === 2) {
+    const lower = deref(resolved.args[0], env);
+    const upper = deref(resolved.args[1], env);
+    if (lower?.type !== COMPOUND || lower.name !== 'n' || lower.arity !== 1 ||
+        upper?.type !== COMPOUND || upper.name !== 'n' || upper.arity !== 1) return false;
+    const lowerNumber = deref(lower.args[0], env);
+    const upperNumber = deref(upper.args[0], env);
+    if (lowerNumber.type !== NUMBER || upperNumber.type !== NUMBER ||
+        !isDecimalInteger(lowerNumber.name) || !isDecimalInteger(upperNumber.name)) return false;
+    const first = BigInt(lowerNumber.name);
+    const last = BigInt(upperNumber.name);
+    if (last < first || last - first > 30n) return false;
+    for (let value = first; value <= last; value++) output.add(value);
+    return true;
+  }
+  if (resolved.name === 'split' && resolved.arity === 3) {
+    return finiteDomainValues(resolved.args[1], env, output) &&
+      finiteDomainValues(resolved.args[2], env, output);
+  }
+  return false;
+}
+
+function clpzAttributeFor(name, env) {
+  const wrapper = env.getPrologAttribute(name, 'clpz', 'clpz', 1);
+  const attribute = wrapper == null ? null : deref(wrapper.args[0], env);
+  return attribute?.type === COMPOUND && attribute.name === 'clpz_attr' && attribute.arity === 6
+    ? attribute
+    : null;
+}
+
+function activeClpzPropagators(attribute, env) {
+  const props = deref(attribute.args[4], env);
+  if (props?.type !== COMPOUND || props.name !== 'fd_props' || props.arity !== 3) return null;
+  const result = [];
+  for (const list of props.args) {
+    const entries = properListItems(list, env);
+    if (entries == null) return null;
+    for (const entry of entries) {
+      const propagator = deref(entry, env);
+      if (propagator?.type !== COMPOUND || propagator.name !== 'propagator' || propagator.arity !== 2) {
+        return null;
+      }
+      const state = deref(propagator.args[1], env);
+      if (state.type === ATOM && state.name === 'dead') continue;
+      const constraint = deref(propagator.args[0], env);
+      if (constraint?.type !== COMPOUND || !['pdistinct', 'pexclude'].includes(constraint.name)) {
+        return null;
+      }
+      result.push(constraint);
+    }
+  }
+  return result;
+}
+
+function allDistinctMatchingExists(domains, ground, forcedIndex = -1, forcedValue = null) {
+  if (forcedIndex >= 0 && (ground.has(forcedValue) || !domains[forcedIndex].includes(forcedValue))) return false;
+  const matching = new Map();
+  if (forcedIndex >= 0) matching.set(forcedValue, forcedIndex);
+
+  const augment = (variableIndex, seen) => {
+    for (const value of domains[variableIndex]) {
+      if (ground.has(value) || seen.has(value)) continue;
+      seen.add(value);
+      const previous = matching.get(value);
+      if (previous == null || (previous !== forcedIndex && augment(previous, seen))) {
+        matching.set(value, variableIndex);
+        return true;
+      }
+    }
+    return false;
+  };
+
+  for (let index = 0; index < domains.length; index++) {
+    if (index === forcedIndex) continue;
+    if (!augment(index, new Set())) return false;
+  }
+  return true;
+}
+
+function distinctExpansion(goal, env) {
+  const members = properListItems(goal.args[0], env);
+  if (members == null || members.length > 16) return null;
+  const variables = [];
+  const domains = [];
+  const variableNames = new Set();
+  const ground = new Set();
+  for (const member of members) {
+    const value = deref(member, env);
+    if (value.type === NUMBER && isDecimalInteger(value.name)) {
+      const integer = BigInt(value.name);
+      if (ground.has(integer)) return atom('false');
+      ground.add(integer);
+      continue;
+    }
+    if (value.type !== VAR || variableNames.has(value.name)) return atom('false');
+    const attribute = clpzAttributeFor(value.name, env);
+    if (attribute == null) return null;
+    const values = new Set();
+    if (!finiteDomainValues(attribute.args[3], env, values) || values.size === 0 || values.size > 30) return null;
+    variableNames.add(value.name);
+    variables.push(value);
+    domains.push([...values]);
+  }
+  if (!allDistinctMatchingExists(domains, ground)) return atom('false');
+
+  const removals = [];
+  for (let index = 0; index < variables.length; index++) {
+    for (const value of domains[index]) {
+      if (ground.has(value) || !allDistinctMatchingExists(domains, ground, index, value)) {
+        removals.push([variables[index], value]);
+      }
+    }
+  }
+  if (removals.length === 0) return compound('=', [goal.args[1], goal.args[2]]);
+  const goals = [];
+  let state = goal.args[1];
+  for (let index = 0; index < removals.length; index++) {
+    const nextState = index + 1 === removals.length
+      ? goal.args[2]
+      : variable(`__clpz_distinct_state_${++distinctStateId}`);
+    goals.push(qualified('neq_num', [removals[index][0], numberTerm(removals[index][1]), state, nextState]));
+    state = nextState;
+  }
+  return conjunction(goals);
+}
+
+function finiteAllDistinctModel(items, env) {
+  const variableNames = [];
+  const variableIndexes = new Map();
+  for (const item of items) {
+    const value = deref(item, env);
+    if (value.type === NUMBER && isDecimalInteger(value.name)) continue;
+    if (value.type !== VAR || variableIndexes.has(value.name)) return null;
+    variableIndexes.set(value.name, variableNames.length);
+    variableNames.push(value.name);
+  }
+  if (variableNames.length === 0 || env._prologAttributes?.size !== variableNames.length) return null;
+
+  const domainSets = [];
+  const constraints = new Map();
+  for (const name of variableNames) {
+    const modules = env._prologAttributes.get(name);
+    if (modules?.size !== 1 || !modules.has('clpz') || modules.get('clpz')?.size !== 1) return null;
+    const attribute = clpzAttributeFor(name, env);
+    if (attribute == null) return null;
+    const values = new Set();
+    if (!finiteDomainValues(attribute.args[3], env, values) || values.size === 0) return null;
+    domainSets.push(values);
+    const propagators = activeClpzPropagators(attribute, env);
+    if (propagators == null) return null;
+    for (const constraint of propagators) {
+      if (constraint.name !== 'pdistinct') continue;
+      const members = properListItems(constraint.args[0], env);
+      if (members == null) return null;
+      const keyParts = [];
+      const normalized = [];
+      for (const member of members) {
+        const value = deref(member, env);
+        if (value.type === VAR) {
+          const index = variableIndexes.get(value.name);
+          if (index == null) return null;
+          keyParts.push(`v${index}`);
+          normalized.push(index);
+        } else if (value.type === NUMBER && isDecimalInteger(value.name)) {
+          const integer = BigInt(value.name);
+          keyParts.push(`n${integer}`);
+          normalized.push(integer);
+        } else return null;
+      }
+      constraints.set(keyParts.join(','), normalized);
+    }
+  }
+  if (constraints.size === 0) return null;
+  const universe = [...new Set(domainSets.flatMap((set) => [...set]))].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  if (universe.length === 0 || universe.length > 30) return null;
+  const bits = new Map(universe.map((value, index) => [value, 2 ** index]));
+  const domains = domainSets.map((set) => {
+    let mask = 0;
+    for (const value of set) mask += bits.get(value);
+    return mask;
+  });
+  const groups = [];
+  for (const members of constraints.values()) {
+    let groundMask = 0;
+    const variables = [];
+    const seenVariables = new Set();
+    for (const member of members) {
+      if (typeof member === 'number') {
+        if (seenVariables.has(member)) return null;
+        seenVariables.add(member);
+        variables.push(member);
+      } else {
+        const bit = bits.get(member);
+        if (bit == null || (groundMask & bit) !== 0) return null;
+        groundMask |= bit;
+      }
+    }
+    groups.push({ variables, groundMask });
+  }
+  return { variableNames, universe, domains, groups };
+}
+
+function bitCount(mask) {
+  let count = 0;
+  while (mask !== 0) {
+    mask &= mask - 1;
+    count++;
+  }
+  return count;
+}
+
+function allDistinctMaskMatchingExists(domains, group, forcedIndex = -1, forcedBit = 0) {
+  if (forcedIndex >= 0 && ((domains[forcedIndex] & forcedBit) === 0 ||
+      (group.groundMask & forcedBit) !== 0)) return false;
+  const matching = new Map();
+  if (forcedIndex >= 0) matching.set(forcedBit, forcedIndex);
+  const augment = (variableIndex, seen) => {
+    let remaining = domains[variableIndex] & ~group.groundMask;
+    while (remaining !== 0) {
+      const bit = remaining & -remaining;
+      remaining &= ~bit;
+      if (seen.has(bit)) continue;
+      seen.add(bit);
+      const previous = matching.get(bit);
+      if (previous == null || (previous !== forcedIndex && augment(previous, seen))) {
+        matching.set(bit, variableIndex);
+        return true;
+      }
+    }
+    return false;
+  };
+  for (const index of group.variables) {
+    if (index === forcedIndex) continue;
+    if (!augment(index, new Set())) return false;
+  }
+  return true;
+}
+
+function propagateAllDistinct(domains, groups) {
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const group of groups) {
+      if (!allDistinctMaskMatchingExists(domains, group)) return false;
+      for (const index of group.variables) {
+        const domain = domains[index];
+        let reduced = domain;
+        let remaining = domain;
+        while (remaining !== 0) {
+          const bit = remaining & -remaining;
+          remaining &= ~bit;
+          if ((group.groundMask & bit) !== 0 ||
+              !allDistinctMaskMatchingExists(domains, group, index, bit)) reduced &= ~bit;
+        }
+        if (reduced === 0) return false;
+        if (reduced !== domain) {
+          domains[index] = reduced;
+          changed = true;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+function* finiteAllDistinctSearch(solver, model, domains, iterations) {
+  if (!propagateAllDistinct(domains, model.groups)) return;
+  let selected = -1;
+  let selectedSize = Infinity;
+  for (let index = 0; index < domains.length; index++) {
+    const size = bitCount(domains[index]);
+    if (size > 1 && size < selectedSize) {
+      selected = index;
+      selectedSize = size;
+    }
+  }
+  if (selected < 0) {
+    yield domains;
+    return;
+  }
+  if ((++iterations.value & 1023) === 0) solver.checkMemoryLimit(true);
+  const bit = domains[selected] & -domains[selected];
+  const assigned = domains.slice();
+  assigned[selected] = bit;
+  yield* finiteAllDistinctSearch(solver, model, assigned, iterations);
+  const rejected = domains.slice();
+  rejected[selected] &= ~bit;
+  yield* finiteAllDistinctSearch(solver, model, rejected, iterations);
+}
+
+function* nativeLabeling({ solver, goal, env }) {
+  const model = goal._clpzModel;
+  for (const solution of finiteAllDistinctSearch(solver, model, model.domains.slice(), { value: 0 })) {
+    const next = env.clone();
+    next._prologAttributes = null;
+    for (let index = 0; index < model.variableNames.length; index++) {
+      const valueIndex = 31 - Math.clz32(solution[index]);
+      next.bind(model.variableNames[index], numberTerm(model.universe[valueIndex]));
+    }
+    yield next;
+  }
+}
+
+function expandLabeling({ solver, goal, env }) {
+  const options = properListItems(goal.args[0], env);
+  const option = options?.length === 1 ? deref(options[0], env) : null;
+  const items = properListItems(goal.args[1], env);
+  const model = option?.type === ATOM && option.name === 'ff' && items != null
+    ? finiteAllDistinctModel(items, env)
+    : null;
+  if (model == null) return qualified('labeling_portable', goal.args);
+  solver.stats.clpz_native_labelings++;
+  const native = compound('eyeprolog__clpz_labeling_native', goal.args);
+  native._clpzModel = model;
+  return native;
+}
+
+function expandDistinct({ solver, goal, env }) {
+  const expanded = distinctExpansion(goal, env);
+  if (expanded == null) return qualified('distinct_portable', goal.args);
+  solver.stats.clpz_native_distinct_propagations++;
+  return expanded;
+}
+
+function* unreachable() {
+  throw new Error('CLP adapter expansion was not applied');
+}
+
+export const clpzHostBuiltins = {
+  register(registry) {
+    registry.add('eyeprolog__clpz_labeling', 2, unreachable, {
+      expandGoal: expandLabeling,
+      eyePrologLibrary: true,
+    });
+    registry.add('eyeprolog__clpz_labeling_native', 2, nativeLabeling, { eyePrologLibrary: true });
+    registry.add('eyeprolog__clpz_distinct', 3, unreachable, {
+      expandGoal: expandDistinct,
+      eyePrologLibrary: true,
+    });
+  },
+};

package/src/lib/clpb.pl

@@ -1399,8 +1399,7 @@ node_ite(Node, Node-ite(Var,High,Low)) :-
 labeling(Vs0) :-
         must_be(list, Vs0),
         maplist(labeling_var, Vs0),
-        variables_in_index_order(Vs0, Vs),
-        maplist(indomain, Vs).
+        eyeprolog__clpb_labeling(Vs0).
 
 labeling_var(V) :- var(V), !.
 labeling_var(V) :- V == 0, !.
@@ -1417,10 +1416,6 @@ var_with_index(V, I-V) :-
         ;   I = 0
         ).
 
-indomain(0).
-indomain(1).
-
-
 %% sat_count(+Expr, -Count) is det.
 %
 % Count the number of admissible assignments. Count is the number of

package/src/lib/clpz.pl

@@ -1877,6 +1877,9 @@ labeling(Options, Vars) :-
         must_be(list, labeling(Options, Vars)-1, Options),
         fd_must_be_list(Vars, labeling(Options, Vars)-2),
         maplist(finite_domain(labeling(Options, Vars), 2), Vars),
+        eyeprolog__clpz_labeling(Options, Vars).
+
+labeling_portable(Options, Vars) :-
         label(Options, Options, default(leftmost), default(up), default(step), [], upto_ground, Vars).
 
 
@@ -6319,7 +6322,9 @@ with_local_attributes(Vars, Goal, Result) :-
               local_attributes(Vars-Result),
               true).
 
-distinct(Vars) -->
+distinct(Vars) --> eyeprolog__clpz_distinct(Vars).
+
+distinct_portable(Vars) -->
         { with_local_attributes(Vars,
            (   difference_arcs(Vars, FreeLeft, FreeRight0),
                length(FreeLeft, LFL),

package/src/solver.js

@@ -214,6 +214,9 @@ export class Solver {
       datalog_facts_derived: 0,
       wfs_fixpoint_rounds: 0,
       wfs_undefined_answers: 0,
+      clpz_native_labelings: 0,
+      clpz_native_distinct_propagations: 0,
+      clpb_native_labelings: 0,
     };
   }
 

package/src/standard-library.js

@@ -9,6 +9,8 @@ import { cryptoHostBuiltins } from './crypto-host.js';
 import { dcgsHostBuiltins } from './dcgs-host.js';
 import { arithmeticHostBuiltins } from './arithmetic-host.js';
 import { charsioHostBuiltins } from './charsio-host.js';
+import { clpbHostBuiltins } from './clpb-host.js';
+import { clpzHostBuiltins } from './clpz-host.js';
 import { filesHostBuiltins } from './files-host.js';
 import { difHostBuiltins } from './dif-host.js';
 import { formatHostBuiltins } from './format-host.js';
@@ -378,6 +380,8 @@ export function createEyePrologRegistry() {
   expansionBuiltins.register(registry);
   arithmeticHostBuiltins.register(registry);
   charsioHostBuiltins.register(registry);
+  clpbHostBuiltins.register(registry);
+  clpzHostBuiltins.register(registry);
   filesHostBuiltins.register(registry);
   difHostBuiltins.register(registry);
   formatHostBuiltins.register(registry);

package/test/regression/cases-api.mjs

@@ -465,6 +465,7 @@ answer(X,Y,U,R,F,W,G,C,T) :-
         assertEqual(result.stdout,
           'answer(1, 0, "abc", "abc", "aa", yes, shared1, "A", [[1, 3], [2, 4]]).\n',
           'composed common-library answer');
+        assertEqual(result.stats.clpb_native_labelings, 1, 'CLP(B) labeling takes its host search-plan path');
       },
     },
     {
@@ -1303,7 +1304,7 @@ answer(ok) :-
         assertEqual(Boolean(registry.get('is', 2)), true, 'ISO is/2 exists');
         assertEqual(Boolean(registry.get('append', 3)), false, 'append/3 is not ISO core');
         assertEqual(library.eyePrologLibrary, true, 'complete registry marker');
-        assertEqual(library.defs.size, 223, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS predicates, and generic library adapters');
+        assertEqual(library.defs.size, 227, 'EyeProlog registry contains ISO definitions, cleanup controls, observability extensions, WFS predicates, and generic library adapters');
         assertEqual(registry.get('eyeprolog__dynify', 1), null, 'Eyelet dynify adapter is absent from the ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__dynify', 1)), true, 'Eyelet dynify adapter is an internal EyeProlog library primitive');
         assertEqual(registry.get('eyeprolog__eyelet_emit', 2), null, 'Eyelet event adapter is absent from the ISO registry');
@@ -1359,7 +1360,9 @@ answer(ok) :-
         assertEqual(registry.get('eyeprolog__countall', 2), null, 'private countall adapter is absent from ISO registry');
         assertEqual(Boolean(library.get('eyeprolog__countall', 2)), true, 'private countall adapter is registered for EyeProlog');
         assertEqual(Boolean(library.get('eyeprolog__time', 1)), true, 'private time adapter is registered for EyeProlog');
-        assertEqual(library.get('eyeprolog__clpz_labeling', 2), null, 'CLP(Z) labeling is implemented in Prolog');
+        assertEqual(Boolean(library.get('eyeprolog__clpz_labeling', 2)), true, 'CLP(Z) labeling dispatch has a private host adapter');
+        assertEqual(Boolean(library.get('eyeprolog__clpz_distinct', 3)), true, 'CLP(Z) all-distinct propagation has a private host adapter');
+        assertEqual(Boolean(library.get('eyeprolog__clpb_labeling', 1)), true, 'CLP(B) labeling has a private host adapter');
         assertEqual(library.get('eyeprolog__clpz_global_cardinality', 3), null, 'CLP(Z) cardinality is implemented in Prolog');
         assertEqual(registry.get('put_atts', 2), null, 'put_atts/2 is absent from the ISO registry');
         assertEqual(Boolean(library.get('put_atts', 2)), true, 'put_atts/2 is registered for attributed-variable libraries');
@@ -1586,6 +1589,24 @@ repeated(X) :- X in 1..3, all_distinct([X, X]).
           'answer(1, 4, 1).\nanswer(2, 3, 0).\npruned(1 \\/ 3).\nhall(3..3).\n', 'CLP(Z) constrained answers');
       },
     },
+    {
+      name: 'CLP(Z) specializes finite all_distinct first-fail labeling without changing answer order',
+      run: () => {
+        const result = run(`:- use_module(library(clpz)).
+answer(A, B, C) :-
+  [A, B, C] ins 1..3,
+  all_distinct([A, B, C]),
+  labeling([ff], [A, B, C]).
+`, { goal: 'answer(A, B, C)' });
+        assertEqual(result.stdout,
+          'answer(1, 2, 3).\nanswer(1, 3, 2).\nanswer(2, 1, 3).\n' +
+          'answer(2, 3, 1).\nanswer(3, 1, 2).\nanswer(3, 2, 1).\n',
+          'native finite-domain search preserves step/up answer order');
+        assertEqual(result.stats.clpz_native_labelings, 1, 'finite all_distinct labeling takes native path');
+        assertEqual(result.stats.clpz_native_distinct_propagations > 0, true,
+          'finite all_distinct propagation takes native matching path');
+      },
+    },
     {
       name: 'CLP(Z) finite global constraints match the portable example',
       run: () => {

package/the-art-of-eyeprolog.md

@@ -9619,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 'sudoku4_solution(S)' examples/clpz-sudoku-9x9.pl
+eyeprolog --portable --goal 'sudoku9(S)' examples/clpz-sudoku-9x9.pl
 eyeprolog --stats --goal 'path(a, X)' examples/path-discovery.pl > answers.pl 2> run.stats
 ```
 
@@ -9986,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; 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) |
+| [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, genuinely searched from its clues as the default example goal. | [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) |