neural_attractor: an energy-based threshold computer where computation is relaxation to a ground state and the program is the coupling matrix. No program counter, no clock, no forward-only execution: clamp any subset of wires and relax. AND/OR/NOT energy gadgets (each zero iff the gate relation holds) make it universal by construction; forward evaluation is exact, and clamping outputs runs circuits backward (an 8x8 multiplier compiled to couplings factors 35=5x7, 143=11x13) or solves SAT. Module, tests, artifact builder, and the shipped coupling matrix.

README.md

@@ -457,6 +457,48 @@ noise margins. The processor is no longer *described by* a neural network; it
 
 ---
 
+## neural_attractor — computation as relaxation, run in any direction
+
+`neural_matrix8` still runs a program forward. `neural_attractor` drops the
+last of the von Neumann structure: no program counter, no clock, no forward-only
+execution. A computation is compiled into an energy function `E(s)` whose global
+minimum, with the known wires clamped, is the unique consistent assignment of the
+whole circuit. The program is the coupling matrix `Q` (with linear terms `L`);
+running is relaxation toward the minimum, and the relaxation update is itself a
+threshold neuron, `s_i <- H(-(L[i] + sum_j Q[i,j] s_j))`, so the machine is the
+same substrate, one weight matrix with no controller.
+
+Each gate contributes a gadget that is non-negative and equals zero exactly when
+the gate relation holds (binary variables): `AND` is `3z + xy - 2xz - 2yz`, `OR`
+is `x + y + z + xy - 2xz - 2yz`, `NOT` is `1 - x - z + 2xz`. Those are universal,
+so any circuit compiles and universality is a theorem about the gadgets rather
+than a hope about the dynamics. Forward evaluation is exact: clamp the inputs and
+propagate through the gate relations in topological order, landing on the
+energy-0 fixed point; the canonical form anneals the whole network to the same
+minimum.
+
+What no program counter can do falls out of clamping a different subset of wires:
+
+- **Run circuits backward.** Clamp a multiplier's product and relax over the
+  inputs, and the machine returns factors. The shipped `neural_attractor` is an
+  8x8 multiplier compiled to couplings (913 wires); it multiplies forward
+  bit-exactly and, run in reverse, factors (35 = 5 x 7, 143 = 11 x 13).
+- **Solve.** Clamp a CNF formula's output to 1 and the minimum is a satisfying
+  assignment, so the same object is a circuit evaluator and a SAT solver.
+
+The forward direction is exact and cheap; the backward and open-constraint modes
+are genuine annealed search, and that hardness is the point. Factoring is hard,
+and an exact integer-ternary substrate with structured gadgets, where the ground
+state sits at energy 0 by construction rather than being approximated by an
+analog annealer, is the interesting place to attack it.
+
+```bash
+python tools/build_attractor.py      # compile a multiplier to variants/neural_attractor.safetensors
+python tools/test_attractor.py       # forward eval, whole-network relaxation, factoring, SAT
+```
+
+---
+
 ## neural_subleq8io and the universal constructor — a machine that prints itself
 
 `neural_subleq8io` is the one-instruction machine extended with three

src/attractor.py

