Give neural_attractor and neural_reversible a machine metadata field and eval_all skip entries, so python src/eval_all.py variants/ skips them cleanly instead of erroring (it scores fitness variants and skips standalone machines by that field). README sync: list both new machines in the variant table, intro, and repository layout; correct the standalone-machine count (5->7), the eval_all skip count (four->seven), and the universal-constructor family round-trip (23->26 files, 551->971 MB, both new files codec-verified byte-identical).

README.md

@@ -38,10 +38,12 @@ variants/neural_rv32.safetensors                                 RV32IM + F-subs
 variants/neural_matrix8.safetensors                              the CPU as one recurrent ternary matrix stack
 variants/neural_subleq8io.safetensors                            SUBLEQ host for the universal constructor
 variants/neural_reflect.safetensors                              interpreter whose state holds its own weights
+variants/neural_attractor.safetensors                            energy-based solver; a multiplier run backward factors
+variants/neural_reversible.safetensors                           reversible arithmetic core, a bijection with no erasure
 ```
 
-Five further machines are detailed in their own sections below, and together
-they carry the family from the smallest possible processor to three results
+Seven further machines are detailed in their own sections below, and together
+they carry the family from the smallest possible processor to several results
 about what a threshold network can be. `neural_subleq8` is a Turing-complete
 one-instruction computer whose entire control flow is a single threshold
 neuron. `neural_rv32` is a RISC-V processor (RV32IM plus an F subset) that
@@ -56,7 +58,13 @@ machine's weight file byte for byte, self-reproduction being the case where
 the description is its own. And `neural_reflect` is a universal interpreter
 over ternary threshold netlists: its fixed transition circuit evaluates a
 netlist held in the writable state, so the machine it runs is stored data that
-a program reads, edits, and reproduces.
+a program reads, edits, and reproduces. `neural_attractor` drops sequential
+control entirely: a circuit compiles to an energy function whose minimum is its
+consistent assignment, so clamping different wires runs the same network forward
+to evaluate, backward to invert (a multiplier run backward returns factors), or
+as a SAT solver. And `neural_reversible` makes the entire state transition a
+bijection, so no step erases information and the machine runs backward to
+reconstruct its input, a processor with no Landauer erasure floor.
 
 ---
 
@@ -352,7 +360,7 @@ Every weight and bias tensor in the canonical model fits in `int8`. The eval pip
 
 The 8-bit arithmetic and ALU tests use strategic sampling rather than the full 65,536-case sweep because exhaustive coverage at 8-bit is feasible but not necessary given that the circuits are constructed gate-by-gate. The 16-bit and 32-bit arithmetic tests sample edge cases only; full exhaustive coverage at those widths is infeasible without specialized hardware.
 
-`src/eval_all.py` runs the unified suite. Exit code is the number of failing variants (0 means all pass). **Testing is evaluation, not rebuilding**: `python src/eval_all.py variants/` scores all 18 fitness variants against the shipped weights in about two minutes (~6 s each, the composed float netlists evaluated in `NetlistEvaluator`'s leveled mode) and cleanly skips the four standalone machines. Rebuilding the models (`tools/build_all.py`, ~50 min for all 18) is a separate step, needed only when the circuit constructions in `src/build.py` change; routine verification never rebuilds. The batched evaluator is population-safe: every chained intermediate (carry, borrow, mux select) is computed per population slot, so `tools/prune_weights.py`'s parallel fitness screens are exact rather than slot-0 approximations.
+`src/eval_all.py` runs the unified suite. Exit code is the number of failing variants (0 means all pass). **Testing is evaluation, not rebuilding**: `python src/eval_all.py variants/` scores all 18 fitness variants against the shipped weights in about two minutes (~6 s each, the composed float netlists evaluated in `NetlistEvaluator`'s leveled mode) and cleanly skips the seven standalone machines. Rebuilding the models (`tools/build_all.py`, ~50 min for all 18) is a separate step, needed only when the circuit constructions in `src/build.py` change; routine verification never rebuilds. The batched evaluator is population-safe: every chained intermediate (carry, borrow, mux select) is computed per population slot, so `tools/prune_weights.py`'s parallel fitness screens are exact rather than slot-0 approximations.
 
 ---
 
@@ -516,8 +524,8 @@ then the byte-for-byte safetensors file of the host itself.
 
 The equality is machine-checked rather than observed on one run:
 
-- the recipe codec round-trips every file in the family (all 23 shipped
-  `.safetensors`, 551 MB, byte-identical and sha-verified);
+- the recipe codec round-trips every file in the family (all 26 shipped
+  `.safetensors`, 971 MB, byte-identical and sha-verified);
 - the constructor program is executed on three independently-verified
   backends — a pure-integer reference, the gate-graph `SubleqThresholdCPU`
   walking the shipped netlist, and the host itself compiled to recurrent
@@ -821,9 +829,10 @@ Loss components: BCE on output bits, BCE on extracted A and B bits (2× weight),
 
 ```
 neural_computer.safetensors         canonical model (32-bit, 64 KB, ~8.61M params)
