datalog: built-ins + body arithmetic + order-aware safety (Phase 4, 106/106)

New lib/datalog/builtins.sx: (< <= > >= = !=) and (is X expr) with
+ - * /. dl-eval-arith recursively evaluates nested compounds.
Safety analysis now walks body left-to-right tracking the bound
set: comparisons require all args bound, is RHS vars must be bound
(LHS becomes bound), = special-cases the var/non-var combos.
db.sx keeps the simple safety check as a forward-reference
fallback; builtins.sx redefines dl-rule-check-safety to the
comprehensive version. eval.sx dispatches built-ins through
dl-eval-builtin instead of erroring. 19 new tests.

plans/datalog-on-sx.md

@@ -107,19 +107,23 @@ Key differences from Prolog:
 Almost every real query needs `<`, `=`, simple arithmetic, and string
 comparisons in body position. These are not EDB lookups — they're
 constraints that filter bindings.
-- [ ] Recognise built-in predicates in body: `(< X Y)`, `(<= X Y)`, `(> X Y)`,
+- [x] Recognise built-in predicates in body: `(< X Y)`, `(<= X Y)`, `(> X Y)`,
       `(>= X Y)`, `(= X Y)`, `(!= X Y)` and arithmetic forms `(is Z (+ X Y))`,
-      `(is Z (- X Y))`, `(is Z (* X Y))`, `(is Z (/ X Y))`.
-- [ ] Built-in evaluation: at the join step, after binding variables from
-      EDB lookups, evaluate built-ins as constraints. If any built-in fails
-      or has unbound inputs, drop the candidate substitution.
-- [ ] **Safety extension**: `is` binds its left operand iff right operand is
-      fully ground. `(< X Y)` requires both X and Y bound by some prior body
-      literal — reject unsafe at `dl-add-rule!` time.
-- [ ] Wire arithmetic operators through to SX numeric primitives — no
-      separate Datalog number tower.
-- [ ] Tests: range filters, arithmetic derivations, comparison-based
-      queries, safety violation on `(p X) :- (< X 5).`
+      `(is Z (- X Y))`, `(is Z (* X Y))`, `(is Z (/ X Y))`. Live in
+      `lib/datalog/builtins.sx`.
+- [x] `dl-eval-builtin` dispatches; `dl-eval-arith` recursively evaluates
+      `(+ a b)` etc. with full nesting. `=` unifies; `!=` rejects equal
+      ground terms.
+- [x] Order-aware safety analysis (`dl-rule-check-safety`): walks body
+      left-to-right tracking which vars are bound. `is`'s RHS vars must
+      be already bound; LHS becomes bound. Comparisons require both
+      sides bound. `=` is special-cased — at least one side bound binds
+      the other. Negation vars must be bound (will be enforced fully in
+      Phase 7).
+- [x] Wired through SX numeric primitives — no separate number tower.
+- [x] Tests in `lib/datalog/tests/builtins.sx` (19): range filters,
+      arithmetic derivations, equality binding, eight safety violations
+      and three safe-shape tests. Conformance 106 / 106.
 
 ### Phase 5 — semi-naive evaluation (performance)
 - [ ] Delta sets: track newly derived tuples per iteration
@@ -196,6 +200,19 @@ _(none yet)_
 
 _Newest first._
 
+- 2026-05-07 — Phase 4 done. `lib/datalog/builtins.sx` (~280 LOC) adds
+  `(< X Y)`, `(<= X Y)`, `(> X Y)`, `(>= X Y)`, `(= X Y)`, `(!= X Y)`,
+  and `(is X expr)` with `+ - * /`. `dl-eval-builtin` dispatches;
+  `dl-eval-arith` recursively evaluates nested compounds. Safety
+  check is now order-aware — it walks body literals left-to-right
+  tracking the bound set, requires comparison/`is` inputs to be
+  already bound, and special-cases `=` (binds the var-side; both
+  sides must include at least one bound to bind the other). Phase 3's
+  simple safety check stays in db.sx as a forward-reference fallback;
+  builtins.sx redefines `dl-rule-check-safety` to the comprehensive
+  version. eval.sx's `dl-match-lit` now dispatches built-ins through
+  `dl-eval-builtin`. 19 builtins tests; conformance 106 / 106.
+
 - 2026-05-07 — Phase 3 done. `lib/datalog/db.sx` (~250 LOC) holds facts
   indexed by relation name plus the rules list, with `dl-add-fact!` /
   `dl-add-rule!` (rejects non-ground facts and unsafe rules);