eyeling 1.14.2 → 1.14.4

package/HANDBOOK.md

@@ -979,15 +979,7 @@ If the types don’t fit any supported case, the builtin fails.
 
 This is a pragmatic inversion, not a full algebra system.
 
-#### `math:bigExponentiation`
-
-**Shape:** `( $base $exp ) math:bigExponentiation $result`
-
-- Exact integer exponentiation only.
-- Requires integer `$base` and non-negative integer `$exp`.
-- Fails if the estimated output size exceeds Eyeling’s built-in safety cap.
-
-This builtin exists to avoid rule-level “repeat multiply” derivations that can explode memory for large exponents (e.g., the Ackermann example).
+The **BigInt exact-integer mode** exists specifically to avoid rule-level “repeat multiply” derivations that can explode memory for large exponents (e.g., the Ackermann example).
 
 #### Unary “math relations” (often invertible)
 
@@ -1563,12 +1555,6 @@ If `i` is out of range, `out` is the original string.
 
 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/ackermann.n3

@@ -39,11 +39,11 @@
     (?Y ?Z) math:product ?A.
 }.
 
-# exponentiation (x=3) — use BigInt exponentiation builtin to avoid blow-up
+# exponentiation (x=3) — use BigInt-capable math:exponentiation to avoid blow-up
 {
     (3 ?Y ?Z) :ackermann ?A.
 } <= {
-    (?Z ?Y) math:bigExponentiation ?A.
+    (?Z ?Y) math:exponentiation ?A.
 }.
 
 # exponentiation (x=3), tetration (x=4), pentation (x=5), hexation (x=6), etc

package/examples/fastpow.n3

@@ -0,0 +1,111 @@
+# ========================
+# Fast exponentiation demo
+# ========================
+#
+# Shows why using math:exponentiation (BigInt-capable) matters.
+# The naive :powSlow definition uses repeated multiplication and should
+# only be used for small exponents.
+
+@prefix :     <http://example.org/fastpow#>.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix log:  <http://www.w3.org/2000/10/swap/log#>.
+
+# ----------------------
+# Fast power via builtin
+# ----------------------
+# pow(base, exp) = base^exp
+{
+  (?B ?E) :pow ?R.
+} <= {
+  (?B ?E) math:exponentiation ?R.
+}.
+
+# --------------------------------
+# Slow power via repeated multiply
+# --------------------------------
+# powSlow(base, 0) = 1
+{
+  (?B 0) :powSlow 1.
+} <= {
+  0 math:equalTo 0.
+}.
+
+# powSlow(base, E>0) = powSlow(base, E-1) * base
+{
+  (?B ?E) :powSlow ?R.
+} <= {
+  ?E math:greaterThan 0.
+  (?E 1) math:difference ?E1.
+  (?B ?E1) :powSlow ?Prev.
+  (?Prev ?B) math:product ?R.
+}.
+
+# ----------------------------------
+# Power tower (tetration) using :pow
+# ----------------------------------
+# tower(base, 0) = 1
+{
+  (?B 0) :tower 1.
+} <= {
+  0 math:equalTo 0.
+}.
+
+# tower(base, H>0) = base ^ tower(base, H-1)
+{
+  (?B ?H) :tower ?R.
+} <= {
+  ?H math:greaterThan 0.
+  (?H 1) math:difference ?H1.
+  (?B ?H1) :tower ?Prev.
+  (?B ?Prev) math:exponentiation ?R.
+}.
+
+# -----------------------------------------
+# “Projection” helpers to keep output small
+# -----------------------------------------
+# powMod1e6(base, exp) = (base^exp) mod 1,000,000
+{
+  (?B ?E) :powMod1e6 ?M.
+} <= {
+  (?B ?E) :pow ?R.
+  (?R 1000000) math:remainder ?M.
+}.
+
+# towerMod1e6(base, height) = tower(base,height) mod 1,000,000
+{
+  (?B ?H) :towerMod1e6 ?M.
+} <= {
+  (?B ?H) :tower ?R.
+  (?R 1000000) math:remainder ?M.
+}.
+
+# ----
+# test
+# ----
+{
+  # small sanity: fast and slow should agree
+  (2 10) :pow ?P10.
+  (2 10) :powSlow ?S10.
+
+  # big exponent, but only output mod 1e6 (so results stay short)
+  (2 10000) :powMod1e6 ?M1.
+  (3 10000) :powMod1e6 ?M2.
+
+  # power tower (2 ↑↑ 4 = 65536), and a slightly larger one modulo 1e6
+  (2 4) :tower ?T4.
+  (2 5) :towerMod1e6 ?TM5.
+
+  # WARNING: uncommenting this will be slow / memory-hungry (repeat multiply)
+  # (2 10000) :powSlow ?Boom.
+}
+=>
+{
+  :test :is {
+    (2 10) :pow ?P10.
+    (2 10) :powSlow ?S10.
+    (2 10000) :powMod1e6 ?M1.
+    (3 10000) :powMod1e6 ?M2.
+    (2 4) :tower ?T4.
+    (2 5) :towerMod1e6 ?TM5.
+  }.
+}.

