gdp-wired 0.4.0 → 0.5.0

package/README.md

@@ -148,6 +148,9 @@ const failsClosed = trial.decide('a missing fact means no trial', ({spent}) => s
 - **Kinds**: `nat`, `upTo(k)`, `bool`, `oneOf(...)`, `maybe(kind)`, `int`, `decimal(places)`, `str({like, maxLength})`;
   their assumptions (a bit is 0 or 1, a choice is in range) go to the kernel by themselves, and
   `encodeInput`/`encodeParams` turn runtime values into the numbers the machine reads.
+- **State of any kind**: `.state({open: bool.from(true), status: oneOf('new', 'done').from('new'), owner: str().from(''), note: maybe(nat).from(null)})`;
+  a step writes each kind's own values, `when(c, a, b)` chooses between any two values of a kind, and `rule.decode(state)`
+  reads them back as runtime values.
 - **Integers and decimals**: `int` and `decimal(places)` inputs, `.ints({...})` and `.decimals(places, {...})` state;
   `plus`, `minus`, `negate`, `times(k)` (k may be negative), `min`, `max`, `abs`, `isNegative`, comparisons with numbers
   (a decimal's literals are scaled: `price.atMost(19.99)`). Each is two naturals underneath, so the kernel and the Lean
@@ -226,7 +229,7 @@ Lean, compiled natively, wins where the state stays small. Details in [`docs/com
 | `core/` | Machines, the interpreter and JS compiler, the builders, composition (`compose.ts`), the linear solver and its checker, Houdini invariants, models, the first Lean export |
 | `kernel/` | The trusted kernel and the untrusted prover, with soundness fuzz (`kernel.test.ts`, `history.test.ts`) |
 | `lean-kernel/` | The kernel's Lean twin, its soundness proofs, and the exported trees |
-| `examples/` | The builders at work: `domains/` (92 rules across nine domains, each with laws and broken variants), `harness.ts` (the triple check), `readme.ts`, `budget.ts`, `composition.ts`, `sets.ts`, `quantifiers.ts`, `functions.ts`, `lists.ts`, `sizes.ts`, `liveness.ts`, and `jev-fabric/` (a Bend project's 59 proven laws, ported) |
+| `examples/` | The builders at work: `domains/` (92 rules across nine domains, each with laws and broken variants), `harness.ts` (the triple check), `readme.ts`, `budget.ts`, `composition.ts`, `sets.ts`, `quantifiers.ts`, `functions.ts`, `lists.ts`, `sizes.ts`, `liveness.ts`, `steps.ts` (laws over up to 16 steps), and `jev-fabric/` (a Bend project's 59 proven laws, ported) |
 | `docs/` | The comparison with Bend and Lean, and the full scope |
 | `compare/` | The same three rules in gdp-wired, Bend and plain Lean, checked and measured |
 | `research/` | Everything around the library ([`research/README.md`](research/README.md)): the GPU searches (`search/`, `hw/`, `modal-gpu/`), invariant and rank synthesis (`synth/`), relational laws and guard synthesis (`next/`), bit-vector laws (`sat/`), the enumeration and benchmarks (`enum/`, `gpu/`, `perf/`), the first Lean checker (`lean/`) and the first prototype, the audit path (`audit/`) |

package/dist/core/dsl.d.ts

@@ -39,19 +39,32 @@ export declare function when(c: Cond, then: TermLike, otherwise: TermLike): Term
 export declare function when(c: Cond, then: Decimal, otherwise: Decimal | number): Decimal;
 export declare function when(c: Cond, then: Decimal | number, otherwise: Decimal): Decimal;
 export declare function when(c: Cond, then: IntLike, otherwise: IntLike): Int;
+export declare function when<K extends string>(c: Cond, then: Choice<K>, otherwise: Choice<K>): Choice<K>;
+export declare function when(c: Cond, then: Str, otherwise: Str): Str;
+export declare function when<V>(c: Cond, then: Maybe<V>, otherwise: Maybe<V>): Maybe<V>;
+export declare function when(c: Cond, then: Cond, otherwise: Cond): Cond;
 export declare const choose: (c: Cond, then: Cond, otherwise: Cond) => Cond;
 export declare const count: (c: Cond) => Term;
 export declare const sum: (first: TermLike, ...rest: TermLike[]) => Term;
 type Rand = (k: number) => number;
 type Raw = number | boolean | string | null | undefined;
+export type At = string | ((name: string) => string);
+export type Init<V> = {
+    readonly kind: Kind<V>;
+    readonly init: Raw | ((p: never) => unknown);
+};
 export declare abstract class Kind<V> {
     readonly _value: V;
     abstract vars(name: string): string[];
     abstract assume(name: string): Cond[];
-    abstract value(name: string, prefix?: string): V;
+    abstract value(name: string, at?: At): V;
     abstract encode(name: string, raw: Raw): Record<string, number>;
     abstract random(name: string, rand: Rand, bound: number): Record<string, number>;
+    abstract store(name: string, value: unknown): Record<string, TermLike>;
+    abstract decode(name: string, vars: Record<string, number>): Raw;
+    abstract empty(): Raw;
     sample(_rand: Rand, _bound: number): Raw;
+    from(init: Raw | ((p: never) => unknown)): Init<V>;
 }
 export type IntLike = Int | Term | number;
 export declare class Int {
@@ -117,8 +130,8 @@ export declare class Choice<K extends string> {
 }
 export declare const oneOf: <const K extends string>(...values: K[]) => Kind<Choice<K>>;
 export declare class Maybe<V> {
-    private readonly present;
-    private readonly inner;
+    readonly present: Term;
+    readonly inner: V;
     constructor(present: Term, inner: V);
     get isSome(): Cond;
     get isNone(): Cond;
@@ -142,8 +155,11 @@ export declare class Str {
     readonly length: Term;
     private readonly bits;
     constructor(id: Term, length: Term, bits: ReadonlyMap<string, Term>);
+    get patterns(): string[];
+    choose(c: Cond, other: Str): Str;
     like(pattern: string): Cond;
     get isEmpty(): Cond;
+    bit(pattern: string): Term;
     eq(b: Str | string): Cond;
     ne(b: Str | string): Cond;
 }
@@ -236,8 +252,9 @@ type ValuesOf<K extends Kinds> = {
     [n in keyof K]: K[n] extends Kind<infer V> ? V : never;
 };
 type Obj = object;
+type Writes<V> = V extends Decimal ? DecimalLike | string : V extends Int ? IntLike : V extends Cond ? Cond | boolean : V extends Choice<infer K> ? Choice<K> | K : V extends Maybe<infer W> ? Maybe<W> | Writes<W> | null : V extends Str ? Str | string : TermLike;
 type Update<S extends Obj, M extends Obj> = Partial<{
-    [k in keyof S]: S[k] extends Decimal ? DecimalLike : S[k] extends Int ? IntLike : TermLike;
+    [k in keyof S]: Writes<S[k]>;
 } & {
     [k in keyof M]: MapWrite;
 }>;
@@ -248,7 +265,7 @@ type Spec = {
     state: [string, number | ((p: never) => TermLike)][];
     maps: [string, number][];
     lists?: string[];
-    signed?: [string, number | undefined][];
+    kinded?: [string, Kind<unknown>][];
     carried?: string[];
     fns?: [string, FnDef][];
     facts?: ((env: never) => Record<string, Cond | Forall>)[];
@@ -273,8 +290,8 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     get name(): string;
     params<K extends Kinds>(kinds: K): Rule<P & ValuesOf<K>, I, S, M, F, R, Su, Q>;
     inputs<K extends Kinds>(kinds: K): Rule<P, I & ValuesOf<K>, S, M, F, R, Su, Q>;
-    state<T extends Record<string, number | ((p: P) => TermLike)>>(init: T): Rule<P, I, S & {
-        [k in keyof T]: Term;
+    state<T extends Record<string, number | ((p: P) => TermLike) | Init<unknown>>>(init: T): Rule<P, I, S & {
+        [k in keyof T]: T[k] extends Init<infer V> ? V : Term;
     }, M, F, R, Su, Q>;
     maps<T extends Record<string, number>>(init: T): Rule<P, I, S, M & {
         [k in keyof T]: MapRef;
@@ -285,7 +302,6 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     decimals<T extends Record<string, number | string | ((p: P) => DecimalLike)>>(places: number, init: T): Rule<P, I, S & {
         [k in keyof T]: Decimal;
     }, M, F, R, Su, Q>;
-    private signedState;
     lists<const N extends string>(...names: N[]): Rule<P, I, S & {
         [k in N as `${k}_len`]: Term;
     }, M & {
@@ -330,7 +346,7 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     decide(name: string, given: (env: P & I) => Cond | Cond[], then: (env: P & I) => Cond): Decision;
     relate(name: string, given: (a: P & I, b: P & I) => Cond | Cond[], then: (a: P & I, b: P & I) => Cond): Decision;
     private kindAssumptions;
-    private signedValue;
+    private afterEnv;
     private env;
     private names;
     private whatIs;
@@ -372,7 +388,7 @@ export declare class Rule<P extends Obj = {}, I extends Obj = {}, S extends Obj
     }): Request;
     randomParams(rand: Rand, bound: number): Record<string, number>;
     randomInput(rand: Rand, bound: number): Request;
-    decode(st: State): Record<string, number>;
+    decode(st: State): Record<string, Raw>;
     get orderedBy(): string | undefined;
     interpreter(): {
         init: (params: {
@@ -410,15 +426,16 @@ export type Decision = {
     goal: Goal;
 };
 type Result<T> = {
-    [k in keyof T]: T[k] extends Cond ? Cond : T[k] extends Decimal ? Decimal : T[k] extends Int ? Int : Term;
+    [k in keyof T]: T[k] extends Cond ? Cond : T[k] extends Decimal ? Decimal : T[k] extends Int ? Int : T[k] extends Choice<infer K> ? Choice<K> : T[k] extends Str ? Str : Term;
 };
 type Value<T> = {
-    [k in keyof T]: T[k] extends Cond ? boolean : number;
+    [k in keyof T]: T[k] extends Cond ? boolean : T[k] extends Choice<infer K> ? K : T[k] extends Str ? string : number;
 };
+type Field = Term | Cond | Int | Decimal | Choice<string> | Str;
 export declare class Fun<P extends Obj = {}, I extends Obj = {}, O extends Obj = {}> {
     private readonly r;
     private readonly out?;
-    constructor(r: Rule<P, I>, out?: ((env: never) => Record<string, TermLike | Cond | Int | Decimal>) | undefined);
+    constructor(r: Rule<P, I>, out?: ((env: never) => Record<string, TermLike | Field>) | undefined);
     get name(): string;
     params<K extends Kinds>(kinds: K): Fun<P & ValuesOf<K>, I, O>;
     inputs<K extends Kinds>(kinds: K): Fun<P, I & ValuesOf<K>, O>;
@@ -428,7 +445,7 @@ export declare class Fun<P extends Obj = {}, I extends Obj = {}, O extends Obj =
     facts(f: (p: P) => Record<string, Cond | Forall>): Fun<P, I, O>;
     pre(f: (p: P) => Cond): Fun<P, I, O>;
     assume(f: (env: P & I) => Cond): Fun<P, I, O>;
-    returns<T extends Record<string, TermLike | Cond | Int | Decimal>>(f: (env: P & I) => T): Fun<P, I, Result<T>>;
+    returns<T extends Record<string, TermLike | Field>>(f: (env: P & I) => T): Fun<P, I, Result<T>>;
     private result;
     law(name: string, given: (env: P & I, out: O) => Cond | Cond[], then: (out: O, env: P & I) => Cond): Decision;
     relate(name: string, given: (a: P & I, b: P & I) => Cond | Cond[], then: (outA: O, outB: O, a: P & I, b: P & I) => Cond): Decision;

package/dist/core/dsl.js

@@ -82,6 +82,17 @@ export const not = (c) => c.not();
 export const min = (a, b) => new Term({ op: 'min', a: termOf(a), b: termOf(b) }, both(valOf(a), valOf(b), Math.min));
 export const max = (a, b) => new Term({ op: 'max', a: termOf(a), b: termOf(b) }, both(valOf(a), valOf(b), Math.max));
 export function when(c, then, otherwise) {
+    if (then instanceof Cond && otherwise instanceof Cond)
+        return choose(c, then, otherwise);
+    if (then instanceof Choice && otherwise instanceof Choice)
+        return new Choice(when(c, then.n, otherwise.n), then.values);
+    if (then instanceof Str && otherwise instanceof Str)
+        return then.choose(c, otherwise);
+    if (then instanceof Maybe && otherwise instanceof Maybe)
+        return new Maybe(when(c, then.present, otherwise.present), when(c, then.inner, otherwise.inner));
+    return pickNumbers(c, then, otherwise);
+}
+function pickNumbers(c, then, otherwise) {
     if (then instanceof Decimal || otherwise instanceof Decimal) {
         const places = (then instanceof Decimal ? then : otherwise).places, d = new Decimal(Int.of(0), places);
         return new Decimal(when(c, d.lift(then), d.lift(otherwise)), places);
@@ -97,11 +108,13 @@ export const choose = (c, then, otherwise) => any(all(c, then), all(c.not(), oth
 // 1 where c holds, else 0: what a sum over a history adds per record.
 export const count = (c) => when(c, 1, 0);
 export const sum = (first, ...rest) => rest.reduce((acc, t) => acc.plus(t), typeof first === 'number' ? lit(first) : first);
-// A kind names the variables a value is encoded in, what is assumed of them, the value the builders hand out, and how
-// a runtime value is encoded and drawn at random (the examples' harness draws inputs this way).
+const named = (at, n) => (typeof at === 'string' ? at + n : at(n));
+const primed = (n) => `${n}'`;
 export class Kind {
     // A runtime value of the kind (what encode takes), for comparing a rule with the code it describes (compare).
     sample(_rand, _bound) { throw new Error('this kind draws no runtime values'); }
+    // A state variable of this kind starting at a runtime value, or at a value over the params: `.state({open: bool.from(true)})`.
+    from(init) { return { kind: this, init }; }
 }
 const v = (name) => new Term({ op: 'var', name }, scope?.vars[name]);
 let scope;
@@ -177,7 +190,6 @@ export class Int {
 }
 // The same value with at most one part nonzero (what a state variable holds).
 const normal = (i) => (isZero(i.neg) || isZero(i.pos) ? i : new Int(i.pos.minus(i.neg), i.neg.minus(i.pos)));
-const termValue = (t) => (t.e.op === 'const' ? t.e.value : 0);
 const scaledOf = (x, places, what = 'a decimal') => {
     const text = typeof x === 'number' ? x.toFixed(places + 3) : x.trim();
     const m = /^(-?)(\d+)(?:\.(\d+))?$/.exec(text);
@@ -234,7 +246,10 @@ class NatKind extends Kind {
     }
     vars(name) { return [name]; }
     assume(name) { return this.maxValue === undefined ? [] : [v(name).atMost(this.maxValue)]; }
-    value(name, prefix = '') { return v(prefix + name); }
+    value(name, at = '') { return v(named(at, name)); }
+    store(name, value) { return { [name]: value }; }
+    decode(name, vars) { return vars[name]; }
+    empty() { return 0; }
     encode(name, raw) {
         const n = asNat(name, raw);
         if (this.maxValue !== undefined && n > this.maxValue)
@@ -258,7 +273,10 @@ export class Bool extends Cond {
 class BoolKind extends Kind {
     vars(name) { return [name]; }
     assume(name) { return [v(name).atMost(1)]; }
-    value(name, prefix = '') { return new Bool(v(prefix + name)); }
+    value(name, at = '') { return new Bool(v(named(at, name))); }
+    store(name, value) { return { [name]: typeof value === 'boolean' ? (value ? 1 : 0) : count(value) }; }
+    decode(name, vars) { return vars[name] === 1; }
+    empty() { return false; }
     encode(name, raw) {
         if (typeof raw === 'boolean')
             return { [name]: raw ? 1 : 0 };
@@ -304,7 +322,10 @@ class OneOfKind extends Kind {
     }
     vars(name) { return [name]; }
     assume(name) { return [v(name).lt(this.values.length)]; }
-    value(name, prefix = '') { return new Choice(v(prefix + name), this.values); }
+    value(name, at = '') { return new Choice(v(named(at, name)), this.values); }
+    store(name, value) { return { [name]: value instanceof Choice ? value.n : this.encode(name, value)[name] }; }
+    decode(name, vars) { return this.values[vars[name]]; }
+    empty() { return this.values[0]; }
     encode(name, raw) {
         const i = this.values.indexOf(raw);
         if (i < 0)
@@ -345,7 +366,17 @@ class MaybeKind extends Kind {
     has(name) { return `${name}$some`; }
     vars(name) { return [this.has(name), ...this.of.vars(name)]; }
     assume(name) { return [v(this.has(name)).atMost(1), ...this.of.assume(name)]; }
-    value(name, prefix = '') { return new Maybe(v(prefix + this.has(name)), this.of.value(name, prefix)); }
+    value(name, at = '') { return new Maybe(v(named(at, this.has(name))), this.of.value(name, at)); }
+    // null for none, a Maybe as it is, any other value as some.
+    store(name, value) {
+        if (value === null || value === undefined)
+            return { [this.has(name)]: 0, ...this.of.store(name, this.of.empty()) };
+        if (value instanceof Maybe)
+            return { [this.has(name)]: value.present, ...this.of.store(name, value.inner) };
+        return { [this.has(name)]: 1, ...this.of.store(name, value) };
+    }
+    decode(name, vars) { return vars[this.has(name)] === 1 ? this.of.decode(name, vars) : null; }
+    empty() { return null; }
     encode(name, raw) {
         if (raw === null || raw === undefined)
             return { [this.has(name)]: 0, ...Object.fromEntries(this.of.vars(name).map(n => [n, 0])) };
@@ -414,6 +445,9 @@ export class Str {
         this.length = length;
         this.bits = bits;
     }
+    get patterns() { return [...this.bits.keys()]; }
+    // This string where c holds, else `other` (the patterns both declare).
+    choose(c, other) { return new Str(when(c, this.id, other.id), when(c, this.length, other.length), new Map([...this.bits].filter(([p]) => other.bits.has(p)).map(([p, b]) => [p, when(c, b, other.bits.get(p))]))); }
     // The string matches `pattern`, one the kind declared.
     like(pattern) {
         const b = this.bits.get(pattern);
@@ -422,6 +456,9 @@ export class Str {
         return b.eq(1);
     }
     get isEmpty() { return this.id.eq(0); }
+    // A declared pattern's bit (0 or 1).
+    bit(pattern) { const b = this.bits.get(pattern); if (!b)
+        throw new Error(`no pattern "${pattern}" on this string`); return b; }
     eq(b) {
         if (typeof b === 'string')
             return all(this.id.eq(literal(b)), this.length.eq(b.length), ...[...this.bits].map(([p, bit]) => bit.eq(globMatch(p, b) ? 1 : 0)));
@@ -443,7 +480,17 @@ class StrKind extends Kind {
         return [v(name).eq(0).iff(v(`${name}$len`).eq(0)), ...(this.maxLength === undefined ? [] : [v(`${name}$len`).atMost(this.maxLength)]),
             ...this.patterns.map((p, i) => (p.replaceAll('\\*', '').includes('*') ? v(this.bit(name, i)).atMost(1) : v(this.bit(name, i)).eq(1).iff(v(name).eq(literal(p.replaceAll('\\*', '*'))))))];
     }
-    value(name, prefix = '') { return new Str(v(prefix + name), v(`${prefix}${name}$len`), new Map(this.patterns.map((p, i) => [p, v(prefix + this.bit(name, i))]))); }
+    value(name, at = '') { return new Str(v(named(at, name)), v(named(at, `${name}$len`)), new Map(this.patterns.map((p, i) => [p, v(named(at, this.bit(name, i)))]))); }
+    store(name, value) {
+        if (typeof value === 'string')
+            return { [name]: literal(value), [`${name}$len`]: value.length, ...Object.fromEntries(this.patterns.map((p, i) => [this.bit(name, i), globMatch(p, value) ? 1 : 0])) };
+        const t = value;
+        return { [name]: t.id, [`${name}$len`]: t.length, ...Object.fromEntries(this.patterns.map((p, i) => [this.bit(name, i), t.bit(p)])) };
+    }
+    decode(name, vars) { const id = vars[name]; for (const [text, n] of internTable)
+        if (n === id)
+            return text; throw new Error(`${name}: no string is interned as ${id}`); }
+    empty() { return ''; }
     encode(name, raw) {
         if (typeof raw !== 'string')
             throw new RangeError(`${name} must be a string, not ${String(raw)}`);
@@ -466,7 +513,10 @@ export const str = (opts = {}) => new StrKind(opts.like ?? [], opts.maxLength);
 class IntKind extends Kind {
     vars(name) { return [name, `${name}$neg`]; }
     assume() { return []; }
-    value(name, prefix = '') { return new Int(v(prefix + name), v(`${prefix}${name}$neg`)); }
+    value(name, at = '') { return new Int(v(named(at, name)), v(named(at, `${name}$neg`))); }
+    store(name, value) { const i = normal(Int.of(value)); return { [name]: i.pos, [`${name}$neg`]: i.neg }; }
+    decode(name, vars) { return vars[name] - vars[`${name}$neg`]; }
+    empty() { return 0; }
     encode(name, raw) {
         if (typeof raw !== 'number' || !Number.isSafeInteger(raw))
             throw new RangeError(`${name} must be an integer, not ${String(raw)}`);
@@ -485,7 +535,13 @@ class DecimalKind extends Kind {
     }
     vars(name) { return [name, `${name}$neg`]; }
     assume() { return []; }
-    value(name, prefix = '') { return new Decimal(new Int(v(prefix + name), v(`${prefix}${name}$neg`)), this.places); }
+    value(name, at = '') { return new Decimal(new Int(v(named(at, name)), v(named(at, `${name}$neg`))), this.places); }
+    store(name, value) {
+        const i = normal(typeof value === 'string' ? Int.of(scaledOf(value, this.places)) : new Decimal(Int.of(0), this.places).lift(value));
+        return { [name]: i.pos, [`${name}$neg`]: i.neg };
+    }
+    decode(name, vars) { return (vars[name] - vars[`${name}$neg`]) / 10 ** this.places; }
+    empty() { return 0; }
     encode(name, raw) {
         if (typeof raw !== 'number' && typeof raw !== 'string')
             throw new RangeError(`${name} must be a decimal, not ${String(raw)}`);
@@ -836,28 +892,39 @@ export class Rule {
     get name() { return this.spec.name; }
     params(kinds) { return this.with({ params: [...this.spec.params, ...Object.entries(kinds)] }); }
     inputs(kinds) { return this.with({ inputs: [...this.spec.inputs, ...Object.entries(kinds)] }); }
-    // Each variable starts at a natural or at a term over the params.
+    // Each variable starts at a natural or at a term over the params, or is declared by a kind and starts where `from`
+    // says: `.state({balance: int.from(-5), status: oneOf('open', 'closed').from('open'), note: maybe(nat).from(null)})`.
     state(init) {
-        return this.with({ state: [...this.spec.state, ...Object.entries(init)] });
+        const entries = [], kinded = [];
+        for (const [n, x] of Object.entries(init)) {
+            if (typeof x === 'number' || typeof x === 'function') {
+                entries.push([n, x]);
+                continue;
+            }
+            const { kind, init: start } = x;
+            kinded.push([n, kind]);
+            if (typeof start === 'function') {
+                const parts = (p) => kind.store(n, start(p));
+                for (const part of kind.vars(n))
+                    entries.push([part, p => parts(p)[part]]);
+            }
+            else {
+                const enc = kind.encode(n, start);
+                for (const part of kind.vars(n))
+                    entries.push([part, enc[part]]);
+            }
+        }
+        return this.with({ state: [...this.spec.state, ...entries], kinded: [...(this.spec.kinded ?? []), ...kinded] });
     }
     maps(init) { return this.with({ maps: [...this.spec.maps, ...Object.entries(init)] }); }
     // Integers (Int), each starting at an integer or at one over the params; kept as two naturals, <name> and <name>$neg.
-    ints(init) { return this.signedState(init, undefined); }
+    ints(init) {
+        return this.state(Object.fromEntries(Object.entries(init).map(([n, x]) => [n, int.from(x)])));
+    }
     // Decimals with `places` places (Decimal), each starting at a number, a string ("12.50") or one over the params.
     decimals(places, init) {
-        decimal(places);
-        return this.signedState(init, places);
-    }
-    signedState(init, places) {
-        const parts = (n, x) => {
-            if (typeof x !== 'function') {
-                const i = places === undefined ? Int.of(x) : Int.of(scaledOf(x, places));
-                return [[n, termValue(i.pos)], [`${n}$neg`, termValue(i.neg)]];
-            }
-            const at = (p) => normal(places === undefined ? Int.of(x(p)) : new Decimal(Int.of(0), places).lift(x(p)));
-            return [[n, p => at(p).pos], [`${n}$neg`, p => at(p).neg]];
-        };
-        return this.with({ state: [...this.spec.state, ...Object.entries(init).flatMap(([n, x]) => parts(n, x))], signed: [...(this.spec.signed ?? []), ...Object.keys(init).map(n => [n, places])] });
+        const kind = decimal(places);
+        return this.state(Object.fromEntries(Object.entries(init).map(([n, x]) => [n, kind.from(x)])));
     }
     // Lists, each empty at the start: a map of positions and its length <name>_len (ListRef).
     lists(...names) {
@@ -917,19 +984,7 @@ export class Rule {
     //   counter.stepLaw('never goes back', ({used}, after) => used.atMost(after.used))
     stepLaw(name, then, when) {
         const env = this.env();
-        const after = {};
-        for (const [n] of this.spec.state)
-            after[n] = v(`${n}'`);
-        for (const [n] of this.spec.sums)
-            after[n] = v(`${n}'`);
-        for (const [n, init] of this.spec.maps)
-            after[n] = new MapRef(`${n}'`, init);
-        for (const n of this.spec.lists ?? [])
-            after[n] = new ListRef(`${n}'`, v(`${n}_len'`));
-        for (const [n, places] of this.spec.signed ?? []) {
-            after[n] = this.signedValue(n, places, `${n}'`, `${n}$neg'`);
-            delete after[`${n}$neg`];
-        }
+        const after = this.afterEnv();
         const out = then(env, after), w = when ? { when: when(env).c } : {};
         const key = `key$${++keyCounter}`, src = { step: { then: then, ...(when ? { when: when } : {}) } };
         if (out instanceof Cond) {
@@ -945,19 +1000,7 @@ export class Rule {
     //   meter.stepsLaw('two requests spend at most 2m', 2, ({spent, m}, after) => after.spent.atMost(spent.plus(m).plus(m)))
     stepsLaw(name, k, then, when) {
         const env = this.env();
-        const after = {};
-        for (const [n] of this.spec.state)
-            after[n] = v(`${n}'`);
-        for (const [n] of this.spec.sums)
-            after[n] = v(`${n}'`);
-        for (const [n, init] of this.spec.maps)
-            after[n] = new MapRef(`${n}'`, init);
-        for (const n of this.spec.lists ?? [])
-            after[n] = new ListRef(`${n}'`, v(`${n}_len'`));
-        for (const [n, places] of this.spec.signed ?? []) {
-            after[n] = this.signedValue(n, places, `${n}'`, `${n}$neg'`);
-            delete after[`${n}$neg`];
-        }
+        const after = this.afterEnv();
         // The j-th request's values over marked names, renamed to the kernel's input@j once built.
         const mark = (j) => `${j}:`;
         const requests = Array.from({ length: k }, (_, j) => {
@@ -1019,10 +1062,23 @@ export class Rule {
         const is = which === 'params' ? [] : this.spec.inputs.flatMap(([n, k]) => k.assume(n));
         return [...ps, ...is].map(c => c.c);
     }
-    // A signed state variable's value over these names of its two parts.
-    signedValue(n, places, pos, neg) {
-        const i = new Int(v(pos), v(neg));
-        return places === undefined ? i : new Decimal(i, places);
+    // The state after a step, as a step law reads it: every state variable, sum, map and list, primed.
+    afterEnv() {
+        const after = {};
+        for (const [n] of this.spec.state)
+            after[n] = v(`${n}'`);
+        for (const [n] of this.spec.sums)
+            after[n] = v(`${n}'`);
+        for (const [n, init] of this.spec.maps)
+            after[n] = new MapRef(`${n}'`, init);
+        for (const n of this.spec.lists ?? [])
+            after[n] = new ListRef(`${n}'`, v(`${n}_len'`));
+        for (const [n, k] of this.spec.kinded ?? []) {
+            for (const part of k.vars(n))
+                delete after[part];
+            after[n] = k.value(n, primed);
+        }
+        return after;
     }
     // The values handed to the builders' callbacks.
     env(parts = {}) {
@@ -1047,9 +1103,10 @@ export class Rule {
                 out[n] = new ListRef(n, v(`${n}_len`));
             for (const [n] of this.spec.sums)
                 out[n] = v(n);
-            for (const [n, places] of this.spec.signed ?? []) {
-                out[n] = this.signedValue(n, places, n, `${n}$neg`);
-                delete out[`${n}$neg`];
+            for (const [n, k] of this.spec.kinded ?? []) {
+                for (const part of k.vars(n))
+                    delete out[part];
+                out[n] = k.value(n);
             }
         }
         if (parts.queries !== false)
@@ -1108,14 +1165,13 @@ export class Rule {
                 flags[n] = out;
         }
         const updates = { ...s.step?.(env) };
-        // A signed variable's update, as its two parts, normalized.
-        for (const [n, places] of s.signed ?? []) {
+        // A kinded variable's update, as its variables' terms.
+        for (const [n, k] of s.kinded ?? []) {
             const u = updates[n];
             if (u === undefined)
                 continue;
-            const i = normal(places === undefined ? Int.of(u) : new Decimal(Int.of(0), places).lift(u));
-            updates[n] = i.pos;
-            updates[`${n}$neg`] = i.neg;
+            delete updates[n];
+            Object.assign(updates, k.store(n, u));
         }
         const state = {}, maps = {};
         for (const [n, u] of Object.entries(updates)) {
@@ -1253,22 +1309,17 @@ export class Rule {
             if (sc.flags[n] !== (req[`?${n}`] === 1))
                 return `flag ${n}: its callback says ${sc.flags[n]}, the step decides ${req[`?${n}`] === 1}`;
         }
-        // The updates: each written value (an integer's or a decimal's as its count), every scalar not written kept, each map write.
+        // The updates: every state variable as its value is written (a kinded one through its kind's `store`, as the
+        // machine is built) or kept, and each map write.
         const updates = inScope(sc, () => s.step?.(this.env()) ?? {});
-        const signed = new Map(s.signed ?? []);
+        const written = { ...updates };
+        inScope(sc, () => { for (const [n, k] of s.kinded ?? [])
+            if (updates[n] !== undefined) {
+                delete written[n];
+                Object.assign(written, k.store(n, updates[n]));
+            } });
         for (const n of Object.keys(st.scalars)) {
-            if (n.endsWith('$neg') && signed.has(n.slice(0, -4)))
-                continue;
-            const u = updates[n], got = signed.has(n) ? next.scalars[n] - next.scalars[`${n}$neg`] : next.scalars[n];
-            let want;
-            if (u === undefined)
-                want = signed.has(n) ? st.scalars[n] - st.scalars[`${n}$neg`] : st.scalars[n];
-            else if (signed.has(n)) {
-                const i = signed.get(n) === undefined ? Int.of(u) : new Decimal(Int.of(0), signed.get(n)).lift(u);
-                want = both(i.pos.val, i.neg.val, (a, b) => a - b);
-            }
-            else
-                want = valOf(u);
+            const u = written[n], got = next.scalars[n], want = u === undefined ? st.scalars[n] : valOf(u);
             if (want === undefined)
                 continue;
             count();
@@ -1304,19 +1355,7 @@ export class Rule {
             const after = { ...sc, keys, vars: { ...sc.vars, ...Object.fromEntries(Object.entries(next.scalars).map(([n, x]) => [`${n}'`, x])) },
                 maps: { ...sc.maps, ...Object.fromEntries(Object.entries(next.maps).map(([n, cells]) => [`${n}'`, { cells, dflt: next.defaults?.[n] ?? m.maps?.[n] ?? 0 }])) } };
             const ok = inScope(after, () => {
-                const env = this.env(), afterEnv = {};
-                for (const [n] of s.state)
-                    afterEnv[n] = v(`${n}'`);
-                for (const [n] of s.sums)
-                    afterEnv[n] = v(`${n}'`);
-                for (const [n, init] of s.maps)
-                    afterEnv[n] = new MapRef(`${n}'`, init);
-                for (const n of s.lists ?? [])
-                    afterEnv[n] = new ListRef(`${n}'`, v(`${n}_len'`));
-                for (const [n, places] of s.signed ?? []) {
-                    afterEnv[n] = this.signedValue(n, places, `${n}'`, `${n}$neg'`);
-                    delete afterEnv[`${n}$neg`];
-                }
+                const env = this.env(), afterEnv = this.afterEnv();
                 const w = src.when ? src.when(env).ok : true;
                 return w === undefined ? undefined : w ? this.verdict(src.then(env, afterEnv), keys) : true;
             });
@@ -1373,13 +1412,14 @@ export class Rule {
             out[n] = new Map(Array.from({ length: bound + 1 }, (_, key) => [key, rand(2)]).filter(([, cell]) => cell === 1));
         return out;
     }
-    // The state's scalars as values: an integer's two parts as one signed number, a decimal as its number.
+    // The state's scalars as runtime values: each kinded variable as its kind decodes it (an integer as one signed
+    // number, a decimal as its number, a choice by name, a string as itself, none as null).
     decode(st) {
         const out = { ...st.scalars };
-        for (const [n, places] of this.spec.signed ?? []) {
-            const x = (st.scalars[n] ?? 0) - (st.scalars[`${n}$neg`] ?? 0);
-            out[n] = places === undefined ? x : x / 10 ** places;
-            delete out[`${n}$neg`];
+        for (const [n, k] of this.spec.kinded ?? []) {
+            for (const part of k.vars(n))
+                delete out[part];
+            out[n] = k.decode(n, st.scalars);
         }
         return out;
     }
@@ -1392,6 +1432,8 @@ export class Rule {
 }
 const encode = (kinds, values) => Object.assign({}, ...kinds.map(([n, k]) => k.encode(n, values[n])));
 export const rule = (name) => new Rule({ name, params: [], inputs: [], state: [], maps: [], flags: [], pre: [], assume: [], sums: [], queries: [] });
+// The kind a result field is kept in.
+const kindOf = (t) => (t instanceof Cond ? bool : t instanceof Int ? int : t instanceof Decimal ? decimal(t.places) : t instanceof Choice ? oneOf(...t.values) : t instanceof Str ? str({ like: t.patterns }) : nat);
 export class Fun {
     r;
     out;
@@ -1411,7 +1453,7 @@ export class Fun {
     result(env) {
         if (!this.out)
             throw new Error(`${this.name}: no result (returns)`);
-        return Object.fromEntries(Object.entries(this.out(env)).map(([k, t]) => [k, t instanceof Cond || t instanceof Int || t instanceof Decimal ? t : new Term(termOf(t))]));
+        return Object.fromEntries(Object.entries(this.out(env)).map(([k, t]) => [k, typeof t === 'number' ? lit(t) : t]));
     }
     // Whenever the arguments (and the result) meet `given`, the result meets `then`.
     law(name, given, then) {
@@ -1442,11 +1484,9 @@ export class Fun {
     // The one-step rule it compiles to: the result's fields are its state (named out.<field>, apart from the arguments).
     get rule() {
         const fields = Object.entries(this.result(this.r['env']({ flags: false, state: false, queries: false })));
-        const name = (k) => `out.${k}`, of = (pick) => Object.fromEntries(fields.filter(([, t]) => pick(t)).map(([k]) => [name(k), 0]));
-        let r = this.r.state(of(t => t instanceof Term || t instanceof Cond)).ints(of(t => t instanceof Int));
-        for (const places of new Set(fields.flatMap(([, t]) => (t instanceof Decimal ? [t.places] : []))))
-            r = r.decimals(places, of(t => t instanceof Decimal && t.places === places));
-        return r.step(env => Object.fromEntries(Object.entries(this.result(env)).map(([k, t]) => [name(k), t instanceof Cond ? count(t) : t])));
+        const name = (k) => `out.${k}`;
+        return this.r.state(Object.fromEntries(fields.map(([k, t]) => { const kind = kindOf(t); return [name(k), kind.from(kind.empty())]; })))
+            .step(env => Object.fromEntries(Object.entries(this.result(env)).map(([k, t]) => [name(k), t])));
     }
     compiledRule;
     // The result at these arguments (and params), from the compiled rule: numbers, and booleans for the conditions.
@@ -1455,7 +1495,7 @@ export class Fun {
         const { rule, gen } = this.compiledRule, ps = rule.encodeParams(params);
         const kinds = Object.entries(this.result(this.r['env']({ flags: false, state: false, queries: false })));
         const st = rule.decode(gen.step(ps, gen.init(ps), rule.encodeInput(values)));
-        return Object.fromEntries(kinds.map(([k, t]) => [k, t instanceof Cond ? st[`out.${k}`] === 1 : st[`out.${k}`]]));
+        return Object.fromEntries(kinds.map(([k]) => [k, st[`out.${k}`]]));
     }
 }
 export const fun = (name) => new Fun(rule(name));

package/dist/kernel/kernel.d.ts

@@ -20,6 +20,10 @@ export type Path = Map<string, {
 export declare const canon: (lin: Lin) => string;
 export declare const atomOf: (lin: Lin, holds: boolean) => Constraint;
 export declare function linear(e: E, path: Path): Lin | undefined;
+export declare const termColumn: (e: E) => string;
+export declare const columnTerm: (name: string) => E | undefined;
+export declare function decided(e: E, path: Path): boolean;
+export declare function termRows(name: string, path: Path): Lin[];
 export declare function truth(c: C, path: Path): boolean | undefined;
 export declare function facts(c: C, path: Path, positive?: boolean): Lin[];
 export declare function leafConstraints(goal: Goal, path: Path): Constraint[];
@@ -33,6 +37,7 @@ export type Subst = {
 export declare function substE(e: E, s: Subst): E;
 export declare function substC(c: C, s: Subst): C;
 export type Instances = Record<string, E[]>;
+export declare const stateName: (n: string, j: number) => string;
 export declare const assumed: (laws: Law[], instances: Instances) => C[];
 export declare function scope(m: Machine, laws?: Law[]): void;
 export declare const keyTerm: (e: E, key: string) => boolean;
@@ -104,6 +109,7 @@ export declare function checkStepLaws(m: Machine, laws: Law[], stepLaws: StepLaw
     perStep?: Record<string, Instances>;
     trees: Record<string, Tree>;
 }): boolean;
+export declare const stepZone: (m: Machine, k: number) => string[];
 export type Fold = {
     name: string;
     params: string[];