-variants/                           18 fitness variants + 5 standalone machines
+variants/                           18 fitness variants + 7 standalone machines
                                     (neural_subleq8, neural_rv32, neural_matrix8,
-                                     neural_subleq8io, neural_reflect)
+                                     neural_subleq8io, neural_reflect,
+                                     neural_attractor, neural_reversible)
 src/                                the library (run scripts as `python src/<name>.py`)
   ├── build.py                      generator (one safetensors per invocation; also `subleq`, `rv32`)
   ├── quantize.py                   min integer dtypes + ternary verification/repair
@@ -835,12 +844,20 @@ src/                                the library (run scripts as `python src/<nam
   │                                 exhaustive equality suite and the analog crossbar simulation
   ├── constructor8.py               the neural_subleq8io host, the recipe codec, and the universal
   │                                 constructor / self-reproduction suite
-  └── reflect.py                    neural_reflect: a universal threshold interpreter whose state
-                                    holds its own gate table; universality / quine / matrix suites
+  ├── reflect.py                    neural_reflect: a universal threshold interpreter whose state
+  │                                 holds its own gate table; universality / quine / matrix suites
+  ├── attractor.py                  neural_attractor: energy-based solver (forward eval, inversion,
+  │                                 SAT) built from a QUBO gate-gadget compiler
+  ├── reversible.py                 neural_reversible: reversible threshold gates, Cuccaro ALU,
+  │                                 Bennett construction
+  ├── reversible_cpu.py             reversible register machine: bijective step, backward execution
+  └── reversible_prog.py            structured reversible programs (multiply, Fibonacci, Janus IF)
 tools/                              build_all.py (build + quantize + verify every profile),
                                     cpu_programs.py (assembler + CPU program suite), test_cpu.py
                                     (program suite vs a variant), play.py (interactive demo),
-                                    prune_weights.py (GPU-batched weight reduction)
+                                    prune_weights.py (GPU-batched weight reduction),
+                                    build_attractor.py / test_attractor.py (neural_attractor),
+                                    build_reversible.py (neural_reversible artifact)
 llm_integration/                    SmolLM2 extractor + circuit wrapper + training code
   ├── circuits.py                   FrozenThresholdCircuits (loads safetensors, exposes
   │                                 add_8bit / sub_8bit / mul_8bit / compare_*)

src/attractor.py

@@ -223,7 +223,7 @@ def to_tensors(circ: Circuit, io: dict):
     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),
+    meta = {"machine": "attractor", "n": str(circ.n), "const": str(circ.const),
             "io": json.dumps({k: v for k, v in io.items()})}
     return t, meta
 

src/eval_all.py

@@ -670,6 +670,8 @@ MACHINE_VERIFIER = {
     "matrix8": "matrix8.py",
     "subleq8io": "constructor8.py",
     "reflect": "reflect.py",
+    "attractor": "tools/test_attractor.py",
+    "reversible": "src/reversible.py",
 }
 
 

tools/build_reversible.py

@@ -52,7 +52,7 @@ def main() -> int:
 
     tensors = {"gate_code": codes, "gate_args": args, **_SUBSTRATE}
     import json
-    meta = {"width": str(WIDTH), "n_wires": str(n),
+    meta = {"machine": "reversible", "width": str(WIDTH), "n_wires": str(n),
             "a_bits": json.dumps(a_bits), "b_bits": json.dumps(b_bits),
             "carry": str(carry), "circuit": "in-place reversible adder b<-a+b"}
     save_file(tensors, OUT, metadata=meta)

variants/neural_attractor.safetensors

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

variants/neural_reversible.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9ee9363e618d246cc2009082e61ccc48fc237917d75231bb417e9175238073f1
-size 2304
+oid sha256:b77a985dea3104679d73cfaf20b9c3efc72646cd177412dbec41475a7a37d5c0
+size 2320