eyeling 1.13.7 → 1.14.1

package/HANDBOOK.md

@@ -1516,6 +1516,47 @@ A tiny `sprintf` subset:
 - Any other specifier (`%d`, `%f`, …) causes the builtin to fail.
 - Missing arguments are treated as empty strings.
 
+### Length and character utilities (Eyeling extensions)
+
+Eyeling also implements a few **non-standard** `string:` helpers that are handy for string-based algorithms. These are **not** part of the SWAP builtin set, so treat them as Eyeling extensions.
+
+#### `string:length`
+
+**Shape:** `s string:length n`
+
+Casts `s` to a string and returns its length as an integer literal token.
+
+#### `string:charAt`
+
+**Shape:** `( s i ) string:charAt ch`
+
+- `i` is a numeric term, truncated to an integer.
+- Indexing is **0-based** (like JavaScript).
+- If `i` is out of range, `ch` is the empty string `""`.
+
+#### `string:setCharAt`
+
+**Shape:** `( s i ch ) string:setCharAt out`
+
+Returns a copy of `s` with the character at index `i` (0-based) replaced by:
+
+- the **first character** of `ch` if `ch` is non-empty, otherwise
+- the empty string.
+
+If `i` is out of range, `out` is the original string.
+
+#### `string:hammingDistance`
+
+**Shape:** `( a b ) string:hammingDistance d`
+
+Returns the number of differing positions between `a` and `b`. Fails if the two strings have different lengths.
+
+#### `string:mutateSelectBest`
+
+**Shape:** `( samples current target mutProb seedState ) string:mutateSelectBest ( best bestScore seedState2 )`
+
+Generates `samples` mutated variants of `current` (mutating each character with probability `mutProb` percent), scores each candidate against `target` (Hamming distance), and returns the best candidate (lowest score). RNG is a deterministic 31-bit LCG, threaded via `seedState` → `seedState2`, so runs are reproducible.
+
 ### Containment and prefix/suffix tests
 
 - `string:contains`

package/examples/genetic-algorithm.n3