@@ -0,0 +1,277 @@
+"""Attractor computer: computation as relaxation of a threshold network.
+
+Every other machine in this repository is a stored-program computer whose gates
+happen to be threshold neurons: it has a program counter, a fetch, and an
+instruction stream. This one has none of those. A computation is compiled into
+an energy function E(s) whose global minimum, with the known wires clamped, is
+the unique consistent assignment of the whole circuit. The "program" is the
+coupling matrix Q (with linear terms L); running is relaxation toward the
+minimum. The relaxation update is itself a threshold neuron,
+
+    s_i <- H( -( L[i] + sum_j Q[i,j] s_j ) ),
+
+so the machine is the same substrate as the rest of the repo, one weight matrix
+iterated to a fixed point, with no controller.
+
+Each gate contributes a gadget that is >= 0 and equals 0 exactly when the gate
+relation holds (binary variables in {0,1}):
+
+    AND z=x&y : 3z + xy - 2xz - 2yz
+    OR  z=x|y : x + y + z + xy - 2xz - 2yz
+    NOT z=~x  : 1 - x - z + 2xz
+
+AND/OR/NOT are universal, so any circuit compiles, and universality of the
+machine is a theorem about the gadgets rather than a hope about the dynamics.
+
+Two things a program counter cannot do fall out of this:
+
+  * Evaluate in any direction. Clamp inputs and relax to read outputs; or clamp
+    outputs and relax to recover inputs. Running a multiplier backward is
+    integer factoring; running any predicate backward is search.
+  * Solve. Clamp a formula's output to 1 and the minimum is a satisfying
+    assignment, so the same object is a circuit evaluator and a SAT solver.
+
+Forward evaluation (inputs clamped) is exact and cheap: propagate through the
+gate relations in topological order, which lands on the energy-0 fixed point.
+Backward and open-constraint modes are genuine search, annealed over the free
+wires; that hardness is the point (factoring is hard), and an exact integer
+substrate with structured gadgets is the interesting place to attack it.
+"""
+from __future__ import annotations
+import math
+import random
+from collections import defaultdict
+from typing import Dict, List, Optional, Tuple
+
+
+class Circuit:
+    """Wire allocator and energy accumulator. Gates append exact QUBO gadgets
+    and record the relation for topological forward evaluation."""
+
+    def __init__(self) -> None:
+        self.n = 0
+        self.L: Dict[int, int] = defaultdict(int)
+        self.Q: Dict[Tuple[int, int], int] = defaultdict(int)
+        self.const = 0
+        self.gates: List[Tuple[str, int, Tuple[int, ...]]] = []
+
+    def wire(self) -> int:
+        i = self.n
+        self.n += 1
+        return i
+
+    def wires(self, k: int) -> List[int]:
+        return [self.wire() for _ in range(k)]
+
+    def _q(self, i: int, j: int, c: int) -> None:
+        if i == j:
+            self.L[i] += c
+        else:
+            self.Q[(min(i, j), max(i, j))] += c
+
+    def AND(self, x: int, y: int) -> int:
+        z = self.wire()
+        self.L[z] += 3
+        self._q(x, y, 1); self._q(x, z, -2); self._q(y, z, -2)
+        self.gates.append(("AND", z, (x, y)))
+        return z
+
+    def OR(self, x: int, y: int) -> int:
+        z = self.wire()
+        self.L[x] += 1; self.L[y] += 1; self.L[z] += 1
+        self._q(x, y, 1); self._q(x, z, -2); self._q(y, z, -2)
+        self.gates.append(("OR", z, (x, y)))
+        return z
+
+    def NOT(self, x: int) -> int:
+        z = self.wire()
+        self.const += 1
+        self.L[x] += -1; self.L[z] += -1
+        self._q(x, z, 2)
+        self.gates.append(("NOT", z, (x,)))
+        return z
+
+    def XOR(self, x: int, y: int) -> int:
+        return self.OR(self.AND(x, self.NOT(y)), self.AND(self.NOT(x), y))
+
+    def full_adder(self, x: int, y: int, cin: int) -> Tuple[int, int]:
+        axy = self.XOR(x, y)
+        s = self.XOR(axy, cin)
+        cout = self.OR(self.AND(x, y), self.AND(cin, axy))
+        return s, cout
+
+    # ---- energy + couplings ------------------------------------------------
+    def energy(self, s: List[int]) -> int:
+        e = self.const
+        for i, c in self.L.items():
+            e += c * s[i]
+        for (i, j), c in self.Q.items():
+            e += c * s[i] * s[j]
+        return e
+
+    def neighbors(self) -> Dict[int, List[Tuple[int, int]]]:
+        nbr: Dict[int, List[Tuple[int, int]]] = defaultdict(list)
+        for (i, j), c in self.Q.items():
+            nbr[i].append((j, c))
+            nbr[j].append((i, c))
+        return nbr
+
+    # ---- relaxation modes --------------------------------------------------
+    def forward_eval(self, clamp: Dict[int, int]) -> List[int]:
+        """Exact forward relaxation: propagate clamped inputs through the gate
+        relations in topological order onto the energy-0 fixed point."""
+        s = [0] * self.n
+        for w, v in clamp.items():
+            s[w] = v
+        for op, z, ins in self.gates:
+            if op == "AND":
+                s[z] = s[ins[0]] & s[ins[1]]
+            elif op == "OR":
+                s[z] = s[ins[0]] | s[ins[1]]
+            else:
+                s[z] = 1 - s[ins[0]]
+        return s
+
+    def relax_energy(self, clamp: Dict[int, int], sweeps: int = 4000,
+                     t0: float = 4.0, t1: float = 0.02, seed: int = 0
+                     ) -> Tuple[List[int], bool]:
+        """Canonical relaxation: anneal the full threshold network (every free
+        wire), tracking the lowest-energy state. Universal but hard; the exact
+        gadgets keep the target at energy 0."""
+        nbr = self.neighbors()
+        rng = random.Random(seed)
+        s = [rng.randint(0, 1) for _ in range(self.n)]
+        for w, v in clamp.items():
+            s[w] = v
+        free = [i for i in range(self.n) if i not in clamp]
+        best, best_e = list(s), self.energy(s)
+        for step in range(sweeps):
+            T = t0 * (t1 / t0) ** (step / max(1, sweeps - 1))
+            for _ in range(len(free)):
+                i = free[rng.randrange(len(free))]
+                field = self.L[i] + sum(c * s[j] for j, c in nbr[i])
+                dE = (1 - 2 * s[i]) * field
+                if dE <= 0 or rng.random() < math.exp(-dE / T):
+                    s[i] ^= 1
+            e = self.energy(s)
+            if e < best_e:
+                best, best_e = list(s), e
+                if best_e == 0:
+                    return best, True
+        return best, best_e == 0
+
+    def solve(self, free_inputs: List[int], fixed: Dict[int, int],
+              target: Dict[int, int], sweeps: int = 3000, restarts: int = 80,
+              seed: int = 0) -> Optional[List[int]]:
+        """Open-constraint relaxation over a chosen set of driver wires, with
+        the rest slaved through the circuit; anneal the output Hamming mismatch
+        to zero. Clamp outputs and pass the inputs here to run backward."""
+        rng = random.Random(seed)
+
+        def mism(vals: Dict[int, int]) -> int:
+            s = self.forward_eval({**fixed, **vals})
+            return sum(1 for w, v in target.items() if s[w] != v)
+
+        for _ in range(restarts):
+            vals = {w: rng.randint(0, 1) for w in free_inputs}
+            m = mism(vals)
+            if m == 0:
+                return self.forward_eval({**fixed, **vals})
+            for step in range(sweeps):
+                T = 2.0 * (0.02 / 2.0) ** (step / sweeps)
+                w = free_inputs[rng.randrange(len(free_inputs))]
+                vals[w] ^= 1
+                m2 = mism(vals)
+                if m2 <= m or rng.random() < math.exp(-(m2 - m) / T):
+                    m = m2
+                    if m == 0:
+                        return self.forward_eval({**fixed, **vals})
+                else:
+                    vals[w] ^= 1
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Circuit builders
+# ---------------------------------------------------------------------------
+def adder(bits: int) -> Tuple[Circuit, dict]:
+    c = Circuit()
+    xs, ys = c.wires(bits), c.wires(bits)
+    cin = c.wire()
+    outs, carry = [], cin
+    for k in range(bits):
+        s, carry = c.full_adder(xs[k], ys[k], carry)
+        outs.append(s)
+    return c, {"xs": xs, "ys": ys, "cin": cin, "sum": outs + [carry]}
+
+
+def multiplier(bits: int) -> Tuple[Circuit, dict]:
+    c = Circuit()
+    xs, ys = c.wires(bits), c.wires(bits)
+    zero = c.wire()
+    acc = [zero] * (2 * bits)
+    for i in range(bits):
+        carry = zero
+        for j in range(bits):
+            acc[i + j], carry = c.full_adder(acc[i + j], c.AND(xs[i], ys[j]), carry)
+        acc[i + bits] = carry
+    return c, {"xs": xs, "ys": ys, "zero": zero, "prod": acc}
+
+
+_OPCODE = {"AND": 0, "OR": 1, "NOT": 2}
+_OPNAME = {v: k for k, v in _OPCODE.items()}
+
+
+def to_tensors(circ: Circuit, io: dict):
+    """Serialize the coupling matrix (the program) and the gate list to tensors.
+    Q is stored sparsely as index pairs and integer values."""
+    import torch
+    qi = sorted(circ.Q)
+    q_idx = torch.tensor(qi if qi else [], dtype=torch.long).reshape(-1, 2)
+    q_val = torch.tensor([circ.Q[k] for k in qi], dtype=torch.long)
+    li = sorted(circ.L)
+    l_idx = torch.tensor(li, dtype=torch.long)
+    l_val = torch.tensor([circ.L[i] for i in li], dtype=torch.long)
+    g_op = torch.tensor([_OPCODE[op] for op, _, _ in circ.gates], dtype=torch.long)
+    g_out = torch.tensor([o for _, o, _ in circ.gates], dtype=torch.long)
+    g_in = torch.tensor([[ins[0], ins[1] if len(ins) > 1 else -1]
+                         for _, _, ins in circ.gates], dtype=torch.long).reshape(-1, 2)
+    t = {"Q_idx": q_idx, "Q_val": q_val, "L_idx": l_idx, "L_val": l_val,
+         "gate_op": g_op, "gate_out": g_out, "gate_in": g_in}
+    import json
+    meta = {"n": str(circ.n), "const": str(circ.const),
+            "io": json.dumps({k: v for k, v in io.items()})}
+    return t, meta
+
+
+def from_tensors(t: dict, meta: dict) -> Tuple[Circuit, dict]:
+    import json
+    c = Circuit()
+    c.n = int(meta["n"])
+    c.const = int(meta["const"])
+    for (i, j), v in zip(t["Q_idx"].tolist(), t["Q_val"].tolist()):
+        c.Q[(i, j)] = v
+    for i, v in zip(t["L_idx"].tolist(), t["L_val"].tolist()):
+        c.L[i] = v
+    for op, out, ins in zip(t["gate_op"].tolist(), t["gate_out"].tolist(), t["gate_in"].tolist()):
+        c.gates.append((_OPNAME[op], out, tuple(x for x in ins if x >= 0)))
+    return c, json.loads(meta["io"])
+
+
+def cnf(clauses: List[List[int]], n_vars: int) -> Tuple[Circuit, dict]:
+    """Compile a CNF formula. Literals are +v (var v) or -v (negation), v>=1.
+    Returns the circuit, the variable wires, and the wire that is 1 iff the
+    formula is satisfied. Clamp that wire to 1 and relax to find a model."""
+    c = Circuit()
+    var = {v: c.wire() for v in range(1, n_vars + 1)}
+    clause_ws = []
+    for cl in clauses:
+        lits = [var[abs(l)] if l > 0 else c.NOT(var[abs(l)]) for l in cl]
+        acc = lits[0]
+        for w in lits[1:]:
+            acc = c.OR(acc, w)
+        clause_ws.append(acc)
+    sat = clause_ws[0]
+    for w in clause_ws[1:]:
+        sat = c.AND(sat, w)
+    return c, {"vars": var, "sat": sat}

