@metta-ts/libraries 1.3.0

package/dist/index.js

@@ -0,0 +1,1265 @@
+// src/index.ts
+import { registerBuiltinModule } from "@metta-ts/core";
+
+// src/generated/sources.ts
+var LIBRARY_MODULE_SRCS = {
+  vector: '\n  (: dot (-> Expression Expression Number))\n  (: norm (-> Expression Number))\n  (: cosine (-> Expression Expression Number))\n  (: cosine-of-normalized (-> Expression Expression Number))\n  (: random-normal-vector (-> Number Expression))\n\n  (@doc dot\n    (@desc "Dot product of two equal-length numeric vectors written as expression lists")\n    (@params ((@param "First vector") (@param "Second vector")))\n    (@return "Sum of the elementwise products"))\n  (= (dot $u $v)\n     (if (== $u ())\n         0.0\n         (let* ((($a $as) (decons-atom $u)) (($b $bs) (decons-atom $v)))\n              (+ (* $a $b) (dot $as $bs)))))\n\n  (@doc norm\n    (@desc "Euclidean norm (length) of a numeric vector")\n    (@params ((@param "Vector")))\n    (@return "Square root of the vector dotted with itself"))\n  (= (norm $v) (sqrt-math (dot $v $v)))\n\n  (@doc cosine-of-normalized\n    (@desc "Cosine similarity when both vectors are already unit length, which is just their dot product")\n    (@params ((@param "First unit vector") (@param "Second unit vector")))\n    (@return "Dot product of the two vectors"))\n  (= (cosine-of-normalized $a $b) (dot $a $b))\n\n  (@doc cosine\n    (@desc "Cosine similarity of two numeric vectors, their dot product over the product of their norms")\n    (@params ((@param "First vector") (@param "Second vector")))\n    (@return "Dot product divided by the product of the norms"))\n  (= (cosine $a $b)\n     (/ (dot $a $b) (* (norm $a) (norm $b))))\n\n  (@doc random-normal-vector\n    (@desc "A random N-dimensional unit vector: N samples in [0, 1) scaled to length one")\n    (@params ((@param "Dimension N")))\n    (@return "A normalized vector of length N"))\n  (= (random-normal-vector $n) (random-normal-vector-acc $n ()))\n  ; cons-atom is a data constructor and does not evaluate its head, so force each random draw with\n  ; a let before consing; otherwise the unevaluated (random-float ...) is re-rolled by norm and map.\n  (= (random-normal-vector-acc $n $acc)\n     (if (> $n 0)\n         (let $r (random-float 0.0 1.0)\n              (random-normal-vector-acc (- $n 1) (cons-atom $r $acc)))\n         (let $len (norm $acc) (map-atom $acc $x (/ $x $len)))))\n',
+  roman: '\n  ; ---------- Tracing ----------\n  (: traceid (-> $t $t))\n  (@doc traceid\n    (@desc "Print an atom to the trace log and return it unchanged, for inspecting a value mid-evaluation")\n    (@params ((@param "The atom to trace and return")))\n    (@return "The same atom"))\n  (= (traceid $x) (trace! $x $x))\n\n  (: tracem (-> Atom $t $t))\n  (@doc tracem\n    (@desc "Print a labelled atom (the message paired with the value) to the trace log and return the value unchanged")\n    (@params ((@param "A label printed alongside the value") (@param "The value to trace and return")))\n    (@return "The value, unchanged"))\n  (= (tracem $msg $x) (trace! ($msg $x) $x))\n\n  ; ---------- Higher-order functions over expression lists ----------\n  (: map-flat (-> Atom Expression Expression))\n  (@doc map-flat\n    (@desc "Apply a unary function to each element of a flat expression list, returning the list of results")\n    (@params ((@param "A unary function f, applied as (f element)") (@param "An expression list")))\n    (@return "The list of (f element) values, in order"))\n  (= (map-flat $f $l)\n     (if (== $l ())\n         ()\n         (let* ((($x $xs) (decons-atom $l))\n                ($h ($f $x))\n                ($t (map-flat $f $xs)))\n           (cons-atom $h $t))))\n\n  (: map-nested (-> Atom Expression Expression))\n  (@doc map-nested\n    (@desc "Apply a unary function to each leaf of a nested expression list, recursing into sub-expressions and keeping the shape")\n    (@params ((@param "A unary function f, applied as (f leaf)") (@param "A possibly nested expression list")))\n    (@return "The list with f applied at every leaf and the nesting preserved"))\n  (= (map-nested $f $l)\n     (if (== $l ())\n         ()\n         (let* ((($x $xs) (decons-atom $l)))\n           (if (is-expr $x)\n               (let* (($h (map-nested $f $x)) ($t (map-nested $f $xs))) (cons-atom $h $t))\n               (let* (($h ($f $x)) ($t (map-nested $f $xs))) (cons-atom $h $t))))))\n\n  (: fold-flat (-> Atom $a Expression $a))\n  (@doc fold-flat\n    (@desc "Left fold over a flat expression list, combining the accumulator with each element left to right as (f acc element)")\n    (@params ((@param "A binary function f, applied as (f acc element)") (@param "The initial accumulator") (@param "An expression list")))\n    (@return "The final accumulator"))\n  (= (fold-flat $f $init $l)\n     (if (== $l ())\n         $init\n         (let* ((($x $xs) (decons-atom $l)))\n           (fold-flat $f ($f $init $x) $xs))))\n\n  (: foldr-flat (-> Atom $a Expression $a))\n  (@doc foldr-flat\n    (@desc "Right fold over a flat expression list, combining each element with the folded tail as (f element acc)")\n    (@params ((@param "A binary function f, applied as (f element acc)") (@param "The initial accumulator") (@param "An expression list")))\n    (@return "The folded result"))\n  (= (foldr-flat $f $init $l)\n     (if (== $l ())\n         $init\n         (let* ((($x $xs) (decons-atom $l)))\n           ($f $x (foldr-flat $f $init $xs)))))\n\n  (: fold-nested (-> Atom $a Expression $a))\n  (@doc fold-nested\n    (@desc "Left fold over a nested expression list, folding recursively through each sub-expression before continuing")\n    (@params ((@param "A binary function f, applied as (f acc leaf)") (@param "The initial accumulator") (@param "A possibly nested expression list")))\n    (@return "The final accumulator after folding every leaf"))\n  (= (fold-nested $f $init $l)\n     (if (== $l ())\n         $init\n         (let* ((($x $xs) (decons-atom $l)))\n           (if (is-expr $x)\n               (fold-nested $f (fold-nested $f $init $x) $xs)\n               (fold-nested $f ($f $init $x) $xs)))))\n\n  ; ---------- Set operations on expression lists ----------\n  ; A predicate is any two-argument function returning a Bool. The = variants match by unification, the\n  ; == variants by strict equality, and the =a variants by alpha-equality.\n\n  ; True when $a matches some element of $bs under the two-argument predicate $pred.\n  (= (roman-elem? $pred $a $bs)\n     (if (== $bs ())\n         False\n         (let* ((($b $rest) (decons-atom $bs)))\n           (if ($pred $a $b) True (roman-elem? $pred $a $rest)))))\n\n  ; The = predicate, re-expressed for a Hyperon engine: two atoms are related when they unify.\n  (= (roman-unify? $a $b) (unify $a $b True False))\n\n  (: /?\\ (-> Atom Expression Expression Expression))\n  (@doc /?\\\n    (@desc "Intersection of two expression lists under a predicate: the elements of the first list that match some element of the second")\n    (@params ((@param "A two-argument boolean predicate") (@param "The first expression list") (@param "The second expression list")))\n    (@return "The elements of the first list that match under the predicate, in their original order"))\n  (= (/?\\ $pred $l $bs)\n     (if (== $l ())\n         ()\n         (let* ((($a $as) (decons-atom $l)))\n           (if (roman-elem? $pred $a $bs)\n               (let $rest (/?\\ $pred $as $bs) (cons-atom $a $rest))\n               (/?\\ $pred $as $bs)))))\n\n  (: /=\\ (-> Expression Expression Expression))\n  (@doc /=\\\n    (@desc "Intersection by unification")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "Elements of the first list that unify with some element of the second"))\n  (= (/=\\ $a $b) (/?\\ roman-unify? $a $b))\n\n  (: /==\\ (-> Expression Expression Expression))\n  (@doc /==\\\n    (@desc "Intersection by strict equality")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "Elements of the first list equal to some element of the second"))\n  (= (/==\\ $a $b) (/?\\ == $a $b))\n\n  (: /=a\\ (-> Expression Expression Expression))\n  (@doc /=a\\\n    (@desc "Intersection by alpha-equality")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "Elements of the first list alpha-equal to some element of the second"))\n  (= (/=a\\ $a $b) (/?\\ =alpha $a $b))\n\n  (: \\? (-> Atom Expression Expression Expression))\n  (@doc \\?\n    (@desc "Subtraction of two expression lists under a predicate: the elements of the first list that match no element of the second")\n    (@params ((@param "A two-argument boolean predicate") (@param "The first expression list") (@param "The second expression list")))\n    (@return "The elements of the first list with no match in the second, in their original order"))\n  (= (\\? $pred $l $bs)\n     (if (== $l ())\n         ()\n         (let* ((($a $as) (decons-atom $l)))\n           (if (roman-elem? $pred $a $bs)\n               (\\? $pred $as $bs)\n               (let $rest (\\? $pred $as $bs) (cons-atom $a $rest))))))\n\n  (: \\= (-> Expression Expression Expression))\n  (@doc \\=\n    (@desc "Subtraction by unification")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "Elements of the first list that unify with no element of the second"))\n  (= (\\= $a $b) (\\? roman-unify? $a $b))\n\n  (: \\== (-> Expression Expression Expression))\n  (@doc \\==\n    (@desc "Subtraction by strict equality")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "Elements of the first list equal to no element of the second"))\n  (= (\\== $a $b) (\\? == $a $b))\n\n  (: \\=a (-> Expression Expression Expression))\n  (@doc \\=a\n    (@desc "Subtraction by alpha-equality")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "Elements of the first list alpha-equal to no element of the second"))\n  (= (\\=a $a $b) (\\? =alpha $a $b))\n\n  (: \\?/ (-> Atom Expression Expression Expression))\n  (@doc \\?/\n    (@desc "Union of two expression lists under a predicate: the second list, prefixed by the elements of the first that it does not already contain")\n    (@params ((@param "A two-argument boolean predicate") (@param "The first expression list") (@param "The second expression list")))\n    (@return "The unmatched elements of the first list followed by the whole second list"))\n  (= (\\?/ $pred $l $bs)\n     (if (== $l ())\n         $bs\n         (let* ((($a $as) (decons-atom $l)))\n           (if (roman-elem? $pred $a $bs)\n               (\\?/ $pred $as $bs)\n               (let $rest (\\?/ $pred $as $bs) (cons-atom $a $rest))))))\n\n  (: \\=/ (-> Expression Expression Expression))\n  (@doc \\=/\n    (@desc "Union by unification")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "The second list prefixed by the elements of the first that unify with none of it"))\n  (= (\\=/ $a $b) (\\?/ roman-unify? $a $b))\n\n  (: \\==/ (-> Expression Expression Expression))\n  (@doc \\==/\n    (@desc "Union by strict equality")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "The second list prefixed by the elements of the first equal to none of it"))\n  (= (\\==/ $a $b) (\\?/ == $a $b))\n\n  (: \\=a/ (-> Expression Expression Expression))\n  (@doc \\=a/\n    (@desc "Union by alpha-equality")\n    (@params ((@param "First list") (@param "Second list")))\n    (@return "The second list prefixed by the elements of the first alpha-equal to none of it"))\n  (= (\\=a/ $a $b) (\\?/ =alpha $a $b))\n\n  ; ---------- Function composition ----------\n  (: . (-> Atom Atom Atom $t))\n  (@doc .\n    (@desc "Compose two unary functions and apply them to an argument, computing (f1 (f2 arg))")\n    (@params ((@param "The outer function f1") (@param "The inner function f2") (@param "The argument")))\n    (@return "(f1 (f2 arg))"))\n  (= (. $f1 $f2 $arg) ($f1 ($f2 $arg)))\n\n  (: .. (-> Atom Atom Atom $t))\n  (@doc ..\n    (@desc "Compose two unary functions and apply them to an argument, computing (f1 (f2 arg)) (an alias of .)")\n    (@params ((@param "The outer function f1") (@param "The inner function f2") (@param "The argument")))\n    (@return "(f1 (f2 arg))"))\n  (= (.. $f1 $f2 $arg) ($f1 ($f2 $arg)))\n\n  (: .: (-> Atom Atom Atom Atom $t))\n  (@doc .:\n    (@desc "Compose a unary function with a binary function, computing (f1 (f2 arg1 arg2))")\n    (@params ((@param "The outer unary function f1") (@param "The inner binary function f2") (@param "First argument") (@param "Second argument")))\n    (@return "(f1 (f2 arg1 arg2))"))\n  (= (.: $f1 $f2 $arg1 $arg2) ($f1 ($f2 $arg1 $arg2)))\n\n  (: &&& (-> Atom Atom Atom Expression))\n  (@doc &&&\n    (@desc "Fan out one argument through two functions, pairing their results as ((f1 arg) (f2 arg))")\n    (@params ((@param "First function f1") (@param "Second function f2") (@param "The shared argument")))\n    (@return "The two-element list ((f1 arg) (f2 arg))"))\n  (= (&&& $f1 $f2 $arg) (($f1 $arg) ($f2 $arg)))\n\n  (: &^& (-> Atom Atom Atom $t))\n  (@doc &^&\n    (@desc "Fan out one argument through two functions and return both results non-deterministically")\n    (@params ((@param "First function f1") (@param "Second function f2") (@param "The shared argument")))\n    (@return "(f1 arg), then (f2 arg), as separate results"))\n  (= (&^& $f1 $f2 $arg) (superpose (($f1 $arg) ($f2 $arg))))\n\n  ; ---------- Reverse function matching ----------\n  (: @ (-> Atom Atom $t))\n  (@doc @\n    (@desc "Match a pattern against a value and return the pattern with its variables bound, running the usual match in reverse")\n    (@params ((@param "A pattern atom") (@param "A value to match the pattern against")))\n    (@return "The pattern instantiated by matching it against the value"))\n  (= (@ $a $b) (let $a $b $a))\n\n  ; ---------- List ends ----------\n  (: head (-> Expression $t))\n  (@doc head\n    (@desc "The first element of an expression list")\n    (@params ((@param "A non-empty expression list")))\n    (@return "The first element"))\n  (= (head $l) (car-atom $l))\n\n  (: tail (-> Expression Expression))\n  (@doc tail\n    (@desc "Every element of an expression list except the first")\n    (@params ((@param "A non-empty expression list")))\n    (@return "The list without its first element"))\n  (= (tail $l) (cdr-atom $l))\n\n  (: mylast (-> Expression $t))\n  (@doc mylast\n    (@desc "The last element of an expression list, found as the first element of its reverse")\n    (@params ((@param "A non-empty expression list")))\n    (@return "The last element"))\n  (= (mylast $l) (let $r (reverse $l) (car-atom $r)))\n\n  (: init (-> Expression Expression))\n  (@doc init\n    (@desc "Every element of an expression list except the last, found by reversing, dropping the head, and reversing back")\n    (@params ((@param "A non-empty expression list")))\n    (@return "The list without its last element"))\n  (= (init $l) (let* (($r (reverse $l)) ($c (cdr-atom $r))) (reverse $c)))\n\n  (: rcons (-> Expression Atom Expression))\n  (@doc rcons\n    (@desc "Append a single element to the end of an expression list")\n    (@params ((@param "An expression list") (@param "The element to append")))\n    (@return "The list with the element added at the end"))\n  (= (rcons $xs $x) (union-atom $xs ($x)))\n\n  ; ---------- Pair accessors ----------\n  (: fst (-> Expression $t))\n  (@doc fst\n    (@desc "The first component of a two-element expression")\n    (@params ((@param "A two-element expression (a b)")))\n    (@return "The first component a"))\n  (= (fst ($a $b)) $a)\n\n  (: snd (-> Expression $t))\n  (@doc snd\n    (@desc "The second component of a two-element expression")\n    (@params ((@param "A two-element expression (a b)")))\n    (@return "The second component b"))\n  (= (snd ($a $b)) $b)\n',
+  combinatorics: '\n  (: range (-> Number Number Number))\n  (: choose2 (-> Expression Expression))\n  (: choose2l (-> Expression Expression))\n  (: chooseKl (-> Expression Number Expression))\n  (: chooseK (-> Expression Number Expression))\n  (: takeK (-> Number Expression Expression))\n\n  (@doc range\n    (@desc "Each integer from K up to but not including N, delivered as separate nondeterministic results")\n    (@params ((@param "Start value K, included") (@param "End value N, excluded")))\n    (@return "One result per integer in the half-open range from K to N"))\n  (= (range $K $N) (let $lst (range-list $K $N) (superpose $lst)))\n  (= (range-list $K $N)\n     (if (< $K $N)\n         (let $rest (range-list (+ $K 1) $N) (cons-atom $K $rest))\n         ()))\n\n  (@doc choose2\n    (@desc "Each unordered pair of distinct positions in a list, so (a b) appears but (b a) does not")\n    (@params ((@param "List to draw the pair from")))\n    (@return "One (first second) pair per combination, nondeterministically"))\n  (= (choose2 $L)\n     (let $j (range 0 (length $L))\n          (let $i (range 0 $j)\n               ((index-atom $L $i) (index-atom $L $j)))))\n\n  (@doc choose2l\n    (@desc "Every unordered pair of distinct list elements, gathered into one tuple")\n    (@params ((@param "List to draw pairs from")))\n    (@return "A tuple holding all the pairs"))\n  (= (choose2l $L) (collapse (choose2 $L)))\n\n  (@doc chooseKl\n    (@desc "All the ways to pick exactly K elements from a list, unordered, as a list of those combinations")\n    (@params ((@param "List to choose from") (@param "Number of elements K to pick")))\n    (@return "A list whose elements are the K-element combinations"))\n  (= (chooseKl $L $k)\n     (if (== $k 0)\n         (())\n         (if (== $L ())\n             ()\n             (let* ((($h $t) (decons-atom $L)))\n                  (let $sub (chooseKl $t (- $k 1))\n                       (append (map-atom $sub $c (cons-atom $h $c))\n                               (chooseKl $t $k)))))))\n\n  (@doc chooseK\n    (@desc "Pick exactly K elements from a list, unordered, one combination per nondeterministic result")\n    (@params ((@param "List to choose from") (@param "Number of elements K to pick")))\n    (@return "One K-element combination per result"))\n  (= (chooseK $L $k) (let $options (chooseKl $L $k) (superpose $options)))\n\n  (@doc takeK\n    (@desc "The first K elements of a list, or the whole list when it has fewer than K")\n    (@params ((@param "Count K of leading elements to keep") (@param "List to take from")))\n    (@return "A list of at most the first K elements"))\n  (= (takeK $k $L)\n     (if (== $L ())\n         ()\n         (if (> $k 0)\n             (let* ((($head $tail) (decons-atom $L)))\n                  (let $rest (takeK (- $k 1) $tail) (cons-atom $head $rest)))\n             ())))\n',
+  patrick: '\n  (: compose (-> Expression Atom %Undefined%))\n\n  (@doc compose\n    (@desc "Compose a list of single-argument functions, applied right to left, over an argument tuple")\n    (@params ((@param "List of function symbols, innermost last") (@param "Argument tuple passed to the innermost function")))\n    (@return "The result of the composed application"))\n  (= (compose $fs $args)\n     (let* ((($f $rest) (decons-atom $fs)))\n       (if (== $rest ())\n           (if (== (length $args) 1)\n               (let ($arg) $args ($f $arg))\n               (let $func (cons-atom $f $args) (reduce $func)))\n           ($f (compose $rest $args)))))\n',
+  datastructures: `
+  (: empty-queue (-> Expression))
+  (: enqueue (-> Atom Expression Expression))
+  (: dequeue (-> Expression Expression))
+  (: add-unique-or-fail (-> Grounded Atom %Undefined%))
+
+  (@doc empty-queue
+    (@desc "The empty queue: two empty stacks and a zero count")
+    (@params ())
+    (@return "A queue (queue () () 0) holding no elements"))
+  (= (empty-queue) (queue () () 0))
+
+  (@doc enqueue
+    (@desc "Add an element to the back of the queue in amortized O(1) by pushing it onto the in-stack")
+    (@params ((@param "Element to add") (@param "Queue")))
+    (@return "The queue with the element appended at the back"))
+  (= (enqueue $e $q)
+     (let (queue $in $out $n) $q
+       (queue (cons-atom $e $in) $out (+ $n 1))))
+
+  (@doc dequeue
+    (@desc "Remove the front element and return it paired with the rest of the queue. When the out-stack is empty it first reverses the in-stack onto the out-stack, the amortized step. Yields nothing on an empty queue")
+    (@params ((@param "Queue")))
+    (@return "(Pair <front element> <rest of the queue>), or no result when the queue is empty"))
+  (= (dequeue $q)
+     (let (queue $in $out $n) $q
+       (if (== $out ())
+           (if (== $in ())
+               (empty)
+               (let* (($rev (reverse $in)) (($h $t) (decons-atom $rev)))
+                 (Pair $h (queue () $t (- $n 1)))))
+           (let* ((($h $t) (decons-atom $out)))
+             (Pair $h (queue $in $t (- $n 1)))))))
+
+  (@doc add-unique-or-fail
+    (@desc "Intern (s <repr of the expression>) into the space only if no equal key is already present, otherwise yield nothing. A fast set insertion keyed on the atom's textual form")
+    (@params ((@param "Space") (@param "Expression to intern as a key")))
+    (@return "The add-atom result when newly inserted, or no result when the key already exists"))
+  (= (add-unique-or-fail $space $expression)
+     (let $st (s (repr $expression))
+       (if (== (,) (collapse (once (match $space $st True))))
+           (add-atom $space $st)
+           (empty))))
+`,
+  spaces: '\n  (: migrateAtoms (-> Grounded Grounded Atom %Undefined%))\n  (: remove-all-atoms (-> Grounded %Undefined%))\n\n  (@doc migrateAtoms\n    (@desc "Move every atom matching the pattern from one space to another: add each match to the target space, then remove it from the source space")\n    (@params ((@param "Source space") (@param "Target space") (@param "Pattern to match and move")))\n    (@return "The per-atom results of the move"))\n  (= (migrateAtoms $FromSpace $ToSpace $Pattern)\n     (match $FromSpace $Pattern\n       (let $moved (add-atom $ToSpace $Pattern)\n         (remove-atom $FromSpace $Pattern))))\n\n  (@doc remove-all-atoms\n    (@desc "Remove every atom from the space by matching each one and removing it")\n    (@params ((@param "Space")))\n    (@return "The collapsed results of removing each atom"))\n  (= (remove-all-atoms $space)\n     (collapse (match $space $x (remove-atom $space $x))))\n',
+  nars: `
+  ; ---------- Truth values ----------
+  (: Truth_c2w (-> Number Number))
+  (@doc Truth_c2w
+    (@desc "Convert NARS confidence to evidence weight")
+    (@params ((@param "Confidence c")))
+    (@return "Evidence weight c / (1 - c)"))
+  (= (Truth_c2w $c)
+     (/ $c (- 1 $c)))
+
+  (: Truth_w2c (-> Number Number))
+  (@doc Truth_w2c
+    (@desc "Convert evidence weight to NARS confidence")
+    (@params ((@param "Evidence weight w")))
+    (@return "Confidence w / (w + 1)"))
+  (= (Truth_w2c $w)
+     (/ $w (+ $w 1)))
+
+  (: Truth_Deduction (-> Expression Expression Expression))
+  (@doc Truth_Deduction
+    (@desc "NAL deduction truth function over two simple truth values")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "(stv (* f1 f2) (* f1 f2 c1 c2))"))
+  (= (Truth_Deduction (stv $f1 $c1)
+                      (stv $f2 $c2))
+     (stv (* $f1 $f2) (* (* $f1 $f2) (* $c1 $c2))))
+
+  (: Truth_Abduction (-> Expression Expression Expression))
+  (@doc Truth_Abduction
+    (@desc "NAL abduction truth function")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Abductive simple truth value"))
+  (= (Truth_Abduction (stv $f1 $c1)
+                      (stv $f2 $c2))
+     (stv $f2 (Truth_w2c (* (* $f1 $c1) $c2))))
+
+  (: Truth_Induction (-> Expression Expression Expression))
+  (@doc Truth_Induction
+    (@desc "NAL induction, defined as reversed abduction")
+    (@params ((@param "First truth value") (@param "Second truth value")))
+    (@return "Inductive simple truth value"))
+  (= (Truth_Induction $T1 $T2)
+     (Truth_Abduction $T2 $T1))
+
+  (: Truth_Exemplification (-> Expression Expression Expression))
+  (@doc Truth_Exemplification
+    (@desc "NAL exemplification truth function")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Exemplification simple truth value"))
+  (= (Truth_Exemplification (stv $f1 $c1)
+                            (stv $f2 $c2))
+     (stv 1.0 (Truth_w2c (* (* $f1 $f2) (* $c1 $c2)))))
+
+  (: Truth_StructuralDeduction (-> Expression Expression))
+  (@doc Truth_StructuralDeduction
+    (@desc "Structural deduction against the fixed NARS truth value (stv 1.0 0.9)")
+    (@params ((@param "Input truth value")))
+    (@return "Structurally deduced truth value"))
+  (= (Truth_StructuralDeduction $T)
+     (Truth_Deduction $T (stv 1.0 0.9)))
+
+  (: Truth_Negation (-> Expression Expression))
+  (@doc Truth_Negation
+    (@desc "Negate the frequency of a simple truth value while preserving confidence")
+    (@params ((@param "Truth value (stv f c)")))
+    (@return "(stv (1 - f) c)"))
+  (= (Truth_Negation (stv $f $c))
+     (stv (- 1 $f) $c))
+
+  (: Truth_StructuralDeductionNegated (-> Expression Expression))
+  (@doc Truth_StructuralDeductionNegated
+    (@desc "Structural deduction followed by truth negation")
+    (@params ((@param "Input truth value")))
+    (@return "Negated structural deduction truth value"))
+  (= (Truth_StructuralDeductionNegated $T)
+     (Truth_Negation (Truth_StructuralDeduction $T)))
+
+  (: Truth_Intersection (-> Expression Expression Expression))
+  (@doc Truth_Intersection
+    (@desc "Truth function for intersection")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "(stv (* f1 f2) (* c1 c2))"))
+  (= (Truth_Intersection (stv $f1 $c1)
+                         (stv $f2 $c2))
+     (stv (* $f1 $f2) (* $c1 $c2)))
+
+  (: Truth_StructuralIntersection (-> Expression Expression))
+  (@doc Truth_StructuralIntersection
+    (@desc "Structural intersection against the fixed NARS truth value (stv 1.0 0.9)")
+    (@params ((@param "Input truth value")))
+    (@return "Structurally intersected truth value"))
+  (= (Truth_StructuralIntersection $T)
+     (Truth_Intersection $T (stv 1.0 0.9)))
+
+  (: Truth_or (-> Number Number Number))
+  (@doc Truth_or
+    (@desc "Probabilistic OR over two frequencies")
+    (@params ((@param "First frequency") (@param "Second frequency")))
+    (@return "1 - (1 - a) * (1 - b)"))
+  (= (Truth_or $a $b)
+     (- 1 (* (- 1 $a) (- 1 $b))))
+
+  (: Truth_Comparison (-> Expression Expression Expression))
+  (@doc Truth_Comparison
+    (@desc "NAL comparison truth function")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Comparison simple truth value"))
+  (= (Truth_Comparison (stv $f1 $c1)
+                       (stv $f2 $c2))
+     (let $f0 (Truth_or $f1 $f2)
+          (stv (if (== $f0 0.0)
+                   0.0
+                   (/ (* $f1 $f2) $f0))
+               (Truth_w2c (* $f0 (* $c1 $c2))))))
+
+  (: Truth_Analogy (-> Expression Expression Expression))
+  (@doc Truth_Analogy
+    (@desc "NAL analogy truth function")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Analogy simple truth value"))
+  (= (Truth_Analogy (stv $f1 $c1)
+                    (stv $f2 $c2))
+     (stv (* $f1 $f2) (* (* $c1 $c2) $f2)))
+
+  (: Truth_Resemblance (-> Expression Expression Expression))
+  (@doc Truth_Resemblance
+    (@desc "NAL resemblance truth function")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Resemblance simple truth value"))
+  (= (Truth_Resemblance (stv $f1 $c1)
+                        (stv $f2 $c2))
+     (stv (* $f1 $f2) (* (* $c1 $c2) (Truth_or $f1 $f2))))
+
+  (: Truth_Union (-> Expression Expression Expression))
+  (@doc Truth_Union
+    (@desc "PeTTa lib_nars union truth function; the upstream body returns a two-element expression, not an stv-headed value")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "A two-element expression matching PeTTa's source"))
+  (= (Truth_Union (stv $f1 $c1)
+                  (stv $f2 $c2))
+     ((Truth_or $f1 $f2) (* $c1 $c2)))
+
+  (: Truth_Difference (-> Expression Expression Expression))
+  (@doc Truth_Difference
+    (@desc "NAL difference truth function")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Difference simple truth value"))
+  (= (Truth_Difference (stv $f1 $c1)
+                       (stv $f2 $c2))
+     (stv (* $f1 (- 1 $f2)) (* $c1 $c2)))
+
+  (: Truth_DecomposePNN (-> Expression Expression Expression))
+  (@doc Truth_DecomposePNN
+    (@desc "NAL decomposition truth function for positive-negative-negative decomposition")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Decomposition simple truth value"))
+  (= (Truth_DecomposePNN (stv $f1 $c1)
+                         (stv $f2 $c2))
+     (let $fn (* $f1 (- 1 $f2))
+          (stv (- 1 $fn) (* $fn (* $c1 $c2)))))
+
+  (: Truth_DecomposeNPP (-> Expression Expression Expression))
+  (@doc Truth_DecomposeNPP
+    (@desc "NAL decomposition truth function for negative-positive-positive decomposition")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Decomposition simple truth value"))
+  (= (Truth_DecomposeNPP (stv $f1 $c1)
+                         (stv $f2 $c2))
+     (let $f (* (- 1 $f1) $f2)
+          (stv $f (* $f (* $c1 $c2)))))
+
+  (: Truth_DecomposePNP (-> Expression Expression Expression))
+  (@doc Truth_DecomposePNP
+    (@desc "NAL decomposition truth function for positive-negative-positive decomposition")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Decomposition simple truth value"))
+  (= (Truth_DecomposePNP (stv $f1 $c1)
+                         (stv $f2 $c2))
+     (let $f (* $f1 (- 1 $f2))
+          (stv $f (* $f (* $c1 $c2)))))
+
+  (: Truth_DecomposePPP (-> Expression Expression Expression))
+  (@doc Truth_DecomposePPP
+    (@desc "NAL decomposition truth function for positive-positive-positive decomposition")
+    (@params ((@param "First truth value") (@param "Second truth value")))
+    (@return "Decomposition simple truth value"))
+  (= (Truth_DecomposePPP $v1 $v2)
+     (Truth_DecomposeNPP (Truth_Negation $v1) $v2))
+
+  (: Truth_DecomposeNNN (-> Expression Expression Expression))
+  (@doc Truth_DecomposeNNN
+    (@desc "PeTTa lib_nars decomposition for negative-negative-negative; the upstream body returns a two-element expression, not an stv-headed value")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "A two-element expression matching PeTTa's source"))
+  (= (Truth_DecomposeNNN (stv $f1 $c1)
+                         (stv $f2 $c2))
+     (let $fn (* (- 1 $f1) (- 1 $f2))
+          ((- 1 $fn) (* $fn (* $c1 $c2)))))
+
+  (: Truth_Eternalize (-> Expression Expression))
+  (@doc Truth_Eternalize
+    (@desc "Eternalize a simple truth value by converting its confidence as a weight")
+    (@params ((@param "Truth value (stv f c)")))
+    (@return "Eternalized simple truth value"))
+  (= (Truth_Eternalize (stv $f $c))
+     (stv $f (Truth_w2c $c)))
+
+  (: Truth_Revision (-> Expression Expression Expression))
+  (@doc Truth_Revision
+    (@desc "Revise two independent simple truth values by combining their evidence weights")
+    (@params ((@param "First truth value (stv f c)") (@param "Second truth value (stv f c)")))
+    (@return "Revised simple truth value"))
+  (= (Truth_Revision (stv $f1 $c1)
+                     (stv $f2 $c2))
+     (let* (($w1 (Truth_c2w $c1))
+            ($w2 (Truth_c2w $c2))
+            ($w (+ $w1 $w2))
+            ($f (/ (+ (* $w1 $f1) (* $w2 $f2)) $w))
+            ($c (Truth_w2c $w)))
+       (stv (min 1.00 $f) (min 0.99 (max (max $c $c1) $c2)))))
+
+  (: Truth_Expectation (-> Expression Number))
+  (@doc Truth_Expectation
+    (@desc "Expectation of a simple truth value")
+    (@params ((@param "Truth value (stv f c)")))
+    (@return "c * (f - 0.5) + 0.5"))
+  (= (Truth_Expectation (stv $f $c))
+     (+ (* $c (- $f 0.5)) 0.5))
+
+  ; ---------- Inference rules ----------
+  (@doc |-
+    (@desc "PeTTa lib_nars NAL inference rules. Binary forms combine two judgements; unary forms decompose one judgement")
+    (@params ((@param "One or two NARS judgements, each written as (<term> <truth>)")))
+    (@return "A derived judgement (<term> <truth>)"))
+
+  ; NAL-1: revision and inheritance syllogisms.
+  (= (|- ($T $T1) ($T $T2)) ($T (Truth_Revision $T1 $T2)))
+  (= (|- ((--> $a $b) $T1) ((--> $b $c) $T2)) ((--> $a $c) (Truth_Deduction $T1 $T2)))
+  (= (|- ((--> $a $b) $T1) ((--> $a $c) $T2)) ((--> $c $b) (Truth_Induction $T1 $T2)))
+  (= (|- ((--> $a $c) $T1) ((--> $b $c) $T2)) ((--> $b $a) (Truth_Abduction $T1 $T2)))
+  (= (|- ((--> $a $b) $T1) ((--> $b $c) $T2)) ((--> $c $a) (Truth_Exemplification $T1 $T2)))
+
+  ; PeTTa's lib_nars source has no NAL-2 block.
+
+  ; NAL-3: sets and extensional/intensional decomposition.
+  (= (|- ((--> ({} $A $B) $M) $T)) ((--> ({} $A) $M) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> ({} $A $B) $M) $T)) ((--> ({} $B) $M) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> $M ([] $A $B)) $T)) ((--> $M ([] $A)) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> $M ([] $A $B)) $T)) ((--> $M ([] $B)) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> (\u222A $S $P) $M) $T)) ((--> $S $M) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> $M (\u2229 $S $P)) $T)) ((--> $M $S) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> (\u222A $S $P) $M) $T)) ((--> $P $M) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> $M (\u2229 $S $P)) $T)) ((--> $M $P) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> (~ $A $S) $M) $T)) ((--> $A $M) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> $M (\u2212 $B $S)) $T)) ((--> $M $B) (Truth_StructuralDeduction $T)))
+  (= (|- ((--> (~ $A $S) $M) $T)) ((--> $S $M) (Truth_StructuralDeductionNegated $T)))
+  (= (|- ((--> $M (\u2212 $B $S)) $T)) ((--> $M $S) (Truth_StructuralDeductionNegated $T)))
+  (= (|- ((--> $S $M) $T1) ((--> (\u222A $S $P) $M) $T2)) ((--> $P $M) (Truth_DecomposePNN $T1 $T2)))
+  (= (|- ((--> $P $M) $T1) ((--> (\u222A $S $P) $M) $T2)) ((--> $S $M) (Truth_DecomposePNN $T1 $T2)))
+  (= (|- ((--> $S $M) $T1) ((--> (\u2229 $S $P) $M) $T2)) ((--> $P $M) (Truth_DecomposeNPP $T1 $T2)))
+  (= (|- ((--> $P $M) $T1) ((--> (\u2229 $S $P) $M) $T2)) ((--> $S $M) (Truth_DecomposeNPP $T1 $T2)))
+  (= (|- ((--> $S $M) $T1) ((--> (~ $S $P) $M) $T2)) ((--> $P $M) (Truth_DecomposePNP $T1 $T2)))
+  (= (|- ((--> $S $M) $T1) ((--> (~ $P $S) $M) $T2)) ((--> $P $M) (Truth_DecomposeNNN $T1 $T2)))
+  (= (|- ((--> $M $S) $T1) ((--> $M (\u2229 $S $P)) $T2)) ((--> $M $P) (Truth_DecomposePNN $T1 $T2)))
+  (= (|- ((--> $M $P) $T1) ((--> $M (\u2229 $S $P)) $T2)) ((--> $M $S) (Truth_DecomposePNN $T1 $T2)))
+  (= (|- ((--> $M $S) $T1) ((--> $M (\u222A $S $P)) $T2)) ((--> $M $P) (Truth_DecomposeNPP $T1 $T2)))
+  (= (|- ((--> $M $P) $T1) ((--> $M (\u222A $S $P)) $T2)) ((--> $M $S) (Truth_DecomposeNPP $T1 $T2)))
+  (= (|- ((--> $M $S) $T1) ((--> $M (\u2212 $S $P)) $T2)) ((--> $M $P) (Truth_DecomposePNP $T1 $T2)))
+  (= (|- ((--> $M $S) $T1) ((--> $M (\u2212 $P $S)) $T2)) ((--> $M $P) (Truth_DecomposeNNN $T1 $T2)))
+
+  ; NAL-4: relation component rules.
+  (= (|- ((--> (\xD7 $A $B) $R) $T1) ((--> (\xD7 $C $B) $R) $T2)) ((--> $C $A) (Truth_Abduction $T1 $T2)))
+  (= (|- ((--> (\xD7 $A $B) $R) $T1) ((--> (\xD7 $A $C) $R) $T2)) ((--> $C $B) (Truth_Abduction $T1 $T2)))
+  (= (|- ((--> $R (\xD7 $A $B)) $T1) ((--> $R (\xD7 $C $B)) $T2)) ((--> $C $A) (Truth_Induction $T1 $T2)))
+  (= (|- ((--> $R (\xD7 $A $B)) $T1) ((--> $R (\xD7 $A $C)) $T2)) ((--> $C $B) (Truth_Induction $T1 $T2)))
+  (= (|- ((--> (\xD7 $A $B) $R) $T1) ((--> $C $A) $T2)) ((--> (\xD7 $C $B) $R) (Truth_Deduction $T1 $T2)))
+  (= (|- ((--> (\xD7 $A $B) $R) $T1) ((--> $A $C) $T2)) ((--> (\xD7 $C $B) $R) (Truth_Induction $T1 $T2)))
+  (= (|- ((--> (\xD7 $A $B) $R) $T1) ((--> $C $B) $T2)) ((--> (\xD7 $A $C) $R) (Truth_Deduction $T1 $T2)))
+  (= (|- ((--> (\xD7 $A $B) $R) $T1) ((--> $B $C) $T2)) ((--> (\xD7 $A $C) $R) (Truth_Induction $T1 $T2)))
+  (= (|- ((--> $R (\xD7 $A $B)) $T1) ((--> $A $C) $T2)) ((--> $R (\xD7 $C $B)) (Truth_Deduction $T1 $T2)))
+  (= (|- ((--> $R (\xD7 $A $B)) $T1) ((--> $C $A) $T2)) ((--> $R (\xD7 $C $B)) (Truth_Abduction $T1 $T2)))
+  (= (|- ((--> $R (\xD7 $A $B)) $T1) ((--> $B $C) $T2)) ((--> $R (\xD7 $A $C)) (Truth_Deduction $T1 $T2)))
+  (= (|- ((--> $R (\xD7 $A $B)) $T1) ((--> $C $B) $T2)) ((--> $R (\xD7 $A $C)) (Truth_Abduction $T1 $T2)))
+
+  ; NAL-5: negation, conjunction, disjunction, and higher-order decomposition.
+  (= (|- ((\xAC $A) $T)) ($A (Truth_Negation $T)))
+  (= (|- ((\u2227 $A $B) $T)) ($A (Truth_StructuralDeduction $T)))
+  (= (|- ((\u2227 $A $B) $T)) ($B (Truth_StructuralDeduction $T)))
+  (= (|- ($S $T1) ((\u2227 $S $A) $T2)) ($A (Truth_DecomposePNN $T1 $T2)))
+  (= (|- ($S $T1) ((\u2228 $S $A) $T2)) ($A (Truth_DecomposeNPP $T1 $T2)))
+  (= (|- ($S $T1) ((\u2227 (\xAC $S) $A) $T2)) ($A (Truth_DecomposeNNN $T1 $T2)))
+  (= (|- ($S $T1) ((\u2228 (\xAC $S) $A) $T2)) ($A (Truth_DecomposePPP $T1 $T2)))
+  (= (|- ($A $T1) ((==> $A $B) $T2)) ($B (Truth_Deduction $T1 $T2)))
+  (= (|- ($A $T1) ((==> (\u2227 $A $B) $C) $T2)) ((==> $B $C) (Truth_Deduction $T1 $T2)))
+  (= (|- ($B $T1) ((==> $A $B) $T2)) ($A (Truth_Abduction $T1 $T2)))
+
+  ; ---------- Derivation and query engine ----------
+  (: NARS.Config.MaxSteps (-> Number))
+  (@doc NARS.Config.MaxSteps
+    (@desc "Default maximum number of derivation task selections")
+    (@params ())
+    (@return "100"))
+  (= (NARS.Config.MaxSteps) 100)
+
+  (: NARS.Config.TaskQueueSize (-> Number))
+  (@doc NARS.Config.TaskQueueSize
+    (@desc "Default active task queue bound")
+    (@params ())
+    (@return "10"))
+  (= (NARS.Config.TaskQueueSize) 10)
+
+  (: NARS.Config.BeliefQueueSize (-> Number))
+  (@doc NARS.Config.BeliefQueueSize
+    (@desc "Default belief buffer bound")
+    (@params ())
+    (@return "100"))
+  (= (NARS.Config.BeliefQueueSize) 100)
+
+  (: NARS.CollapseToList (-> Atom Expression))
+  (@doc NARS.CollapseToList
+    (@desc "Collect nondeterministic results and convert this engine's comma-headed collapse tuple into a plain expression list")
+    (@params ((@param "Nondeterministic query to collapse")))
+    (@return "A plain expression list of the collapsed results"))
+  (= (NARS.CollapseToList $query)
+     (let* (($collapsed (collapse $query))
+            ($plain (cdr-atom $collapsed)))
+       (exclude-item Empty $plain)))
+
+  (: StampDisjoint (-> Expression Expression Bool))
+  (@doc StampDisjoint
+    (@desc "True when two evidence stamps share no evidence item")
+    (@params ((@param "First evidence stamp list") (@param "Second evidence stamp list")))
+    (@return "Bool indicating whether the stamps are disjoint"))
+  (= (StampDisjoint $Ev1 $Ev2)
+     (== () (intersection-atom $Ev1 $Ev2)))
+
+  (: StampConcat (-> Expression Expression Expression))
+  (@doc StampConcat
+    (@desc "Concatenate a stamp with new evidence and sort it, preserving PeTTa lib_nars' stamp-combination shape")
+    (@params ((@param "Base evidence stamp") (@param "Evidence stamp to add")))
+    (@return "Sorted combined evidence stamp"))
+  (= (StampConcat $stamp $addition)
+     (if (== $addition ())
+         $stamp
+         (sort (append $stamp $addition))))
+
+  (: BestCandidate (-> Atom %Undefined% Expression %Undefined%))
+  (@doc BestCandidate
+    (@desc "Return the item in a candidate list with the highest score under an evaluator function")
+    (@params ((@param "Unary evaluator function") (@param "Current best candidate") (@param "Candidate list")))
+    (@return "The best candidate, or the initial best candidate when the list is empty"))
+  (= (BestCandidate $evaluateCandidateFunction $bestCandidate $tuple)
+     (max-by-atom $evaluateCandidateFunction $bestCandidate $tuple))
+
+  (: PriorityRank (-> Expression Number))
+  (@doc PriorityRank
+    (@desc "Task priority score: the confidence of a sentence, with a low sentinel for the empty candidate")
+    (@params ((@param "A Sentence candidate or ()")))
+    (@return "Priority score"))
+  (= (PriorityRank (Sentence ($x (stv $f $c)) $Ev1)) $c)
+  (= (PriorityRank ()) -99999.0)
+
+  (: PriorityRankNeg (-> Expression Number))
+  (@doc PriorityRankNeg
+    (@desc "Negated task priority score, used to find the lowest-priority queue item")
+    (@params ((@param "A Sentence candidate or ()")))
+    (@return "Negated priority score"))
+  (= (PriorityRankNeg (Sentence ($x (stv $f $c)) $Ev1)) (- 0.0 $c))
+  (= (PriorityRankNeg ()) -99999.0)
+
+  (: LimitSize (-> Expression Number Expression))
+  (@doc LimitSize
+    (@desc "Bound a priority queue to fewer than the size limit by dropping the lowest-priority items")
+    (@params ((@param "Candidate list") (@param "Size bound")))
+    (@return "Bounded candidate list"))
+  (= (LimitSize $L $size)
+     (top-k-by-atom PriorityRank $size $L))
+
+  (: NARS.PairInference (-> Expression Expression Expression))
+  (@doc NARS.PairInference
+    (@desc "Apply the binary inference rules in both premise orders")
+    (@params ((@param "First judgement") (@param "Second judgement")))
+    (@return "A derived judgement"))
+  (= (NARS.PairInference $x $y) (|- $x $y))
+  (= (NARS.PairInference $x $y) (|- $y $x))
+
+  (: NARS.BinaryDerivation (-> Expression Expression Expression Expression))
+  (@doc NARS.BinaryDerivation
+    (@desc "Derive sentences from one selected task and one belief when their stamps are disjoint")
+    (@params ((@param "Selected task judgement") (@param "Selected task evidence stamp") (@param "Belief sentence")))
+    (@return "A derived Sentence, or no result when stamps overlap or no rule applies"))
+  (= (NARS.BinaryDerivation $x $Ev1 (Sentence $y $Ev2))
+     (if (StampDisjoint $Ev1 $Ev2)
+         (let $stamp (StampConcat $Ev1 $Ev2)
+              (case (NARS.PairInference $x $y)
+                    ((($T $TV) (Sentence ($T $TV) $stamp)))))
+         (empty)))
+
+  (: NARS.UnaryDerivation (-> Expression Expression Expression))
+  (@doc NARS.UnaryDerivation
+    (@desc "Derive sentences from one selected task using unary inference rules")
+    (@params ((@param "Selected task judgement") (@param "Selected task evidence stamp")))
+    (@return "A derived Sentence, or no result when no unary rule applies"))
+  (= (NARS.UnaryDerivation $x $Ev1)
+     (case (|- $x)
+           ((($T (stv $f $c)) (Sentence ($T (stv $f $c)) $Ev1)))))
+
+  (@doc NARS.Derive
+    (@desc "Priority-queue forward derivation over tasks and beliefs")
+    (@params ((@param "Task list") (@param "Belief list") (@param "Optional step and queue bounds")))
+    (@return "A pair (tasks beliefs) after bounded derivation"))
+  (= (NARS.Derive $Tasks $Beliefs $steps $maxsteps $taskqueuesize $beliefqueuesize)
+     (if (or (> $steps $maxsteps) (== $Tasks ()))
+         ($Tasks $Beliefs)
+         (let $selected (BestCandidate PriorityRank () $Tasks)
+           (let (Sentence $x $Ev1) $selected
+             (let $fromBeliefs (NARS.CollapseToList
+                                 (let $belief (superpose $Beliefs)
+                                   (NARS.BinaryDerivation $x $Ev1 $belief)))
+               (let $fromTask (NARS.CollapseToList
+                               (NARS.UnaryDerivation $x $Ev1))
+                 (let $derivations (append $fromBeliefs $fromTask)
+                   (let $_ (trace! (SELECTED $steps (Sentence $x $Ev1)) 42)
+                     (let $taskCandidates (unique-atom (append $Tasks $derivations))
+                       (let $withoutSelected (exclude-item $selected $taskCandidates)
+                         (let $newTasks (LimitSize $withoutSelected $taskqueuesize)
+                           (let $beliefCandidates (unique-atom (append $Beliefs $derivations))
+                             (let $newBeliefs (LimitSize $beliefCandidates $beliefqueuesize)
+                               (NARS.Derive $newTasks
+                                            $newBeliefs
+                                            (+ $steps 1)
+                                            $maxsteps
+                                            $taskqueuesize
+                                            $beliefqueuesize))))))))))))))
+
+  (= (NARS.Derive $Tasks $Beliefs $maxsteps $taskqueuesize $beliefqueuesize)
+     (NARS.Derive $Tasks $Beliefs 1 $maxsteps $taskqueuesize $beliefqueuesize))
+
+  (= (NARS.Derive $Tasks $Beliefs $maxsteps)
+     (NARS.Derive $Tasks $Beliefs $maxsteps (NARS.Config.TaskQueueSize) (NARS.Config.BeliefQueueSize)))
+
+  (= (NARS.Derive $Tasks $Beliefs)
+     (NARS.Derive $Tasks $Beliefs (NARS.Config.MaxSteps)))
+
+  (: ConfidenceRank (-> Expression Number))
+  (@doc ConfidenceRank
+    (@desc "Query-answer score: the confidence of a (truth evidence) pair, with zero for the empty candidate")
+    (@params ((@param "A query answer ((stv f c) evidence) or ()")))
+    (@return "Confidence score"))
+  (= (ConfidenceRank ((stv $f $c) $Ev)) $c)
+  (= (ConfidenceRank ()) 0)
+
+  (@doc NARS.Query
+    (@desc "Query a term against a NARS knowledge base after bounded forward derivation")
+    (@params ((@param "Task list or knowledge base") (@param "Belief list or term") (@param "Term and optional bounds")))
+    (@return "The highest-confidence answer as ((stv f c) evidence), or () when no belief matches"))
+  ; let-force the candidate list: imported into &self, BestCandidate's Expression-typed argument is not
+  ; re-evaluated if it already looks like an Expression, so evaluate NARS.CollapseToList explicitly first.
+  (= (NARS.Query $Tasks $Beliefs $term $maxsteps $taskqueuesize $beliefqueuesize)
+     (let $candidates
+          (NARS.CollapseToList
+            (let ($TasksRet $BeliefsRet) (NARS.Derive $Tasks $Beliefs $maxsteps $taskqueuesize $beliefqueuesize)
+              (case (superpose $BeliefsRet)
+                    (((Sentence ($Term $TV) $Ev)
+                      (case (== $Term $term)
+                            ((True ($TV $Ev)))))))))
+          (BestCandidate ConfidenceRank () $candidates)))
+
+  (= (NARS.Query $kb $term $maxsteps $taskqueuesize $beliefqueuesize)
+     (NARS.Query $kb $kb $term $maxsteps $taskqueuesize $beliefqueuesize))
+
+  (= (NARS.Query $kb $term $maxsteps)
+     (NARS.Query $kb $term $maxsteps (NARS.Config.TaskQueueSize) (NARS.Config.BeliefQueueSize)))
+
+  (= (NARS.Query $kb $term)
+     (NARS.Query $kb $term (NARS.Config.MaxSteps)))
+`,
+  pln: `
+  ; ---------- Tuple helpers ----------
+  (@doc PLN.Force
+    (@desc "Evaluate a raw expression call while preserving already-data expression lists")
+    (@params ((@param "Atom to force")))
+    (@return "The evaluated atom, or the original atom when eval leaves it unreduced"))
+  (= (PLN.Force $atom)
+     (let $forced (eval $atom)
+       (case $forced
+             (((eval $raw) $atom)
+              ($_ $forced)))))
+
+  (: clamp (-> Number Number Number Number))
+  (@doc clamp
+    (@desc "Clamp a number to the inclusive range [min, max]")
+    (@params ((@param "Value") (@param "Minimum") (@param "Maximum")))
+    (@return "The value bounded by the range"))
+  (= (clamp $v $min $max)
+     (min $max (max $v $min)))
+
+  (: TupleConcat (-> Expression Expression Expression))
+  (@doc TupleConcat
+    (@desc "Concatenate two tuple lists represented as Hyperon expression lists")
+    (@params ((@param "First tuple list") (@param "Second tuple list")))
+    (@return "The concatenated tuple list"))
+  (= (TupleConcat $Ev1 $Ev2)
+     (append $Ev1 $Ev2))
+
+  (: TupleCount (-> Expression Number))
+  (@doc TupleCount
+    (@desc "Count items in a tuple list")
+    (@params ((@param "Tuple list")))
+    (@return "The item count"))
+  (= (TupleCount $tuple)
+     (size-atom $tuple))
+
+  (: and5 (-> Bool Bool Bool Bool Bool Bool))
+  (@doc and5
+    (@desc "Five-argument boolean conjunction")
+    (@params ((@param "First boolean") (@param "Second boolean") (@param "Third boolean") (@param "Fourth boolean") (@param "Fifth boolean")))
+    (@return "True when all five inputs are true"))
+  (= (and5 $0 $1 $2 $3 $4)
+     (and $0 (and $1 (and $2 (and $3 $4)))))
+
+  (: min5 (-> Number Number Number Number Number Number))
+  (@doc min5
+    (@desc "Minimum of five numbers")
+    (@params ((@param "First number") (@param "Second number") (@param "Third number") (@param "Fourth number") (@param "Fifth number")))
+    (@return "The smallest input"))
+  (= (min5 $0 $1 $2 $3 $4)
+     (min $0 (min $1 (min $2 (min $3 $4)))))
+
+  (: /safe (-> Number Number Number))
+  (@doc /safe
+    (@desc "Division guarded like PeTTa lib_pln: divide only when the denominator is positive")
+    (@params ((@param "Numerator") (@param "Denominator")))
+    (@return "The quotient, or no result when the denominator is not positive"))
+  (= (/safe $A $B)
+     (if (> $B 0.0)
+         (/ $A $B)
+         (empty)))
+
+  (: negate (-> Number Number))
+  (@doc negate
+    (@desc "Return 1 minus the argument")
+    (@params ((@param "Number")))
+    (@return "1 - x"))
+  (= (negate $arg)
+     (- 1.0 $arg))
+
+  (: invert (-> Number Number))
+  (@doc invert
+    (@desc "Return the reciprocal through /safe")
+    (@params ((@param "Number")))
+    (@return "1 / x, or no result when x is not positive"))
+  (= (invert $arg)
+     (/safe 1.0 $arg))
+
+  (: InsertSorted (-> Number Expression Expression))
+  (@doc InsertSorted
+    (@desc "Insert a numeric item into a sorted tuple list")
+    (@params ((@param "Item") (@param "Sorted tuple list")))
+    (@return "The sorted tuple list with the item inserted"))
+  (= (InsertSorted $x $L)
+     (if (== $L ())
+         ($x)
+         (let* ((($head $tail) (decons-atom $L)))
+           (if (< $x $head)
+               (TupleConcat ($x $head) $tail)
+               (let $inserted (InsertSorted $x $tail)
+                    (TupleConcat ($head) $inserted))))))
+
+  (: InsertionSort (-> Expression Expression Expression))
+  (@doc InsertionSort
+    (@desc "Sort a tuple list. The second argument is preserved for PeTTa lib_pln call compatibility and is ignored by the upstream implementation")
+    (@params ((@param "Tuple list") (@param "Ignored accumulator")))
+    (@return "Sorted tuple list"))
+  (= (InsertionSort $L $Ret)
+     (let $items (PLN.Force $L)
+       (if (== $items ())
+           $Ret
+           (let* ((($x $rest) (decons-atom $items))
+                  ($newRet (InsertSorted $x $Ret)))
+             (InsertionSort $rest $newRet)))))
+
+  (: Without (-> Expression %Undefined% Expression))
+  (@doc Without
+    (@desc "Remove an item from a tuple list")
+    (@params ((@param "Tuple list") (@param "Item to remove")))
+    (@return "Tuple list without the item"))
+  (= (Without $Tuple $a)
+     (exclude-item $a $Tuple))
+
+  (: ElementOf (-> %Undefined% Expression Bool))
+  (@doc ElementOf
+    (@desc "Check whether an item is a member of a tuple list")
+    (@params ((@param "Item") (@param "Tuple list")))
+    (@return "Bool membership result"))
+  (= (ElementOf $a $Tuple)
+     (is-member $a $Tuple))
+
+  (: Unique (-> Expression Expression Expression))
+  (@doc Unique
+    (@desc "Deduplicate a tuple list. The second argument is preserved for PeTTa lib_pln call compatibility and is ignored by the upstream implementation")
+    (@params ((@param "Tuple list") (@param "Ignored accumulator")))
+    (@return "Deduplicated tuple list"))
+  (= (Unique $L $Ret)
+     (unique-atom $L))
+
+  ; ---------- Consistency helpers ----------
+  (: smallest-intersection-probability (-> Number Number Number))
+  (@doc smallest-intersection-probability
+    (@desc "Lower bound for a conditional intersection probability")
+    (@params ((@param "Strength of A") (@param "Strength of B")))
+    (@return "Clamped lower probability bound"))
+  (= (smallest-intersection-probability $As $Bs)
+     (clamp (/ (- (+ $As $Bs) 1) $As) 0 1))
+
+  (: largest-intersection-probability (-> Number Number Number))
+  (@doc largest-intersection-probability
+    (@desc "Upper bound for a conditional intersection probability")
+    (@params ((@param "Strength of A") (@param "Strength of B")))
+    (@return "Clamped upper probability bound"))
+  (= (largest-intersection-probability $As $Bs)
+     (clamp (/ $Bs $As) 0 1))
+
+  (: conditional-probability-consistency (-> Number Number Number Bool))
+  (@doc conditional-probability-consistency
+    (@desc "Check PeTTa lib_pln conditional probability bounds")
+    (@params ((@param "Strength of A") (@param "Strength of B") (@param "Strength of A implies B")))
+    (@return "True when the conditional probability is inside the PLN bounds"))
+  (= (conditional-probability-consistency $As $Bs $ABs)
+     (and (< 0 $As)
+          (and (<= (smallest-intersection-probability $As $Bs) $ABs)
+               (<= $ABs (largest-intersection-probability $As $Bs)))))
+
+  (: Consistency_ImplicationImplicantConjunction (-> Number Number Number Number Number Bool))
+  (@doc Consistency_ImplicationImplicantConjunction
+    (@desc "Check PeTTa lib_pln implication and implicant conjunction consistency")
+    (@params ((@param "Strength of A") (@param "Strength of B") (@param "Strength of C") (@param "Strength of A implies C") (@param "Strength of B implies C")))
+    (@return "Bool consistency result"))
+  (= (Consistency_ImplicationImplicantConjunction $As $Bs $Cs $ACs $BCs)
+     (and5 (> $As 0) (> $Bs 0) (> $Cs 0)
+           (<= $ACs (/ $Cs $As))
+           (<= $BCs (/ $Cs $Bs))))
+
+  ; ---------- Truth functions ----------
+  ; PeTTa lib_pln leaves STV as a stub so callers can define node truth values.
+  (= (STV $stv) (empty))
+
+  (: Truth_c2w (-> Number Number))
+  (@doc Truth_c2w
+    (@desc "Convert PLN confidence to evidence weight")
+    (@params ((@param "Confidence c")))
+    (@return "Evidence weight c / (1 - c), or no result when c is 1"))
+  (= (Truth_c2w $c)
+     (/safe $c (- 1 $c)))
+
+  (: Truth_w2c (-> Number Number))
+  (@doc Truth_w2c
+    (@desc "Convert evidence weight to PLN confidence")
+    (@params ((@param "Evidence weight w")))
+    (@return "Confidence w / (w + 1)"))
+  (= (Truth_w2c $w)
+     (/safe $w (+ $w 1)))
+
+  (: Truth_Deduction (-> Expression Expression Expression Expression Expression Expression))
+  (@doc Truth_Deduction
+    (@desc "PeTTa lib_pln five-argument PLN deduction truth function")
+    (@params ((@param "Truth of P") (@param "Truth of Q") (@param "Truth of R") (@param "Truth of P implies Q") (@param "Truth of Q implies R")))
+    (@return "Deductive simple truth value"))
+  (= (Truth_Deduction (stv $Ps $Pc)
+                      (stv $Qs $Qc)
+                      (stv $Rs $Rc)
+                      (stv $PQs $PQc)
+                      (stv $QRs $QRc))
+     (if (and (conditional-probability-consistency $Ps $Qs $PQs)
+              (conditional-probability-consistency $Qs $Rs $QRs))
+         (stv (if (< 0.9999 $Qs)
+                  $Rs
+                  (+ (* $PQs $QRs)
+                     (/safe (* (- 1 $PQs) (- $Rs (* $Qs $QRs))) (- 1 $Qs))))
+              (min $Pc (min $Qc (min $Rc (min $PQc $QRc)))))
+         (stv 1 0)))
+
+  (: Truth_Induction (-> Expression Expression Expression Expression Expression Expression))
+  (@doc Truth_Induction
+    (@desc "PeTTa lib_pln five-argument PLN induction truth function")
+    (@params ((@param "Truth of A") (@param "Truth of B") (@param "Truth of C") (@param "Truth of B implies A") (@param "Truth of B implies C")))
+    (@return "Inductive simple truth value"))
+  (= (Truth_Induction (stv $sA $cA)
+                      (stv $sB $cB)
+                      (stv $sC $cC)
+                      (stv $sBA $cBA)
+                      (stv $sBC $cBC))
+     (stv (+ (/safe (* (* $sBA $sBC) $sB) $sA)
+             (* (- 1 (/safe (* $sBA $sB) $sA))
+                (/safe (- $sC (* $sB $sBC)) (- 1 $sB))))
+          (Truth_w2c (min $cBA $cBC))))
+
+  (: Truth_Abduction (-> Expression Expression Expression Expression Expression Expression))
+  (@doc Truth_Abduction
+    (@desc "PeTTa lib_pln five-argument PLN abduction truth function")
+    (@params ((@param "Truth of A") (@param "Truth of B") (@param "Truth of C") (@param "Truth of A implies B") (@param "Truth of C implies B")))
+    (@return "Abductive simple truth value"))
+  (= (Truth_Abduction (stv $sA $cA)
+                      (stv $sB $cB)
+                      (stv $sC $cC)
+                      (stv $sAB $cAB)
+                      (stv $sCB $cCB))
+     (stv (+ (/safe (* (* $sAB $sCB) $sC)
+                    $sB)
+             (/safe (* $sC (* (- 1 $sAB) (- 1 $sCB)))
+                    (- 1 $sB)))
+          (Truth_w2c (min $cAB $cCB))))
+
+  (: Truth_ModusPonens (-> Expression Expression Expression))
+  (@doc Truth_ModusPonens
+    (@desc "PeTTa lib_pln modus ponens truth function")
+    (@params ((@param "Antecedent truth value") (@param "Implication truth value")))
+    (@return "Conclusion truth value"))
+  (= (Truth_ModusPonens (stv $f1 $c1) (stv $f2 $c2))
+     (stv (+ (* $f1 $f2) (* 0.02 (- 1 $f1)))
+          (* $c1 $c2)))
+
+  (: Truth_SymmetricModusPonens (-> Expression Expression Expression))
+  (@doc Truth_SymmetricModusPonens
+    (@desc "PeTTa lib_pln symmetric modus ponens truth function")
+    (@params ((@param "Source truth value") (@param "Similarity truth value")))
+    (@return "Conclusion truth value"))
+  (= (Truth_SymmetricModusPonens (stv $sA $cA) (stv $sAB $cAB))
+     (let* (($snotAB 0.2)
+            ($cnotAB 1.0))
+       (stv (+ (* $sA $sAB) (* (* $snotAB (negate $sA)) (+ 1.0 $sAB)))
+            (min (min $cAB $cnotAB) $cA))))
+
+  (: Truth_Revision (-> Expression Expression Expression))
+  (@doc Truth_Revision
+    (@desc "PeTTa lib_pln heuristic revision of two simple truth values")
+    (@params ((@param "First truth value") (@param "Second truth value")))
+    (@return "Revised truth value"))
+  (= (Truth_Revision (stv $f1 $c1) (stv $f2 $c2))
+     (let* (($w1 (Truth_c2w $c1))
+            ($w2 (Truth_c2w $c2))
+            ($w (+ $w1 $w2))
+            ($f (/safe (+ (* $w1 $f1) (* $w2 $f2)) $w))
+            ($c (Truth_w2c $w)))
+       (stv (min 1.0 $f)
+            (min 1.0 (max (max $c $c1) $c2)))))
+
+  (: Truth_Negation (-> Expression Expression))
+  (@doc Truth_Negation
+    (@desc "Negate the strength of a simple truth value while preserving confidence")
+    (@params ((@param "Truth value")))
+    (@return "Negated truth value"))
+  (= (Truth_Negation (stv $s $c))
+     (stv (- 1.0 $s) $c))
+
+  (: Truth_inversion (-> Expression Expression Expression))
+  (@doc Truth_inversion
+    (@desc "PeTTa lib_pln inversion truth function")
+    (@params ((@param "Target node truth value") (@param "Link truth value")))
+    (@return "Inverted truth value"))
+  (= (Truth_inversion (stv $Bs $Bc) (stv $ABs $ABc))
+     (stv $ABs (* $Bc (* $ABc 0.6))))
+
+  (: Truth_equivalenceToImplication (-> Expression Expression Expression Expression))
+  (@doc Truth_equivalenceToImplication
+    (@desc "Convert an equivalence truth value into an implication truth value")
+    (@params ((@param "Truth of A") (@param "Truth of B") (@param "Truth of equivalence A B")))
+    (@return "Implication truth value"))
+  (= (Truth_equivalenceToImplication (stv $As $Ac) (stv $Bs $Bc) (stv $ABs $ABc))
+     (let* (($ConclS (if (< 0.99 (* $ABs $ABc))
+                         $ABs
+                         (/safe (* (+ 1.0 (/safe $Bs $As)) $ABs) (+ 1.0 $ABs)))))
+       (stv $ConclS $ABc)))
+
+  (: TransitiveSimilarityStrength (-> Number Number Number Number Number Number))
+  (@doc TransitiveSimilarityStrength
+    (@desc "PeTTa lib_pln transitive similarity strength helper")
+    (@params ((@param "Strength of A") (@param "Strength of B") (@param "Strength of C") (@param "Strength of A similar B") (@param "Strength of B similar C")))
+    (@return "Transitive similarity strength"))
+  (= (TransitiveSimilarityStrength $sA $sB $sC $sAB $sBC)
+     (let* (($T1 (/ (* (+ 1.0 (/ $sB $sA)) $sAB) (+ 1.0 $sAB)))
+            ($T2 (/ (* (+ 1.0 (/ $sC $sB)) $sBC) (+ 1.0 $sBC)))
+            ($T3 (/ (* (+ 1.0 (/ $sB $sC)) $sBC) (+ 1.0 $sBC)))
+            ($T4 (/ (* (+ 1.0 (/ $sA $sB)) $sAB) (+ 1.0 $sAB))))
+       (invert (- (+ (invert (+ (* $T1 $T2)
+                                (* (negate $T1)
+                                   (/safe (- $sC (* $sB $T2)) (negate $sB)))))
+                     (invert (+ (* $T3 $T4)
+                                (* (negate $T3)
+                                   (/safe (- $sC (* $sB $T4)) (negate $sB))))))
+                  1.0))))
+
+  (: Truth_transitiveSimilarity (-> Expression Expression Expression Expression Expression Expression))
+  (@doc Truth_transitiveSimilarity
+    (@desc "PeTTa lib_pln transitive similarity truth function")
+    (@params ((@param "Truth of A") (@param "Truth of B") (@param "Truth of C") (@param "Truth of A similar B") (@param "Truth of B similar C")))
+    (@return "Transitive similarity truth value"))
+  (= (Truth_transitiveSimilarity (stv $As $Ac)
+                                 (stv $Bs $Bc)
+                                 (stv $Cs $Cc)
+                                 (stv $ABs $ABc)
+                                 (stv $BCs $BCc))
+     (let* (($ConclS (TransitiveSimilarityStrength $As $Bs $Cs $ABs $BCs))
+            ($ConclC (min $ABc $BCc)))
+       (stv $ConclS $ConclC)))
+
+  (: simpleDeductionStrength (-> Number Number Number Number Number Number))
+  (@doc simpleDeductionStrength
+    (@desc "PeTTa lib_pln simple deduction strength helper")
+    (@params ((@param "Strength of A") (@param "Strength of B") (@param "Strength of C") (@param "Strength of A implies B") (@param "Strength of B implies C")))
+    (@return "Deduction strength, or no result when consistency checks fail"))
+  (= (simpleDeductionStrength $sA $sB $sC $sAB $sBC)
+     (if (and (conditional-probability-consistency $sA $sB $sAB)
+              (conditional-probability-consistency $sB $sC $sBC))
+         (if (< 0.99 $sB)
+             $sC
+             (+ (* $sAB $sBC)
+                (/safe (* (- 1.0 $sAB) (- $sC (* $sB $sBC))) (- 1.0 $sB))))
+         (empty)))
+
+  (: Truth_evaluationImplication (-> Expression Expression Expression Expression Expression Expression))
+  (@doc Truth_evaluationImplication
+    (@desc "PeTTa lib_pln evaluation implication truth function")
+    (@params ((@param "Truth of A") (@param "Truth of B") (@param "Truth of C") (@param "Truth of A implies B") (@param "Truth of A implies C")))
+    (@return "Evaluation implication truth value"))
+  (= (Truth_evaluationImplication (stv $As $Ac)
+                                  (stv $Bs $Bc)
+                                  (stv $Cs $Cc)
+                                  (stv $ABs $ABc)
+                                  (stv $ACs $ACc))
+     (let* (($ConclS (simpleDeductionStrength $Bs $As $Cs $ABs $ACs))
+            ($ConclC (* (* 0.9 0.9)
+                        (min5 $Bc $Ac $Cc $ACc (* 0.9 $ABc)))))
+       (stv $ConclS $ConclC)))
+
+  ; ---------- Inference rules ----------
+  (@doc |-
+    (@desc "PeTTa lib_pln PLN inference rules")
+    (@params ((@param "One or two PLN sentences written as (<term> <truth>)")))
+    (@return "A derived sentence written as (<term> <truth>)"))
+
+  ; Revision.
+  (= (|- ($T $T1)
+         ($T $T2))
+     (let $TV (Truth_Revision $T1 $T2)
+       ($T $TV)))
+
+  ; Modus ponens.
+  (= (|- ($A $T1)
+         ((Implication $A $B) $T2))
+     (let $TV (Truth_ModusPonens $T1 $T2)
+       ($B $TV)))
+
+  ; Guards for link-specific rules. Missing guard facts intentionally leave the rule unreduced.
+  (= (SymmetricModusPonensRuleGuard Similarity) True)
+  (= (SymmetricModusPonensRuleGuard IntentionalSimilarity) True)
+  (= (SymmetricModusPonensRuleGuard ExtensionalSimilarity) True)
+
+  (= (|- ($A $TruthA)
+         (($LinkType $A $B) $TruthAB))
+     (if (SymmetricModusPonensRuleGuard $LinkType)
+         (let $TV (Truth_SymmetricModusPonens $TruthA $TruthAB)
+           ($B $TV))
+         (empty)))
+
+  (= (SyllogisticRuleGuard Inheritance) True)
+  (= (SyllogisticRuleGuard Implication) True)
+
+  (= (|- (($LinkType $A $B) $T1)
+         (($LinkType $B $C) $T2))
+     (if (SyllogisticRuleGuard $LinkType)
+         (let* (($TruthA (STV $A))
+                ($TruthB (STV $B))
+                ($TruthC (STV $C))
+                ($TV (Truth_Deduction $TruthA $TruthB $TruthC $T1 $T2)))
+           (($LinkType $A $C) $TV))
+         (empty)))
+
+  (= (|- (($LinkType $C $A) $T1)
+         (($LinkType $C $B) $T2))
+     (if (SyllogisticRuleGuard $LinkType)
+         (let* (($TruthA (STV $A))
+                ($TruthB (STV $B))
+                ($TruthC (STV $C))
+                ($TV (Truth_Induction $TruthA $TruthB $TruthC $T1 $T2)))
+           (($LinkType $A $B) $TV))
+         (empty)))
+
+  (= (|- (($LinkType $A $C) $T1)
+         (($LinkType $B $C) $T2))
+     (if (SyllogisticRuleGuard $LinkType)
+         (let* (($TruthA (STV $A))
+                ($TruthB (STV $B))
+                ($TruthC (STV $C))
+                ($TV (Truth_Abduction $TruthA $TruthB $TruthC $T1 $T2)))
+           (($LinkType $A $B) $TV))
+         (empty)))
+
+  ; Usage of inheritance for predicates.
+  (= (|- ((Evaluation (Predicate $x)
+                      (List (Concept $C))) $T1)
+         ((Inheritance (Concept $S) (Concept $C)) $T2))
+     (let $TV (Truth_ModusPonens $T1 $T2)
+       ((Evaluation (Predicate $x)
+                    (List (Concept $S)))
+        $TV)))
+
+  (= (|- ((Evaluation (Predicate $x)
+                      (List (Concept $C1) (Concept $C2))) $T1)
+         ((Inheritance (Concept $S) (Concept $C1)) $T2))
+     (let $TV (Truth_ModusPonens $T1 $T2)
+       ((Evaluation (Predicate $x)
+                    (List (Concept $S) (Concept $C2)))
+        $TV)))
+
+  (= (|- ((Evaluation (Predicate $x)
+                      (List (Concept $C1) (Concept $C2))) $T1)
+         ((Inheritance (Concept $S) (Concept $C2)) $T2))
+     (let $TV (Truth_ModusPonens $T1 $T2)
+       ((Evaluation (Predicate $x)
+                    (List (Concept $C1) (Concept $S)))
+        $TV)))
+
+  (= (|- ((Not $A) $T))
+     (let $TV (Truth_Negation $T)
+       ($A $TV)))
+
+  (= (|- ((Inheritance $A $B) $Truth))
+     (let* (($TruthB (STV $B))
+            ($TV (Truth_inversion $TruthB $Truth)))
+       ((Inheritance $B $A) $TV)))
+
+  (= (|- ((Implication $A $B) $Truth))
+     (let* (($TruthB (STV $B))
+            ($TV (Truth_inversion $TruthB $Truth)))
+       ((Implication $B $A) $TV)))
+
+  (= (|- ((Equivalence $A $B) $Truth))
+     (let* (($TruthA (STV $A))
+            ($TruthB (STV $B))
+            ($TV (Truth_equivalenceToImplication $TruthA $TruthB $Truth)))
+       ((Implication $A $B) $TV)))
+
+  (= (|- ((Equivalence $A $B) $Truth))
+     (let* (($TruthA (STV $A))
+            ($TruthB (STV $B))
+            ($TV (Truth_equivalenceToImplication $TruthA $TruthB $Truth)))
+       ((Implication $B $A) $TV)))
+
+  (= (|- ((Similarity $A $B) $T1)
+         ((Similarity $B $C) $T2))
+     (let* (($TruthA (STV $A))
+            ($TruthB (STV $B))
+            ($TruthC (STV $C))
+            ($TV (Truth_transitiveSimilarity $TruthA $TruthB $TruthC $T1 $T2)))
+       ((Similarity $A $C) $TV)))
+
+  (= (|- ((Evaluation $A $B) $TruthAB)
+         ((Implication $A $C) $TruthAC))
+     (let* (($TruthA (STV $A))
+            ($TruthB (STV $B))
+            ($TruthC (STV $C))
+            ($TV (Truth_evaluationImplication $TruthA $TruthB $TruthC $TruthAB $TruthAC)))
+       ((Evaluation $C $B) $TV)))
+
+  (= (|- ((Member $A $B) $T1)
+         ((Inheritance $B $C) $T2))
+     (let* (($TruthA (STV $A))
+            ($TruthB (STV $B))
+            ($TruthC (STV $C))
+            ($TV (Truth_Deduction $TruthA $TruthB $TruthC $T1 $T2)))
+       ((Member $A $C) $TV)))
+
+  ; ---------- Derivation and query engine ----------
+  (: PLN.Config.MaxSteps (-> Number))
+  (@doc PLN.Config.MaxSteps
+    (@desc "Default maximum number of derivation task selections")
+    (@params ())
+    (@return "100"))
+  (= (PLN.Config.MaxSteps) 100)
+
+  (: PLN.Config.TaskQueueSize (-> Number))
+  (@doc PLN.Config.TaskQueueSize
+    (@desc "Default active task queue bound")
+    (@params ())
+    (@return "10"))
+  (= (PLN.Config.TaskQueueSize) 10)
+
+  (: PLN.Config.BeliefQueueSize (-> Number))
+  (@doc PLN.Config.BeliefQueueSize
+    (@desc "Default belief buffer bound")
+    (@params ())
+    (@return "100"))
+  (= (PLN.Config.BeliefQueueSize) 100)
+
+  (: PLN.CollapseToList (-> Atom Expression))
+  (@doc PLN.CollapseToList
+    (@desc "Collect nondeterministic results and convert this engine's comma-headed collapse tuple into a plain expression list")
+    (@params ((@param "Nondeterministic query to collapse")))
+    (@return "A plain expression list of collapsed results"))
+  (= (PLN.CollapseToList $query)
+     (let* (($collapsed (collapse $query))
+            ($plain (cdr-atom $collapsed)))
+       (exclude-item Empty $plain)))
+
+  (: StampDisjoint (-> Expression Expression Bool))
+  (@doc StampDisjoint
+    (@desc "True when two evidence stamps share no evidence item")
+    (@params ((@param "First evidence stamp") (@param "Second evidence stamp")))
+    (@return "Bool indicating whether the stamps are disjoint"))
+  (= (StampDisjoint $Ev1 $Ev2)
+     (== () (intersection-atom $Ev1 $Ev2)))
+
+  (: StampConcat (-> Expression Expression Expression))
+  (@doc StampConcat
+    (@desc "Concatenate a stamp with new evidence and sort it")
+    (@params ((@param "Base evidence stamp") (@param "Evidence stamp to add")))
+    (@return "Sorted combined evidence stamp"))
+  (= (StampConcat $stamp $addition)
+     (if (== $addition ())
+         $stamp
+         (let $combined (TupleConcat $stamp $addition)
+              (InsertionSort $combined ()))))
+
+  (: BestCandidate (-> Atom %Undefined% Expression %Undefined%))
+  (@doc BestCandidate
+    (@desc "Return the candidate with the highest score under an evaluator function")
+    (@params ((@param "Unary evaluator function") (@param "Current best candidate") (@param "Candidate list")))
+    (@return "The best candidate, or the initial best candidate when the list is empty"))
+  (= (BestCandidate $evaluateCandidateFunction $bestCandidate $tuple)
+     (max-by-atom $evaluateCandidateFunction $bestCandidate $tuple))
+
+  (: PriorityRank (-> Expression Number))
+  (@doc PriorityRank
+    (@desc "Task priority score: the confidence of a Sentence candidate")
+    (@params ((@param "Sentence candidate or empty sentinel")))
+    (@return "Priority score"))
+  (= (PriorityRank (Sentence ($x (stv $f $c)) $Ev1)) $c)
+  (= (PriorityRank ()) -99999.0)
+
+  (: PriorityRankNeg (-> Expression Number))
+  (@doc PriorityRankNeg
+    (@desc "Negated task priority score, used to find the lowest-priority queue item")
+    (@params ((@param "Sentence candidate or empty sentinel")))
+    (@return "Negated priority score"))
+  (= (PriorityRankNeg (Sentence ($x (stv $f $c)) $Ev1)) (- 0.0 $c))
+  (= (PriorityRankNeg ()) -99999.0)
+
+  (: LimitSize (-> Expression Number Expression))
+  (@doc LimitSize
+    (@desc "Limit a priority queue by removing the lowest-priority item when the accumulator reaches the size bound")
+    (@params ((@param "Candidate list") (@param "Size bound")))
+    (@return "Bounded candidate list"))
+  (= (LimitSize $L $size)
+     (top-k-by-atom PriorityRank $size $L))
+
+  (: PLN.PairInference (-> Expression Expression Expression))
+  (@doc PLN.PairInference
+    (@desc "Apply binary inference rules in both premise orders")
+    (@params ((@param "First judgement") (@param "Second judgement")))
+    (@return "A derived judgement"))
+  (= (PLN.PairInference $x $y) (|- $x $y))
+  (= (PLN.PairInference $x $y) (|- $y $x))
+
+  (: PLN.BinaryDerivation (-> Expression Expression Expression Expression))
+  (@doc PLN.BinaryDerivation
+    (@desc "Derive sentences from one selected task and one belief when their stamps are disjoint")
+    (@params ((@param "Selected task judgement") (@param "Selected task evidence stamp") (@param "Belief sentence")))
+    (@return "A derived Sentence, or no result"))
+  (= (PLN.BinaryDerivation $x $Ev1 (Sentence $y $Ev2))
+     (if (StampDisjoint $Ev1 $Ev2)
+         (let $stamp (StampConcat $Ev1 $Ev2)
+              (case (PLN.PairInference $x $y)
+                    ((($T $TV) (let $forcedTV $TV
+                                  (Sentence ($T $forcedTV) $stamp))))))
+         (empty)))
+
+  (: PLN.UnaryDerivation (-> Expression Expression Expression))
+  (@doc PLN.UnaryDerivation
+    (@desc "Derive sentences from one selected task using unary inference rules")
+    (@params ((@param "Selected task judgement") (@param "Selected task evidence stamp")))
+    (@return "A derived Sentence, or no result"))
+  (= (PLN.UnaryDerivation $x $Ev1)
+     (case (|- $x)
+           ((($T $TV) (let $forcedTV $TV
+                        (Sentence ($T $forcedTV) $Ev1))))))
+
+  (@doc PLN.Derive
+    (@desc "Priority-queue forward derivation over tasks and beliefs")
+    (@params ((@param "Task list") (@param "Belief list") (@param "Optional step and queue bounds")))
+    (@return "A pair (tasks beliefs) after bounded derivation"))
+  (= (PLN.Derive $Tasks $Beliefs $steps $maxsteps $taskqueuesize $beliefqueuesize)
+     (if (or (> $steps $maxsteps) (== $Tasks ()))
+         ($Tasks $Beliefs)
+         (let $selected (BestCandidate PriorityRank () $Tasks)
+           (let (Sentence $x $Ev1) $selected
+             (let $fromBeliefs (PLN.CollapseToList
+                                 (let $belief (superpose $Beliefs)
+                                   (PLN.BinaryDerivation $x $Ev1 $belief)))
+               (let $fromTask (PLN.CollapseToList
+                               (PLN.UnaryDerivation $x $Ev1))
+                 (let $derivations (TupleConcat $fromBeliefs $fromTask)
+                   (let $_ (trace! (SELECTED $steps (Sentence $x $Ev1)) 42)
+                     (let $taskCandidates (TupleConcat $Tasks $derivations)
+                       (let $uniqueTasks (Unique $taskCandidates ())
+                         (let $withoutSelected (Without $uniqueTasks $selected)
+                           (let $newTasks (LimitSize $withoutSelected $taskqueuesize)
+                             (let $beliefCandidates (TupleConcat $Beliefs $derivations)
+                               (let $uniqueBeliefs (Unique $beliefCandidates ())
+                                 (let $newBeliefs (LimitSize $uniqueBeliefs $beliefqueuesize)
+                                   (PLN.Derive $newTasks
+                                               $newBeliefs
+                                               (+ $steps 1)
+                                               $maxsteps
+                                               $taskqueuesize
+                                               $beliefqueuesize))))))))))))))))
+
+  (= (PLN.Derive $Tasks $Beliefs $maxsteps $taskqueuesize $beliefqueuesize)
+     (PLN.Derive $Tasks $Beliefs 1 $maxsteps $taskqueuesize $beliefqueuesize))
+
+  (= (PLN.Derive $Tasks $Beliefs $maxsteps)
+     (PLN.Derive $Tasks
+                 $Beliefs
+                 $maxsteps
+                 (PLN.Config.TaskQueueSize)
+                 (PLN.Config.BeliefQueueSize)))
+
+  (= (PLN.Derive $Tasks $Beliefs)
+     (PLN.Derive $Tasks $Beliefs (PLN.Config.MaxSteps)))
+
+  (: ConfidenceRank (-> Expression Number))
+  (@doc ConfidenceRank
+    (@desc "Query-answer score: the confidence of a (truth evidence) pair")
+    (@params ((@param "Query answer or empty sentinel")))
+    (@return "Confidence score"))
+  (= (ConfidenceRank ((stv $f $c) $Ev)) $c)
+  (= (ConfidenceRank ()) 0)
+
+  (: PLN.QueryCandidate (-> %Undefined% Expression Expression))
+  (@doc PLN.QueryCandidate
+    (@desc "Return a query answer when a belief Sentence has the requested term")
+    (@params ((@param "Requested term") (@param "Belief sentence")))
+    (@return "A (truth evidence) pair, or no result when the term differs"))
+  (= (PLN.QueryCandidate $term (Sentence ($term $TV) $Ev))
+     ($TV $Ev))
+  (= (PLN.QueryCandidate $term $sentence)
+     (empty))
+
+  (@doc PLN.QueryCandidates
+    (@desc "Collect all belief truth/evidence pairs whose term matches a query after bounded derivation")
+    (@params ((@param "Task list") (@param "Belief list") (@param "Term") (@param "Step and queue bounds")))
+    (@return "A plain expression list of query candidates"))
+  (= (PLN.QueryCandidates $qcTasks $qcBeliefs $qcTerm $qcMaxSteps $qcTaskQueueSize $qcBeliefQueueSize)
+     (let $TasksEval (PLN.Force $qcTasks)
+       (let $BeliefsEval (PLN.Force $qcBeliefs)
+         (let* (($maxstepsEval (+ 0 $qcMaxSteps))
+                ($taskqueuesizeEval (+ 0 $qcTaskQueueSize))
+                ($beliefqueuesizeEval (+ 0 $qcBeliefQueueSize)))
+           (let ($TasksRet $BeliefsRet)
+                (PLN.Derive $TasksEval $BeliefsEval 1 $maxstepsEval $taskqueuesizeEval $beliefqueuesizeEval)
+             (PLN.CollapseToList
+               (let $belief (superpose $BeliefsRet)
+                 (PLN.QueryCandidate $qcTerm $belief))))))))
+
+  (@doc PLN.Query
+    (@desc "Query a term against a PLN knowledge base after bounded forward derivation")
+    (@params ((@param "Task list or knowledge base") (@param "Belief list or term") (@param "Term and optional bounds")))
+    (@return "The highest-confidence answer as ((stv f c) evidence), or () when no belief matches"))
+  (= (PLN.Query $ts $bs $term $m $t $b)
+     (let* (($TasksClone (filter-atom $ts $taskItem True))
+            ($BeliefsClone (filter-atom $bs $beliefItem True)))
+       (BestCandidate ConfidenceRank ()
+                      (PLN.QueryCandidates $TasksClone
+                                           $BeliefsClone
+                                           $term
+                                           $m
+                                           $t
+                                           $b))))
+
+  (= (PLN.Query $k $term $m $t $b)
+     (let $kbClone (filter-atom $k $kbItem True)
+       (BestCandidate ConfidenceRank ()
+                      (PLN.QueryCandidates $kbClone
+                                           $kbClone
+                                           $term
+                                           $m
+                                           $t
+                                           $b))))
+
+  (= (PLN.Query $k $term $m)
+     (PLN.Query $k $term $m (PLN.Config.TaskQueueSize) (PLN.Config.BeliefQueueSize)))
+
+  (= (PLN.Query $k $term)
+     (PLN.Query $k $term (PLN.Config.MaxSteps)))
+`
+};
+
+// src/index.ts
+var done = false;
+function registerLibraries() {
+  if (done) return;
+  for (const [name, src] of Object.entries(LIBRARY_MODULE_SRCS)) {
+    registerBuiltinModule(name, src);
+  }
+  done = true;
+}
+registerLibraries();
+export {
+  LIBRARY_MODULE_SRCS,
+  registerLibraries
+};