@@ -0,0 +1,177 @@
+# ==========================================================================================
+# Genetic algorithm demo
+#
+# Genetic algorithm (GA) in a nutshell:
+# - Start with a random candidate string of the same length as the target.
+# - Repeatedly create a batch of “children” by copying the current best string and randomly
+#   mutating each character with a small probability.
+# - Score each child by how many positions differ from the target (Hamming distance).
+# - Keep the best-scoring child as the new current string and iterate until the score is 0.
+# This is a simple hill-climbing GA (selection + mutation, no crossover), using a seeded RNG
+# so runs are reproducible.
+#
+# The GA is still expressed as backward rules (<=) for the outer evolution loop,
+# but the expensive inner loop ("take N mutated samples and keep the best") is
+# handled by a single string builtin to avoid huge proof trees and OOM.
+#
+# ==========================================================================================
+
+@prefix :       <urn:ga:>.
+@prefix log:    <http://www.w3.org/2000/10/swap/log#>.
+@prefix math:   <http://www.w3.org/2000/10/swap/math#>.
+@prefix list:   <http://www.w3.org/2000/10/swap/list#>.
+@prefix string: <http://www.w3.org/2000/10/swap/string#>.
+
+:cfg
+  :mutationProbability 5;
+  :samples 80;
+  :seed 100;
+
+  # Debug knobs:
+  :traceEvery 1;        # 0 disables; 1 traces every generation
+  :maxGenerations 0;    # 0 means unlimited
+
+  :alphabet (" " "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M"
+             "N" "O" "P" "Q" "R" "S" "T" "U" "V" "W" "X" "Y" "Z").
+
+# ------------------------
+# Small arithmetic helpers
+# ------------------------
+
+{ ( ?N 1 ) :dec ?N1 } <= { ( ?N 1 ) math:difference ?N1 }.
+{ ( ?N 1 ) :inc ?N1 } <= { ( ?N 1 ) math:sum ?N1 }.
+
+# ----------------------------------------------
+# Seeded RNG (LCG) and JS Math.round(rnd() * N)
+# (Used only for the initial random chromosome.)
+# ----------------------------------------------
+
+{ ?S0 :lcgNext ?S1 } <= {
+  ( ?S0 1103515245 ) math:product ?P .
+  ( ?P 12345 ) math:sum ?T .
+  ( ?T 2147483648 ) math:remainder ?S1
+}.
+
+{ ( ?S0 ?N ) :randRound ( ?R ?S1 ) } <= {
+  ?S0 :lcgNext ?S1 .
+  ( ?S1 ?N ) math:product ?A .
+  ( ?A ?A ) math:sum ?TwoA .
+  ( ?TwoA 2147483648 ) math:sum ?Num .
+  ( 2147483648 2 ) math:product ?Den .
+  ( ?Num ?Den ) math:integerQuotient ?R
+}.
+
+{ ?S0 :randomAlpha ( ?Ch ?S1 ) } <= {
+  :cfg :alphabet ?Alphabet .
+  ( ?S0 26 ) :randRound ( ?Idx ?S1 ) .
+  ( ?Alphabet ?Idx ) list:memberAt ?Ch
+}.
+
+{ ( 0 ?S0 ) :randomText ( "" ?S0 ) } <= true.
+
+{ ( ?Len ?S0 ) :randomText ( ?Out ?S2 ) } <= {
+  ?Len math:greaterThan 0 .
+  ( ?Len 1 ) :dec ?Len1 .
+  ?S0 :randomAlpha ( ?Ch ?S1 ) .
+  ( ?Len1 ?S1 ) :randomText ( ?Rest ?S2 ) .
+  ( "%s%s" ?Ch ?Rest ) string:format ?Out
+}.
+
+# -------------------------
+# tracing helper (optional)
+# -------------------------
+
+{ ( 0 ?Gen ?Score ?Value ) :traceMaybe true } <= true.
+
+{ ( ?Every ?Gen ?Score ?Value ) :traceMaybe true } <= {
+  ?Every math:greaterThan 0 .
+  ( ?Gen ?Every ) math:remainder ?R .
+  ?R math:equalTo 0 .
+  ?Gen log:trace ( ?Score ?Value )
+}.
+
+# --------------
+# evolution loop
+# --------------
+
+# Stop when score == 0
+{ ( ?Current 0 ?Target ?MutProb ?Samples ?Gen ?S0 ?MaxGen ?TraceEvery )
+    :evolve ( ?Current ?Gen ?S0 ) } <= true.
+
+# Stop when generation cap is reached (only if MaxGen > 0)
+{ ( ?Current ?Score ?Target ?MutProb ?Samples ?Gen ?S0 ?MaxGen ?TraceEvery )
+    :evolve ( ?Current ?Gen ?S0 ) } <= {
+  ?Score math:notEqualTo 0 .
+  ?MaxGen math:greaterThan 0 .
+  ?Gen math:equalTo ?MaxGen
+}.
+
+# Unlimited run (MaxGen == 0): keep evolving
+{ ( ?Current ?Score ?Target ?MutProb ?Samples ?Gen ?S0 0 ?TraceEvery )
+    :evolve ( ?Final ?FinalGen ?S2 ) } <= {
+  ?Score math:notEqualTo 0 .
+  ( ?Samples ?Current ?Target ?MutProb ?S0 )
+    string:mutateSelectBest
+  ( ?Best ?BestScore ?S1 ) .
+  ( ?Gen 1 ) :inc ?Gen1 .
+  ( ?TraceEvery ?Gen1 ?BestScore ?Best ) :traceMaybe true .
+  ( ?Best ?BestScore ?Target ?MutProb ?Samples ?Gen1 ?S1 0 ?TraceEvery )
+    :evolve ( ?Final ?FinalGen ?S2 )
+}.
+
+# Bounded run (MaxGen > 0): keep evolving while Gen < MaxGen
+{ ( ?Current ?Score ?Target ?MutProb ?Samples ?Gen ?S0 ?MaxGen ?TraceEvery )
+    :evolve ( ?Final ?FinalGen ?S2 ) } <= {
+  ?Score math:notEqualTo 0 .
+  ?MaxGen math:greaterThan 0 .
+  ?Gen math:lessThan ?MaxGen .
+  ( ?Samples ?Current ?Target ?MutProb ?S0 )
+    string:mutateSelectBest
+  ( ?Best ?BestScore ?S1 ) .
+  ( ?Gen 1 ) :inc ?Gen1 .
+  ( ?TraceEvery ?Gen1 ?BestScore ?Best ) :traceMaybe true .
+  ( ?Best ?BestScore ?Target ?MutProb ?Samples ?Gen1 ?S1 ?MaxGen ?TraceEvery )
+    :evolve ( ?Final ?FinalGen ?S2 )
+}.
+
+# ----------------------------------
+# Public solver wrapper (string API)
+# ----------------------------------
+
+{ ?TargetString :solveResult ( ?Gen 0 ?Value ?Seed ) } <= {
+  :cfg :mutationProbability ?MutProb;
+       :samples ?Samples;
+       :seed ?Seed;
+       :traceEvery ?TraceEvery;
+       :maxGenerations ?MaxGen.
+
+  ?TargetString string:length ?Len .
+
+  ( ?Len ?Seed ) :randomText ( ?Current0 ?S1 ) .
+
+  # initial score using string:hammingDistance
+  ( ?Current0 ?TargetString ) string:hammingDistance ?Score0 .
+
+  ( ?Current0 ?Score0 ?TargetString ?MutProb ?Samples 0 ?S1 ?MaxGen ?TraceEvery )
+    :evolve
+  ( ?Value ?Gen ?S2 ) .
+
+  # Succeeds only when solved:
+  ( ?Value ?TargetString ) string:hammingDistance 0 .
+  ?Value log:equalTo ?TargetString .
+  ?S2 log:equalTo ?_FinalSeedState
+}.
+
+{ ?TargetString :solved true } <= {
+  ?TargetString :solveResult ( ?Gen 0 ?TargetString ?Seed )
+}.
+
+# --------------------------------------------------------
+# Requested output: solve('METHINKS IT IS LIKE A WEASEL').
+# --------------------------------------------------------
+
+{ "METHINKS IT IS LIKE A WEASEL" :solved true .
+  ( "solve('%s').\n" "METHINKS IT IS LIKE A WEASEL" ) string:format ?Line
+}
+log:query
+{ 1 log:outputString ?Line }.