tools/build_attractor.py

@@ -0,0 +1,68 @@
+"""Compile a circuit into the attractor computer's coupling matrix and ship it
+as variants/neural_attractor.safetensors, a peer artifact to the other machines:
+here the weights are the couplings Q (with linear terms L), and running is
+relaxation. Round-trips the file and checks forward evaluation and a backward
+inversion (factoring)."""
+from __future__ import annotations
+import os
+import random
+import sys
+
+import torch
+from safetensors.torch import save_file, load_file
+from safetensors import safe_open
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(ROOT, "src"))
+from attractor import multiplier, to_tensors, from_tensors
+
+OUT = os.path.join(ROOT, "variants", "neural_attractor.safetensors")
+BITS = 8
+
+
+def main() -> int:
+    c, io = multiplier(BITS)
+    tensors, meta = to_tensors(c, io)
+    save_file(tensors, OUT, metadata=meta)
+    size = os.path.getsize(OUT)
+    print(f"Built {os.path.relpath(OUT, ROOT)}: {BITS}x{BITS} multiplier as couplings")
+    print(f"  wires={c.n}  Q entries={len(c.Q)}  L entries={len(c.L)}  size={size/1024:.1f} KB")
+
+    # round-trip
+    t = load_file(OUT)
+    with safe_open(OUT, framework="pt") as f:
+        m = f.metadata()
+    c2, io2 = from_tensors(t, m)
+    xs, ys, zero, prod = io2["xs"], io2["ys"], io2["zero"], io2["prod"]
+
+    rng = random.Random(0)
+    bad = 0
+    for _ in range(200):
+        a, b = rng.randint(0, 255), rng.randint(0, 255)
+        clamp = {zero: 0}
+        for k in range(BITS):
+            clamp[xs[k]] = (a >> k) & 1
+            clamp[ys[k]] = (b >> k) & 1
+        s = c2.forward_eval(clamp)
+        got = sum(s[w] << k for k, w in enumerate(prod))
+        if got != a * b or c2.energy(s) != 0:
+            bad += 1
+    print(f"  round-trip forward multiply (200 cases): {'OK' if bad == 0 else f'FAIL({bad})'}")
+
+    # backward: factor a small product through the loaded couplings
+    N = 35
+    target = {prod[k]: (N >> k) & 1 for k in range(2 * BITS)}
+    s = c2.solve(xs + ys, {zero: 0}, target, sweeps=2500, restarts=120, seed=N)
+    if s is not None:
+        fa = sum(s[xs[k]] << k for k in range(BITS))
+        fb = sum(s[ys[k]] << k for k in range(BITS))
+        print(f"  round-trip backward factor {N}: {fa} x {fb} {'OK' if fa * fb == N else 'WRONG'}")
+        ok = fa * fb == N
+    else:
+        print(f"  round-trip backward factor {N}: not found")
+        ok = False
+    return 0 if (bad == 0 and ok) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tools/test_attractor.py