package/examples/genetic-algorithm.n3

@@ -1,19 +1,17 @@
 # ==========================================================================================
 # 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.
+# We "evolve" a genome (a bitstring) that encodes a target integer.
 #
-# 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.
+# - Genome: a string of '0'/'1' bits (same length as :weights).
+# - Phenotype: sum of selected weights where the genome bit is '1'.
+# - Fitness: remaining distance to the target, with a heavy penalty for overshoot:
+#     if sum <= target: fitness = target - sum
+#     if sum >  target: fitness = 1_000_000 + (sum - target)
+# - Variation: single-point mutation (flip one bit).
+# - Selection: pick the candidate with the lowest fitness (ties keep the earlier candidate).
 #
+# With powers-of-two weights, this deterministic hill-climbing GA converges quickly.
 # ==========================================================================================
 
 @prefix :       <urn:ga:>.
@@ -23,155 +21,200 @@
 @prefix string: <http://www.w3.org/2000/10/swap/string#>.
 
 :cfg
-  :mutationProbability 5;
-  :samples 80;
-  :seed 100;
+  :target 2026;
+  :maxGenerations 64;
 
-  # Debug knobs:
-  :traceEvery 1;        # 0 disables; 1 traces every generation
-  :maxGenerations 0;    # 0 means unlimited
+  # weights align with bit positions (index 0 is the left-most bit):
+  # genome = b0 b1 ... b10
+  # value  = b0*1024 + b1*512 + ... + b10*1
+  :weights (1024 512 256 128 64 32 16 8 4 2 1).
 
-  :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 helpers
+# -------------
 
-# ------------------------
-# 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.)
-# ----------------------------------------------
+# build a string of N zeros
+{ ( 0 ) :zeros "" } <= true.
+
+{ ( ?N ) :zeros ?S } <= {
+  ?N math:greaterThan 0 .
+  ( ?N 1 ) math:difference ?N1 .
+  ( ?N1 ) :zeros ?Rest .
+  ( "%s%s" "0" ?Rest ) string:format ?S
+}.
+
+# flip a bit at index i in a 0/1 string
+{ ( ?S ?I ) :flipBit ?Out } <= {
+  ( ?S ?I ) string:charAt "0" .
+  ( ?S ?I "1" ) string:setCharAt ?Out
+}.
+
+{ ( ?S ?I ) :flipBit ?Out } <= {
+  ( ?S ?I ) string:charAt "1" .
+  ( ?S ?I "0" ) string:setCharAt ?Out
+}.
+
+# generate all single-bit mutants of S: [flip(0), flip(1), ..., flip(len-1)]
+{ ( ?S ?Len ) :mutants ?Out } <= {
+  ( ?S 0 ?Len ) :mutantsFrom ?Out
+}.
+
+{ ( ?S ?I ?Len ) :mutantsFrom () } <= {
+  ?I math:equalTo ?Len
+}.
+
+{ ( ?S ?I ?Len ) :mutantsFrom ?Out } <= {
+  ?I math:lessThan ?Len .
+  ( ?S ?I ) :flipBit ?Cand .
+  ( ?I 1 ) :inc ?I1 .
+  ( ?S ?I1 ?Len ) :mutantsFrom ?Rest .
+  ( ( ?Cand ) ?Rest ) list:append ?Out
+}.
+
+# ------------------------
+# decode genome -> integer
+# ------------------------
 