package/examples/output/genetic-algorithm.n3

@@ -0,0 +1,3 @@
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+1 log:outputString "solve('METHINKS IT IS LIKE A WEASEL').\n" .

package/eyeling-builtins.ttl

@@ -5,6 +5,7 @@
 @prefix list: <http://www.w3.org/2000/10/swap/list#> .
 @prefix log: <http://www.w3.org/2000/10/swap/log#> .
 @prefix string: <http://www.w3.org/2000/10/swap/string#> .
+@prefix ega: <urn:eyeling:ga:> .
 @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
 @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
 @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
@@ -333,3 +334,17 @@ string:scrape a ex:Builtin ; ex:kind ex:Function ;
 string:format a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Simple formatter: (fmt arg1 ... argN) -> output string. Only %s and %% are supported; other specifiers fail." .
 
+string:length a ex:Builtin ; ex:kind ex:Function ;
+  rdfs:comment "Function: binds/unifies object with the character length of the subject after string-casting. Output is an integer literal token." .
+
+string:charAt a ex:Builtin ; ex:kind ex:Function ;
+  rdfs:comment "Function: subject is a 2-item list (string idx). Binds/unifies object with the 1-character string at 0-based idx; out-of-range yields the empty string." .
+
+string:setCharAt a ex:Builtin ; ex:kind ex:Function ;
+  rdfs:comment "Function: subject is a 3-item list (string idx ch). Returns a copy of the string with position idx (0-based) replaced by the first character of ch; out-of-range returns the original string." .
+
+string:hammingDistance a ex:Builtin ; ex:kind ex:Function ;
+  rdfs:comment "Function: subject is a 2-item list (a b). Binds/unifies object with the number of differing positions (Hamming distance). Fails if lengths differ." .
+
+string:mutateSelectBest a ex:Builtin ; ex:kind ex:Function ;
+  rdfs:comment "Shape: (samples current target mutProb seedState) string:mutateSelectBest (best bestScore seedState2). Generates samples mutated variants of current (mutating each character with probability mutProb percent), scores each candidate against target (Hamming distance), and returns the best candidate (lowest score). RNG is a deterministic 31-bit LCG, threaded via seedState → seedState2, so runs are reproducible." .