@@ -0,0 +1,120 @@
+"""Exercise the attractor computer: exact forward evaluation, the canonical
+whole-network energy relaxation, backward inversion (factoring), and SAT
+solving (universality of the solve direction)."""
+from __future__ import annotations
+import os
+import random
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+from attractor import Circuit, adder, multiplier, cnf
+
+
+def test_forward():
+    ok = True
+    for bits in (4, 8):
+        c, io = adder(bits)
+        rng = random.Random(bits)
+        bad = 0
+        for _ in range(300):
+            a, b = rng.randint(0, (1 << bits) - 1), rng.randint(0, (1 << bits) - 1)
+            clamp = {io["cin"]: 0}
+            for k in range(bits):
+                clamp[io["xs"][k]] = (a >> k) & 1
+                clamp[io["ys"][k]] = (b >> k) & 1
+            s = c.forward_eval(clamp)
+            got = sum(s[w] << k for k, w in enumerate(io["sum"]))
+            if got != a + b or c.energy(s) != 0:
+                bad += 1
+        print(f"  forward adder {bits}-bit: {'OK' if bad == 0 else f'FAIL({bad})'}")
+        ok &= bad == 0
+    for bits in (3, 5):
+        c, io = multiplier(bits)
+        rng = random.Random(100 + bits)
+        bad = 0
+        for _ in range(300):
+            a, b = rng.randint(0, (1 << bits) - 1), rng.randint(0, (1 << bits) - 1)
+            clamp = {io["zero"]: 0}
+            for k in range(bits):
+                clamp[io["xs"][k]] = (a >> k) & 1
+                clamp[io["ys"][k]] = (b >> k) & 1
+            s = c.forward_eval(clamp)
+            got = sum(s[w] << k for k, w in enumerate(io["prod"]))
+            if got != a * b or c.energy(s) != 0:
+                bad += 1
+        print(f"  forward multiplier {bits}-bit: {'OK' if bad == 0 else f'FAIL({bad})'}")
+        ok &= bad == 0
+    return ok
+
+
+def test_energy_relax():
+    """The canonical form: anneal the whole network (no propagation shortcut)."""
+    c, io = adder(4)
+    rng = random.Random(3)
+    bad = 0
+    for _ in range(20):
+        a, b = rng.randint(0, 15), rng.randint(0, 15)
+        clamp = {io["cin"]: 0}
+        for k in range(4):
+            clamp[io["xs"][k]] = (a >> k) & 1
+            clamp[io["ys"][k]] = (b >> k) & 1
+        conv = False
+        for attempt in range(4):                 # annealers restart
+            s, conv = c.relax_energy(clamp, sweeps=6000, seed=rng.randint(0, 1 << 30))
+            got = sum(s[w] << k for k, w in enumerate(io["sum"]))
+            if conv and got == a + b:
+                break
+        if not conv:
+            bad += 1
+    print(f"  whole-network energy relaxation (4-bit adder, 20 cases): "
+          f"{'OK' if bad == 0 else f'reached ground state in {20 - bad}/20'}")
+    return bad == 0
+
+
+def test_factor():
+    ok = True
+    for bits, targets in ((4, [15, 35, 143]), (5, [21, 55, 91])):
+        c, io = multiplier(bits)
+        for N in targets:
+            target = {io["prod"][k]: (N >> k) & 1 for k in range(2 * bits)}
+            s = c.solve(io["xs"] + io["ys"], {io["zero"]: 0}, target, seed=N)
+            if s is None:
+                print(f"  factor {N}: not found")
+                ok = False
+                continue
+            a = sum(s[io["xs"][k]] << k for k in range(bits))
+            b = sum(s[io["ys"][k]] << k for k in range(bits))
+            good = a * b == N and 1 < a < N and 1 < b < N
+            print(f"  factor {N} ({bits}x{bits}): {a} x {b} {'OK' if a * b == N else 'WRONG'}")
+            ok &= a * b == N
+    return ok
+
+
+def test_sat():
+    # (x1 | x2 | ~x3) & (~x1 | x3) & (x2 | x3) & (~x2 | ~x3), a satisfiable 3-SAT.
+    clauses = [[1, 2, -3], [-1, 3], [2, 3], [-2, -3]]
+    c, io = cnf(clauses, 3)
+    s = c.solve(list(io["vars"].values()), {}, {io["sat"]: 1}, seed=1)
+    if s is None:
+        print("  SAT solve: no model found")
+        return False
+    assign = {v: s[w] for v, w in io["vars"].items()}
+    sat = all(any((assign[abs(l)] == 1) if l > 0 else (assign[abs(l)] == 0) for l in cl)
+              for cl in clauses)
+    print(f"  SAT solve: model {assign} {'satisfies' if sat else 'FAILS'} the formula")
+    return sat
+
+
+if __name__ == "__main__":
+    print("Attractor computer\n" + "=" * 40)
+    print("Forward evaluation (exact, energy 0):")
+    a = test_forward()
+    print("Canonical relaxation:")
+    b = test_energy_relax()
+    print("Backward inversion (factoring by relaxation):")
+    c_ = test_factor()
+    print("SAT (clamp output to 1, relax to a model):")
+    d = test_sat()
+    print("=" * 40)
+    print("ALL PASS" if (a and b and c_ and d) else "FAILURES")
+    sys.exit(0 if (a and b and c_ and d) else 1)

variants/neural_attractor.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad9bb1b7bb6110bc76fc2f946f822c7bc80dbba9673b2547a780b56690938150
+size 95968