-{ ?S0 :lcgNext ?S1 } <= {
-  ( ?S0 1103515245 ) math:product ?P .
-  ( ?P 12345 ) math:sum ?T .
-  ( ?T 2147483648 ) math:remainder ?S1
+{ ( ?Bits ?Weights ) :value ?Sum } <= {
+  ?Bits string:length ?Len .
+  ( ?Bits ?Weights 0 ?Len 0 ) :valueAcc ?Sum
 }.
 
-{ ( ?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
+{ ( ?Bits ?Weights ?I ?Len ?Acc ) :valueAcc ?Acc } <= {
+  ?I math:equalTo ?Len
 }.
 
-{ ?S0 :randomAlpha ( ?Ch ?S1 ) } <= {
-  :cfg :alphabet ?Alphabet .
-  ( ?S0 26 ) :randRound ( ?Idx ?S1 ) .
-  ( ?Alphabet ?Idx ) list:memberAt ?Ch
+{ ( ?Bits ?Weights ?I ?Len ?Acc ) :valueAcc ?Sum } <= {
+  ?I math:lessThan ?Len .
+  ( ?Weights ?I ) list:memberAt ?W .
+
+  ( ?Bits ?I ) string:charAt "1" .
+  ( ?Acc ?W ) math:sum ?Acc1 .
+  ( ?I 1 ) :inc ?I1 .
+  ( ?Bits ?Weights ?I1 ?Len ?Acc1 ) :valueAcc ?Sum
 }.
 
-{ ( 0 ?S0 ) :randomText ( "" ?S0 ) } <= true.
+{ ( ?Bits ?Weights ?I ?Len ?Acc ) :valueAcc ?Sum } <= {
+  ?I math:lessThan ?Len .
+  ( ?Weights ?I ) list:memberAt ?W .
 
-{ ( ?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
+  ( ?Bits ?I ) string:charAt "0" .
+  ( ?I 1 ) :inc ?I1 .
+  ( ?Bits ?Weights ?I1 ?Len ?Acc ) :valueAcc ?Sum
 }.
 
 # -------------------------
-# tracing helper (optional)
+# fitness (lower is better)
 # -------------------------
 
-{ ( 0 ?Gen ?Score ?Value ) :traceMaybe true } <= true.
+{ ( ?Sum ?Target ) :fitness ?F } <= {
+  ?Sum math:notGreaterThan ?Target .
+  ( ?Target ?Sum ) math:difference ?F
+}.
+
+{ ( ?Sum ?Target ) :fitness ?F } <= {
+  ?Sum math:greaterThan ?Target .
+  ( ?Sum ?Target ) math:difference ?Over .
+  ( 1000000 ?Over ) math:sum ?F
+}.
+
+{ ( ?Bits ?Target ?Weights ) :candidateScore ( ?Fit ?Sum ) } <= {
+  ( ?Bits ?Weights ) :value ?Sum .
+  ( ?Sum ?Target ) :fitness ?Fit
+}.
+
+# pick best of two candidates by fitness (ties keep the left candidate)
+{ ( ?C1 ?S1 ?Sum1 ?C2 ?S2 ?Sum2 ) :pickBest ( ?C1 ?S1 ?Sum1 ) } <= {
+  ?S1 math:notGreaterThan ?S2
+}.
+
+{ ( ?C1 ?S1 ?Sum1 ?C2 ?S2 ?Sum2 ) :pickBest ( ?C2 ?S2 ?Sum2 ) } <= {
+  ?S1 math:greaterThan ?S2
+}.
+
+# best candidate from a list
+{ ( ?Target ?Weights ?L ) :bestMutant ( ?Best ?BestScore ?BestSum ) } <= {
+  ?L list:length 1 .
+  ?L list:first ?Best .
+  ( ?Best ?Target ?Weights ) :candidateScore ( ?BestScore ?BestSum )
+}.
+
+{ ( ?Target ?Weights ?L ) :bestMutant ( ?Best ?BestScore ?BestSum ) } <= {
+  ?L list:length ?N .
+  ?N math:greaterThan 1 .
+
+  ?L list:first ?H .
+  ?L list:rest ?T .
+
+  ( ?Target ?Weights ?T ) :bestMutant ( ?B2 ?S2 ?Sum2 ) .
+  ( ?H ?Target ?Weights ) :candidateScore ( ?S1 ?Sum1 ) .
 
-{ ( ?Every ?Gen ?Score ?Value ) :traceMaybe true } <= {
-  ?Every math:greaterThan 0 .
-  ( ?Gen ?Every ) math:remainder ?R .
-  ?R math:equalTo 0 .
-  ?Gen log:trace ( ?Score ?Value )
+  ( ?H ?S1 ?Sum1 ?B2 ?S2 ?Sum2 ) :pickBest ( ?Best ?BestScore ?BestSum )
 }.
 
 # --------------
 # 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
+# solved
+{ ( ?Bits ?Target ?Weights ?Gen ?MaxGen ) :evolve ( ?Bits ?Gen ) } <= {
+  ( ?Bits ?Target ?Weights ) :candidateScore ( 0 ?Sum )
 }.
 
-# 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 )
+# generation cap (safety)
+{ ( ?Bits ?Target ?Weights ?Gen ?MaxGen ) :evolve ( ?Bits ?Gen ) } <= {
+  ?Gen math:equalTo ?MaxGen
 }.
 
-# 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 .
+# stop if best doesn't improve
+{ ( ?Bits ?Target ?Weights ?Gen ?MaxGen ) :evolve ( ?Bits ?Gen ) } <= {
   ?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 )
-}.
+  ( ?Bits ?Target ?Weights ) :candidateScore ( ?Score ?Sum ) .
 
-# ----------------------------------
-# Public solver wrapper (string API)
-# ----------------------------------
+  ?Bits string:length ?Len .
+  ( ?Bits ?Len ) :mutants ?Ms .
+  ( ( ?Bits ) ?Ms ) list:append ?Candidates .
 
-{ ?TargetString :solveResult ( ?Gen 0 ?Value ?Seed ) } <= {
-  :cfg :mutationProbability ?MutProb;
-       :samples ?Samples;
-       :seed ?Seed;
-       :traceEvery ?TraceEvery;
-       :maxGenerations ?MaxGen.
-
-  ?TargetString string:length ?Len .
+  ( ?Target ?Weights ?Candidates ) :bestMutant ( ?Best ?BestScore ?BestSum ) .
+  ?BestScore math:equalTo ?Score
+}.
 
-  ( ?Len ?Seed ) :randomText ( ?Current0 ?S1 ) .
+# keep evolving while improvement exists
+{ ( ?Bits ?Target ?Weights ?Gen ?MaxGen ) :evolve ( ?Final ?FinalGen ) } <= {
+  ?Gen math:lessThan ?MaxGen .
+  ( ?Bits ?Target ?Weights ) :candidateScore ( ?Score ?Sum ) .
 
-  # initial score using string:hammingDistance
-  ( ?Current0 ?TargetString ) string:hammingDistance ?Score0 .
+  ?Bits string:length ?Len .
+  ( ?Bits ?Len ) :mutants ?Ms .
+  ( ( ?Bits ) ?Ms ) list:append ?Candidates .
 
-  ( ?Current0 ?Score0 ?TargetString ?MutProb ?Samples 0 ?S1 ?MaxGen ?TraceEvery )
-    :evolve
-  ( ?Value ?Gen ?S2 ) .
+  ( ?Target ?Weights ?Candidates ) :bestMutant ( ?Best ?BestScore ?BestSum ) .
+  ?BestScore math:notEqualTo ?Score .
 
-  # Succeeds only when solved:
-  ( ?Value ?TargetString ) string:hammingDistance 0 .
-  ?Value log:equalTo ?TargetString .
-  ?S2 log:equalTo ?_FinalSeedState
+  ( ?Gen 1 ) :inc ?Gen1 .
+  ( ?Best ?Target ?Weights ?Gen1 ?MaxGen ) :evolve ( ?Final ?FinalGen )
 }.
 
-{ ?TargetString :solved true } <= {
-  ?TargetString :solveResult ( ?Gen 0 ?TargetString ?Seed )
-}.
+# --------------
+# query / output
+# --------------
+
+{
+  :cfg :target ?T;
+       :maxGenerations ?Max;
+       :weights ?W.
+
+  ?W list:length ?Len .
+  ( ?Len ) :zeros ?Start .
 
-# --------------------------------------------------------
-# Requested output: solve('METHINKS IT IS LIKE A WEASEL').
-# --------------------------------------------------------
+  ( ?Start ?T ?W 0 ?Max ) :evolve ( ?Best ?Gen ) .
+  ( ?Best ?W ) :value ?Sum .
+  ?Sum math:equalTo ?T .
 
-{ "METHINKS IT IS LIKE A WEASEL" :solved true .
-  ( "solve('%s').\n" "METHINKS IT IS LIKE A WEASEL" ) string:format ?Line
+  ( "GA evolved %s -> %s in %s generations.\n" ?Best ?Sum ?Gen )
+    string:format ?Line
 }
 log:query
 { 1 log:outputString ?Line }.

package/examples/modexp.n3

@@ -0,0 +1,87 @@
+# ===============================================
+# Fast modular exponentiation (repeated squaring)
+# ===============================================
+
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+@prefix :     <https://eyereasoner.github.io/ns#>.
+
+# (a * b) mod m
+{
+    (?A ?B ?M) :modMul ?R.
+} <= {
+    (?A ?B) math:product ?P.
+    (?P ?M) math:remainder ?R.
+}.
+
+# modPow(b, 0, m) = 1 mod m
+{
+    (?B 0 ?M) :modPow ?R.
+} <= {
+    ?M math:greaterThan 0.
+    (1 ?M) math:remainder ?R.
+}.
+
+# modPow(b, 1, m) = b mod m
+{
+    (?B 1 ?M) :modPow ?R.
+} <= {
+    ?M math:greaterThan 0.
+    (?B ?M) math:remainder ?R.
+}.
+
+# even exponent: modPow(b, e, m) = modPow((b*b mod m), e/2, m)
+{
+    (?B ?E ?M) :modPow ?R.
+} <= {
+    ?M math:greaterThan 0.
+    ?E math:greaterThan 1.
+    (?E 2) math:remainder 0.
+
+    (?B ?B ?M) :modMul ?B2.
+    (?E 2) math:integerQuotient ?Half.
+    (?B2 ?Half ?M) :modPow ?R.
+}.
+
+# odd exponent: modPow(b, e, m) = (b * modPow((b*b mod m), (e-1)/2, m)) mod m
+{
+    (?B ?E ?M) :modPow ?R.
+} <= {
+    ?M math:greaterThan 0.
+    ?E math:greaterThan 1.
+    (?E 2) math:remainder 1.
+
+    (?B ?B ?M) :modMul ?B2.
+    (?E 1) math:difference ?E1.
+    (?E1 2) math:integerQuotient ?Half.
+
+    (?B2 ?Half ?M) :modPow ?T.
+    (?B ?T ?M) :modMul ?R.
+}.
+
+# -----------------
+# tests / showcases
+# -----------------
+{
+    # sanity check against a small naive computation:
+    (7 13) math:exponentiation ?PowSmall.
+    (?PowSmall 97) math:remainder ?NaiveSmall.
+    (7 13 97) :modPow ?FastSmall.
+
+    # “impressive” case: 7^1,000,000,000 mod 1,000,000,007
+    (7 1000000000 1000000007) :modPow ?R1.
+
+    # exponent itself computed via exponentiation: 2^25 = 33,554,432
+    (2 25) math:exponentiation ?E25.
+    (3 ?E25 1000000007) :modPow ?R2.
+
+    # last 12 digits of 2^(2^20)
+    (2 20) math:exponentiation ?E20.
+    (2 ?E20 1000000000000) :modPow ?Last12.
+}
+=>
+{
+    :test :smallCheck [ :naive ?NaiveSmall; :fast ?FastSmall ].
+    :test :sevenPow1e9Mod1e9p7 ?R1.
+    :test :threePow2Pow25Mod1e9p7 ?R2.
+    :test :last12DigitsOf2Pow2Pow20 ?Last12.
+}.

package/examples/output/fastpow.n3

@@ -0,0 +1,10 @@
+@prefix : <http://example.org/fastpow#> .
+
+:test :is {
+    (2 10) :pow 1024 .
+    (2 10) :powSlow 1024 .
+    (2 10000) :powMod1e6 709376 .
+    (3 10000) :powMod1e6 200001 .
+    (2 4) :tower 65536 .
+    (2 5) :towerMod1e6 156736 .
+} .

package/examples/output/genetic-algorithm.n3

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

package/examples/output/modexp.n3

@@ -0,0 +1,8 @@
+@prefix : <https://eyereasoner.github.io/ns#> .
+
+:test :smallCheck _:sk_0 .
+_:sk_0 :naive 38 .
+_:sk_0 :fast 38 .
+:test :sevenPow1e9Mod1e9p7 312556845 .
+:test :threePow2Pow25Mod1e9p7 849572438 .
+:test :last12DigitsOf2Pow2Pow20 940335579136 .

package/eyeling-builtins.ttl

@@ -101,9 +101,6 @@ math:rounded a ex:Builtin ; ex:kind ex:Function ;
 math:exponentiation a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Exponentiation. Forward: (base exponent) -> result. If both arguments are integer literals and exponent is non-negative, Eyeling uses exact BigInt exponentiation (with a safety cap on result size). Otherwise it falls back to Number exponentiation. Limited inverse: if base is numeric and exponent is a variable, may solve exponent via logs for positive base != 1 and positive result (Number mode only)." .
 
-math:bigExponentiation a ex:Builtin ; ex:kind ex:Function ;
-  rdfs:comment "Exact integer exponentiation (BigInt-only). Shape: (base exponent) math:bigExponentiation result. Requires integer base and non-negative integer exponent; fails if the estimated result size exceeds Eyeling's safety cap." .
-
 math:absoluteValue a ex:Builtin ; ex:kind ex:Function ;
   rdfs:comment "Absolute value. Computes |s| and unifies/binds object; output datatype follows common numeric datatype selection." .
 
@@ -349,5 +346,3 @@ string:setCharAt a ex:Builtin ; ex:kind ex:Function ;
 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

@@ -1792,10 +1792,9 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   }
 
   // math:exponentiation
-  // math:bigExponentiation (exact-integer BigInt-only variant)
-  if (pv === MATH_NS + 'exponentiation' || pv === MATH_NS + 'bigExponentiation') {
-    const onlyBigInt = pv === MATH_NS + 'bigExponentiation';
-
+  // Schema: ( $base $exp ) math:exponentiation $result
+  // Supports exact integer exponentiation via BigInt when both inputs are integers and exp >= 0.
+  if (pv === MATH_NS + 'exponentiation') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const baseTerm = g.s.elems[0];
     const expTerm = g.s.elems[1];
@@ -1832,9 +1831,6 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       return s2 !== null ? [s2] : [];
     }
 
-    // bigExponentiation is intentionally strict.
-    if (onlyBigInt) return [];
-
     // 2) Numeric mode (Number): forward + limited inverse
     const a = parseNum(baseTerm);
     const b = a !== null ? parseNum(expTerm) : null;
@@ -3614,89 +3610,6 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     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 [];
 }
@@ -3966,7 +3879,7 @@ function main() {
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +
       `  -p, --proof-comments         Enable proof explanations.\n` +
-      `  -r, --strings                Print log:outputString strings (ordered by key) instead of N3 output.\n` +
+      `  -r, --strings                Print log:outputString strings (ordered by key), including via log:query.\n` +
       `  -s, --super-restricted       Disable all builtins except => and <=.\n` +
       `  -t, --stream                 Stream derived triples as soon as they are derived.\n` +
       `  -v, --version                Print version and exit.\n`;
@@ -4076,8 +3989,21 @@ function main() {
   // If requested, print log:outputString values (ordered by subject key) and exit.
   // Note: log:outputString values may depend on derived facts, so we must saturate first.
   if (outputStringsMode) {
-    engine.forwardChain(facts, frules, brules);
-    const out = engine.collectOutputStringsFromFacts(facts, prefixes);
+    const hasQueries = Array.isArray(qrules) && qrules.length;
+
+    // If log:query directives are present, the intended output may not be part of the
+    // saturated fact store (queries are output-selection statements). In that case,
+    // collect log:outputString triples from the instantiated query conclusions.
+    let outTriples;
+    if (hasQueries) {
+      const res = engine.forwardChainAndCollectLogQueryConclusions(facts, frules, brules, qrules);
+      outTriples = res.queryTriples;
+    } else {
+      engine.forwardChain(facts, frules, brules);
+      outTriples = facts;
+    }
+
+    const out = engine.collectOutputStringsFromFacts(outTriples, prefixes);
     if (out) process.stdout.write(out);
     process.exit(0);
   }

package/lib/builtins.js

@@ -1780,10 +1780,9 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
   }
 
   // math:exponentiation
-  // math:bigExponentiation (exact-integer BigInt-only variant)
-  if (pv === MATH_NS + 'exponentiation' || pv === MATH_NS + 'bigExponentiation') {
-    const onlyBigInt = pv === MATH_NS + 'bigExponentiation';
-
+  // Schema: ( $base $exp ) math:exponentiation $result
+  // Supports exact integer exponentiation via BigInt when both inputs are integers and exp >= 0.
+  if (pv === MATH_NS + 'exponentiation') {
     if (!(g.s instanceof ListTerm) || g.s.elems.length !== 2) return [];
     const baseTerm = g.s.elems[0];
     const expTerm = g.s.elems[1];
@@ -1820,9 +1819,6 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
       return s2 !== null ? [s2] : [];
     }
 
-    // bigExponentiation is intentionally strict.
-    if (onlyBigInt) return [];
-
     // 2) Numeric mode (Number): forward + limited inverse
     const a = parseNum(baseTerm);
     const b = a !== null ? parseNum(expTerm) : null;
@@ -3602,89 +3598,6 @@ function evalBuiltin(goal, subst, facts, backRules, depth, varGen, maxResults) {
     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/lib/cli.js

@@ -71,7 +71,7 @@ function main() {
       `  -e, --enforce-https          Rewrite http:// IRIs to https:// for log dereferencing builtins.\n` +
       `  -h, --help                   Show this help and exit.\n` +
       `  -p, --proof-comments         Enable proof explanations.\n` +
-      `  -r, --strings                Print log:outputString strings (ordered by key) instead of N3 output.\n` +
+      `  -r, --strings                Print log:outputString strings (ordered by key), including via log:query.\n` +
       `  -s, --super-restricted       Disable all builtins except => and <=.\n` +
       `  -t, --stream                 Stream derived triples as soon as they are derived.\n` +
       `  -v, --version                Print version and exit.\n`;
@@ -181,8 +181,21 @@ function main() {
   // If requested, print log:outputString values (ordered by subject key) and exit.
   // Note: log:outputString values may depend on derived facts, so we must saturate first.
   if (outputStringsMode) {
-    engine.forwardChain(facts, frules, brules);
-    const out = engine.collectOutputStringsFromFacts(facts, prefixes);
+    const hasQueries = Array.isArray(qrules) && qrules.length;
+
+    // If log:query directives are present, the intended output may not be part of the
+    // saturated fact store (queries are output-selection statements). In that case,
+    // collect log:outputString triples from the instantiated query conclusions.
+    let outTriples;
+    if (hasQueries) {
+      const res = engine.forwardChainAndCollectLogQueryConclusions(facts, frules, brules, qrules);
+      outTriples = res.queryTriples;
+    } else {
+      engine.forwardChain(facts, frules, brules);
+      outTriples = facts;
+    }
+
+    const out = engine.collectOutputStringsFromFacts(outTriples, prefixes);
     if (out) process.stdout.write(out);
     process.exit(0);
   }

package/package.json

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