package/eyeling.js

@@ -3463,6 +3463,176 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     return sStr.startsWith(oStr) ? [{ ...subst }] : [];
   }
 
+  // -----------------------------------------------------------------
+  // 4.6.1 extended string: builtins (Eyeling extensions)
+  // -----------------------------------------------------------------
+
+  // string:length
+  // Schema: $s+ string:length $o?
+  // $o is an integer literal (untyped numeric token).
+  if (pv === STRING_NS + 'length') {
+    const sStr = termToJsString(g.s);
+    if (sStr === null) return [];
+    const lit = internLiteral(String(sStr.length));
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:charAt
+  // Schema: ( $str $idx ) string:charAt $ch
+  // $ch is a (possibly empty) string literal.
+  if (pv === STRING_NS + 'charAt') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
+    const sStr = termToJsString(g.s.elems[0]);
+    const idxNum = parseNum(g.s.elems[1]);
+    if (sStr === null || idxNum === null) return [];
+    const idx = Math.trunc(idxNum);
+    const ch = idx < 0 || idx >= sStr.length ? '' : sStr.charAt(idx);
+    const lit = makeStringLiteral(ch);
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:setCharAt
+  // Schema: ( $str $idx $ch ) string:setCharAt $out
+  // If idx out of range, returns the original string.
+  if (pv === STRING_NS + 'setCharAt') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 3) return [];
+    const sStr = termToJsString(g.s.elems[0]);
+    const idxNum = parseNum(g.s.elems[1]);
+    const chStr = termToJsString(g.s.elems[2]);
+    if (sStr === null || idxNum === null || chStr === null) return [];
+    const idx = Math.trunc(idxNum);
+    const rep = chStr.length ? chStr[0] : '';
+    let out = sStr;
+    if (idx >= 0 && idx < sStr.length) out = sStr.slice(0, idx) + rep + sStr.slice(idx + 1);
+    const lit = makeStringLiteral(out);
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:hammingDistance
+  // Schema: ( $a $b ) string:hammingDistance $d
+  // Fails if strings have different length.
+  if (pv === STRING_NS + 'hammingDistance') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
+    const a = termToJsString(g.s.elems[0]);
+    const b = termToJsString(g.s.elems[1]);
+    if (a === null || b === null) return [];
+    if (a.length !== b.length) return [];
+    let diffs = 0;
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) diffs++;
+    const lit = internLiteral(String(diffs));
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:mutateSelectBest
+  // Schema:
+  //   ( $samples $current $target $mutProb $seedState )
+  //     string:mutateSelectBest
+  //   ( $best $bestScore $seedState2 )
+  //
+  // Deterministic 31-bit LCG (same as the GA demo):
+  //   state = (1103515245 * state + 12345) % 2^31
+  // and randRound(N) = Math.round((state/2^31) * N) with state advanced once per draw.
+  //
+  // This builtin exists to keep GA-style "many samples × many characters" loops out of
+  // the proof search (dramatically reducing memory use).
+  if (pv === STRING_NS + 'mutateSelectBest') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 5) return [];
+
+    const samplesNum = parseNum(g.s.elems[0]);
+    const current = termToJsXsdStringNoLang(g.s.elems[1]);
+    const target = termToJsXsdStringNoLang(g.s.elems[2]);
+    const mutProbNum = parseNum(g.s.elems[3]);
+    const seedNum = parseNum(g.s.elems[4]);
+
+    if (samplesNum === null || current === null || target === null || mutProbNum === null || seedNum === null)
+      return [];
+    if (current.length !== target.length) return [];
+
+    const samples = Math.max(1, Math.trunc(samplesNum));
+    const mutProb = Math.max(0, Math.trunc(mutProbNum));
+    const seed0 = Math.trunc(seedNum);
+
+    let state = BigInt(seed0);
+    const MOD = 2147483648n; // 2^31
+    const A = 1103515245n;
+    const C = 12345n;
+
+    function rnd() {
+      state = (A * state + C) % MOD;
+      return Number(state) / 2147483648;
+    }
+
+    function randRound(N) {
+      return Math.round(rnd() * N);
+    }
+
+    function randomAlpha() {
+      const p = randRound(26);
+      return p === 0 ? ' ' : String.fromCharCode(64 + p);
+    }
+
+    function mutate(str) {
+      let out = '';
+      for (let i = 0; i < str.length; i++) {
+        const p = randRound(100);
+        if (p > mutProb) out += str[i];
+        else out += randomAlpha();
+      }
+      return out;
+    }
+
+    function score(str) {
+      let diffs = 0;
+      for (let i = 0; i < target.length; i++) if (str[i] !== target[i]) diffs++;
+      return diffs;
+    }
+
+    let best = '';
+    let bestScore = Infinity;
+
+    for (let i = 0; i < samples; i++) {
+      const cand = mutate(current);
+      const candScore = score(cand);
+      if (candScore < bestScore) {
+        best = cand;
+        bestScore = candScore;
+      }
+    }
+
+    const outList = new ListTerm([
+      makeStringLiteral(best),
+      internLiteral(String(bestScore)),
+      internLiteral(state.toString()),
+    ]);
+
+    const s2 = unifyTerm(g.o, outList, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
   // Unknown builtin
   return [];
 }

