eyeling 1.34.3 → 1.34.4

package/lib/eyelang/builtins/registry.js

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

package/lib/eyelang/builtins/strings.js

@@ -1,16 +1,76 @@
 // String builtins.
 // They mostly project from already-ground terms to avoid guessing string domains.
-import { compound, lexicalValue, stringTerm, unify } from '../term.js';
+import {
+  atom,
+  compound,
+  deref,
+  isDecimalInteger,
+  lexicalValue,
+  listFromItems,
+  numberTerm,
+  parseFiniteNumber,
+  properListItems,
+  stringTerm,
+  termToString,
+  unify,
+} from '../term.js';
 
 export const stringBuiltins = {
   register(registry) {
     registry.add('str_concat', 3, concat, { deterministic: true });
     for (const name of ['contains', 'matches', 'not_matches']) registry.add(name, 2, contains(name), { deterministic: true });
     registry.add('matches', 3, matchCaptures, { deterministic: true });
+    registry.add('split', 3, split, { deterministic: true, fallbackWhenNotReady: true, ready: firstTwoLexicalReady });
+    registry.add('join', 3, join, { deterministic: true, fallbackWhenNotReady: true, ready: listAndSecondLexicalReady });
+    registry.add('substring', 4, substring, { deterministic: true, fallbackWhenNotReady: true, ready: substringReady });
+    registry.add('replace', 4, replace, { deterministic: true, fallbackWhenNotReady: true, ready: firstThreeLexicalReady });
+    registry.add('lowercase', 2, caseFold('lower'), { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('uppercase', 2, caseFold('upper'), { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('trim', 2, trim, { deterministic: true, fallbackWhenNotReady: true, ready: firstLexicalReady });
+    registry.add('number_string', 2, numberString, { deterministic: true, fallbackWhenNotReady: true, ready: numberStringReady });
+    registry.add('atom_string', 2, atomString, { deterministic: true, fallbackWhenNotReady: true, ready: atomStringReady });
+    registry.add('term_string', 2, termString, { deterministic: true, fallbackWhenNotReady: true, ready: firstNonvarReady });
   }
 };
 
 
+
+function firstLexicalReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null;
+}
+
+function firstTwoLexicalReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null && lexicalValue(goal.args[1], env) !== null;
+}
+
+function firstThreeLexicalReady(goal, env) {
+  return firstTwoLexicalReady(goal, env) && lexicalValue(goal.args[2], env) !== null;
+}
+
+function listAndSecondLexicalReady(goal, env) {
+  return properListItems(goal.args[0], env) !== null && lexicalValue(goal.args[1], env) !== null;
+}
+
+function substringReady(goal, env) {
+  return lexicalValue(goal.args[0], env) !== null && safeIndex(goal.args[1], env) !== null && safeIndex(goal.args[2], env) !== null;
+}
+
+function numberStringReady(goal, env) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  return left.type === 'number' || right.type === 'string' || right.type === 'atom';
+}
+
+function atomStringReady(goal, env) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  return left.type === 'atom' || right.type === 'string' || right.type === 'atom' || right.type === 'number';
+}
+
+function firstNonvarReady(goal, env) {
+  return deref(goal.args[0], env).type !== 'var';
+}
+
 function* concat({ goal, env }) {
   const left = lexicalValue(goal.args[0], env);
   const right = lexicalValue(goal.args[1], env);
@@ -53,6 +113,99 @@ function* matchCaptures({ goal, env }) {
   if (unify(goal.args[2], context, next)) yield next;
 }
 
+function* split({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const separator = lexicalValue(goal.args[1], env);
+  if (text == null || separator == null) return;
+  const parts = text.split(separator).map(stringTerm);
+  const next = env.clone();
+  if (unify(goal.args[2], listFromItems(parts), next)) yield next;
+}
+
+function* join({ goal, env }) {
+  const items = properListItems(goal.args[0], env);
+  const separator = lexicalValue(goal.args[1], env);
+  if (!items || separator == null) return;
+  const strings = [];
+  for (const item of items) {
+    const value = lexicalValue(item, env);
+    if (value == null) return;
+    strings.push(value);
+  }
+  const next = env.clone();
+  if (unify(goal.args[2], stringTerm(strings.join(separator)), next)) yield next;
+}
+
+function* substring({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const start = safeIndex(goal.args[1], env);
+  const count = safeIndex(goal.args[2], env);
+  if (text == null || start == null || count == null || start + count > text.length) return;
+  const next = env.clone();
+  if (unify(goal.args[3], stringTerm(text.slice(start, start + count)), next)) yield next;
+}
+
+function* replace({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  const search = lexicalValue(goal.args[1], env);
+  const replacement = lexicalValue(goal.args[2], env);
+  if (text == null || search == null || replacement == null) return;
+  const out = search === '' ? text : text.split(search).join(replacement);
+  const next = env.clone();
+  if (unify(goal.args[3], stringTerm(out), next)) yield next;
+}
+
+function caseFold(direction) {
+  return function* ({ goal, env }) {
+    const text = lexicalValue(goal.args[0], env);
+    if (text == null) return;
+    const next = env.clone();
+    const out = direction === 'lower' ? text.toLowerCase() : text.toUpperCase();
+    if (unify(goal.args[1], stringTerm(out), next)) yield next;
+  };
+}
+
+function* trim({ goal, env }) {
+  const text = lexicalValue(goal.args[0], env);
+  if (text == null) return;
+  const next = env.clone();
+  if (unify(goal.args[1], stringTerm(text.trim()), next)) yield next;
+}
+
+function* numberString({ goal, env }) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  const next = env.clone();
+  if (left.type === 'number') {
+    if (unify(goal.args[1], stringTerm(left.name), next)) yield next;
+    return;
+  }
+  if (right.type === 'string' || right.type === 'atom') {
+    if (!numericText(right.name)) return;
+    if (unify(goal.args[0], numberTerm(right.name), next)) yield next;
+  }
+}
+
+function* atomString({ goal, env }) {
+  const left = deref(goal.args[0], env);
+  const right = deref(goal.args[1], env);
+  const next = env.clone();
+  if (left.type === 'atom') {
+    if (unify(goal.args[1], stringTerm(left.name), next)) yield next;
+    return;
+  }
+  if (right.type === 'string' || right.type === 'atom' || right.type === 'number') {
+    if (unify(goal.args[0], atom(right.name), next)) yield next;
+  }
+}
+
+function* termString({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'var') return;
+  const next = env.clone();
+  if (unify(goal.args[1], stringTerm(termToString(term, env, true)), next)) yield next;
+}
+
 function contextFromGroups(groups) {
   const terms = [];
   for (const [name, value] of Object.entries(groups)) {
@@ -68,3 +221,14 @@ function contextFromGroups(groups) {
 function simpleAlternationMatch(haystack, pattern) {
   return pattern.split('|').some((part) => part === '' || haystack.includes(part));
 }
+
+function safeIndex(term, env) {
+  const text = lexicalValue(term, env);
+  if (!/^-?\d+$/.test(text ?? '')) return null;
+  const index = Number(text);
+  return Number.isSafeInteger(index) && index >= 0 ? index : null;
+}
+
+function numericText(text) {
+  return isDecimalInteger(text) || parseFiniteNumber(text) != null;
+}

package/lib/eyelang/builtins/terms.js

@@ -0,0 +1,66 @@
+// Term-inspection builtins for reusable meta-programming over eyelang terms.
+import { atom, compound, deref, listFromItems, lexicalValue, numberTerm, properListItems, stringTerm, unify } from '../term.js';
+
+export const termBuiltins = {
+  register(registry) {
+    registry.add('functor', 3, functorBuiltin, { deterministic: true, fallbackWhenNotReady: true, ready: firstNonvarReady });
+    registry.add('arg', 3, argBuiltin, { deterministic: true, fallbackWhenNotReady: true, ready: argReady });
+    registry.add('compound_name_arguments', 3, compoundNameArguments, { deterministic: true, fallbackWhenNotReady: true, ready: compoundNameArgumentsReady });
+  }
+};
+
+
+function firstNonvarReady(goal, env) {
+  return deref(goal.args[0], env).type !== 'var';
+}
+
+function argReady(goal, env) {
+  return /^\d+$/.test(lexicalValue(goal.args[0], env) ?? '') && deref(goal.args[1], env).type === 'compound';
+}
+
+function compoundNameArgumentsReady(goal, env) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'compound') return true;
+  return term.type === 'var' && lexicalValue(goal.args[1], env) !== null && properListItems(goal.args[2], env) !== null;
+}
+
+function* functorBuiltin({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'var') return;
+  const nameTerm = term.type === 'compound' ? atom(term.name) : scalarNameTerm(term);
+  const arity = term.type === 'compound' ? term.arity : 0;
+  const next = env.clone();
+  if (unify(goal.args[1], nameTerm, next) && unify(goal.args[2], numberTerm(arity), next)) yield next;
+}
+
+function* argBuiltin({ goal, env }) {
+  const indexText = lexicalValue(goal.args[0], env);
+  if (!/^\d+$/.test(indexText ?? '')) return;
+  const index = Number(indexText);
+  const term = deref(goal.args[1], env);
+  if (term.type !== 'compound' || !Number.isSafeInteger(index) || index < 1 || index > term.arity) return;
+  const next = env.clone();
+  if (unify(goal.args[2], term.args[index - 1], next)) yield next;
+}
+
+function* compoundNameArguments({ goal, env }) {
+  const term = deref(goal.args[0], env);
+  if (term.type === 'compound') {
+    const next = env.clone();
+    if (unify(goal.args[1], atom(term.name), next) && unify(goal.args[2], listFromItems(term.args), next)) yield next;
+    return;
+  }
+  if (term.type !== 'var') return;
+
+  const name = lexicalValue(goal.args[1], env);
+  const args = properListItems(goal.args[2], env);
+  if (name == null || !args) return;
+  const next = env.clone();
+  if (unify(goal.args[0], compound(name, args), next)) yield next;
+}
+
+function scalarNameTerm(term) {
+  if (term.type === 'atom') return atom(term.name);
+  if (term.type === 'number') return numberTerm(term.name);
+  return stringTerm(term.name);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.34.3",
+  "version": "1.34.4",
   "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, 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, term-inspection helpers, search-control 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/test/eyelang/conformance/cases/extension/036_reusable_numeric_builtins.pl

@@ -0,0 +1,10 @@
+% Reference 9.1: reusable numeric functions and max/3.
+materialize(answer, 2).
+answer(max, X) :- max(17, 42, X).
+answer(sqrt, X) :- sqrt(81, X).
+answer(floor, X) :- floor(3.9, X).
+answer(ceiling, X) :- ceiling(3.1, X).
+answer(trunc, X) :- trunc(-3.9, X).
+answer(exp, X) :- exp(0, X).
+answer(tan, X) :- tan(0, X).
+answer(atan2, X) :- atan2(0, -1, X).

package/test/eyelang/conformance/cases/extension/037_reusable_list_builtins.pl

@@ -0,0 +1,11 @@
+% Reference 9.1: reusable list selectors, slices, summaries, and stable set conversion.
+materialize(answer, 2).
+answer(head, X) :- head([alpha, beta, gamma, beta], X).
+answer(last, X) :- last([alpha, beta, gamma, beta], X).
+answer(take, X) :- take(2, [alpha, beta, gamma, beta], X).
+answer(drop, X) :- drop(2, [alpha, beta, gamma, beta], X).
+answer(slice, X) :- slice(1, 2, [alpha, beta, gamma, beta], X).
+answer(sum, X) :- sum_list([1, 2, 3.5], X).
+answer(min, X) :- min_list([3, 1, 2], X).
+answer(max, X) :- max_list([3, 1, 2], X).
+answer(set, X) :- list_to_set([beta, alpha, beta, gamma, alpha], X).

package/test/eyelang/conformance/cases/extension/038_reusable_string_builtins.pl

@@ -0,0 +1,12 @@
+% Reference 9.1: reusable string normalization, splitting, joining, replacement, and conversions.
+materialize(answer, 2).
+answer(trim, X) :- trim("  Hello Eyelang  ", X).
+answer(lower, X) :- lowercase("Hello Eyelang", X).
+answer(upper, X) :- uppercase("Hello Eyelang", X).
+answer(split, X) :- split("red,green,blue", ",", X).
+answer(join, X) :- join([red, green, blue], ":", X).
+answer(substring, X) :- substring("abcdef", 2, 3, X).
+answer(replace, X) :- replace("red-green-red", "red", "blue", X).
+answer(number_to_string, X) :- number_string(42, X).
+answer(string_to_number, X) :- number_string(X, "3.5").
+answer(atom_string, X) :- atom_string(eyelang, X).

package/test/eyelang/conformance/cases/extension/039_reusable_term_control_builtins.pl

@@ -0,0 +1,11 @@
+% Reference 9.1: term introspection/construction, term strings, and forall/2.
+materialize(answer, 2).
+item(1).
+item(2).
+item(3).
+answer(functor, pair(Name, Arity)) :- functor(edge(a, b), Name, Arity).
+answer(arg, X) :- arg(2, edge(a, b), X).
+answer(decompose, pair(Name, Args)) :- compound_name_arguments(edge(a, b), Name, Args).
+answer(compose, X) :- compound_name_arguments(X, edge, [a, b]).
+answer(term_string, X) :- term_string(edge(a, [b, c]), X).
+answer(forall, ok) :- forall(item(X), lt(X, 4)).

package/test/eyelang/conformance/expected/extension/036_reusable_numeric_builtins.out

@@ -0,0 +1,8 @@
+answer(max, 42).
+answer(sqrt, 9.0).
+answer(floor, 3).
+answer(ceiling, 4).
+answer(trunc, -3).
+answer(exp, 1.0).
+answer(tan, 0.0).
+answer(atan2, 3.1415926535897931).

package/test/eyelang/conformance/expected/extension/037_reusable_list_builtins.out

@@ -0,0 +1,9 @@
+answer(head, alpha).
+answer(last, beta).
+answer(take, [alpha, beta]).
+answer(drop, [gamma, beta]).
+answer(slice, [beta, gamma]).
+answer(sum, 6.5).
+answer(min, 1).
+answer(max, 3).
+answer(set, [beta, alpha, gamma]).

package/test/eyelang/conformance/expected/extension/038_reusable_string_builtins.out

@@ -0,0 +1,10 @@
+answer(trim, "Hello Eyelang").
+answer(lower, "hello eyelang").
+answer(upper, "HELLO EYELANG").
+answer(split, ["red", "green", "blue"]).
+answer(join, "red:green:blue").
+answer(substring, "cde").
+answer(replace, "blue-green-blue").
+answer(number_to_string, "42").
+answer(string_to_number, 3.5).
+answer(atom_string, "eyelang").

package/test/eyelang/conformance/expected/extension/039_reusable_term_control_builtins.out

@@ -0,0 +1,6 @@
+answer(functor, pair(edge, 2)).
+answer(arg, b).
+answer(decompose, pair(edge, [a, b])).
+answer(compose, edge(a, b)).
+answer(term_string, "edge(a, [b, c])").
+answer(forall, ok).

package/examples/eyelang/collatz-1000.pl

@@ -1,14 +0,0 @@
-% Memoize trajectories because different start values quickly merge into
-% shared Collatz tails.
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(collatzTrajectory, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-% Collatz trajectory benchmark adapted from Eyeling collatz-1000.n3.
-% The reusable builtin keeps this large output example focused on data volume
-% rather than recursive integer arithmetic overhead.
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-collatzTrajectory(N, Trajectory) :-
-  between(1, 1000, N),
-  collatz_trajectory(N, Trajectory).

package/examples/eyelang/complex-matrix-stability.pl

@@ -1,45 +0,0 @@
-% 2x2 continuous-time stability check.
-% For matrix [[a,b],[c,d]], a stable second-order linear system has
-% trace < 0 and determinant > 0.  A negative discriminant indicates a
-% complex-conjugate eigenvalue pair.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(trace, 2).
-materialize(determinant, 2).
-materialize(discriminant, 2).
-materialize(eigenShape, 2).
-materialize(status, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-matrix(controller_loop, -0.7, 1.2, -0.4, -0.5).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-trace(Matrix, Trace) :-
-  matrix(Matrix, A, _B, _C, D),
-  add(A, D, Trace).
-
-determinant(Matrix, Determinant) :-
-  matrix(Matrix, A, B, C, D),
-  mul(A, D, AD),
-  mul(B, C, BC),
-  sub(AD, BC, Determinant).
-
-discriminant(Matrix, Disc) :-
-  trace(Matrix, T),
-  determinant(Matrix, Det),
-  mul(T, T, T2),
-  mul(4, Det, FourDet),
-  sub(T2, FourDet, Disc).
-
-stable(Matrix) :-
-  trace(Matrix, T),
-  determinant(Matrix, Det),
-  lt(T, 0),
-  gt(Det, 0).
-
-complex_pair(Matrix) :-
-  discriminant(Matrix, Disc),
-  lt(Disc, 0).
-
-eigenShape(Matrix, complex_conjugate_pair) :- complex_pair(Matrix).
-status(Matrix, asymptotically_stable) :- stable(Matrix).

package/examples/eyelang/gcd-bezout-identity.pl

@@ -1,48 +0,0 @@
-% EYE reasoning-inspired example: greatest common divisor and Bézout identity.
-%
-% This ports the extended Euclidean algorithm idea into ordinary eyelang rules.
-% Each case derives gcd(a,b), coefficients s,t, and validation checks for
-% a*s + b*t = gcd(a,b) and divisibility.
-
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(gcd, 2).
-materialize(bezoutCoefficients, 2).
-materialize(check, 2).
-materialize(status, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-case(c1, 48, 18).
-case(c2, 101, 462).
-case(c3, 0, 5).
-case(c4, 270, 192).
-case(c5, -27, 36).
-case(c6, 123456, 7890).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-answer(Case, Gcd, S, T) :-
-  case(Case, A, B),
-  extended_gcd(A, B, Gcd, S, T).
-
-bezout_ok(Case) :-
-  case(Case, A, B),
-  answer(Case, Gcd, S, T),
-  mul(A, S, AS),
-  mul(B, T, BT),
-  add(AS, BT, Gcd).
-
-divides_ok(Case) :-
-  case(Case, A, B),
-  answer(Case, Gcd, S, T),
-  mod(A, Gcd, 0),
-  mod(B, Gcd, 0).
-
-nonnegative_ok(Case) :-
-  answer(Case, Gcd, S, T),
-  ge(Gcd, 0).
-
-gcd(Case, Gcd) :- answer(Case, Gcd, S, T).
-bezoutCoefficients(Case, [S, T]) :- answer(Case, Gcd, S, T).
-check(Case, bezout_identity) :- bezout_ok(Case).
-check(Case, divides_inputs) :- divides_ok(Case).
-check(Case, nonnegative_gcd) :- nonnegative_ok(Case).
-status(Case, done) :- answer(Case, Gcd, S, T), bezout_ok(Case), divides_ok(Case), nonnegative_ok(Case).

package/examples/eyelang/goldbach-1000.pl

@@ -1,185 +0,0 @@
-% Goldbach pairs up to 1000.
-% Prime numbers are input data; the rule below derives all Goldbach pairs.
-% Output declarations: materialize/2 selects the relations written to this example's golden output.
-materialize(isPrime, 2).
-materialize(goldbachOk, 2).
-
-% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
-prime(2).
-prime(3).
-prime(5).
-prime(7).
-prime(11).
-prime(13).
-prime(17).
-prime(19).
-prime(23).
-prime(29).
-prime(31).
-prime(37).
-prime(41).
-prime(43).
-prime(47).
-prime(53).
-prime(59).
-prime(61).
-prime(67).
-prime(71).
-prime(73).
-prime(79).
-prime(83).
-prime(89).
-prime(97).
-prime(101).
-prime(103).
-prime(107).
-prime(109).
-prime(113).
-prime(127).
-prime(131).
-prime(137).
-prime(139).
-prime(149).
-prime(151).
-prime(157).
-prime(163).
-prime(167).
-prime(173).
-prime(179).
-prime(181).
-prime(191).
-prime(193).
-prime(197).
-prime(199).
-prime(211).
-prime(223).
-prime(227).
-prime(229).
-prime(233).
-prime(239).
-prime(241).
-prime(251).
-prime(257).
-prime(263).
-prime(269).
-prime(271).
-prime(277).
-prime(281).
-prime(283).
-prime(293).
-prime(307).
-prime(311).
-prime(313).
-prime(317).
-prime(331).
-prime(337).
-prime(347).
-prime(349).
-prime(353).
-prime(359).
-prime(367).
-prime(373).
-prime(379).
-prime(383).
-prime(389).
-prime(397).
-prime(401).
-prime(409).
-prime(419).
-prime(421).
-prime(431).
-prime(433).
-prime(439).
-prime(443).
-prime(449).
-prime(457).
-prime(461).
-prime(463).
-prime(467).
-prime(479).
-prime(487).
-prime(491).
-prime(499).
-prime(503).
-prime(509).
-prime(521).
-prime(523).
-prime(541).
-prime(547).
-prime(557).
-prime(563).
-prime(569).
-prime(571).
-prime(577).
-prime(587).
-prime(593).
-prime(599).
-prime(601).
-prime(607).
-prime(613).
-prime(617).
-prime(619).
-prime(631).
-prime(641).
-prime(643).
-prime(647).
-prime(653).
-prime(659).
-prime(661).
-prime(673).
-prime(677).
-prime(683).
-prime(691).
-prime(701).
-prime(709).
-prime(719).
-prime(727).
-prime(733).
-prime(739).
-prime(743).
-prime(751).
-prime(757).
-prime(761).
-prime(769).
-prime(773).
-prime(787).
-prime(797).
-prime(809).
-prime(811).
-prime(821).
-prime(823).
-prime(827).
-prime(829).
-prime(839).
-prime(853).
-prime(857).
-prime(859).
-prime(863).
-prime(877).
-prime(881).
-prime(883).
-prime(887).
-prime(907).
-prime(911).
-prime(919).
-prime(929).
-prime(937).
-prime(941).
-prime(947).
-prime(953).
-prime(967).
-prime(971).
-prime(977).
-prime(983).
-prime(991).
-prime(997).
-
-% Derivation rules: each rule below contributes one logical step toward the displayed results.
-even_between_4_1000(N) :- between(4, 1000, N), mod(N, 2, 0).
-
-isPrime(N, true) :-
-  prime(N).
-
-goldbachOk(N, true) :-
-  even_between_4_1000(N),
-  goldbach_pair(N, _P, _Q).