eyeling 1.34.2 → 1.34.3

package/examples/eyelang/output/path-discovery.pl

@@ -1,3 +1,3 @@
-airroute(discovered, "Ostend-Bruges International Airport -> Liège Airport -> Heraklion International Nikos Kazantzakis Airport -> Václav Havel Airport Prague").
-airroute(discovered, "Ostend-Bruges International Airport -> Liège Airport -> Diagoras Airport -> Václav Havel Airport Prague").
-airroute(discovered, "Ostend-Bruges International Airport -> Liège Airport -> Palma De Mallorca Airport -> Václav Havel Airport Prague").
+airroute("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2, "Ostend-Bruges International Airport -> Liège Airport -> Heraklion International Nikos Kazantzakis Airport -> Václav Havel Airport Prague").
+airroute("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2, "Ostend-Bruges International Airport -> Liège Airport -> Diagoras Airport -> Václav Havel Airport Prague").
+airroute("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2, "Ostend-Bruges International Airport -> Liège Airport -> Palma De Mallorca Airport -> Václav Havel Airport Prague").

package/examples/eyelang/path-discovery.pl

@@ -1,20 +1,35 @@
 % Generic path discovery over the air-routes graph.
-% Change or add route_request(FromLabel, ToLabel, MaxStopOvers) to answer other routes.
+% Add route_request(FromLabel, ToLabel, MaxStopOvers) facts to answer other routes.
+% MaxStopOvers is converted to a leg limit, and the recursive search keeps a
+% visited list so it works without the removed finite-search helper builtins.
+
 % Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(airroute, 2).
+materialize(airroute, 4).
 
 % Program structure: facts set up the scenario, and rules derive the materialized conclusions.
 route_request("Ostend-Bruges International Airport", "Václav Havel Airport Prague", 2).
 
 % Derivation rules: each rule below contributes one logical step toward the displayed results.
-airroute(discovered, RouteText) :-
-  route_request(From, To, MaxStopOvers),
-  airport(Source, From),
-  airport(Destination, To),
+airroute(FromLabel, ToLabel, MaxStopOvers, RouteText) :-
+  route_request(FromLabel, ToLabel, MaxStopOvers),
+  route_between(FromLabel, ToLabel, MaxStopOvers, RouteText).
+
+route_between(FromLabel, ToLabel, MaxStopOvers, RouteText) :-
+  airport(Source, FromLabel),
+  airport(Destination, ToLabel),
   add(MaxStopOvers, 1, MaxLegs),
-  bounded_path(flight, Source, Destination, MaxLegs, Path),
+  simple_path(Source, Destination, MaxLegs, [Source], ReversePath),
+  reverse(ReversePath, Path),
   route_text(Path, RouteText).
 
+simple_path(Node, Node, _RemainingLegs, Visited, Visited).
+simple_path(Node, Goal, RemainingLegs, Visited, Path) :-
+  gt(RemainingLegs, 0),
+  flight(Node, Next),
+  not_member(Next, Visited),
+  sub(RemainingLegs, 1, NextRemainingLegs),
+  simple_path(Next, Goal, NextRemainingLegs, [Next|Visited], Path).
+
 route_text([Node], Text) :-
   airport(Node, Text).
 route_text([Node|Rest], Text) :-

package/lib/eyelang/builtins/registry.js

@@ -7,7 +7,6 @@ import { listBuiltins } from './lists.js';
 import { aggregationBuiltins } from './aggregation.js';
 import { contextBuiltins } from './context.js';
 import { controlBuiltins } from './control.js';
-import { searchBuiltins } from './search.js';
 import { numberTheoryBuiltins } from './number-theory.js';
 import { matrixBuiltins } from './matrix.js';
 
@@ -36,7 +35,7 @@ export class BuiltinRegistry {
 
 export function createDefaultRegistry() {
   const registry = new BuiltinRegistry();
-  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, searchBuiltins, numberTheoryBuiltins, matrixBuiltins]) {
+  for (const mod of [coreBuiltins, arithmeticBuiltins, stringBuiltins, listBuiltins, aggregationBuiltins, contextBuiltins, controlBuiltins, numberTheoryBuiltins, matrixBuiltins]) {
     mod.register(registry);
   }
   return registry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.34.2",
+  "version": "1.34.3",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/eyelang/conformance/README.md

@@ -36,7 +36,7 @@ The runner executes materialized programs in-process through the public JavaScri
 
 `core` covers the portable core language profile from the [eyelang language reference](../../../docs/eyelang-language-reference.md): lexical syntax, facts, definite clauses, first-order terms, lists, conjunction, structured unification through user predicates, left-to-right goal-directed proof search, materialized output, and read-back printing.
 
-`extension` covers the standard built-in and host behavior exercised by the current reference implementation: arithmetic, comparison, strings, list relations, aggregation, context-term helpers, number-theory helpers, finite-search helpers used by the example corpus, matrix helpers, `memoize/2`, `materialize/2`, and default derived output.
+`extension` covers the standard built-in and host behavior exercised by the current reference implementation: arithmetic, comparison, strings, list relations, aggregation, context-term helpers, number-theory helpers, matrix helpers, `memoize/2`, `materialize/2`, and default derived output.
 
 The profile name `extension` is a test-suite grouping name. It does not mean that these cases are outside the eyelang language reference; most of them correspond to the standard built-in profile and standard host profile in the [eyelang language reference](../../../docs/eyelang-language-reference.md).
 

package/examples/eyelang/dense-hamiltonian-cycle.pl

@@ -1,92 +0,0 @@
-% Dense weighted Hamiltonian cycle search.
-%
-% This deliberately stresses finite search: it enumerates symmetry-broken
-% permutations of seven non-start vertices in an eight-vertex complete graph,
-% scores the closed cycles, and keeps the cheapest candidate with
-% aggregate_min/5.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(best, 2).
-materialize(candidateCount, 2).
-materialize(status, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-cities([a, b, c, d, e, f, g, h]).
-
-edge(a, b, 3).
-edge(a, c, 47).
-edge(a, d, 35).
-edge(a, e, 46).
-edge(a, f, 34).
-edge(a, g, 45).
-edge(a, h, 10).
-edge(b, c, 4).
-edge(b, d, 42).
-edge(b, e, 30).
-edge(b, f, 41).
-edge(b, g, 52).
-edge(b, h, 40).
-edge(c, d, 5).
-edge(c, e, 37).
-edge(c, f, 48).
-edge(c, g, 36).
-edge(c, h, 47).
-edge(d, e, 6).
-edge(d, f, 32).
-edge(d, g, 43).
-edge(d, h, 31).
-edge(e, f, 7).
-edge(e, g, 50).
-edge(e, h, 38).
-edge(f, g, 8).
-edge(f, h, 45).
-edge(g, h, 9).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-weight(A, B, W) :- edge(A, B, W).
-weight(A, B, W) :- edge(B, A, W).
-
-permutation([], []).
-permutation(List, [X | Perm]) :-
-  select(X, List, Rest),
-  permutation(Rest, Perm).
-
-last([X], X).
-last([_ | Rest], X) :- last(Rest, X).
-
-path_cost([_Last], 0).
-path_cost([A, B | Rest], Cost) :-
-  weight(A, B, Step),
-  path_cost([B | Rest], Tail),
-  add(Step, Tail, Cost).
-
-symmetry_broken([First | Rest]) :-
-  last([First | Rest], Last),
-  lt(First, Last).
-
-candidate_cycle(Cities, Cycle, Cost) :-
-  weighted_hamiltonian_cycle(edge, Cities, Cycle, Cost).
-
-factorial(0, 1).
-factorial(N, F) :-
-  gt(N, 0),
-  sub(N, 1, N0),
-  factorial(N0, F0),
-  mul(N, F0, F).
-
-best(dense_hamiltonian_cycle, result(Cost, Cycle)) :-
-  cities(Cities),
-  aggregate_min([Cost, Cycle], result(Cost, Cycle), candidate_cycle(Cities, Cycle, Cost), _Key, result(Cost, Cycle)).
-
-candidateCount(dense_hamiltonian_cycle, Count) :-
-  cities([_Start | Rest]),
-  length(Rest, N),
-  factorial(N, Permutations),
-  div(Permutations, 2, Count).
-
-status(dense_hamiltonian_cycle, symmetry_broken_complete_graph_searched) :-
-  eq(ok, ok).
-
-reason(dense_hamiltonian_cycle, "symmetry-broken permutation search scores Hamiltonian cycles and aggregate_min selects the cheapest candidate") :-
-  eq(ok, ok).

package/examples/eyelang/hamiltonian-cycle.pl

@@ -1,55 +0,0 @@
-% Hamiltonian cycle without cut.
-%
-% The graph has eight vertices and enough chords to create a non-trivial search
-% space.  The first vertex is fixed to avoid rotational duplicates; the two
-% cycle directions are still distinct, so the count is for cycles from a fixed
-% start in traversal order.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(status, 2).
-materialize(witness, 2).
-materialize(vertexCount, 2).
-materialize(cycleCountFromA, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-edge(a, b).
-edge(a, f).
-edge(a, g).
-edge(a, h).
-edge(b, c).
-edge(b, d).
-edge(b, g).
-edge(b, h).
-edge(c, d).
-edge(c, e).
-edge(c, g).
-edge(d, e).
-edge(d, g).
-edge(d, h).
-edge(e, f).
-edge(f, g).
-edge(g, h).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-adjacent(X, Y) :- edge(X, Y).
-adjacent(X, Y) :- edge(Y, X).
-
-vertices([a, b, c, d, e, f, g, h]).
-
-hamiltonian_cycle(Cycle) :-
-  vertices(Vertices),
-  hamiltonian_cycle(edge, Vertices, Cycle).
-
-status(hamiltonian_cycle, exists) :-
-  once(hamiltonian_cycle(_Cycle)).
-
-witness(hamiltonian_cycle, Cycle) :-
-  once(hamiltonian_cycle(Cycle)).
-
-vertexCount(hamiltonian_cycle, Count) :-
-  vertices(Vertices),
-  length(Vertices, Count).
-
-cycleCountFromA(hamiltonian_cycle, Count) :-
-  findall(Cycle, hamiltonian_cycle(Cycle), Cycles),
-  length(Cycles, Count).

package/examples/eyelang/n-queens.pl

@@ -1,23 +0,0 @@
-% N-queens search without cut.
-%
-% A solution is represented as a list of column numbers.  The list position is
-% the row, so [1, 5, 8, ...] means row 1 uses column 1, row 2 uses column 5,
-% and so on.  Columns are selected from a finite list, which guarantees that no
-% two queens share a column.
-%
-% The two diagonal sets are carried as accumulator lists.  A queen at
-% row Row/column Q occupies the down diagonal Row + Q and the up diagonal
-% Row - Q.  Rejecting repeats in those two lists enforces the remaining
-% N-queens constraints declaratively, without cut or destructive update.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(solution, 2).
-materialize(solved, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-queens(N, Qs) :-
-  n_queens(N, Qs).
-
-solution(nQueens8, Qs) :- queens(8, Qs).
-solved(nQueens8, true) :- queens(8, _Qs).

package/examples/eyelang/output/dense-hamiltonian-cycle.pl

@@ -1,4 +0,0 @@
-best(dense_hamiltonian_cycle, result(52, [a, b, c, d, e, f, g, h, a])).
-candidateCount(dense_hamiltonian_cycle, 2520).
-status(dense_hamiltonian_cycle, symmetry_broken_complete_graph_searched).
-reason(dense_hamiltonian_cycle, "symmetry-broken permutation search scores Hamiltonian cycles and aggregate_min selects the cheapest candidate").

package/examples/eyelang/output/hamiltonian-cycle.pl

@@ -1,4 +0,0 @@
-status(hamiltonian_cycle, exists).
-witness(hamiltonian_cycle, [a, b, c, d, e, f, g, h, a]).
-vertexCount(hamiltonian_cycle, 8).
-cycleCountFromA(hamiltonian_cycle, 72).

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

@@ -1,93 +0,0 @@
-solution(nQueens8, [1, 5, 8, 6, 3, 7, 2, 4]).
-solution(nQueens8, [1, 6, 8, 3, 7, 4, 2, 5]).
-solution(nQueens8, [1, 7, 4, 6, 8, 2, 5, 3]).
-solution(nQueens8, [1, 7, 5, 8, 2, 4, 6, 3]).
-solution(nQueens8, [2, 4, 6, 8, 3, 1, 7, 5]).
-solution(nQueens8, [2, 5, 7, 1, 3, 8, 6, 4]).
-solution(nQueens8, [2, 5, 7, 4, 1, 8, 6, 3]).
-solution(nQueens8, [2, 6, 1, 7, 4, 8, 3, 5]).
-solution(nQueens8, [2, 6, 8, 3, 1, 4, 7, 5]).
-solution(nQueens8, [2, 7, 3, 6, 8, 5, 1, 4]).
-solution(nQueens8, [2, 7, 5, 8, 1, 4, 6, 3]).
-solution(nQueens8, [2, 8, 6, 1, 3, 5, 7, 4]).
-solution(nQueens8, [3, 1, 7, 5, 8, 2, 4, 6]).
-solution(nQueens8, [3, 5, 2, 8, 1, 7, 4, 6]).
-solution(nQueens8, [3, 5, 2, 8, 6, 4, 7, 1]).
-solution(nQueens8, [3, 5, 7, 1, 4, 2, 8, 6]).
-solution(nQueens8, [3, 5, 8, 4, 1, 7, 2, 6]).
-solution(nQueens8, [3, 6, 2, 5, 8, 1, 7, 4]).
-solution(nQueens8, [3, 6, 2, 7, 1, 4, 8, 5]).
-solution(nQueens8, [3, 6, 2, 7, 5, 1, 8, 4]).
-solution(nQueens8, [3, 6, 4, 1, 8, 5, 7, 2]).
-solution(nQueens8, [3, 6, 4, 2, 8, 5, 7, 1]).
-solution(nQueens8, [3, 6, 8, 1, 4, 7, 5, 2]).
-solution(nQueens8, [3, 6, 8, 1, 5, 7, 2, 4]).
-solution(nQueens8, [3, 6, 8, 2, 4, 1, 7, 5]).
-solution(nQueens8, [3, 7, 2, 8, 5, 1, 4, 6]).
-solution(nQueens8, [3, 7, 2, 8, 6, 4, 1, 5]).
-solution(nQueens8, [3, 8, 4, 7, 1, 6, 2, 5]).
-solution(nQueens8, [4, 1, 5, 8, 2, 7, 3, 6]).
-solution(nQueens8, [4, 1, 5, 8, 6, 3, 7, 2]).
-solution(nQueens8, [4, 2, 5, 8, 6, 1, 3, 7]).
-solution(nQueens8, [4, 2, 7, 3, 6, 8, 1, 5]).
-solution(nQueens8, [4, 2, 7, 3, 6, 8, 5, 1]).
-solution(nQueens8, [4, 2, 7, 5, 1, 8, 6, 3]).
-solution(nQueens8, [4, 2, 8, 5, 7, 1, 3, 6]).
-solution(nQueens8, [4, 2, 8, 6, 1, 3, 5, 7]).
-solution(nQueens8, [4, 6, 1, 5, 2, 8, 3, 7]).
-solution(nQueens8, [4, 6, 8, 2, 7, 1, 3, 5]).
-solution(nQueens8, [4, 6, 8, 3, 1, 7, 5, 2]).
-solution(nQueens8, [4, 7, 1, 8, 5, 2, 6, 3]).
-solution(nQueens8, [4, 7, 3, 8, 2, 5, 1, 6]).
-solution(nQueens8, [4, 7, 5, 2, 6, 1, 3, 8]).
-solution(nQueens8, [4, 7, 5, 3, 1, 6, 8, 2]).
-solution(nQueens8, [4, 8, 1, 3, 6, 2, 7, 5]).
-solution(nQueens8, [4, 8, 1, 5, 7, 2, 6, 3]).
-solution(nQueens8, [4, 8, 5, 3, 1, 7, 2, 6]).
-solution(nQueens8, [5, 1, 4, 6, 8, 2, 7, 3]).
-solution(nQueens8, [5, 1, 8, 4, 2, 7, 3, 6]).
-solution(nQueens8, [5, 1, 8, 6, 3, 7, 2, 4]).
-solution(nQueens8, [5, 2, 4, 6, 8, 3, 1, 7]).
-solution(nQueens8, [5, 2, 4, 7, 3, 8, 6, 1]).
-solution(nQueens8, [5, 2, 6, 1, 7, 4, 8, 3]).
-solution(nQueens8, [5, 2, 8, 1, 4, 7, 3, 6]).
-solution(nQueens8, [5, 3, 1, 6, 8, 2, 4, 7]).
-solution(nQueens8, [5, 3, 1, 7, 2, 8, 6, 4]).
-solution(nQueens8, [5, 3, 8, 4, 7, 1, 6, 2]).
-solution(nQueens8, [5, 7, 1, 3, 8, 6, 4, 2]).
-solution(nQueens8, [5, 7, 1, 4, 2, 8, 6, 3]).
-solution(nQueens8, [5, 7, 2, 4, 8, 1, 3, 6]).
-solution(nQueens8, [5, 7, 2, 6, 3, 1, 4, 8]).
-solution(nQueens8, [5, 7, 2, 6, 3, 1, 8, 4]).
-solution(nQueens8, [5, 7, 4, 1, 3, 8, 6, 2]).
-solution(nQueens8, [5, 8, 4, 1, 3, 6, 2, 7]).
-solution(nQueens8, [5, 8, 4, 1, 7, 2, 6, 3]).
-solution(nQueens8, [6, 1, 5, 2, 8, 3, 7, 4]).
-solution(nQueens8, [6, 2, 7, 1, 3, 5, 8, 4]).
-solution(nQueens8, [6, 2, 7, 1, 4, 8, 5, 3]).
-solution(nQueens8, [6, 3, 1, 7, 5, 8, 2, 4]).
-solution(nQueens8, [6, 3, 1, 8, 4, 2, 7, 5]).
-solution(nQueens8, [6, 3, 1, 8, 5, 2, 4, 7]).
-solution(nQueens8, [6, 3, 5, 7, 1, 4, 2, 8]).
-solution(nQueens8, [6, 3, 5, 8, 1, 4, 2, 7]).
-solution(nQueens8, [6, 3, 7, 2, 4, 8, 1, 5]).
-solution(nQueens8, [6, 3, 7, 2, 8, 5, 1, 4]).
-solution(nQueens8, [6, 3, 7, 4, 1, 8, 2, 5]).
-solution(nQueens8, [6, 4, 1, 5, 8, 2, 7, 3]).
-solution(nQueens8, [6, 4, 2, 8, 5, 7, 1, 3]).
-solution(nQueens8, [6, 4, 7, 1, 3, 5, 2, 8]).
-solution(nQueens8, [6, 4, 7, 1, 8, 2, 5, 3]).
-solution(nQueens8, [6, 8, 2, 4, 1, 7, 5, 3]).
-solution(nQueens8, [7, 1, 3, 8, 6, 4, 2, 5]).
-solution(nQueens8, [7, 2, 4, 1, 8, 5, 3, 6]).
-solution(nQueens8, [7, 2, 6, 3, 1, 4, 8, 5]).
-solution(nQueens8, [7, 3, 1, 6, 8, 5, 2, 4]).
-solution(nQueens8, [7, 3, 8, 2, 5, 1, 6, 4]).
-solution(nQueens8, [7, 4, 2, 5, 8, 1, 3, 6]).
-solution(nQueens8, [7, 4, 2, 8, 6, 1, 3, 5]).
-solution(nQueens8, [7, 5, 3, 1, 6, 8, 2, 4]).
-solution(nQueens8, [8, 2, 4, 1, 7, 5, 3, 6]).
-solution(nQueens8, [8, 2, 5, 3, 1, 7, 4, 6]).
-solution(nQueens8, [8, 3, 1, 6, 2, 5, 7, 4]).
-solution(nQueens8, [8, 4, 1, 3, 6, 2, 7, 5]).
-solved(nQueens8, true).

package/examples/eyelang/output/quine-mccluskey.pl

@@ -1,3 +0,0 @@
-primeImplicants(quine_mccluskey, [[0, 0, x, x], [0, x, x, 1], [x, x, 1, 1]]).
-minimalCover(quine_mccluskey, [[0, 0, x, x], [x, x, 1, 1]]).
-equation(quine_mccluskey, "f = ~A~B + CD").

package/examples/eyelang/output/sat-dpll.pl

@@ -1,5 +0,0 @@
-status(sat_instance, satisfiable).
-witness(sat_instance, [value(a, false), value(b, true), value(c, false), value(d, true), value(e, false), value(f, true), value(g, false), value(h, true)]).
-modelCount(sat_instance, 18).
-variableCount(sat_instance, 8).
-clauseCount(sat_instance, 12).

package/examples/eyelang/output/traveling-salesman.pl

@@ -1 +0,0 @@
-optimalTour([aaa, bbb, ccc, ddd, eee, fff, ggg], [[aaa, bbb, fff, ccc, eee, ddd, ggg], 75]).

package/examples/eyelang/quine-mccluskey.pl

@@ -1,143 +0,0 @@
-% Eyelet-inspired Quine-McCluskey minimization using findall/3 and sort/2.
-% Problem: f(A,B,C,D) = Sigma m(1,3,7,11,15) + d(0,2,5).
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(primeImplicants, 2).
-materialize(minimalCover, 2).
-materialize(equation, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-minterm(1).
-minterm(3).
-minterm(7).
-minterm(11).
-minterm(15).
-
-dont_care(0).
-dont_care(2).
-dont_care(5).
-
-bits(0, [0, 0, 0, 0]).
-bits(1, [0, 0, 0, 1]).
-bits(2, [0, 0, 1, 0]).
-bits(3, [0, 0, 1, 1]).
-bits(4, [0, 1, 0, 0]).
-bits(5, [0, 1, 0, 1]).
-bits(6, [0, 1, 1, 0]).
-bits(7, [0, 1, 1, 1]).
-bits(8, [1, 0, 0, 0]).
-bits(9, [1, 0, 0, 1]).
-bits(10, [1, 0, 1, 0]).
-bits(11, [1, 0, 1, 1]).
-bits(12, [1, 1, 0, 0]).
-bits(13, [1, 1, 0, 1]).
-bits(14, [1, 1, 1, 0]).
-bits(15, [1, 1, 1, 1]).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-initial_pattern(P) :- minterm(M), bits(M, P).
-initial_pattern(P) :- dont_care(D), bits(D, P).
-
-combine(A, B, R) :-
-  diff_count(A, B, 0, 1, [], Rev),
-  reverse(Rev, R).
-
-diff_count([], [], Count, Count, Acc, Acc).
-diff_count([X | A], [X | B], Count, Max, Acc, R) :-
-  diff_count(A, B, Count, Max, [X | Acc], R).
-diff_count([X | A], [Y | B], Count, Max, Acc, R) :-
-  neq(X, Y),
-  add(Count, 1, Next),
-  le(Next, Max),
-  diff_count(A, B, Next, Max, [x | Acc], R).
-
-combined_once(P) :-
-  initial_pattern(A),
-  initial_pattern(B),
-  combine(A, B, P).
-
-combined_twice(P) :-
-  combined_once(A),
-  combined_once(B),
-  combine(A, B, P).
-
-used_initial(P) :-
-  initial_pattern(Q),
-  combine(P, Q, _R).
-
-used_once(P) :-
-  combined_once(Q),
-  combine(P, Q, _R).
-
-prime(P) :-
-  initial_pattern(P),
-  not(used_initial(P)).
-prime(P) :-
-  combined_once(P),
-  not(used_once(P)).
-prime(P) :-
-  combined_twice(P).
-
-prime_implicants(Primes) :-
-  minterms(Minterms),
-  dont_cares(DontCares),
-  bit_table(Bits),
-  qm_prime_implicants(Minterms, DontCares, Bits, Primes).
-
-covers([], []).
-covers([x | Pattern], [_Bit | Bits]) :-
-  covers(Pattern, Bits).
-covers([Bit | Pattern], [Bit | Bits]) :-
-  neq(Bit, x),
-  covers(Pattern, Bits).
-
-covers_int(Pattern, Int) :-
-  bits(Int, Bits),
-  covers(Pattern, Bits).
-
-covers_all(_Cover, []).
-covers_all(Cover, [M | Minterms]) :-
-  member(P, Cover),
-  covers_int(P, M),
-  covers_all(Cover, Minterms).
-
-minterms(Minterms) :-
-  findall(M, minterm(M), Raw),
-  sort(Raw, Minterms).
-
-dont_cares(DontCares) :-
-  findall(D, dont_care(D), Raw),
-  sort(Raw, DontCares).
-
-bit_table(Bits) :-
-  findall(bit(N, Pattern), bits(N, Pattern), Bits).
-
-pair_from([A | Rest], A, B) :-
-  member(B, Rest).
-pair_from([_Head | Rest], A, B) :-
-  pair_from(Rest, A, B).
-
-cover_candidate(Cover) :-
-  prime_implicants(Primes),
-  pair_from(Primes, A, B),
-  sort([A, B], Cover),
-  minterms(Minterms),
-  covers_all(Cover, Minterms).
-
-minimal_cover(Cover) :-
-  minterms(Minterms),
-  dont_cares(DontCares),
-  bit_table(Bits),
-  qm_minimal_cover(Minterms, DontCares, Bits, Cover).
-
-primeImplicants(quine_mccluskey, Primes) :-
-  prime_implicants(Primes).
-
-minimalCover(quine_mccluskey, Cover) :-
-  minimal_cover(Cover).
-
-equation(quine_mccluskey, "f = ~A~B + CD") :-
-  minimal_cover([[0, 0, x, x], [x, x, 1, 1]]).
-
-reason(quine_mccluskey, "findall builds implicant sets and sort removes duplicates before cover selection").

package/examples/eyelang/sat-dpll.pl

@@ -1,80 +0,0 @@
-% SAT solving without cut.
-%
-% A compact DPLL-style example for a finite CNF formula.  The program first
-% generates truth assignments, then checks every clause declaratively.  This
-% larger instance has eight variables and twelve clauses, so it is still small
-% enough for full model collection but no longer a toy four-variable search.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(status, 2).
-materialize(witness, 2).
-materialize(modelCount, 2).
-materialize(variableCount, 2).
-materialize(clauseCount, 2).
-materialize(reason, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-problem(sat_instance,
-  [a, b, c, d, e, f, g, h],
-  [
-    [pos(a), pos(b)],
-    [neg(a), pos(c)],
-    [neg(b), pos(d)],
-    [pos(c), pos(d)],
-    [neg(c), pos(e)],
-    [neg(d), pos(f)],
-    [pos(e), pos(f)],
-    [neg(e), pos(g)],
-    [neg(f), pos(h)],
-    [pos(g), pos(h)],
-    [neg(g), pos(a)],
-    [neg(h), pos(b)]
-  ]).
-
-truth(false).
-truth(true).
-
-assignment([], []).
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-assignment([Var|Vars], [value(Var, Truth)|Rest]) :-
-  truth(Truth),
-  assignment(Vars, Rest).
-
-literal_true(pos(Var), Assignment) :-
-  member(value(Var, true), Assignment).
-literal_true(neg(Var), Assignment) :-
-  member(value(Var, false), Assignment).
-
-clause_true([Literal|_Rest], Assignment) :-
-  literal_true(Literal, Assignment).
-clause_true([_Literal|Rest], Assignment) :-
-  clause_true(Rest, Assignment).
-
-cnf_true([], _Assignment).
-cnf_true([Clause|Clauses], Assignment) :-
-  clause_true(Clause, Assignment),
-  cnf_true(Clauses, Assignment).
-
-model(Name, Assignment) :-
-  problem(Name, Variables, Clauses),
-  cnf_model(Variables, Clauses, Assignment).
-
-status(sat_instance, satisfiable) :-
-  once(model(sat_instance, _Assignment)).
-
-witness(sat_instance, Assignment) :-
-  once(model(sat_instance, Assignment)).
-
-modelCount(sat_instance, Count) :-
-  findall(Assignment, model(sat_instance, Assignment), Models),
-  length(Models, Count).
-
-variableCount(sat_instance, Count) :-
-  problem(sat_instance, Variables, _Clauses),
-  length(Variables, Count).
-
-clauseCount(sat_instance, Count) :-
-  problem(sat_instance, _Variables, Clauses),
-  length(Clauses, Count).
-
-reason(sat_instance, "finite 8-variable CNF search succeeds without cut").

package/examples/eyelang/traveling-salesman.pl

@@ -1,64 +0,0 @@
-% Traveling salesman problem, adapted from Eyelet input/traveling-salesman.pl.
-% The optimal tour matches Eyelet output-swipl/traveling-salesman.pl.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(optimalTour, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-% The target list fixes the city set; weighted_hamiltonian_path/4 searches tours.
-target_cities([aaa, bbb, ccc, ddd, eee, fff, ggg]).
-
-distance(aaa, bbb, 10).
-distance(aaa, ccc, 15).
-distance(aaa, ddd, 20).
-distance(aaa, eee, 25).
-distance(aaa, fff, 30).
-distance(bbb, ccc, 35).
-distance(bbb, ddd, 40).
-distance(bbb, eee, 20).
-distance(bbb, fff, 25).
-distance(ccc, ddd, 30).
-distance(ccc, eee, 15).
-distance(ccc, fff, 10).
-distance(ddd, eee, 10).
-distance(ddd, fff, 35).
-distance(ddd, ggg, 5).
-distance(eee, fff, 20).
-
-% Distances are stored once; distance2/3 makes the graph undirected.
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-distance2(A, B, D) :-
-  distance(A, B, D).
-distance2(A, B, D) :-
-  distance(B, A, D).
-
-permutation([], []).
-permutation(List, [X|Perm]) :-
-  select(X, List, Rest),
-  permutation(Rest, Perm).
-
-total_distance([_Last], 0).
-total_distance([X, Y|Tail], D) :-
-  distance2(X, Y, D1),
-  total_distance([Y|Tail], D2),
-  add(D1, D2, D).
-
-tsp(Cities, Tour, Distance) :-
-  weighted_hamiltonian_path(distance, Cities, Tour, Distance).
-
-% Materialized output keeps only the minimum-distance candidate.
-optimalTour(Cities, Optimal) :-
-  target_cities(Cities),
-  findall([T, D], tsp(Cities, T, D), Solutions),
-  min_distance(Solutions, Optimal).
-
-min_distance([Sol|Sols], Optimal) :-
-  min_distance_acc(Sols, Sol, Optimal).
-
-min_distance_acc([], Best, Best).
-min_distance_acc([[_T, D]|Rest], [_BestTour, BestDistance], Optimal) :-
-  lt(D, BestDistance),
-  min_distance_acc(Rest, [_T, D], Optimal).
-min_distance_acc([[_T, D]|Rest], [BestTour, BestDistance], Optimal) :-
-  ge(D, BestDistance),
-  min_distance_acc(Rest, [BestTour, BestDistance], Optimal).