package/lib/builtins.js

@@ -3451,6 +3451,173 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     return sStr.startsWith(oStr) ? [{ ...subst }] : [];
   }
 
+  // -----------------------------------------------------------------
+  // 4.6.1 extended string: builtins (Eyeling extensions)
+  // -----------------------------------------------------------------
+
+  // string:length
+  // Schema: $s+ string:length $o?
+  // $o is an integer literal (untyped numeric token).
+  if (pv === STRING_NS + 'length') {
+    const sStr = termToJsString(g.s);
+    if (sStr === null) return [];
+    const lit = internLiteral(String(sStr.length));
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:charAt
+  // Schema: ( $str $idx ) string:charAt $ch
+  // $ch is a (possibly empty) string literal.
+  if (pv === STRING_NS + 'charAt') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
+    const sStr = termToJsString(g.s.elems[0]);
+    const idxNum = parseNum(g.s.elems[1]);
+    if (sStr === null || idxNum === null) return [];
+    const idx = Math.trunc(idxNum);
+    const ch = idx < 0 || idx >= sStr.length ? '' : sStr.charAt(idx);
+    const lit = makeStringLiteral(ch);
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:setCharAt
+  // Schema: ( $str $idx $ch ) string:setCharAt $out
+  // If idx out of range, returns the original string.
+  if (pv === STRING_NS + 'setCharAt') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 3) return [];
+    const sStr = termToJsString(g.s.elems[0]);
+    const idxNum = parseNum(g.s.elems[1]);
+    const chStr = termToJsString(g.s.elems[2]);
+    if (sStr === null || idxNum === null || chStr === null) return [];
+    const idx = Math.trunc(idxNum);
+    const rep = chStr.length ? chStr[0] : '';
+    let out = sStr;
+    if (idx >= 0 && idx < sStr.length) out = sStr.slice(0, idx) + rep + sStr.slice(idx + 1);
+    const lit = makeStringLiteral(out);
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:hammingDistance
+  // Schema: ( $a $b ) string:hammingDistance $d
+  // Fails if strings have different length.
+  if (pv === STRING_NS + 'hammingDistance') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
+    const a = termToJsString(g.s.elems[0]);
+    const b = termToJsString(g.s.elems[1]);
+    if (a === null || b === null) return [];
+    if (a.length !== b.length) return [];
+    let diffs = 0;
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) diffs++;
+    const lit = internLiteral(String(diffs));
+    if (g.o instanceof Var) {
+      const s2 = { ...subst };
+      s2[g.o.name] = lit;
+      return [s2];
+    }
+    const s2 = unifyTerm(g.o, lit, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
+  // string:mutateSelectBest
+  // Schema:
+  //   ( $samples $current $target $mutProb $seedState )
+  //     string:mutateSelectBest
+  //   ( $best $bestScore $seedState2 )
+  //
+  // Deterministic 31-bit LCG (same as the GA demo):
+  //   state = (1103515245 * state + 12345) % 2^31
+  // and randRound(N) = Math.round((state/2^31) * N) with state advanced once per draw.
+  if (pv === STRING_NS + 'mutateSelectBest') {
+    if (!(g.s instanceof ListTerm) || g.s.elems.length !== 5) return [];
+
+    const samplesNum = parseNum(g.s.elems[0]);
+    const current = termToJsXsdStringNoLang(g.s.elems[1]);
+    const target = termToJsXsdStringNoLang(g.s.elems[2]);
+    const mutProbNum = parseNum(g.s.elems[3]);
+    const seedNum = parseNum(g.s.elems[4]);
+
+    if (samplesNum === null || current === null || target === null || mutProbNum === null || seedNum === null)
+      return [];
+    if (current.length !== target.length) return [];
+
+    const samples = Math.max(1, Math.trunc(samplesNum));
+    const mutProb = Math.max(0, Math.trunc(mutProbNum));
+    const seed0 = Math.trunc(seedNum);
+
+    let state = BigInt(seed0);
+    const MOD = 2147483648n; // 2^31
+    const A = 1103515245n;
+    const C = 12345n;
+
+    function rnd() {
+      state = (A * state + C) % MOD;
+      return Number(state) / 2147483648;
+    }
+
+    function randRound(N) {
+      return Math.round(rnd() * N);
+    }
+
+    function randomAlpha() {
+      const p = randRound(26);
+      return p === 0 ? ' ' : String.fromCharCode(64 + p);
+    }
+
+    function mutate(str) {
+      let out = '';
+      for (let i = 0; i < str.length; i++) {
+        const p = randRound(100);
+        if (p > mutProb) out += str[i];
+        else out += randomAlpha();
+      }
+      return out;
+    }
+
+    function score(str) {
+      let diffs = 0;
+      for (let i = 0; i < target.length; i++) if (str[i] !== target[i]) diffs++;
+      return diffs;
+    }
+
+    let best = '';
+    let bestScore = Infinity;
+
+    for (let i = 0; i < samples; i++) {
+      const cand = mutate(current);
+      const candScore = score(cand);
+      if (candScore < bestScore) {
+        best = cand;
+        bestScore = candScore;
+      }
+    }
+
+    const outList = new ListTerm([
+      makeStringLiteral(best),
+      internLiteral(String(bestScore)),
+      internLiteral(state.toString()),
+    ]);
+
+    const s2 = unifyTerm(g.o, outList, subst);
+    return s2 !== null ? [s2] : [];
+  }
+
   // Unknown builtin
   return [];
 }

package/package.json

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