Store the host in a two-head machine of 4096 cells so that it reproduces itself by the dynamics, prove the machine's netlist for every window size, add figures and the layouts behind the digests, and remove the interpreter tower and the verification tiers

README.md

@@ -574,14 +574,18 @@ host, its initial memory and its own description tape; each generation is
 instantiated from the bytes the last one emitted, by parsing that output,
 rebuilding the netlist from its first field, and building the evaluator from
 that netlist. It also shows where the restriction to {-1, 0, 1} is paid for,
-that a fixed ternary network of 45,891 units, the two-head machine of
+and that a fixed ternary network, the two-head machine of
 `src/twohead_net.py`, holds a stored network in its state and evaluates one
-record per step, that an organism of 133 records on it translates a description
-of 2930 bits into the idle bank, copies the description and hands over, so that
-started on its own description it reproduces in every generation, the proofs of
-which are checked in Rocq in `rocq/`, that a larger record interpreter of
-`neural_reflect` runs a netlist realizing a smaller one, and that the
-constructor itself runs as a netlist stored in that interpreter's state. Its robustness section gives the margin every orbit has
+record per step, which `rocq/` proves for every window of 2^α cells, bank and
+tape. The host itself, compiled by `src/stored_host.py` into 36,074 records of
+two inputs with records that load its memory, its tape device and a hand-over,
+and stored in the member with 4096 cells, runs the 27-instruction program on a
+recipe for its own records: it writes them into the idle bank, copies the recipe
+and hands control to the copy, so that it reproduces itself, weights included,
+by the dynamics alone; `src/stored_host_run.c` runs three generations of
+79,464,240,088 steps each. An organism of 133 records on the member with 64
+cells does the same with a description code of its own, every generation of it
+proved in Rocq. Its robustness section gives the margin every orbit has
 against perturbation, a certificate of the leakage an orbit tolerates from the
 inputs active along it, and the amplified host of `src/redundant.py`: every row
 of the levelized host replaced by r rows reading all r copies of its inputs,
@@ -590,17 +594,11 @@ wrong copies meet, with a probability of second order that the paper bounds, and
 completes the self-reproducing run under read noise at levels where the host
 fails within its first bytes.
 
-`python src/verify.py` audits every statement of the paper, and `--tier 2` adds
-every construction end to end; the checks of a tier run concurrently. `--tier 3` runs
-the self-reproducing instance on the threshold evaluators, the perturbation
-experiments and the amplified host, whose cost belongs to the object: one
-generation is 1,664,939 steps of a map of 41,967 units, and the amplified host
-reproduces itself in 33,796,449 steps of 125,901 units. The scripts that produce
-every figure are `src/selfrep.py`, `src/netlist_io.py`, `src/host_family.py`,
+The scripts that produce every figure are `src/selfrep.py`, `src/netlist_io.py`, `src/host_family.py`,
 `src/paper_stats.py`, `src/paper_verify.py`, `src/paper_runs.py`,
-`src/twohead.py`, `src/twohead_net.py`, `src/check_c.py`, `src/hierarchy.py`,
-`src/hosted_constructor.py`, `src/throughput.py`, `src/noise.py`,
-`src/redundant.py`, `src/fanin2.py`, `src/neuromorphic.py` and the
+`src/twohead.py`, `src/twohead_net.py`, `src/stored_host.py`,
+`src/stored_host_run.c`, `src/check_c.py`, `src/throughput.py`, `src/noise.py`,
+`src/redundant.py`, `src/neuromorphic.py` and the
 `src/check_*.py` set, and their records are in `paper/runs/`; `rocq/` holds the
 Rocq development, which `src/check_rocq.py` builds.
 
@@ -995,7 +993,7 @@ src/                                the library (run scripts as `python src/<nam
   │                                 program P*, the framing maps, and three evaluators
   ├── canonical.py                  deterministic safetensors writer (pinned key and tensor order)
   ├── paper_stats.py                unit counts, levelization sizes, effective fan-in
-  ├── paper_verify.py               codec, framing, serialization, datapath, interpreter
+  ├── paper_verify.py               codec, framing, serialization, datapath, levelization
   ├── paper_runs.py                 self-description, three generations, lockstep
   ├── host_family.py                the host family H_A: a constant-depth SUBLEQ step for
   │                                 every word width, and its serialization in build order
@@ -1004,23 +1002,22 @@ src/                                the library (run scripts as `python src/<nam
   ├── check_c.py                    the host on the evaluator in C
   ├── twohead.py                    the two-head machine, transcribed, the description code
   │                                 and the translating organism; writes rocq/Organism.v
-  ├── twohead_net.py                the two-head machine as a ternary netlist N_{G,L}: its
-  │                                 check, its file, the organism on it in C, and the
-  │                                 comparison with the netlist extracted from rocq/
+  ├── twohead_net.py                the two-head machine as a ternary netlist N_{G,L} for a window
+  │                                 of 2^α cells: its check, its file, the organism on it in C,
+  │                                 and the comparison with the netlist extracted from rocq/
   ├── twohead_lockstep.c            the organism on N_{G,L} beside the transcription, in C
+  ├── stored_host.py                the host compiled into 36,074 records of the two-head machine
+  │                                 with 4096 cells: one pass against the host's step and device,
+  │                                 the image and its recipe, and its generations
+  ├── stored_host_run.c             the stored host's generations on the two-head machine, in C
   ├── restore_bound.c               the restoration bound of the amplified host along the orbit
   ├── check_rocq.py                 builds rocq/ and prints the assumptions of its theorems
   ├── independent/                  separate code written from the paper's definitions: the host
-  │                                 family, the levelization, the record interpreter, a noise
-  │                                 simulator in C, weight error, and the neuromorphic datapath
+  │                                 family, the levelization, a noise simulator in C, weight
+  │                                 error, and the neuromorphic datapath
   ├── redundant.py                  the amplified host N_r: r-fold redundancy with the restoring
   │                                 organ inside every unit, its self-reproduction, its runs
   │                                 under read noise
-  ├── fanin2.py                     rewrites a netlist to effective fan-in two
-  ├── hierarchy.py                  a larger interpreter interpreting a netlist realizing a
-  │                                 smaller one
-  ├── hosted_constructor.py         the universal constructor as a netlist stored in the
-  │                                 interpreter, with tape, output word and device in signals
   ├── noise.py                      read noise on the self-reproducing run, the deviation curve
   │                                 against the bounds, weight error with zero-entry leakage, the
   │                                 active-input counts that certify an orbit
@@ -1030,8 +1027,9 @@ src/                                the library (run scripts as `python src/<nam
                                     framing, serialization, all 29 machines
 paper/                              the manuscript, and the record of every run it reports
 rocq/                               Rocq proofs: the netlist of the two-head machine computes its
-                                    step, the organism builds every image from any description
-                                    of it and reproduces in every generation
+                                    step for every window of 2^α cells, the organism builds every
+                                    image from any description of it and reproduces in every
+                                    generation
 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),

paper/README.md

@@ -9,37 +9,11 @@ universal_construction_ternary.pdf    typeset
 runs/                                 the record written by each script
 ```
 
-## Reproducing it
-
-```bash
-python src/verify.py             # the statements
-python src/verify.py --tier 2    # and every construction, end to end
-python src/verify.py --tier 3    # and the full-scale runs
-```
-
-Tier one is an exhaustive or near-exhaustive audit of every definition, lemma,
-proposition and theorem, and none of its checks runs the full instance. Tier two
-executes every construction end to end: the self-describing instance and three
-generations of the self-reproducing instance on the integer reference, the
-constructor on four machines of the family through the netlist that
-`variants/neural_subleq8io_netlist.safetensors` denotes, the record interpreters
-of Section 9, the translating organism on the two-head machine and on its
-netlist in C, and the Rocq development of Sections 7 and 8, which needs Rocq 9.1
-and ocamlfind on the PATH. The two together take about forty minutes and cover
-every claim the paper makes.
+## What each script establishes
 
-Tier three runs the self-reproducing instance itself on the threshold
-evaluators, runs the constructor on all twenty-nine machines of the artifact,
-carries out the perturbation experiments and the orbit certificate, and runs
-the amplified host: its exact self-reproduction on the evaluator in C, the
-self-reproducing instance of the host on it under read noise, its deviation
-curve, and the correction of single wrong copies. Its cost belongs to the object and not to the implementation: one
-generation is 1,664,939 steps of a map of 41,967 units, that is 6.99e10 unit
-evaluations, and the amplified host reproduces itself in 33,796,449 steps of
-125,901 units. `runs/paper_throughput.json` holds the rate of each evaluator, so
-the cost of any one run is a multiplication.
+Each script runs on its own and writes its record to `runs/`; `src/check_rocq.py`
+needs Rocq 9.1 and ocamlfind on the PATH.
 
-## What each script establishes
 
 | Script | Record | Establishes |
 |---|---|---|
@@ -61,22 +35,19 @@ the cost of any one run is a multiplication.
 | `src/check_ternarity.py` | `paper_ternarity.json` | no ternary unit computes the branch predicate |
 | `src/check_environment.py` | `paper_environment.json` | the cost of the environment against the cost of the network |
 | `src/check_sigma.py` | — | sigma is a function, injective, and inverted by the parser |
-| `src/fanin2.py` | `paper_fanin2.json` | the fan-in-two rewriting, on the host, the interpreter and every small ternary unit |
 | `src/check_family.py` | `paper_runs_family.json` | the constructor emits all 29 machines |
 | `src/check_family_gate.py` | `paper_runs_family_gate.json` | four of them on the netlist of sigma |
-| `src/check_interp.py` | `paper_interp.json` | the record interpreter's netlist against its definition |
 | `src/check_c.py` | `paper_c_evaluator.json` | the host on the evaluator in C, `src/netlist_eval.c` |
 | `src/check_host_fold.py` | `paper_host_fold.json` | the folded host family, depth 11, against SUBLEQ_A for A = 3 to 12 |
 | `src/twohead.py` | `paper_twohead.json` | the translating organism on the two-head machine, three generations |
-| `src/twohead_net.py` | `paper_twohead_net.json` | the netlist N_{G,L} against the machine, its file, the organism on it in C, and the netlist extracted from Rocq |
-| `src/check_rocq.py` | `paper_rocq.json` | the Rocq development of `rocq/`: the netlist computes the step, construction and self-reproduction by the dynamics |
-| `src/hierarchy.py` | `paper_hierarchy.json` | a larger interpreter runs a smaller one transition by transition |
-| `src/hosted_constructor.py` | `paper_hosted.json` | the constructor as a netlist stored in the interpreter |
+| `src/twohead_net.py` | `paper_twohead_net.json` | the netlist N_{G,L} against the machine for windows of 64 and 4096 cells, its file, the organism on it in C, and the netlist extracted from Rocq |
+| `src/stored_host.py`, `src/stored_host_run.c` | `paper_stored_host.json` | the host compiled into records of the two-head machine: one pass against the host's step and its device, the image and its recipe, three generations in C |
+| `src/check_rocq.py` | `paper_rocq.json` | the Rocq development of `rocq/`: the netlist computes the step for every window, construction and self-reproduction by the organism |
 | `src/throughput.py` | `paper_throughput.json` | the rate of each evaluator |
 | `src/noise.py` | `paper_noise_*.json` | read noise, the deviation curve, weight error with leakage, the active-input counts of the orbit certificate |
 | `src/redundant.py` | `paper_redundant_*.json` | the amplified host N_3: one step against SUBLEQ on replicated states, the margin 3/2, exact self-reproduction in C, the run under noise, the deviation curve and its bound by layer, the failure rate of the state read by majority and the restoration bound, computed by `src/restore_bound.c` |
 | `src/neuromorphic.py` | `paper_neuromorphic.json` | the datapath on the Loihi and Akida neuron models |
-| `src/independent/*.py`, `nsim.c` | `independent_*.json` | separate code written from the paper's definitions: H_A rebuilt from Construction 3.8 for A = 3 to 12, Lev(N_host) from sigma, Definition 9.1 with the hierarchy and the hosted constructor, Tables 4 to 7 with a separate noise simulator, and the datapath on Loihi and Akida |
+| `src/independent/*.py`, `nsim.c` | `independent_*.json` | separate code written from the paper's definitions: H_A rebuilt from Construction 3.8 for A = 3 to 12, Lev(N_host) from sigma, Tables 3 to 6 with a separate noise simulator, and the datapath on Loihi and Akida |
 
 `src/neuromorphic.py run` needs Lava, which requires Python 3.10; everything
 else runs in the environment of the repository.

paper/runs/independent_interpreter.json

@@ -1,40 +0,0 @@
-{
- "hierarchy": {
-  "small_units": 816,
-  "small_state_bits": 131,
-  "fanin2_units": 1403,
-  "signals": 1534,
-  "changed": 35,
-  "records": 1438,
-  "big": {
-   "A": 17,
-   "G": 2088,
-   "b": 62,
-   "span": 1616
-  },
-  "states": 48,
-  "passes": 4,
-  "disagree": 0,
-  "seconds": 5.6
- },
- "hosted": {
-  "records": 494,
-  "noops": 41,
-  "tail_noops": true,
-  "decode_matches": true,
-  "recipes": 41,
-  "recipes_ok": 41,
-  "first": {
-   "recipe_len": 9,
-   "out_len": 12,
-   "steps": 83,
-   "passes": 83,
-   "applications": 44358,
-   "ok": true
-  },
-  "random_states": 2000,
-  "random_halting_steps": 297,
-  "random_disagree": 0,
-  "seconds": 20.4
- }
-}

paper/runs/paper_fanin2.json

@@ -1,27 +0,0 @@
-{
- "small_units": 664,
- "small_unit_failures": 0,
- "netlists": {
-  "N_host": {
-   "units": 17598,
-   "units_fanin2": 33568,
-   "shapes_above_two": {
-    "and": 821,
-    "or": 70,
-    "threshold": 15
-   },
-   "agrees_on_random_inputs": true
-  },
-  "N_U": {
-   "units": 13034,
-   "units_fanin2": 40081,
-   "shapes_above_two": {
-    "and": 3091,
-    "or": 43
-   },
-   "agrees_on_random_inputs": true
-  }
- },
- "seconds": 7.610988596003153,
- "ok": true
-}

paper/runs/paper_hierarchy.json

@@ -1,33 +0,0 @@
-{
- "small": {
-  "S": 128,
-  "G": 3,
-  "units": 816,
-  "units_fanin2": 1403,
-  "signals": 1534,
-  "state_bits": 131
- },
- "big": {
-  "S": 131072,
-  "G": 2088,
-  "b": 62,
-  "span": 1616,
-  "units": 148571,
-  "layers": 65,
-  "Q_bits": 129456
- },
- "records": 1438,
- "copy_records": 35,
- "states": 48,
- "pass_steps": 2088,
- "transitions": 4,
- "mismatches_per_transition": [
-  0,
-  0,
-  0,
-  0
- ],
- "exact": true,
- "mismatched_coordinates": 0,
- "seconds": 62.78045246200054
-}

paper/runs/paper_hosted.json

@@ -1,27 +0,0 @@
-{
- "records": 494,
- "record_semantics_ok": true,
- "S": 32768,
- "G": 535,
- "b": 56,
- "span": 2808,
- "units": 59348,
- "layers": 61,
- "memory_bytes": 128,
- "tape_bytes": 9,
- "target_bytes": 12,
- "target": "ABCCCCCCCCDE",
- "instructions": 83,
- "reference_instructions": 83,
- "interpreter_steps": 44405,
- "emitted": "ABCCCCCCCCDE",
- "exact": true,
- "memory_matches_reference": true,
- "head": 9,
- "random_states_records": 2000,
- "random_states_records_wrong": 0,
- "random_states_netlist": 256,
- "random_states_netlist_wrong": 0,
- "seconds": 157.594675832981,
- "ok": true
-}

paper/runs/paper_interp.json

@@ -1,20 +0,0 @@
-{
- "members": [
-  {
-   "A": 10,
-   "S": 1024,
-   "G": 11,
-   "banks": 2,
-   "units": 13034,
-   "fields": 576,
-   "fields_wrong": 0,
-   "random": 4096,
-   "random_wrong": 0,
-   "halted_not_fixed": 0,
-   "counter_wrong": 0,
-   "ok": true,
-   "seconds": 7.045043751000776
-  }
- ],
- "ok": true
-}

paper/runs/paper_lev.json

@@ -7,8 +7,5 @@
  "nonternary_layers": 0,
  "noninteger_bias_layers": 0,
  "min_margin": 0.5,
- "max_noninteger": 0.0,
- "u_states": 64,
- "u_gates": 13034,
- "u_agree": true
+ "max_noninteger": 0.0
 }

paper/runs/paper_rocq.json

@@ -1,10 +1,12 @@
 {
  "rocq": "The Rocq Prover, version 9.1.1",
  "files": 25,
- "build_seconds": 220.6,
+ "build_seconds": 233.8,
  "theorems": {
   "PhysMain.netlist_step": "closed",
+  "PhysMain.netlist_step64": "closed",
   "PhysFacts.phys_size": "closed",
+  "PhysFacts.phys_size64": "closed",
   "PhysFacts.phys_ternary": "closed",
   "NetMain.network_orbit": "closed",
   "NetMain.network_reproduces": "closed",

paper/runs/paper_stats.json

@@ -128,105 +128,5 @@
    "128": 8,
    "256": 40
   }
- },
- "lev_U": {
-  "depth": 53,
-  "gates": 13002,
-  "netlist_gates": 13034,
-  "state_bits": 1029,
-  "widths": [
-   1029,
-   1948,
-   1957,
-   1500,
-   1487,
-   1074,
-   1104,
-   1126,
-   1096,
-   1099,
-   1093,
-   1096,
-   1090,
-   1093,
-   1087,
-   1090,
-   1084,
-   1087,
-   1081,
-   1084,
-   1078,
-   1081,
-   1075,
-   1078,
-   1072,
-   1072,
-   1069,
-   4111,
-   4111,
-   3089,
-   2065,
-   2075,
-   2071,
-   2071,
-   2069,
-   2070,
-   2067,
-   2068,
-   2064,
-   2066,
-   2062,
-   2063,
-   2060,
-   2059,
-   2057,
-   2057,
-   2056,
-   2056,
-   2055,
-   1031,
-   1030,
-   1039,
-   1038,
-   1029
-  ],
-  "M": 86490,
-  "dense_entries": 160865677,
-  "identity_units": 73488,
-  "new_units": 13002,
-  "max_fanin_netlist": 1024,
-  "nonzero_weights_netlist": 51557,
-  "bias_min": -10,
-  "bias_max": 1,
-  "fanin_hist": {
-   "1": 1494,
-   "2": 8374,
-   "3": 1,
-   "4": 12,
-   "5": 1,
-   "6": 1,
-   "7": 1,
-   "8": 1,
-   "9": 1,
-   "10": 3073,
-   "11": 41,
-   "1024": 2
-  }
- },
- "U_cfg": {
-  "S": 1024,
-  "G": 11,
-  "F": 2,
-  "BB": 4,
-  "banks": 2,
-  "R": 41,
-  "ACC": 6,
-  "SLOT": 13,
-  "A": 10,
-  "NET0": 122,
-  "NET1": 573,
-  "WORK_BASE": 16,
-  "span": 1024,
-  "STATE_BITS": 1029
  }
 }

paper/runs/paper_stored_host.json

@@ -0,0 +1,70 @@
+{
+ "run": {
+  "records": 36074,
+  "window_cells": 2896,
+  "record_bits": 44,
+  "bank_bits": 1587256,
+  "image_bytes": 198407,
+  "tau_bytes": 199971,
+  "passes_expected": 2202812,
+  "generations": [
+   {
+    "generation": 1,
+    "steps": 79464240088,
+    "passes": 2202812,
+    "kappa": 1,
+    "bank_holds_image": 1,
+    "tape_holds_tau": 1,
+    "heads": [
+     0,
+     0,
+     0,
+     0
+    ],
+    "window_fnv": "d17d72606006fc62"
+   },
+   {
+    "generation": 2,
+    "steps": 79464240088,
+    "passes": 2202812,
+    "kappa": 0,
+    "bank_holds_image": 1,
+    "tape_holds_tau": 1,
+    "heads": [
+     0,
+     0,
+     0,
+     0
+    ],
+    "window_fnv": "e3a2c10c6eddcef2"
+   },
+   {
+    "generation": 3,
+    "steps": 79464240088,
+    "passes": 2202812,
+    "kappa": 1,
+    "bank_holds_image": 1,
+    "tape_holds_tau": 1,
+    "heads": [
+     0,
+     0,
+     0,
+     0
+    ],
+    "window_fnv": "d17d72606006fc62"
+   }
+  ],
+  "seconds": 534.3,
+  "sha256_image": "7a769aa264a89860149962d7e98f8b2a5cb34ceb7778e88bcbffdccdc0996154",
+  "sha256_tau": "fb23d9b4b41cd5d0576bce37d0cd53a0f63f33de6d4895f2e784eb1148387185",
+  "state_after_3_equals_after_1": 1,
+  "every_generation_exact": true
+ },
+ "pass_check": {
+  "trials": 300,
+  "disagreements": 0,
+  "records": 36074,
+  "window_cells": 2896,
+  "seconds": 131.8
+ }
+}

paper/runs/paper_twohead_net.json

@@ -12,13 +12,26 @@
    "states": 20,
    "disagreements": 0
   },
+  "wide": {
+   "alpha": 12,
+   "G": 5,
+   "L": 40,
+   "states": 40,
+   "disagreements": 0,
+   "netlist": {
+    "units": 34957,
+    "edges": 201434,
+    "depth": 15,
+    "state_bits": 4613
+   }
+  },
   "netlist": {
    "units": 45891,
    "edges": 99602,
    "depth": 15,
    "state_bits": 12837
   },
-  "seconds": 4.9
+  "seconds": 2.3
  },
  "netlist": {
   "path": "variants/twohead_physics.bin",
@@ -42,10 +55,24 @@
   "seconds": 322.4
  },
  "extraction": {
-  "N": 3458,
-  "L": 2930,
-  "identical": true,
-  "sha256_generator": "0b86fbe2da1d67beafb252a445738794f4eb35ad4aa8987030c65d3612aa50fe",
-  "sha256_rocq": "0b86fbe2da1d67beafb252a445738794f4eb35ad4aa8987030c65d3612aa50fe"
+  "members": [
+   {
+    "alpha": 6,
+    "N": 3458,
+    "L": 2930,
+    "identical": true,
+    "sha256_generator": "0b86fbe2da1d67beafb252a445738794f4eb35ad4aa8987030c65d3612aa50fe",
+    "sha256_rocq": "0b86fbe2da1d67beafb252a445738794f4eb35ad4aa8987030c65d3612aa50fe"
+   },
+   {
+    "alpha": 12,
+    "N": 220,
+    "L": 40,
+    "identical": true,
+    "sha256_generator": "dc3b111811b5f3708641883c2313ff2d40387e4e288cb4a790a7289a0d8fcf4d",
+    "sha256_rocq": "dc3b111811b5f3708641883c2313ff2d40387e4e288cb4a790a7289a0d8fcf4d"
+   }
+  ],
+  "identical": true
  }
 }

paper/runs/paper_verify.json

@@ -39,25 +39,11 @@
   "counter_pairs": 65536,
   "counter_failures": 0
  },
- "interpreter": {
-  "onerecord_cases": 576,
-  "onerecord_failures": 0,
-  "counter_failures": 0,
-  "Q_bits": 451,
-  "influencing": 451,
-  "S": 1024,
-  "G": 11,
-  "R": 41,
-  "b": 41,
-  "Q_size": 451,
-  "records_max": 11,
-  "units_lower_bound": 226
- },
  "lev": {
   "sparse_dense_agree": true,
   "layers": 13,
   "max_width": 8210,
   "total_weights": 124165940
  },
- "seconds": 282.2581712300016
+ "seconds": 190.45070967001084
 }

paper/runs/paper_verify_times.json

@@ -1,75 +0,0 @@
-{
- "tier": 1,
- "total_seconds": 214.8219217349979,
- "failures": 0,
- "checks": {
-  "check_device.py": {
-   "ok": true,
-   "seconds": 0.14191210998978931
-  },
-  "check_framing.py": {
-   "ok": true,
-   "seconds": 0.5073039440030698
-  },
-  "twohead_net.py check": {
-   "ok": true,
-   "seconds": 5.247474653995596
-  },
-  "check_steps.py": {
-   "ok": true,
-   "seconds": 5.269182780990377
-  },
-  "check_optimal.py": {
-   "ok": true,
-   "seconds": 7.710004391003167
-  },
-  "check_codec.py": {
-   "ok": true,
-   "seconds": 7.851285790995462
-  },
-  "check_sigma.py": {
-   "ok": true,
-   "seconds": 11.03636751799786
-  },
-  "fanin2.py": {
-   "ok": true,
-   "seconds": 12.635428726993268
-  },
-  "check_environment.py": {
-   "ok": true,
-   "seconds": 12.856029444010346
-  },
-  "check_interp.py": {
-   "ok": true,
-   "seconds": 13.257643950011698
-  },
-  "check_host.py": {
-   "ok": true,
-   "seconds": 14.019029688002774
-  },
-  "check_ternarity.py": {
-   "ok": true,
-   "seconds": 15.632652968997718
-  },
-  "check_host_family.py": {
-   "ok": true,
-   "seconds": 26.31405289299437
-  },
-  "check_lev.py": {
-   "ok": true,
-   "seconds": 32.38079876700067
-  },
-  "check_host_fold.py": {
-   "ok": true,
-   "seconds": 51.92139666900039
-  },
-  "check_total.py": {
-   "ok": true,
-   "seconds": 205.5435071989923
-  },
-  "redundant.py build": {
-   "ok": true,
-   "seconds": 214.77837346300657
-  }
- }
-}

paper/universal_construction_ternary.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d05a260a7e12935b1e20bb7bc6e5690f2f29d9c04de210aaa7eb3618ab4280e1
-size 356867
+oid sha256:29a8e26ce2577a85810fc815acc5eeaef1925cbaadb629aee163c64bf7cfdcf4
+size 364771

paper/universal_construction_ternary.tex

@@ -7,7 +7,12 @@
 \usepackage{booktabs,tabularx,array}
 \usepackage{cite}
 \usepackage{enumitem}
+\usepackage{tikz}
+\usetikzlibrary{arrows.meta,calc}
+\usepackage{pgfplots}
+\pgfplotsset{compat=1.18}
 \usepackage[margin=1in]{geometry}
+\setlength{\emergencystretch}{2em}
 \usepackage[colorlinks=true,linkcolor=blue,citecolor=blue,urlcolor=blue]{hyperref}
 
 % ---- theorem environments ---------------------------------------------------
@@ -62,30 +67,28 @@ We study recurrent networks of McCulloch--Pitts threshold units with weights in
 $\{-1,0,1\}$ and integer thresholds, iterated as a fixed composition of ternary
 matrix--vector products and Heaviside steps, and construct networks of this kind
 that carry out von Neumann's scheme of universal construction and
-self-reproduction exactly. A SUBLEQ computer of $17{,}598$ units, one member of a
-family whose step has depth $13$ at every word width, runs a program of $21$
-instructions that emits any byte string from a run-length description, and one
-of $27$ instructions whose output is the serialization of every bias and edge of
-the machine with its memory and its tape. This is the standard quine scheme run
-on a universal machine, and a fixed instantiation map of linear cost rebuilds
-the running instance from the output. In a second construction the dynamics
-builds the offspring. A fixed network of $45{,}891$ units holds a stored network
-in its state, two banks of records and two tapes under three heads, and
-evaluates one record per step; an organism of $133$ records translates a
-description of $2930$ bits into the idle bank, copies the description and hands
-over control. Proofs checked in Rocq show that the network computes the step of
-this machine from every state at every size, that the organism builds every
-image of its size from any description of it, and that started on its own
-description it reproduces in every generation. Because every pre-activation is
-an integer, every orbit survives perturbations below $1/2$; a bound computed from
-the pre-activation profile is within $20\%$ of the measured failure rate under
-Gaussian read noise, and the inputs active along an orbit certify $23.5$ times
-the leakage the worst case allows over the first $10{,}000$ steps and $18.6$
-times over the whole run. Replacing each unit by $r$ copies that read every copy
-of their inputs multiplies every margin by $r$, so any noise level is survived
-with redundancy $O(s\sqrt{\log(TM/\delta)})$, and the threefold host completes
-the self-reproducing run at noise levels at which the host fails within its
-first bytes.
+self-reproduction exactly, by their dynamics alone. A SUBLEQ computer of
+$17{,}598$ units, one member of a family whose step has depth $13$ at every word
+width, runs a program of $21$ instructions that emits any byte string from a
+run-length description, and one of $27$ instructions that decodes a description
+and then copies it, with which the computer emits the serialization of every bias
+and edge of itself, its memory and its tape. A fixed network holds a stored
+network in its state, as records in two banks with two tapes under three heads,
+and evaluates one record per step; proofs checked in Rocq show that it computes
+the step of this machine from every state at every size. Stored in it as
+$36{,}074$ records of two inputs, the SUBLEQ computer runs the program of $27$
+instructions on a description of its own records: it writes them into the idle
+bank, copies the description and hands control to the copy, which does the same.
+The fixed network thus rebuilds, exactly and in every generation, the weights of
+the stored network that computes, with no map outside it; a constructor of $133$
+records does the same with every step proved in Rocq. Because every
+pre-activation is an integer, every orbit survives perturbations below $1/2$, and
+a bound computed from the pre-activation profile is within $20\%$ of the measured
+failure rate under Gaussian read noise. Replacing each unit by $r$ copies that
+read every copy of their inputs multiplies every margin by $r$, so any noise level
+is survived with redundancy $O(s\sqrt{\log(TM/\delta)})$, and the threefold host
+completes the self-reproducing run at noise levels at which the host fails within
+its first bytes.
 \end{abstract}
 
 \maketitle
@@ -115,15 +118,17 @@ $F\colon\B^n\to\B^n$ built from ternary matrices and the Heaviside step, and its
 behaviour is the orbit of an initial state. The paper treats two questions.
 The first is whether such an orbit can emit, exactly, a serialization of the
 weights that define $F$ together with the rest of the initial data, so that
-loading the emitted data yields a process that emits the same data. The second
-is whether the offspring can be built by the dynamics: whether a fixed network
-can hold threshold networks in its state as data, and whether a network so held
-can construct another from a description, copy the description, and hand over
-control to what it built. The first is the
+loading the emitted data yields a process that emits the same data. This is the
 setting of program replicators, which rely on an execution environment to
-instantiate what they emit~\cite{CotlerHonglerHudcova2025}; the second is the
-setting of von Neumann's cellular constructions, with a threshold network as the
-transition rule and threshold netlists as the configurations.
+instantiate what they emit~\cite{CotlerHonglerHudcova2025}. The second removes
+the environment: whether a fixed network can hold threshold networks in its state
+as data, and whether a universal computer so held can construct its own records
+from a description, copy the description and hand over control to what it built,
+so that the dynamics alone rebuilds the weights of the network that computes.
+This is the setting of von Neumann's cellular constructions, with a threshold
+network as the transition rule and threshold netlists as the configurations: the
+network that reproduces is held as state, and the fixed network that holds it
+plays the part of the cellular rule.
 
 Integer weights make the reproduction exact. A trained network that outputs an
 approximation of its weights loses information in every generation, while a
@@ -155,24 +160,26 @@ every string $f$ has a description of length at most
 $|f|+\lceil|f|/127\rceil+1$, and none shorter when $f$ has no two equal adjacent
 bytes (Section~\ref{sec:univ}).
 \item \emph{Exact self-reproduction of the host.} A program of $27$
-instructions, separating construction from copying as von Neumann did, whose
-output is the serialization of the host, its memory and its tape. This is the
-standard quine scheme, a program that decodes a description and then copies it,
-run on a universal machine. A fixed instantiation map of linear cost, outside the
-network, turns the output into the next running instance
-(Section~\ref{sec:selfrep}).
+instructions, separating construction from copying as von Neumann did, that
+decodes a recipe and then copies it, so that the host emits the serialization of
+itself, its memory and its tape. This is the standard quine scheme run on a
+universal machine; a fixed instantiation map of linear cost, outside the network,
+turns the output into the next running instance (Section~\ref{sec:selfrep}).
 \item \emph{Self-reproduction by the dynamics.} A family of ternary threshold
-networks $N_{G,L}$ whose state holds a stored network as records in two banks,
-with two tapes and three heads, each step evaluating one record; the network
-computes the step of this two-head machine from every state, for every $G$ and
-$L$ (Theorem~\ref{thm:physnet}). An organism of $133$ records builds every image
-of $133$ records from any description of it and hands control to it, and
-started on its own description, of $2930$ bits, it reproduces in every
-generation, the orbit of the network being periodic
-(Theorems~\ref{thm:construct} and~\ref{thm:organism}). These proofs are checked
-in Rocq. Record interpreters that address their state through an index register
-run one another and the constructor of~(2) as stored netlists
-(Section~\ref{sec:tower}).
+networks $N^\alpha_{G,L}$ whose state holds a stored network as records in two
+banks, with two tapes and three heads, each step evaluating one record; the
+network computes the step of this two-head machine from every state, for every
+window of $2^\alpha$ cells and every $G$ and $L$, a proof checked in Rocq
+(Theorem~\ref{thm:physnet}). Stored in the member with $4096$ cells as
+$36{,}074$ records of two inputs, the units of the host with records that load its
+memory, its tape device and a hand-over, the host running $P^\ast$ builds every
+image of its size from any recipe for it into the idle bank and hands control to
+it, and started on a recipe for its own records it reproduces in every
+generation, weights included, the orbit of the network being periodic
+(Theorems~\ref{thm:storedconstruct} and~\ref{thm:storedrep}); three generations
+of $7.9\times10^{10}$ steps each were run. A constructor of $133$ records with a
+description code of its own does the same in the member with $64$ cells, every
+step of it proved in Rocq (Section~\ref{sec:organism}).
 \item \emph{Robustness.} Every orbit survives perturbations below $1/2$ per
 pre-activation. The tolerances for weight and leakage errors are given by
 fan-in and layer width and, along an orbit, by its active inputs, and a bound
@@ -198,11 +205,12 @@ its first bytes (Section~\ref{sec:amplify}).
 
 Sections~\ref{sec:prelim} to~\ref{sec:robust} define the networks, build the
 host, carry out construction and self-reproduction on it and treat
-perturbations; Sections~\ref{sec:interp} and~\ref{sec:organism} give the
-two-head machine and the organism, Section~\ref{sec:tower} the record
-interpreters, and Section~\ref{sec:related} related work. The appendices give
-the measurements in full, what was executed and checked in Rocq, the proof of
-Theorem~\ref{thm:hosted}, and the listings.
+perturbations. Section~\ref{sec:interp} gives the two-head machine,
+Section~\ref{sec:storedhost} stores the host in it and shows that it reproduces
+itself by the dynamics, Section~\ref{sec:organism} gives the constructor proved in
+Rocq, and Section~\ref{sec:related} related work. The appendices give the
+measurements in full, what was executed and checked in Rocq with what reproduces
+each published digest, and the listings.
 
 % =============================================================================
 \section{Threshold maps, transducers, and reproduction}\label{sec:prelim}
@@ -448,8 +456,9 @@ second statement follows by induction on $k$.
 The maps $\inst$ and $\Lev$ together with the device of
 Definition~\ref{def:transducer} are the \emph{instantiation map}: the network
 emits a description, and $\inst$, $\sigma^{-1}$ and $\Lev$ turn it into the next
-running network. Section~\ref{sec:organism} carries out the same step by the
-dynamics of a fixed network; for the host its cost is the following.
+running network. Section~\ref{sec:storedhost} removes the map: the host, held as
+records in the state of a fixed network, carries out the same step by the
+dynamics. With the map, the cost for the host is the following.
 
 \begin{proposition}[Cost of instantiation]\label{prop:envcost}
 Let $\Omega=(N,m,\tau)$ be an instance whose run halts after $T$ steps, and let
@@ -624,8 +633,11 @@ $(0,1,1,0)$.
 
 \begin{construction}[The host family]\label{con:host}
 For $A\ge3$ the netlist $H_A$ has the blocks of Table~\ref{tab:blocks}, in that
-order, each unit after its predecessors. Its state is the $A$ counter bits, a
-halt bit and the $A\cdot2^A$ memory bits, so $n=A+1+A2^A$. The decode lines $P_j$
+order, each unit after its predecessors. Its state is, in this order, the $A$
+counter bits, a halt bit and the $A\cdot2^A$ memory bits word by word, the counter
+and each word most significant bit first, so $n=A+1+A2^A$; for $A=8$ the counter
+occupies coordinates $0$ to $7$, the halt bit $8$, and bit $k$ of word $j$, $k=0$
+the most significant, coordinate $9+8j+k$. The decode lines $P_j$
 of $p$ give the three operands by reindexing, $M[p+o]_t=\bigvee_j(\mu_{j+o,t}\wedge
 P_j)$, and the bits of $p+3$ as disjunctions of the lines $P_j$ for which the
 corresponding bit of $j+3\bmod 2^A$ is $1$. The decode lines of $a$ and $b$ give
@@ -943,41 +955,44 @@ elsewhere, and let
 \end{construction}
 
 \begin{theorem}[Exact self-reproduction]\label{thm:selfrep}
-Let $\Omega^\ast=(\Nhost,m^\ast,\tau^\ast)$. Then $\Omega^\ast$ is exactly
-self-reproducing: it halts and $\Out(\Omega^\ast)=\ser(\Omega^\ast)$. Hence the
-generations
+For every recipe $\tau$ the instance $(\Nhost,m^\ast,\tau)$ halts and
+$\Out(\Nhost,m^\ast,\tau)=\delta(\tau)\cat\tau$; its run reads no byte at
+$h=|\tau|$ before it requests the rewind, and requests it at $h=|\tau|$. In
+particular $\Omega^\ast=(\Nhost,m^\ast,\tau^\ast)$ is exactly self-reproducing,
+$\Out(\Omega^\ast)=\ser(\Omega^\ast)$, and the generations
 $\Omega_{k+1}=\inst(\Out(\Omega_k))$ starting from $\Omega^\ast$ are constant.
 \end{theorem}
 
 \begin{proof}
 Phase~(A) consists of the instructions of $P$ with the same memory layout, and
 the cells $\cell{EOK}$ and $c_{\mathrm{eot}}$ are not addressed by them, so the
-proof of Theorem~\ref{thm:univ} applies: every token of $\tau^\ast$ is consumed
-in order, and when the end token is read the output word is
-$\delta(\tau^\ast)=\field{\sigma(\Nhost)}\cat\field{m^\ast}$, the head is at
-$|\tau^\ast|$, $M[\cell{Z}]=0$, $M[R_{\mathrm{out}}]=0$, $M[\cell{EOK}]=1$, and
-all request bits are $0$. Phase~(R) assigns $M[c_{\mathrm{rw}}]\leftarrow 1$,
-the result being positive, and the device sets $h=0$ and clears
-$c_{\mathrm{rw}}$.
+proof of Theorem~\ref{thm:univ} applies: every token of $\tau$ is consumed in
+order, no byte is read after the end token, and when the end token is read the
+output word is $\delta(\tau)$, the head is at $|\tau|$, $M[\cell{Z}]=0$,
+$M[R_{\mathrm{out}}]=0$, $M[\cell{EOK}]=1$, and all request bits are $0$.
+Phase~(R) assigns $M[c_{\mathrm{rw}}]\leftarrow 1$, the result being positive, and
+the device sets $h=0$ and clears $c_{\mathrm{rw}}$.
 
 For phase~(B) consider the assertion
 \[
 J_i:\quad
 \begin{minipage}{0.78\textwidth}
 control reaches the head of phase~(B) with head position $i$, output word
-$\omega=\delta(\tau^\ast)\cat\tau^\ast_0\cdots\tau^\ast_{i-1}$,
+$\omega=\delta(\tau)\cat\tau_0\cdots\tau_{i-1}$,
 $M[\cell{Z}]=0$, $M[\cell{EOK}]=1$, $M[R_{\mathrm{out}}]=0$, all request bits $0$.
 \end{minipage}
 \]
 $J_0$ holds. Assume $J_i$; the first instruction requests a read. If
-$i<|\tau^\ast|$, the device loads $\tau^\ast_i$, clears $c_{\mathrm{eot}}$ and
+$i<|\tau|$, the device loads $\tau_i$, clears $c_{\mathrm{eot}}$ and
 advances the head; the second instruction leaves $\cell{EOK}=1$, positive; the
-third and fourth assign $M[\cell{Z}]\leftarrow\nu(\tau^\ast_i)$ and
-$M[R_{\mathrm{out}}]\leftarrow\tau^\ast_i$; the fifth emits $\tau^\ast_i$; the
+third and fourth assign $M[\cell{Z}]\leftarrow\nu(\tau_i)$ and
+$M[R_{\mathrm{out}}]\leftarrow\tau_i$; the fifth emits $\tau_i$; the
 sixth restores $M[\cell{Z}]=0$ and branches back, so $J_{i+1}$ holds. If
-$i=|\tau^\ast|$, the device sets $c_{\mathrm{eot}}=1$, the second instruction
+$i=|\tau|$, the device sets $c_{\mathrm{eot}}=1$, the second instruction
 assigns $M[\cell{EOK}]\leftarrow0$ and transfers control to $\cell{0xFF}$, and the
-output word is $\delta(\tau^\ast)\cat\tau^\ast=\ser(\Omega^\ast)$. The second
+output word is $\delta(\tau)\cat\tau$. For $\tau=\tau^\ast$,
+$\delta(\tau^\ast)=\field{\sigma(\Nhost)}\cat\field{m^\ast}$ by
+Lemma~\ref{lem:describe}, so the output is $\ser(\Omega^\ast)$, and the last
 statement is Lemma~\ref{lem:generations}.
 \end{proof}
 
@@ -1208,7 +1223,7 @@ At $s=0.09$, $0.10$ and $0.11$, where most of the $256$ noisy copies leave the
 exact orbit, the profile bound of Proposition~\ref{prop:profile} lies $2\%$ to
 $19\%$ above the measured per-step rate, in the run of Table~\ref{tab:curve} and
 in a repetition with a separate simulator, and $Mp$ exceeds the bound by a factor
-of $2.7$. Under read noise on every
+of $2.7$ (Figure~\ref{fig:noise}(a)). Under read noise on every
 pre-activation the complete self-reproducing run emits the whole instance at
 $s=0.05$ and has its halt bit set after $143$ bytes at $s=0.10$
 (Table~\ref{tab:noise}). Under static weight error the orbit stays exact up to a
@@ -1216,6 +1231,55 @@ leakage of $3.9\times10^{-3}$ and a programmed-weight error of $1/16$; of the
 thirteen settings of Table~\ref{tab:leak}, Corollary~\ref{cor:mismatch}
 certifies three and Proposition~\ref{prop:orbit} nine.
 
+\begin{figure}[t]
+\centering
+\begin{tikzpicture}
+\begin{semilogyaxis}[name=a,width=7.4cm,height=5.8cm,font=\footnotesize,
+  xlabel={noise deviation $s$},ylabel={per-step probability},
+  xmin=0.055,xmax=0.155,ymin=1e-13,ymax=1e2,
+  xtick={0.06,0.08,0.10,0.12,0.14},
+  xticklabel style={/pgf/number format/fixed,/pgf/number format/fixed zerofill,/pgf/number format/precision=2},
+  ytick={1e-12,1e-9,1e-6,1e-3,1},
+  legend style={font=\scriptsize,at={(0.97,0.03)},anchor=south east,draw=none,fill=white,fill opacity=0.8,text opacity=1},
+  legend cell align=left,title={(a) $\Lev(\Nhost)$},title style={font=\footnotesize}]
+\addplot[densely dashed,thick,black!55] coordinates {(0.06,3.30e-12) (0.08,1.72e-5) (0.09,1.16e-3) (0.10,2.41e-2) (0.11,2.30e-1) (0.12,1.30) (0.15,3.60e1)};
+\addlegendentry{$Mp$}
+\addplot[thick,black] coordinates {(0.06,1.21e-12) (0.08,6.34e-6) (0.09,4.27e-4) (0.10,8.85e-3) (0.11,8.42e-2) (0.12,4.73e-1) (0.15,1.30e1)};
+\addlegendentry{profile bound}
+\addplot[only marks,mark=*,mark size=1.6pt] coordinates {(0.08,6.94e-6) (0.09,4.07e-4) (0.10,8.71e-3) (0.11,7.70e-2) (0.12,3.59e-1) (0.15,1.00)};
+\addlegendentry{measured}
+\end{semilogyaxis}
+\begin{semilogyaxis}[at={(a.east)},anchor=west,xshift=1.0cm,width=7.4cm,height=5.8cm,font=\footnotesize,
+  xlabel={noise deviation $s$},
+  xmin=0.19,xmax=0.37,ymin=1e-13,ymax=1e2,
+  xtick={0.20,0.25,0.30,0.35},
+  xticklabel style={/pgf/number format/fixed,/pgf/number format/fixed zerofill,/pgf/number format/precision=2},
+  ytick={1e-12,1e-9,1e-6,1e-3,1},
+  legend style={font=\scriptsize,at={(0.97,0.03)},anchor=south east,draw=none,fill=white,fill opacity=0.8,text opacity=1},
+  legend cell align=left,title={(b) $N_3$, read by majority},title style={font=\footnotesize}]
+\addplot[densely dashed,thick,black!55] coordinates {(0.20,8.03e-9) (0.22,1.16e-6) (0.25,2.48e-4) (0.27,3.48e-3) (0.30,7.22e-2) (0.33,6.90e-1) (0.36,3.89)};
+\addlegendentry{first order}
+\addplot[thick,black] coordinates {(0.20,3.59e-13) (0.22,1.82e-10) (0.25,1.58e-7) (0.27,4.57e-6) (0.30,2.26e-4) (0.33,4.34e-3) (0.36,4.30e-2)};
+\addlegendentry{restoration bound}
+\addplot[only marks,mark=*,mark size=1.6pt] coordinates {(0.27,4.04e-6) (0.30,2.13e-4) (0.33,3.66e-3) (0.36,2.93e-2)};
+\addlegendentry{measured}
+\addplot[only marks,mark=o,mark size=1.8pt] coordinates {(0.24,9.79e-7) (0.27,8.47e-5) (0.30,2.46e-3) (0.33,2.58e-2)};
+\addlegendentry{a copy deviates}
+\end{semilogyaxis}
+\end{tikzpicture}
+\caption{The per-step probability of leaving the orbit under Gaussian read noise
+of deviation $s$, against the bounds of Section~\ref{sec:robust}; the lines join
+the values computed at the deviations of Tables~\ref{tab:curve}
+and~\ref{tab:bound3}. (a)~$\Lev(\Nhost)$: the rate at which noisy copies first
+leave the exact orbit, the profile bound of Proposition~\ref{prop:profile} and
+the bound $Mp$ of Proposition~\ref{prop:random}. (b)~$N_3$: the rate at which the
+state read by majority first leaves the orbit, the restoration bound of
+Proposition~\ref{prop:restore} and the first-order bound of
+Theorem~\ref{thm:amplify}(ii), with the rate at which some copy of some state bit
+first deviates.}
+\label{fig:noise}
+\end{figure}
+
 \subsection{Fault tolerance by amplification}\label{sec:amplify}
 
 Theorem~\ref{thm:margin} tolerates perturbations below $\tfrac12$ because every
@@ -1535,7 +1599,8 @@ $3.11\times10^{-4}$ at $s=0.22$ and $0.271$ at $s=0.25$, where that bound exceed
 one, and it exceeds one from $s=0.27$. Along the first $20{,}000$ steps of the
 self-describing instance, weighted by the steps each of the $64$ noisy copies
 ran, $b(t)$ lies $1.06$ to $1.47$ times above the measured failure rates
-(Table~\ref{tab:bound3}), which are $21$ and $12$ times below the rates at which
+(Table~\ref{tab:bound3}, Figure~\ref{fig:noise}(b)), which are $21$ and $12$ times
+below the rates at which
 the replicated state left its orbit at $s=0.27$ and $0.30$.
 
 
@@ -1546,32 +1611,71 @@ the replicated state left its orbit at $s=0.27$ and $0.30$.
 This section gives a fixed network whose state holds a threshold network as
 data: a program bank lists the units of the stored network as records, the step
 evaluates the record in front of the bank and turns the bank by one record, and
-three heads read and write a second bank and two tapes.
+three heads read and write a second bank and two tapes
+(Figure~\ref{fig:machine}).
 
 \begin{definition}[The two-head machine]\label{def:twohead}
-Let $G,L\ge1$ and $N=26G$. A state of the machine $T_{G,L}$ consists of a window
-$w\in\B^{64}$, two banks $Q_0,Q_1\in\B^N$ and two tapes $D_0,D_1\in\B^L$, each
-bank and tape circular and listed from its head. Window cell $0$ is the bank bit
-$\kappa$; $Q_\kappa$ is the active bank and $Q_{1-\kappa}$ the idle one, $D_\kappa$
-the read tape and $D_{1-\kappa}$ the copy tape. Window cells $1$, $2$ and $3$ are
-not stored: they name the cell under the read head $D_\kappa[0]$, under the arm
-$Q_{1-\kappa}[0]$ and under the copy head $D_{1-\kappa}[0]$, and cells $4$, $5$
-and $6$ are the requests that move these three heads. A \emph{record} is a word
-$(c_0,c_1,\beta,a_0,a_1,a_o)\in\B^{26}$: two weight codes of two bits, read as
+Let $\alpha\ge3$ and $G,L\ge1$, and put $b=8+3\alpha$ and $N=bG$. A state of the
+machine $T^\alpha_{G,L}$ consists of a window $w\in\B^{2^\alpha}$, two banks
+$Q_0,Q_1\in\B^N$ and two tapes $D_0,D_1\in\B^L$, each bank and tape circular and
+listed from its head. Window cell $0$ is the bank bit $\kappa$; $Q_\kappa$ is the
+active bank and $Q_{1-\kappa}$ the idle one, $D_\kappa$ the read tape and
+$D_{1-\kappa}$ the copy tape. Window cells $1$, $2$ and $3$ are not stored: they
+name the cell under the read head $D_\kappa[0]$, under the arm $Q_{1-\kappa}[0]$
+and under the copy head $D_{1-\kappa}[0]$, and cells $4$, $5$ and $6$ are the
+requests that move these three heads. A \emph{record} is a word
+$(c_0,c_1,\beta,a_0,a_1,a_o)\in\B^{b}$: two weight codes of two bits, read as
 $w=1$ for $01$, $w=-1$ for $10$ and $w=0$ otherwise, a bias $\beta\in[-8,7]$ in
-two's complement on four bits, and three window addresses of six bits, most
-significant first. One step reads the record $Q_\kappa[0..26)$ and the values
+two's complement on four bits, and three window addresses of $\alpha$ bits, most
+significant first. One step reads the record $Q_\kappa[0..b)$ and the values
 $x_a$ of the cells it names, and
 \begin{enumerate}[label=(\roman*)]
 \item computes $v=\Hv(w_0x_{a_0}+w_1x_{a_1}+\beta)$;
 \item writes $v$ into window cell $a_o$ if $a_o=0$ or $a_o\ge4$, under the arm if
 $a_o=2$, under the copy head if $a_o=3$, and nowhere if $a_o=1$;
-\item turns $Q_\kappa$ by $26$ cells, and the read tape, the idle bank and the copy
+\item turns $Q_\kappa$ by $b$ cells, and the read tape, the idle bank and the copy
 tape by one cell each when cell $4$, $5$ or $6$ holds $1$ after the write;
 \item clears cells $4$, $5$ and $6$.
 \end{enumerate}
+We write $T_{G,L}$ for $T^6_{G,L}$, whose window has $64$ cells and whose records
+have $26$ bits.
 \end{definition}
 
+\begin{figure}[t]
+\centering
+\begin{tikzpicture}[font=\footnotesize,>=Stealth,
+  c/.style={draw,minimum height=5.5mm,minimum width=9mm,inner sep=0pt,anchor=west,text height=1.5ex,text depth=0.3ex},
+  s/.style={draw,minimum height=5.5mm,inner sep=0pt,anchor=west,text height=1.5ex,text depth=0.3ex},
+  lab/.style={anchor=east},
+  note/.style={font=\scriptsize,text=black!70}]
+\node[lab] at (0,0) {window $w$};
+\foreach \i/\t in {0/{$\kappa$},1/{rd},2/{arm},3/{cpy},4/{AR},5/{AA},6/{AC},7/{sink}} {
+  \node[c] (w\i) at (0.15+0.9*\i,0) {\t};
+  \node[font=\tiny,text=black!60] at ($(w\i.north)+(0,0.13)$) {\i};
+}
+\node[c,minimum width=40mm] (wr) at (0.15+0.9*8,0) {cells $8,\dots,2^\alpha-1$};
+\node[lab] at (0,-1.45) {active bank $Q_\kappa$};
+\node[s,fill=black!10,minimum width=40mm] (r0) at (0.15,-1.45) {record $(c_0,c_1,\beta,a_0,a_1,a_o)$};
+\node[s,minimum width=24mm] (r1) at (r0.east) {next record};
+\node[s,minimum width=48mm] (r2) at (r1.east) {};
+\node[note,anchor=east] at ($(r2.east)+(-0.1,0)$) {turns one record per step};
+\draw[->,rounded corners=3pt] (r0.north) -- ++(0,0.42) -| node[pos=0.25,fill=white,inner sep=2pt]
+  {$v=\Hv(w_0x_{a_0}+w_1x_{a_1}+\beta)$ into cell $a_o$} (wr.south);
+\foreach \y/\n/\l/\k/\q in {-2.35/rt/{read tape $D_\kappa$}/rd/AR, -3.05/ib/{idle bank $Q_{1-\kappa}$}/arm/AA, -3.75/ct/{copy tape $D_{1-\kappa}$}/cpy/AC} {
+  \node[lab] at (0,\y) {\l};
+  \node[s,fill=black!10,minimum width=9mm] (\n0) at (0.15,\y) {\k};
+  \node[s,minimum width=103mm] (\n1) at (\n0.east) {};
+  \node[note,anchor=east] at ($(\n1.east)+(-0.1,0)$) {turns one cell when \q\ holds $1$};
+}
+\end{tikzpicture}
+\caption{The two-head machine $T^\alpha_{G,L}$. A step evaluates the record in
+front of the active bank on the cells $a_0$ and $a_1$ and writes the result into
+cell $a_o$. Window cells $1$, $2$ and $3$ are the cells under the read head, the
+arm and the copy head, shaded, and cells $4$, $5$ and $6$ turn them. The banks
+and the tapes are circular.}
+\label{fig:machine}
+\end{figure}
+
 A \emph{pass} is $G$ steps. The active bank comes back to the record it started
 with, so a pass evaluates the $G$ records of the bank once each, in order, each
 on the values the records before it left. The bank bit is read at the start of a
@@ -1579,64 +1683,355 @@ step, so a record that writes $\kappa$ passes control to the other bank from
 the next step on.
 
 \begin{theorem}[The machine as a ternary threshold network]\label{thm:physnet}
-For all $G,L\ge1$ there is a clocked ternary threshold netlist $N_{G,L}$ on the
-$61+2N+2L$ bits of the stored window cells, the banks and the tapes, with
-$647+8N+6L$ units, $2198+18N+12L$ edges, every weight $\pm1$ and depth $15$,
-such that for every state $x$ of $T_{G,L}$ the next state $N_{G,L}$ computes
-from the bits of $x$ is the encoding of the next state of $x$.
+For all $\alpha\ge3$ and $G,L\ge1$ there is a clocked ternary threshold netlist
+$N^\alpha_{G,L}$ on the $2^\alpha-3+2N+2L$ bits of the stored window cells
+$0,4,5,\dots,2^\alpha-1$ and of $Q_0$, $Q_1$, $D_0$ and $D_1$, in this order and
+each from its head, with $8\cdot2^\alpha+9\alpha+81+8N+6L$ units,
+$(3\alpha+12)2^\alpha+18\alpha+170+18N+12L$ edges, every weight $\pm1$ and depth
+$15$, such that for every state $x$ of $T^\alpha_{G,L}$ the next state
+$N^\alpha_{G,L}$ computes from the bits of $x$ is the encoding of the next state
+of $x$.
 \end{theorem}
 
 \begin{proof}
 The netlist has twenty-eight blocks. A multiplexer on $\kappa$ selects each bit
 of the record in front of the active bank and the cell under each head. Three
-blocks of $64$ units decode $a_0$, $a_1$ and $a_o$ (Lemma~\ref{lem:mem}), and a
-disjunction of the conjunctions of each decode line with the cell it names reads
-$x_{a_0}$ and $x_{a_1}$, cells $1$ to $3$ through the head multiplexers. From the
-weight codes, units for $[w_k=1]\wedge x_{a_k}$ and $[w_k=-1]\wedge x_{a_k}$ give
-$p=w_0x_{a_0}+w_1x_{a_1}\in[-2,2]$; five units test $p\ge c$ for $c=-2,\dots,2$
-and five test $\beta\ge-c$ on the four bits of $\beta$, and $v$ is the disjunction
-of the five conjunctions, since $p+\beta\ge0$ exactly when some $c$, namely
-$c=p$, has $p\ge c$ and $\beta\ge-c$. A multiplexer on the decode line of each
-stored window cell writes $v$ into it, and the three request cells read a unit
-that never fires. Bit $i$ of a bank is the disjunction of three conjunctions:
-with the bank active, its bit $i+26\bmod N$; with it idle, bit $i+1\bmod N$ or
-bit $i$ of the bank after the arm's write, as cell $5$ after the write requests;
-the cell under the arm after the write is a multiplexer of $v$ and the old cell
-on the decode line of $2$. The tapes are alike, with cells $4$ and $6$ and the
-decode line of $3$. Counting the units and edges of the blocks gives the sizes.
-The depth of a unit depends only on its block: the record and the cells under
-the heads are selected at depth $2$, the decode lines lie at depth $3$, the
-operands at $5$, the products at $6$, the tests $p\ge c$ at $7$ and $v$ at $9$,
-the written window cells, the requests among them, at $11$, the next bank bits
-at $14$, the signals that turn the tapes at $13$ and the next tape bits at
-$15$. That the next state is the encoding of the next state of $x$, for all
-$G$, $L$ and $x$, is proved in Rocq, with the number of units and the weights:
-every unit is given a value in terms of $x$, every unit fires to its own value
-on the values of the units it reads, and induction over the units in their order
-shows that the netlist computes these values, among them the next state.
+blocks of $2^\alpha$ units decode $a_0$, $a_1$ and $a_o$ (Lemma~\ref{lem:mem}),
+and a disjunction of the conjunctions of each decode line with the cell it names
+reads $x_{a_0}$ and $x_{a_1}$, cells $1$ to $3$ through the head multiplexers.
+From the weight codes, units for $[w_k=1]\wedge x_{a_k}$ and $[w_k=-1]\wedge
+x_{a_k}$ give $p=w_0x_{a_0}+w_1x_{a_1}\in[-2,2]$; five units test $p\ge c$ for
+$c=-2,\dots,2$ and five test $\beta\ge-c$ on the four bits of $\beta$, and $v$ is
+the disjunction of the five conjunctions, since $p+\beta\ge0$ exactly when some
+$c$, namely $c=p$, has $p\ge c$ and $\beta\ge-c$. A multiplexer on the decode line
+of each stored window cell writes $v$ into it, and the three request cells read a
+unit that never fires. Bit $i$ of a bank is the disjunction of three
+conjunctions: with the bank active, its bit $i+b\bmod N$; with it idle, bit
+$i+1\bmod N$ or bit $i$ of the bank after the arm's write, as cell $5$ after the
+write requests; the cell under the arm after the write is a multiplexer of $v$
+and the old cell on the decode line of $2$. The tapes are alike, with cells $4$
+and $6$ and the decode line of $3$. Counting the units and edges of the blocks
+gives the sizes. The depth of a unit depends only on its block: the record and
+the cells under the heads are selected at depth $2$, the decode lines lie at
+depth $3$, the operands at $5$, the products at $6$, the tests $p\ge c$ at $7$
+and $v$ at $9$, the written window cells, the requests among them, at $11$, the
+next bank bits at $14$, the signals that turn the tapes at $13$ and the next tape
+bits at $15$. That the next state is the encoding of the next state of $x$, for
+all $\alpha$, $G$, $L$ and $x$, is proved in Rocq, with the number of units and
+the weights: every unit is given a value in terms of $x$, every unit fires to its
+own value on the values of the units it reads, and induction over the units in
+their order shows that the netlist computes these values, among them the next
+state. A decode line is proved for every width through the binary value of an
+address of $\alpha$ bits.
 \end{proof}
 
 \begin{remark}[Corroboration]\label{rem:physcheck}
-For $G=133$ and $L=2930$, the member that Section~\ref{sec:organism} uses,
-$N_{G,L}$ has $45{,}891$ units, $99{,}602$ edges and $12{,}837$ state bits, and
-its depth is $15$; the file the generator writes is byte for byte the netlist
-extracted from the Rocq definition. One step of $N_{5,40}$ agreed with a
-transcription of Definition~\ref{def:twohead} on $300$ random full states and one
-step of $N_{133,2930}$ on $20$, and three generations of the organism of
-Section~\ref{sec:organism}, $2{,}762{,}676$ steps, were run on $N_{133,2930}$ in
+For $\alpha=6$, $G=133$ and $L=2930$, the member that Section~\ref{sec:organism}
+uses, $N^6_{G,L}$ has $45{,}891$ units, $99{,}602$ edges and $12{,}837$ state bits;
+for $\alpha=12$, $G=36{,}074$ and $L=1{,}599{,}768$, the member that
+Section~\ref{sec:storedhost} uses, it has $22{,}329{,}613$ units,
+$47{,}964{,}818$ edges and $6{,}378{,}141$ state bits. The generator writes the
+netlist unit by unit in the order of the Rocq definition, and for $N^6_{133,2930}$
+and $N^{12}_{5,40}$ its file is byte for byte the netlist extracted from that
+definition. One step of the netlist agreed with a transcription of
+Definition~\ref{def:twohead} on $300$ random full states for $N^6_{5,40}$, $20$ for
+$N^6_{133,2930}$ and $40$ for $N^{12}_{5,40}$, and three generations of the organism
+of Section~\ref{sec:organism}, $2{,}762{,}676$ steps, were run on $N^6_{133,2930}$ in
 C beside the transcription, the full state compared after every step.
 \end{remark}
 
 % =============================================================================
-\section{Self-reproduction by the dynamics}\label{sec:organism}
+\section{The host reproduces itself by the dynamics}\label{sec:storedhost}
 % =============================================================================
 
-Inside the two-head machine the instantiation step of
-Section~\ref{sec:selfrep} is a write into the idle bank followed by a change of
-$\kappa$. This section gives a stored network, the organism, that performs von
-Neumann's cycle there: it translates a description into a record image in the
-idle bank, copies the description onto the copy tape, and hands over control to
-the image.
+Inside the two-head machine the instantiation step of Section~\ref{sec:selfrep}
+is a write into the idle bank followed by a change of $\kappa$. This section
+stores the host as a network of two-input records in a bank of $T^{12}_{G,L}$,
+whose window of $4096$ cells holds the host's $2057$ state bits, with a device
+that writes the bytes the host emits under the arm until the tape is rewound and
+under the copy head after it. Run on a recipe for its own records, $P^\ast$ then
+writes the host into the idle bank, copies the recipe and hands control to the
+copy (Figure~\ref{fig:generation}).
+
+\begin{lemma}[Stored netlists]\label{lem:feedback}
+If no record but the last of the active bank writes $\kappa$, a pass evaluates the
+records in order, each on the window and the cells under the heads as the records
+before it left them. A clocked netlist whose units have at most two predecessors
+and whose state bits are window cells is therefore evaluated by one pass of
+records that list its units in an order in which every unit follows its
+predecessors, each record writing a cell that holds the unit's value until the
+last record that reads it, and the record of the next value of each state bit
+writing that bit after every record that reads it.
+\end{lemma}
+
+\begin{proof}
+The active bank turns by one record per step, and $\kappa$, read at the start of a
+step, selects it. Induction over the records shows that each reads the values of
+its predecessors on the current state, a state bit being unchanged until the
+record of its next value, which follows its last reader.
+\end{proof}
+
+Gate-level logic simulation engines evaluate one stored gate per step from
+operand memory and rank-order the gates so that one pass
+suffices~\cite{Denneau1982}, and Lemma~\ref{lem:feedback} is the fixed-order
+sequential schedule of automata networks~\cite{RiosWilsonTheyssier2024c}.
+
+\begin{lemma}[Compilation]\label{cor:compile}
+A ternary threshold unit $\Hv(\sum_{i\in P}x_i-\sum_{i\in N}x_i+b)$ is $1$
+exactly when at least $t=|N|-b$ of its $k$ literals $x_i$ ($i\in P$) and $\neg x_i$
+($i\in N$) are true. It is a constant for $t\le0$ and for $t>k$, a disjunction
+for $t=1$ and a conjunction for $t=k$, each a copy of the literal when $k=1$ and a
+chain of $k-1$ two-input units otherwise, and for $1<t<k$ it satisfies
+$T_t(x_1,\dots,x_k)=T_t(x_2,\dots,x_k)\vee(x_1\wedge T_{t-1}(x_2,\dots,x_k))$.
+Every unit so obtained is a record.
+\end{lemma}
+
+\begin{proof}
+The pre-activation is the number of true literals minus $t$. The unit
+$\Hv(\pm x\pm y+c)$ with $c\in\{0,-1,-2\}$ is the conjunction of any two literals
+and with $c\in\{-1,0,1\}$ their disjunction, a copy is $\Hv(x-1)$ or $\Hv(-x)$, and
+the constants are the disjunction and the conjunction of a literal and its
+negation; a chain conjoins or disjoins each further literal with the result so
+far. The recursion holds because at least $t$ of $x_1,\dots,x_k$ are true exactly
+when at least $t$ of $x_2,\dots,x_k$ are, or $x_1$ is and at least $t-1$ of the
+others are, and its base cases are the chains and the constants.
+\end{proof}
+
+\begin{construction}[The stored host]\label{con:stored}
+Let $\alpha=12$. The window holds, after the eight cells of
+Definition~\ref{def:twohead}, a cell $\mathrm{booted}$ at $8$, a counter
+$\mathrm{cnt}$ of $20$ bits at $9$ to $28$, least significant first, a cell
+$\mathrm{dest}$ at $29$, a limit $\mathrm{lim}$ of $20$ bits at $30$ to $49$, the
+$2057$ state bits of $\Nhost$ at $50$ to $2106$ in the order of
+Construction~\ref{con:host}, and temporaries from $2107$ on. The stored host $S$
+lists the following $36{,}074$ records.
+\begin{enumerate}[label=(\alph*),leftmargin=2em]
+\item \emph{Startup}, $2099$ records: for each memory bit $c$,
+$c\leftarrow c\vee\neg\mathrm{booted}$ if its value in $m^\ast$ is $1$ and
+$c\leftarrow c\wedge\mathrm{booted}$ if it is $0$; then
+$c\leftarrow c\wedge\mathrm{booted}$ for the bits of the counter, the halt bit and
+the bits of $\mathrm{cnt}$, $\mathrm{lim}$ and $\mathrm{dest}$; then
+$\mathrm{booted}\leftarrow1$.
+\item \emph{Step}, $33{,}568$ records: the units of $\Nhost$ compiled by
+Lemma~\ref{cor:compile}, in two stages. The first evaluates every unit that a
+next value depends on, other than the units of the next values and the units read
+by a single unit, each after its predecessors. The second takes the counter bits,
+the halt bit and the memory bits in this order, and evaluates for each the unit of
+its next value, with the units read by it alone just before it, its last record
+writing the bit.
+\item \emph{Device}, $402$ records: the device of Definition~\ref{def:ring} on the
+state that~(b) leaves.
+\item \emph{Hand-over}, five records: $\mathrm{booted}\leftarrow
+\mathrm{booted}\wedge\neg h$, where $h$ is the halt bit; a record with both
+weights $0$ that writes $0$ into the sink, which makes $S$ a whole number of bytes;
+and $\kappa\leftarrow\kappa\oplus h$ in three records.
+\end{enumerate}
+Temporaries whose live intervals, from the first write to the last read, are
+disjoint share a cell, $789$ cells in all, so $S$ uses the window cells $0$ to
+$2895$. The image of $S$, its records in order, has $1{,}587{,}256$ bits, read as
+$198{,}407$ bytes most significant bit first, and $\tau_S=\describe(S)$ has
+$199{,}971$ bytes.
+\end{construction}
+
+\begin{definition}[The device of the stored host]\label{def:ring}
+The device acts on the state $y$ of the host after a step, the registers
+$\mathrm{cnt}$, $\mathrm{lim}$ and $\mathrm{dest}$, the read tape, the idle bank
+and the copy tape, each request firing on the value $1$:
+\begin{enumerate}[label=(\roman*)]
+\item if $y_{c_{\mathrm{wr}}}=1$, the eight bits of $y_{R_{\mathrm{out}}}$, most
+significant first, are written under the arm if $\mathrm{dest}=0$ and under the
+copy head if $\mathrm{dest}=1$, that head turning after each, and
+$R_{\mathrm{out}}$ is cleared;
+\item if $y_{c_{\mathrm{rd}}}=1$, then $c_{\mathrm{eot}}$ is set if
+$\mathrm{dest}=1$ and $\mathrm{cnt}=\mathrm{lim}$, and otherwise the eight bits
+under the read head, the head turning after each, are loaded into
+$R_{\mathrm{in}}$ most significant first, $c_{\mathrm{eot}}$ is cleared and
+$\mathrm{cnt}$ is incremented;
+\item if $y_{c_{\mathrm{rw}}}=1$, then $\mathrm{lim}\leftarrow\mathrm{cnt}$,
+$\mathrm{cnt}\leftarrow0$ and $\mathrm{dest}\leftarrow1$;
+\item the request cells are cleared.
+\end{enumerate}
+\end{definition}
+
+\begin{figure}[t]
+\centering
+\begin{tikzpicture}[font=\footnotesize,>=Stealth,
+  s/.style={draw,minimum height=6mm,inner sep=1pt,anchor=west,text height=1.5ex,text depth=0.3ex},
+  lab/.style={anchor=east},
+  note/.style={font=\scriptsize,text=black!70}]
+\node[lab] at (0,0) {active bank $Q_\kappa$};
+\node[s,fill=black!10,minimum width=13mm] (a1) at (0.15,0) {startup};
+\node[s,fill=black!10,minimum width=35mm] (a2) at (a1.east) {step of $\Nhost$};
+\node[s,fill=black!10,minimum width=13mm] (a3) at (a2.east) {device};
+\node[s,fill=black!10,minimum width=15mm] (a4) at (a3.east) {hand-over};
+\node[note,anchor=south] at (a1.north) {$2099$};
+\node[note,anchor=south] at (a2.north) {$33{,}568$ records};
+\node[note,anchor=south] at (a3.north) {$402$};
+\node[note,anchor=south] at (a4.north) {$5$};
+\node[lab] at (0,-1.1) {read tape $D_\kappa$};
+\node[s,minimum width=76mm] (d0) at (0.15,-1.1) {$\tau_S=\describe(S)$, $199{,}971$ bytes};
+\node[lab] at (0,-2.2) {idle bank $Q_{1-\kappa}$};
+\node[s,densely dashed,minimum width=76mm] (q1) at (0.15,-2.2) {$S$, written under the arm in phase~(A)};
+\node[lab] at (0,-3.3) {copy tape $D_{1-\kappa}$};
+\node[s,densely dashed,minimum width=76mm] (d1) at (0.15,-3.3) {$\tau_S$, written under the copy head in phase~(B)};
+\node[draw,rounded corners,align=left,anchor=north west,text width=31mm,minimum height=39mm,inner sep=4pt]
+  (win) at (9.75,0.3)
+  {\textbf{window}\\[2pt] the host's state, with\\ $P^\ast$ and $m^\ast$ in its\\ memory; the device's\\ $\mathrm{cnt}$, $\mathrm{lim}$, $\mathrm{dest}$;\\ $\mathrm{booted}$; $\kappa$, flipped\\ by the hand-over\\ at the halt};
+\draw[->] (a4.east) -- node[note,above] {runs} (win.west|-a4.east);
+\draw[->] (d0.east) -- node[note,above] {(A), (B)} (win.west|-d0.east);
+\draw[<-] (q1.east) -- node[note,above] {(A)} (win.west|-q1.east);
+\draw[<-] (d1.east) -- node[note,above] {(B)} (win.west|-d1.east);
+\end{tikzpicture}
+\caption{A generation of the stored host. Each pass evaluates the records of $S$
+and carries out one step of the host on the window. $P^\ast$ reads $\tau_S$
+twice: in phase~(A) it decodes it, and the device writes the decoded bytes, the
+image of $S$, under the arm; in phase~(B) it copies $\tau_S$ under the copy head.
+At the halt the hand-over flips $\kappa$, and the next pass, in the other bank,
+loads $m^\ast$ and runs the copy.}
+\label{fig:generation}
+\end{figure}
+
+\begin{proposition}[One pass]\label{prop:storedpass}
+Let a state of $T^{12}_{G,L}$ with $G=36{,}074$ hold $S$ in the active bank from
+its first record, and in the window clear requests and a host state $x$. One pass
+replaces $x$ by $x_0(m^\ast)$ and clears $\mathrm{cnt}$, $\mathrm{lim}$ and
+$\mathrm{dest}$ if $\mathrm{booted}=0$; then carries out one step of $\Nhost$
+followed by the device of Definition~\ref{def:ring}; then sets $\mathrm{booted}$
+to the negation of the halt bit and, if the halt bit is $1$, changes $\kappa$ at
+its last step. It leaves $S$ in the active bank from its first record and the
+requests clear, whatever the temporaries held.
+\end{proposition}
+
+\begin{proof}
+By Lemma~\ref{lem:feedback} the pass evaluates the blocks of
+Construction~\ref{con:stored} in order. The startup records leave every cell
+unchanged when $\mathrm{booted}=1$; otherwise they set each memory bit to its value
+in $m^\ast$ and clear the other cells they name. The step block is $\Nhost$
+compiled by Lemma~\ref{cor:compile}, in an order that Lemma~\ref{lem:feedback}
+admits: the first stage writes temporaries only, and no record reads a state bit
+after the record that writes its next value, a condition checked over the records.
+So after the block the state bits hold the next state of $\Nhost$. The device
+records form the requests $[y_c=1]$ as conjunctions of eight literals, the bit
+$[\mathrm{cnt}=\mathrm{lim}]$ as a conjunction of twenty equivalences, and its
+conjunction with $\mathrm{dest}$. They then write each bit of $R_{\mathrm{out}}$
+under the arm or the copy head by a multiplexer, followed by the request that turns
+that head, and clear $R_{\mathrm{out}}$ on a write; load each bit under the read
+head into $R_{\mathrm{in}}$ by a multiplexer on the condition of a read, followed
+by the request that turns the read tape; set $c_{\mathrm{eot}}$; increment
+$\mathrm{cnt}$ by carries formed before any of its bits changes; carry out the
+rewind; and clear the requests: these are clauses (i) to (iv) of
+Definition~\ref{def:ring}. The hand-over records set $\mathrm{booted}$ and,
+last, $\kappa$. Every temporary is written in the pass before it is read and is not
+written after its last read, so a cell shared by temporaries holds, at each read,
+the value of the temporary read. No record writes the active bank, which turns by
+$G$ records.
+\end{proof}
+
+\begin{theorem}[Universal construction by the dynamics]\label{thm:storedconstruct}
+Let $X$ be an image of $G=36{,}074$ records, read as $198{,}407$ bytes, let $r$ be
+a recipe with $\delta(r)=X$, and let $L=8|r|$. Let $x$ be a state of
+$T^{12}_{G,L}$ with $S$ in the active bank from its first record, $r$ on the read
+tape from its head, and in the window $\mathrm{booted}=0$ and clear requests,
+whatever the idle bank, the copy tape and the other cells hold. After as many
+passes as Proposition~\ref{prop:steps} gives steps for $r$, the idle bank holds
+$X$ and the copy tape $r$, the active bank holds $S$ and the read tape $r$, each
+from its head, the window holds $\mathrm{booted}=0$ and clear requests, and
+$\kappa$ has changed, at the last step of the last pass; from then on
+$T^{12}_{G,L}$ evaluates the records of $X$.
+\end{theorem}
+
+\begin{proof}
+By Proposition~\ref{prop:storedpass} the first pass loads $x_0(m^\ast)$ and
+carries out the first step of the host, and each later pass one more step, with
+the device of Definition~\ref{def:ring}, up to the pass in which the halt bit is
+set, which clears $\mathrm{booted}$ and changes $\kappa$ at its last step. By
+Theorem~\ref{thm:selfrep}, $P^\ast$ on $r$ with the device of
+Definition~\ref{def:transducer} halts after the steps of
+Proposition~\ref{prop:steps} with output $\delta(r)\cat r$, reads no byte at
+$h=|r|$ before it requests the rewind, and requests it at $h=|r|$. On this run the
+two devices agree. A token covers at least one byte in at most two, so
+$|r|\le2|X|+1<2^{20}$ and $\mathrm{cnt}$ does not wrap. Before the rewind
+$\mathrm{dest}=0$ and each read loads the next
+byte of $r$ and increments $\mathrm{cnt}$, so $\mathrm{cnt}=h$; at the rewind the
+read head has turned $8|r|=L$ cells and is back at its start, and $\mathrm{lim}$
+becomes $|r|$. After it each read loads the next byte while
+$\mathrm{cnt}<\mathrm{lim}$ and sets $c_{\mathrm{eot}}$ at $\mathrm{cnt}=|r|$, as
+Definition~\ref{def:transducer} does at $h=|r|$. The bytes emitted before the
+rewind, $\delta(r)=X$, are written under the arm, which turns
+$8\cdot198{,}407=N$ cells and comes back to its start, and those emitted after it,
+$r$, under the copy head, which turns $L$ cells. The active bank and the read tape
+are not written, and the read tape has turned $2L$ cells. From the next step on
+the bank holding $X$ is active, from its first record.
+\end{proof}
+
+By Lemma~\ref{lem:complete} every image of $G$ records has a recipe, so the stored
+host builds every image of its own size, itself among them.
+
+\begin{theorem}[Self-reproduction of the host by the dynamics]\label{thm:storedrep}
+Let $L=8|\tau_S|=1{,}599{,}768$ and let $x_0$ be the state of $T^{12}_{G,L}$ with
+$S$ in $Q_0$, $\tau_S$ on $D_0$, and $Q_1$, $D_1$ and the window clear. For every
+$g\ge1$, the state after $g$ generations of $2{,}202{,}812$ passes,
+$79{,}464{,}240{,}088$ applications of $T^{12}_{G,L}$ each, holds $S$ in both banks
+and $\tau_S$ on both tapes, each from its head, with $\kappa=g\bmod2$, and equals
+the state after $g+2$ generations. The network $N^{12}_{G,L}$ started from the bits
+of $x_0$ holds their bits at the same steps, and its orbit is periodic from the
+first generation on, with a period of two generations.
+\end{theorem}
+
+\begin{proof}
+The first generation is Theorem~\ref{thm:storedconstruct} with $X=S$ and
+$r=\tau_S$, a recipe for $S$ by Lemma~\ref{lem:describe}. The recipe $\tau_S$ has
+$1563$ literal tokens and no repeat token, with $f_{\mathrm{lit}}=198{,}407$, so
+Proposition~\ref{prop:steps} gives $1{,}002{,}983+1+1{,}199{,}828$ passes. After
+it the idle bank and the copy tape hold $S$ and $\tau_S$, the active bank and the
+read tape still hold them, and the window holds $\mathrm{booted}=0$ and clear
+requests, so with the roles of the two banks and the two tapes exchanged the state
+satisfies the hypothesis of Theorem~\ref{thm:storedconstruct} again; induction over
+the generations gives the first statement. Generations $g$ and $g+2$ start from
+states that agree in the banks, the tapes, $\kappa$ and $\mathrm{booted}=0$. In the
+first pass of a generation the startup records write values that do not depend on
+the cells they read, and every other cell a record reads is written earlier in the
+pass, apart from $\kappa$, the cells under the heads and the sink, whose value
+changes no result; the cells from $2896$ on are never addressed. So the two
+generations perform the same steps and end in the same state.
+Theorem~\ref{thm:physnet} carries the statement to the network.
+\end{proof}
+
+\begin{remark}[Corroboration]\label{rem:storedcheck}
+Three generations from $x_0$ were run on a transcription of
+Definition~\ref{def:twohead} in C, $79{,}464{,}240{,}088$ steps each: after each
+the new active bank held $S$ and the new read tape $\tau_S$, each from its head,
+the other bank and tape still held them, $\kappa$ alternated, and the full state
+after the third generation equalled the state after the first. A transcription in
+Python agreed with the C program on the full state after three passes and
+$12{,}345$ further steps. One pass was compared with the startup, one step of
+$\Nhost$ and the device of Definition~\ref{def:ring} from $300$ random states, a
+fifth of them not booted and a third with requests holding random bytes, with
+random tapes, idle bank, registers and temporaries, and agreed in every case; that no
+record of the step block reads a state bit after the record of its next value, and
+that no temporary is written after its last read, was checked over the records.
+\end{remark}
+
+\begin{remark}\label{rem:storedvn}
+The network $N^{12}_{G,L}$ is the fixed physics; $S$ carries the constructor,
+phase~(A) of $P^\ast$, the copier, phase~(B), and the control, its startup and
+hand-over records; and $\tau_S$ is the description, used twice. The records of $S$ are the
+units of $\Nhost$, weights and biases, compiled into two-input units, together
+with its memory image in the startup records, so each generation rebuilds the
+stored network that computes, its weights included, by the dynamics of a fixed
+network and with no map outside it. The constructor is a universal computer and
+the description a recipe of Section~\ref{sec:univ}.
+\end{remark}
+
+% =============================================================================
+\section{A constructor proved in Rocq}\label{sec:organism}
+% =============================================================================
+
+Theorem~\ref{thm:storedrep} is proved on paper from Theorem~\ref{thm:physnet} and
+was run for three generations. This section gives a smaller stored network, the
+organism, that performs von Neumann's cycle in $T_{G,L}$, the machine of $64$
+cells, with a description code of its own; every step of its reproduction is
+proved in Rocq.
 
 \begin{definition}[The description code]\label{def:code}
 A \emph{gate} is a record that computes the conjunction or the disjunction of
@@ -1658,8 +2053,8 @@ having read the whole word.
 \end{definition}
 
 An image of $n$ records of which $e$ are not gates has a description of
-$22n+8e+4$ bits, and the gates include every unit of a netlist compiled as in
-Corollary~\ref{cor:compile}, conjunctions, disjunctions and negated copies.
+$22n+8e+4$ bits, and the gates include every unit that Lemma~\ref{cor:compile}
+produces.
 
 \begin{lemma}[Completeness of the code]\label{lem:code}
 For every image $X$ of whole records, $\describe(X)$ is a description of $X$.
@@ -1675,12 +2070,13 @@ the end codon closes the induction. The proof is checked in Rocq.
 \begin{construction}[The organism]\label{con:organism}
 The organism $\rho$ is the image of the $133$ records listed in
 Appendix~\ref{app:listings}, $3458$ bits. It uses $36$ window cells: the bank bit,
-the six head and request cells, a sink, thirteen cells that hold the state of a
-decoder, and fifteen temporaries, each written in a pass before it is read in
-that pass. The decoder's state is a mode $m$, construct ($m=0$) or copy, a phase,
-codon C, gate bits G or address bits A, a counter $z$ on five bits and a codon
-register $c_3c_2c_1c_0$. One pass carries out one step of the decoder, with $r$
-the bit under the read head:
+the six head and request cells, the sink, thirteen cells $8$ to $20$ that hold the
+state of a decoder, and fifteen temporaries in cells $21$ to $35$, each written in
+a pass before it is read in that pass. The decoder's state is a mode $m$,
+construct ($m=0$) or copy, in cell $8$; a phase, codon C, gate bits G or address
+bits A, one cell each, $9$, $10$ and $11$; a codon register $c_3c_2c_1c_0$, $c_i$
+in cell $12+i$; and a counter $z=z_4\cdots z_0$, $z_i$ in cell $16+i$. One pass
+carries out one step of the decoder, with $r$ the bit under the read head:
 \begin{enumerate}[label=(\roman*),leftmargin=2em]
 \item in phase C, $r$ is consumed and shifted into the codon register, and in copy
 mode copied under the copy head; at $z=0$ the codon decides: at end the mode
@@ -1721,7 +2117,7 @@ record. The refinement, the independence from the temporaries and the evaluation
 are checked in Rocq.
 \end{proof}
 
-\begin{theorem}[Universal construction by the dynamics]\label{thm:construct}
+\begin{theorem}[Universal construction by the organism]\label{thm:construct}
 Let $X$ be an image of $133$ records and $d$ a description of $X$ of $L$ bits. Let
 $x$ be a state of $T_{133,L}$ with $\rho$ in the active bank $Q_\kappa$ from its
 first record, $d$ on the read tape from its head, and in the window clear
@@ -1752,13 +2148,13 @@ By Lemma~\ref{lem:code} every image of $133$ gates has a description of $2930$
 bits, so in $T_{133,2930}$ the organism builds every image of $133$ gates, and in
 $T_{133,2930+8e}$ every image of $133$ records of which $e$ are not gates.
 
-\begin{theorem}[Self-reproduction by the dynamics]\label{thm:organism}
+\begin{theorem}[Self-reproduction of the organism]\label{thm:organism}
 Let $x_0$ be the state of $T_{133,2930}$ with $\rho$ in $Q_0$, $\describe(\rho)$
 on $D_0$, $Q_1$ and $D_1$ clear, $\kappa=0$, and in the window clear requests and
 the decoder in phase C with $z=3$ in construct mode. For every $g\ge1$, the state
 after $g$ generations of $6924$ passes, $920{,}892$ applications of $T$ each,
 holds $\rho$ in both banks and $\describe(\rho)$ on both tapes, with
-$\kappa=g\bmod2$. The network $N_{133,2930}$ started from the bits of $x_0$ holds
+$\kappa=g\bmod2$. The network $N^6_{133,2930}$ started from the bits of $x_0$ holds
 their bits at the same steps. Its orbit is periodic from the first generation
 on, with a period of two generations.
 \end{theorem}
@@ -1776,281 +2172,16 @@ generations, $2{,}762{,}676$ applications of $T$, in the Rocq kernel, and are
 equal, so the orbit is periodic from the first generation on.
 \end{proof}
 
-\begin{remark}\label{rem:vonneumann}
-The network $N_{133,2930}$ is the fixed physics, the organism the constructor
-and the copier, and $\describe(\rho)$ the description, used twice: translated in
-construct mode and copied in copy mode. The description is not the bank: a gate
-is named by four bits and its eight bits are written by the organism, so the
-description of $\rho$ has $2930$ bits against $3458$ for the bank. What is
-reproduced is the weight set of the network that runs, since the records are
-the units of the stored network, weights and biases included.
-\end{remark}
-
-\begin{remark}[Corroboration]\label{rem:organismcheck}
-Three generations from $x_0$ were run on the transcription of
+\begin{remark}\label{rem:organismcheck}
+The description of $\rho$ has $2930$ bits against $3458$ for the bank: a gate is
+named by four bits and its eight bits are written by the organism. Three
+generations from $x_0$ were also run on the transcription of
 Definition~\ref{def:twohead}, each of $920{,}892$ steps, and on the netlist in C
 beside it (Remark~\ref{rem:physcheck}); after each both banks held $\rho$ and
 both tapes $\describe(\rho)$, and the full state after the third generation
-equalled the state after the first. The first generation was also evaluated in
-the Rocq kernel step by step, $\kappa$ staying $0$ until its last step. The Rocq
-definition of the organism and its description equal those of the
-transcription, and so do the full states of $T$ after $1000$ and $20{,}000$
-steps.
-\end{remark}
-
-% =============================================================================
-\section{Interpreters running interpreters}\label{sec:tower}
-% =============================================================================
-
-The records of the two-head machine name window cells. The record interpreters
-of this section address a state of $2^A$ coordinates through addresses of $A$
-bits and an index register, so that a member of their family can run another
-member, and the constructor of Section~\ref{sec:univ}, as stored netlists. A
-member is fixed by an address width $A$, with state width $S=2^A$, a record
-count $G$, a bias width of $4$ bits, a number of record banks, one or two, and
-an addressed span, the number of coordinates a record may read or write. The
-state $x\in\B^S$ holds, in this order from coordinate $0$: a pointer register
-$\mathrm{PTR}$ of $A$ bits, most significant first; the signals
-$\mathrm{OUT\_DATA}$, $\mathrm{OUT\_STROBE}$, $\mathrm{ADV}$, $\kappa$ (the bank
-bit), $\mathrm{HALT}$ and a sink that no record reads; a data region; and, at the
-top of the state, the record regions $Q_0$ and, for a two-bank member, $Q_1$, of
-$Gb$ bits each, $b$ the record width of Definition~\ref{def:records}. Further
-state bits outside $\B^S$ hold the record counter $g$, on $\lceil\log_2G\rceil$
-bits, and a halt bit. The members used are those of Table~\ref{tab:cfg}; $U$
-denotes the first, a map on $\B^{1029}$.
-
-\begin{table}[ht]
-\centering\small
-\begin{tabular}{@{}lrrrrrrrl@{}}
-\toprule
-Member & $A$ & $S$ & $G$ & $b$ & banks & span & units & Used in\\
-\midrule
-$U$ & $10$ & $1024$ & $11$ & $41$ & 2 & $1024$ & $13{,}034$
- & Constr.~\ref{con:interp}, Rem.~\ref{rem:fanin2}\\
-$U_{128}$ & $7$ & $128$ & $3$ & $32$ & 1 & $32$ & $816$
- & Prop.~\ref{prop:hierarchy}, run\\
-$U_{2^{17}}$ & $17$ & $131{,}072$ & $2088$ & $62$ & 1 & $1616$ & $148{,}571$
- & Prop.~\ref{prop:hierarchy}, running\\
-$U_{2^{15}}$ & $15$ & $32{,}768$ & $535$ & $56$ & 1 & $2808$ & $59{,}348$
- & Thm.~\ref{thm:hosted}\\
-\bottomrule
-\end{tabular}
-\caption{The members of the interpreter family used here. Where the span is
-smaller than $S$ the record regions are read by index only and are not
-themselves addressable.}
-\label{tab:cfg}
-\end{table}
-
-\begin{definition}[Stored netlists]\label{def:records}
-A \emph{record} is a tuple
-$\rho=(a_0,w_0,i_0,\,a_1,w_1,i_1,\,\beta,\,a_o,i_o)$ with addresses
-$a\in\{0,\dots,S-1\}$ on $A$ bits, weights $w\in\Tern$ encoded in two bits by
-$1\mapsto(0,1)$, $-1\mapsto(1,0)$ and $0\mapsto(0,0)$ or $(1,1)$, index flags
-$i\in\B$, and a bias $\beta\in[-8,7]$ in two's complement on four bits, so a
-record occupies $b=2(A+3)+4+(A+1)=3A+11$ bits. For a value of $\mathrm{PTR}$ the
-effective address is $\eff(a,i)=(a+i\cdot\mathrm{PTR})\bmod S$, and a read
-outside the span returns $0$. \emph{Evaluating} $\rho$ on a state $x$ with halt
-bit $0$ produces $x'$ in two stages. First
-\[
-x'_{\eff(a_o,i_o)}\leftarrow
-\Hv\bigl(w_0\,x_{\eff(a_0,i_0)}+w_1\,x_{\eff(a_1,i_1)}+\beta\bigr),
-\]
-all other coordinates being unchanged. Then the \emph{pointer clause}: if
-$x'_{\mathrm{ADV}}=1$, $\mathrm{PTR}$ is incremented modulo $S$ and
-$\mathrm{ADV}$ is cleared. The next halt bit is the disjunction of the halt bit
-with $x_{\mathrm{HALT}}$, and a state with halt bit $1$ is left unchanged. A
-\emph{stored netlist} of length $G$ is a sequence $\rho_0,\dots,\rho_{G-1}$
-encoded in the active record region, $Q_\kappa$. The interpreter applied to a
-state with halt bit $0$ and record counter $g$ evaluates $\rho_g$ and sets the
-counter to $g+1\bmod G$. The output clause is carried out by the runtime: when
-$x'_{\mathrm{OUT\_STROBE}}=1$ the runtime appends $x'_{\mathrm{OUT\_DATA}}$ to an
-output word and clears the strobe.
-\end{definition}
-
-\begin{construction}[The interpreter netlist]\label{con:interp}
-The clocked ternary threshold netlist $N_U$ on $1029$ state bits has $13{,}034$
-units, and $\Lev(N_U)$ has depth $53$; the same blocks give every member of the
-family. A one-hot decoding of the counter by units of the form of
-Lemma~\ref{lem:mem} and, for each record position, a multiplexer on $\kappa$ and
-a disjunction over the records select the bits of $\rho_g$. For each slot the
-conjunctions of the pointer bits with the index flag and an $A$-bit ripple-carry
-chain of full adders form the effective address, which the
-units of Lemma~\ref{lem:mem} decode, and a disjunction of conjunctions reads the
-addressed coordinate. The units $\mathrm{AND}(\overline h,l)$ and
-$\mathrm{AND}(h,\overline l)$ decode a weight code $(h,l)$, and with the read
-value $v$ give $w\cdot v$ in two's complement on six bits, which hold
-$|w_0v_0+w_1v_1+\beta|\le10$; two ripple-carry chains form that sum, and the
-negation of its sign bit is $\Hv$ of the sum. The decoded output address drives a
-multiplexer for each coordinate of the span, which writes the value when the
-halt bit is $0$. The pointer clause adds
-$\mathrm{AND}(\hat x_{\mathrm{ADV}},\overline{\mathrm{halt}})$ to the written
-pointer, the carry into bit $j$ one unit of fan-in $j+1$, and clears
-$\mathrm{ADV}$; the counter is incremented by a ripple-carry chain, reset on the
-one-hot line of $G-1$ and held when the halt bit is $1$, and the next halt bit is
-the disjunction of the halt bit with $x_{\mathrm{HALT}}$. These blocks carry out
-the interpreter of Definition~\ref{def:records} on states whose halt bit is $0$
-and hold a state with halt bit $1$ fixed.
-\end{construction}
-
-\begin{remark}[Corroboration]\label{rem:interpcheck}
-The netlist of $U$ was compared with a transcription of
-Definition~\ref{def:records} on all $576$ configurations of
-$(w_0,w_1,\beta,x_{a_0},x_{a_1})$ and on $4096$ uniformly random full states,
-stored records, pointer, $\mathrm{ADV}$ and counter included; halted states were
-checked to be fixed points and the counter to advance modulo $G$ from every
-value. The netlists of $U_{2^{17}}$ and $U_{2^{15}}$ ran the passes of
-Remarks~\ref{rem:hierarchycheck} and~\ref{rem:hostedcheck}.
-\end{remark}
-
-\begin{definition}[Pass]\label{def:pass}
-A \emph{pass} consists of $G$ consecutive applications of the interpreter
-starting with record counter $0$.
-\end{definition}
-
-\begin{lemma}[Netlists with feedback]\label{lem:feedback}
-Let $\rho_0,\dots,\rho_{G-1}$ be any stored netlist with $\mathrm{PTR}$ constant and
-let $\theta_g\colon\B^S\to\B^S$ evaluate $\rho_g$. Then one pass computes
-$\theta_{G-1}\circ\dots\circ\theta_0$, the sequential update of the automata
-network in record order, and $k$ passes compute its $k$-th iterate.
-\end{lemma}
-
-\begin{proof}
-Definitions~\ref{def:records} and~\ref{def:pass}.
-\end{proof}
-
-Gate-level logic simulation engines evaluate one stored gate per step from
-operand memory and rank-order the gates so that one pass
-suffices~\cite{Denneau1982}, and Lemma~\ref{lem:feedback} is the fixed-order
-sequential schedule of automata networks~\cite{RiosWilsonTheyssier2024c}.
-
-\begin{corollary}[Compilation]\label{cor:compile}
-Every ternary threshold unit $\Hv(\sum_{i\in P}x_i-\sum_{i\in N}x_i+b)$ is a
-threshold over its literals: it is $1$ exactly when at least $t=|N|-b$ of the
-literals $x_i$ ($i\in P$), $\neg x_i$ ($i\in N$) are true. A disjunction
-($t=1$) or a conjunction ($t=k$) of $k>2$ literals is computed by a balanced
-binary tree of $k-1$ two-input units, negated literals being carried by the signs
-of the weights, and a threshold $1<t<k$ by the recursion
-$T_t(x_1,\dots,x_k)=T_t(x_2,\dots,x_k)\vee(x_1\wedge T_{t-1}(x_2,\dots,x_k))$.
-An acyclic netlist of fan-in at most $2$ whose signals and records fit in the
-data region and the record region, compiled one record per unit in topological
-order, is evaluated by one pass.
-\end{corollary}
-
-\begin{proof}
-For the trees pair the literals at the leaves: $\Hv(\pm x\pm y+c)$ with
-$c\in\{0,-1,-2\}$ is the conjunction of any two literals and with
-$c\in\{-1,0,1\}$ their disjunction; each level of the tree halves the number of
-signals, and a signal left over at a level is carried to the next. The recursion
-holds because at least $t$ of $x_1,\dots,x_k$ are true exactly when at least $t$
-of $x_2,\dots,x_k$ are, or $x_1$ is and at least $t-1$ of the others are; its
-two base cases are the trees. A record carries the addresses of the unit's
-predecessors with index flag $0$, its weights and its bias, and writes a fresh
-data address, so by Lemma~\ref{lem:feedback} each record reads values already
-computed in the pass.
-\end{proof}
-
-\begin{remark}\label{rem:fanin2}
-Every unit of fan-in greater than two in $N_U$ is a disjunction or a conjunction
-of literals, and in $\Nhost$ so is every one except the fifteen units of the sum
-bits and the branch, for which the recursion of Corollary~\ref{cor:compile}
-gives four and eight units; the $17{,}598$ units of $\Nhost$ become $33{,}568$
-and the $13{,}034$ of $N_U$ become $40{,}081$, and the rewriting agrees with the
-original netlists on random states. Records may read and write record fields,
-their own included, inside the span: stored netlists of $U$ were run that emit
-their own records, rewrite a weight of their own record between passes, switch
-the active bank, and hold a two-bit counter through feedback.
-\end{remark}
-
-\begin{proposition}[A larger member runs a smaller one]\label{prop:hierarchy}
-For an address width $A$ let $N_2$ be the netlist of fan-in at most $2$ obtained
-from the netlist of $U_{2^A}$ by Corollary~\ref{cor:compile}, with $n_2(A)$
-units, let $c(A)$ be the number of state coordinates of $U_{2^A}$ whose next value
-is not the coordinate itself, and let $m(A)$ be the number of state bits of
-$U_{2^A}$ plus $n_2(A)$. If a one-bank member $U_{S'}$, $S'=2^{A'}$, has
-$G'\ge n_2(A)+c(A)$ records and addressed span at least $m(A)$, then the stored
-netlist consisting of the records of $N_2$ in topological order followed by one
-copy record for each of the $c(A)$ coordinates satisfies: for every state $y$ of
-$U_{2^A}$ held in the input coordinates, one pass of $U_{S'}$ replaces $y$ by
-$U_{2^A}(y)$ there. So $k$ passes carry out $k$ transitions, and $U_{S'}$ runs
-$U_{2^A}$, stored netlist and all. Such $A'$ exist for every $A$, and
-$S'=O(2^AA^2)$ suffices.
-\end{proposition}
-
-\begin{proof}
-By Lemma~\ref{lem:feedback} a pass evaluates the records in order. The records of
-$N_2$ come in topological order and write fresh coordinates, so each reads its
-predecessors after they have been evaluated on $y$, the input coordinates being
-unmodified until the copy records; after them every unit signal holds its value on
-$y$. Each copy record reads a unit signal, which no copy record writes, and writes
-a distinct input coordinate, so after all of them the input coordinates hold
-$U_{2^A}(y)$, those not copied keeping their values, which are their next values.
-No next value of $U_{2^A}$ is another input coordinate, since every next value is
-a multiplexer output, a disjunction, or the coordinate itself. A record of
-$U_{S'}$ occupies $3A'+11$ bits, so the conditions say that the records fit in
-$G'(3A'+11)$ bits and the signals in $S'-G'(3A'+11)$. Since $U_{2^A}$ has
-$O(2^A)$ units of total fan-in $O(2^AA)$, $n_2(A)=O(2^AA)$, and
-$2^{A'}\ge c\,2^AA\,A'$ holds for $A'=A+O(\log A)$.
-\end{proof}
-
-\begin{remark}\label{rem:hierarchycheck}
-For $A=7$ the netlist of $U_{128}$ has $816$ units and its fan-in-two form $1403$
-units on $1534$ signals, and $35$ of its $131$ state coordinates change in a
-transition. The member with $A'=17$ and $G'=2088$ records of $62$ bits has
-$148{,}571$ units and span $1616$. From $48$ uniformly random states of $U_{128}$,
-stored records included, four passes of $2088$ applications each reproduced four
-transitions of $U_{128}$ in every one of its $131$ coordinates.
-\end{remark}
-
-The host's constructor runs inside the family as a stored netlist. Let $P^{128}$
-be the program $P$ with its variable and device cells placed at the same offsets
-from the top of a $128$-byte memory, so that $\cell{0xF0}$ to $\cell{0xFF}$
-become $\cell{0x70}$ to $\cell{0x7F}$; $P$ occupies $\cell{0x00}$ to $\cell{0x3E}$
-and its branch targets are unchanged. The hosted transducer is that of
-Definitions~\ref{def:transducer} and~\ref{def:subleq} with addresses modulo
-$128$, halting at $\cell{0x7F}$, whose tape is the content of a $64$-byte tape
-region and whose output word is held in a $64$-byte output region.
-
-\begin{theorem}[The constructor as a stored netlist]\label{thm:hosted}
-In the member $U_{2^{15}}$ of Table~\ref{tab:cfg} there is a stored netlist of
-$494$ records, holding in data coordinates a $128$-byte memory as eight bit
-planes, the tape region, the output region, the program counter, the head and
-the write pointer, such that one pass carries out one step of the hosted
-transducer from every state in which the head is at most $64$, the write pointer
-at most $63$, the output region clear from the write pointer on and the
-pointer-advance, strobe and halt signals clear; at a step that reaches the halt
-address the interpreter halts within the pass, with the memory, the head and
-the output as the step leaves them. Consequently, for every recipe $r$ with
-$|r|\le64$ and $|\delta(r)|\le63$, the interpreter started from the state holding
-$P^{128}$ and $r$ halts after exactly as many passes as Theorem~\ref{thm:univ}
-gives steps, with the output region holding $\delta(r)$.
-\end{theorem}
-
-\begin{proof}
-A pass evaluates the records in order (Lemma~\ref{lem:feedback}). The records
-form cells, each a fixed sequence of records computing a Boolean function of the
-current values of its sources into a destination through temporaries written
-once: copies, negations, conjunctions and disjunctions of two literals, exclusive
-ors, multiplexers, conjunctions of literals as balanced trees, the addition of a
-constant and an increment gated by a bit; an indexed read or write is a single
-record. In order, the pass forms $p+1$, $p+2$, $p+3$; fetches the three operands
-and the two words they address through the index register; subtracts and tests
-the result; writes it back; applies the device to the memory so updated; and
-replaces the counter by the branch target, raising the halt signal at the halt
-address. Appendix~\ref{app:hosted} proves each cell and each stage, the
-invariants of the run, and the halt.
-\end{proof}
-
-\begin{remark}\label{rem:hostedcheck}
-$U_{2^{15}}$ has $59{,}348$ units in $61$ levels. On the recipe for
-\texttt{ABCCCCCCCCDE}, which exercises a literal token, a repeat token and the end
-token, the interpreter halted in pass $83$, as Theorem~\ref{thm:univ} predicts,
-at application $44{,}358$, with the output region holding the target byte
-for byte, the head at the end of the recipe, and all $128$ memory bytes equal to
-those of the reference machine. One pass was compared with one step of the hosted
-transducer from $2000$ random states on a transcription of
-Definition~\ref{def:records} and from $256$ random states on the netlist, the
-memory, counter, tape, head, write pointer and output below it random, and agreed
-in every case.
+equalled the state after the first. The Rocq definition of the organism and its
+description equal those of the transcription, and so do the full states of $T$
+after $1000$ and $20{,}000$ steps.
 \end{remark}
 
 % =============================================================================
@@ -2094,7 +2225,8 @@ looped transformer whose state tensor holds the program~\cite{Turkcan2026}. Thes
 constructions use real-valued weights, and Loom includes a layer that restores
 persistent state to $\pm1$ after numerical drift. The two-head machine of
 Section~\ref{sec:interp} is a fixed ternary network of the same kind, which
-evaluates any network stored in its own state.
+evaluates any network stored in its own state, and Section~\ref{sec:storedhost}
+stores a SUBLEQ computer in it.
 Valiant's universal circuits are combinational circuits of size
 $\Theta(n\log n)$ that simulate any circuit of size $n$ given its program bits as
 input~\cite{Valiant1976}; intrinsic simulation between families of automata
@@ -2166,9 +2298,11 @@ not imply it, and require that the maps mediating between symbolic computation a
 the dynamics be simpler than the computation attributed to the
 system~\cite{CotlerHonglerHudcova2025}. In those terms Section~\ref{sec:selfrep}
 is a replicator relative to an instantiation map whose cost
-Proposition~\ref{prop:envcost} counts, and Section~\ref{sec:organism} is von
-Neumann's constructor in the configuration space of a fixed threshold network,
-with the configuration holding the weights of the machine that runs.
+Proposition~\ref{prop:envcost} counts, and Sections~\ref{sec:storedhost}
+and~\ref{sec:organism} remove the map: the constructor is a configuration of a
+fixed threshold network, and the configuration holds the weights of the network
+that computes, in Section~\ref{sec:storedhost} the universal computer of
+Section~\ref{sec:host}.
 
 \subsection{Networks that produce their own parameters}
 
@@ -2377,35 +2511,39 @@ or from its $75{,}501$ nonzero entries; and (d) an evaluator in C,
 \texttt{src/netlist\_eval.c}, with its own SUBLEQ reference, device, parser and
 levelization, sharing no code with (a)--(c). Evaluators (b)--(d) are built from
 $\sigma(\Nhost)$, and every generation of every run instantiated its evaluator
-afresh from the bytes the previous generation emitted. The record interpreters
-were evaluated by a transcription of Definition~\ref{def:records}, by the netlist
-of each member, by $\Lev(N_U)$ and by evaluator~(d), and the two-head machine by a
-transcription of Definition~\ref{def:twohead}, by the netlist $N_{G,L}$ in Python
-and in C, and in the Rocq kernel. Separate code in \texttt{src/independent/},
-written from the definitions of this paper, rebuilds $H_A$ from
-Construction~\ref{con:host} for $A=3$ to $12$, levelizes $\sigma(\Nhost)$,
-transcribes Definition~\ref{def:records} to run Proposition~\ref{prop:hierarchy}
-and Theorem~\ref{thm:hosted}, repeats Tables~\ref{tab:curve} to~\ref{tab:bound3}
+afresh from the bytes the previous generation emitted. The two-head machine was
+evaluated by transcriptions of Definition~\ref{def:twohead} in Python and in C, by
+the netlist $N^\alpha_{G,L}$ in Python and in C, and in the Rocq kernel. The
+stored host is built from $\sigma(\Nhost)$ by \texttt{src/stored\_host.py}, which
+also compares one pass with the host's step and the device, and its generations
+are run by \texttt{src/stored\_host\_run.c}, a transcription of
+Definition~\ref{def:twohead} that decodes the active bank once per change of
+$\kappa$; the three generations of Remark~\ref{rem:storedcheck} take $9$ minutes.
+Separate code in \texttt{src/independent/}, written from the definitions of this
+paper, rebuilds $H_A$ from Construction~\ref{con:host} for $A=3$ to $12$,
+levelizes $\sigma(\Nhost)$, repeats Tables~\ref{tab:curve} to~\ref{tab:bound3}
 with a simulator in C and on the accelerator, and maps the datapath onto Loihi
 and Akida; its sizes, depths and exact runs are those stated here, and its noisy
 runs agree with Appendix~\ref{app:measure} within sampling error.
 
 The Rocq development, \texttt{rocq/} in the artifact, has $25$ files and
-$3{,}802$ lines and builds with Rocq 9.1.1 in under four minutes on the machine
-below, most of it in the kernel's evaluations of the first three generations. It
-defines the two-head machine, its netlist block by block, the organism, the
-description code and the decoder, and proves Theorem~\ref{thm:physnet} for every
-bank length $N\ge26$ and tape length $L\ge1$ together with the number of units
-and the weights, Lemma~\ref{lem:code}, Proposition~\ref{prop:pass},
-Theorem~\ref{thm:construct} for images of any number of records with an idle
-bank of their length, and Theorem~\ref{thm:organism}. The file that defines the
+$4{,}017$ lines and builds with Rocq 9.1.1 in under four minutes on the machine
+below, most of it in the kernel's evaluations of the first three generations of
+the organism. It defines the two-head machine for every address width, its
+netlist block by block, the organism, the description code and the decoder, and
+proves Theorem~\ref{thm:physnet} for every address width $\alpha\ge3$, bank
+length $N\ge8+3\alpha$ and tape length $L\ge1$, together with the number of units
+and the weights, the machine of $64$ cells being the case $\alpha=6$ by
+computation; it proves Lemma~\ref{lem:code}, Proposition~\ref{prop:pass},
+Theorem~\ref{thm:construct} for images of any number of records with an idle bank
+of their length, and Theorem~\ref{thm:organism}. The file that defines the
 organism and its description is written by \texttt{src/twohead.py}, and the
-netlist definition, extracted to OCaml, writes a file byte for byte equal to the
-netlist file \texttt{variants/twohead\_physics.bin} that
+netlist definition, extracted to OCaml, writes for $N^6_{133,2930}$ and
+$N^{12}_{5,40}$ files byte for byte equal to those that
 \texttt{src/twohead\_net.py} writes.
 
 Besides the runs recorded in the remarks of Sections~\ref{sec:host}
-to~\ref{sec:tower} and in Appendix~\ref{app:measure}, the following were
+to~\ref{sec:organism} and in Appendix~\ref{app:measure}, the following were
 checked. The encoder satisfies $\delta(\describe(f))=f$ within the bound of
 Lemma~\ref{lem:describe} on the $29$ serialized machines of the artifact,
 $971{,}266{,}155$ bytes, and on $68{,}061$ further strings chosen to straddle
@@ -2419,9 +2557,8 @@ $16{,}320$ steps and the device with its four clauses on $20{,}580$ applications
 $\inst(\ser(\Omega))=\Omega$ on $310$ instances; and rebuilding the host from
 source reproduces its serialization byte for byte. Evaluator~(d) agrees with its
 own reference on $2^{20}$ random full states of the netlist and of its
-levelization, and $\Lev(\Nhost)$ and $\Lev(N_U)$ agree with the netlists they come
-from on random states, every weight in $\Tern$ and every pre-activation an
-integer.
+levelization, and $\Lev(\Nhost)$ agrees with the netlist it comes from on random
+states, every weight in $\Tern$ and every pre-activation an integer.
 
 The constructor was run on the $29$ recipes of the artifact's machines on the
 integer reference, emitting $971{,}266{,}155$ bytes in $4{,}714{,}592{,}952$ steps,
@@ -2458,179 +2595,57 @@ generations on~(d) ran in lockstep.}
 Every run of $\Omega^\ast$ produced the same output, of SHA-256 digest
 \texttt{c5950d3f\ldots6e7fb523}, and the artifact~\cite{Norton2026} is identified by
 the digests of $\ser(\Omega^\ast)$, of the host serialization, of the serialization
-of $N_3$, of $\ser(\Omega^\ast_3)$, of the netlist file of $N_{133,2930}$, and of
+of $N_3$, of $\ser(\Omega^\ast_3)$, of the netlist file of $N^6_{133,2930}$, of
 the organism's record image and its description written as $3458$ and $2930$
-bytes of value $0$ or $1$:
+bytes of value $0$ or $1$, and of the image of the stored host and $\tau_S$ as
+bytes:
 \begin{center}\ttfamily\small
 \begin{tabular}{@{}l@{\quad}l@{}}
 \normalfont $\ser(\Omega^\ast)$ & c5950d3fec6bcf70e8111586a030d21b2dfa55bd69a1c7fe5f016cb06e7fb523\\
 \normalfont $\sigma(\Nhost)$ & 55c555bd64302190d5bde57ee0cd41b36dac5cf65066d0ed3468567a57e85fa3\\
 \normalfont $\sigma(N_3)$ & 111bb202e6f2728449c6b0761f57a059bc0fb38e3e5ba8447bac6613ec7ce313\\
 \normalfont $\ser(\Omega^\ast_3)$ & 05005d59c373fb4998576ac098093de6df046355348e00370dbdccb1d458e3de\\
-\normalfont $N_{133,2930}$ & 0b86fbe2da1d67beafb252a445738794f4eb35ad4aa8987030c65d3612aa50fe\\
+\normalfont $N^6_{133,2930}$ & 0b86fbe2da1d67beafb252a445738794f4eb35ad4aa8987030c65d3612aa50fe\\
 \normalfont organism $\rho$ & e798ce81da252d6717b0f99321aa401924637b48fe09558a6590006de2e2ffe1\\
-\normalfont $\describe(\rho)$ & 59c917d4b2602b253bbae19d9866869587abea197730197fee8054acc8781d54
+\normalfont $\describe(\rho)$ & 59c917d4b2602b253bbae19d9866869587abea197730197fee8054acc8781d54\\
+\normalfont stored host $S$ & 7a769aa264a89860149962d7e98f8b2a5cb34ceb7778e88bcbffdccdc0996154\\
+\normalfont $\tau_S$ & fb23d9b4b41cd5d0576bce37d0cd53a0f63f33de6d4895f2e784eb1148387185
 \end{tabular}
 \end{center}
-The script \texttt{src/verify.py} runs the checks in three tiers, the checks of a
-tier concurrently: the statements, sixteen checks that execute no construction
-and take $3.6$ minutes of wall time on the machine below; every construction end
-to end; and the runs on the threshold evaluators with the perturbation
-experiments. One generation of $\Omega^\ast$ takes $0.3$ seconds on~(a), $45$
-seconds on~(d) and $9$ minutes on~(b), and the artifact records the rate of every
-evaluator. All figures were
+The layouts behind these digests are the following. The metadata of
+$\sigma(\Nhost)$ is \texttt{machine} \texttt{subleq8},
+\texttt{weight\_quantization} \texttt{ternary}, \texttt{signal\_registry} the
+first string below, the state layout of Construction~\ref{con:host} by first
+coordinate and width, with the number of words for the memory, and \texttt{io}
+the second, the addresses of Table~\ref{tab:device}:
+\begin{center}\ttfamily\small
+\{"halt":[8,1],"mem":[9,256,8],"pc":[0,8]\}\\
+\{"c\_eot":250,"c\_rd":252,"c\_rw":251,"c\_wr":249,"halt\_pc":255,"r\_in":253,"r\_out":254\}
+\end{center}
+The scalars are the \texttt{I32} tensors
+\texttt{manifest.addr\_bits}, \texttt{data\_bits}, \texttt{memory\_words},
+\texttt{pc\_width}, \texttt{state\_bits}, \texttt{units} and \texttt{version},
+holding $8$, $8$, $256$, $8$, $2057$, $17{,}598$ and $6$, and the vectors are
+\texttt{net.fanin}, \texttt{net.next} and \texttt{net.pred} of type \texttt{I16}
+and \texttt{net.bias} of type \texttt{I8}. A netlist file holds little-endian
+$32$-bit integers: the numbers of state bits, units and edges; the bias of each
+unit; the fan-in of each unit; one signed entry per edge, its magnitude the index
+of the predecessor plus one and its sign the weight; and, for each state bit, the
+index of the signal computing its next value, the state bits being numbered first,
+in the order of Theorem~\ref{thm:physnet}, and the units after them in the order of
+the Rocq definition. The records of the organism and of $S$ are laid out as in
+Definition~\ref{def:twohead}, with the window cells of
+Constructions~\ref{con:organism} and~\ref{con:stored}; within each block of
+Construction~\ref{con:stored} the order of the records is that of
+\texttt{src/stored\_host.py}, which gives each temporary the least cell free over
+its live interval.
+One generation of $\Omega^\ast$ takes $0.3$ seconds on~(a), $45$ seconds on~(d)
+and $9$ minutes on~(b). All figures were
 produced with Python 3.12.3, PyTorch 2.14.0 with CUDA 12.6, NumPy 2.5.3,
 safetensors 0.8.0 and GCC 13.3.0 on Ubuntu 24.04, on an Intel Core i9-12900H
 with $20$ hardware threads and $31$ GiB of memory and an NVIDIA GeForce RTX 3070
 Ti Laptop GPU with $8$ GiB of memory.
 
-% =============================================================================
-\section{Proof of Theorem~\ref{thm:hosted}}\label{app:hosted}
-% =============================================================================
-
-Throughout, $U'=U_{2^{15}}$: $A=15$, one bank of $G=535$ records of $b=56$ bits
-at the coordinates from $2808$ on, and the addressed span the coordinates $0$ to
-$2807$. Coordinates $0$ to $14$ hold $\mathrm{PTR}$, most significant first,
-$15$ to $19$ hold $\mathrm{OUT\_DATA}$, $\mathrm{OUT\_STROBE}$, $\mathrm{ADV}$,
-$\kappa$ and $\mathrm{HALT}$, and $20$ is the sink. The stored netlist is the
-$494$ records described below, followed by $41$ records with both weights $0$
-and bias $-1$ that write $0$ into the sink, which no record reads. Its signals
-are the work region, coordinates $21$ to $720$, holding the registers
-$\mathrm{PC}$, $P_1$, $P_2$, $P_3$, $\mathrm{NPC}$, $\mathrm{head}$ and $\mathrm{wp}$
-of seven bits and $A$, $B$, $C$, $X$, $Y$, $R$ of eight bits, least significant
-bit first, and the temporaries; the memory, bit $t$ of byte $j$ at $721+128t+j$;
-the tape region, bit $t$ of byte $i$ at $1745+64t+i$; and the output region, bit
-$t$ of byte $i$ at $2257+64t+i$, bit $0$ being the least significant.
-
-A hosted state $(M,p,\tau,h,\omega)$, with $M\in\Sigma^{128}$, $p<128$,
-$\tau\in\Sigma^{64}$, $h\le64$ and an output word $\omega$ of $w\le63$ bytes, is
-\emph{held} by a state $x$ of $U'$ when the memory, the tape region and the
-first $w$ bytes of the output region hold $M$, $\tau$ and $\omega$, the bytes
-from $w$ on of the output region are $0$, the registers $\mathrm{PC}$,
-$\mathrm{head}$ and $\mathrm{wp}$ hold $p$, $h$ and $w$, the signals
-$\mathrm{ADV}$, $\mathrm{OUT\_STROBE}$ and $\mathrm{HALT}$ are $0$, and the record
-counter and the halt bit are $0$.
-
-\subsection*{Records}
-A pass evaluates the records in order, each on the state the records before it
-left (Lemma~\ref{lem:feedback}). The first eight records clear the bits $7$ to
-$14$ of $\mathrm{PTR}$, and the pass writes the low seven bits only by copying a
-register into them, so every indexed slot names a coordinate $\mathrm{base}+p'$
-with $p'\le127$; the bases and offsets used below keep every named coordinate in
-the work, memory, tape or output region or at most one coordinate past the tape
-region, all inside the span, so no read returns the default $0$ in place of a
-stored value. No record writes $\mathrm{ADV}$, $\mathrm{OUT\_STROBE}$, $\kappa$ or
-the bank, so the pointer and output clauses never fire and the stored netlist
-does not change.
-
-\subsection*{Cells}
-Each temporary is the destination of one record, which precedes every record
-that reads it. A record with weights $w_0,w_1$ and bias $\beta$ writes
-$\Hv(w_0x_0+w_1x_1+\beta)$, so the following single records are correct on
-$\B$: a constant, bias $0$ or $-1$ and no input; a copy $\Hv(x-1)$; a negation
-$\Hv(-x)$; a conjunction of two literals, weights $\pm1$ by polarity and bias
-minus the number of positive literals; a disjunction $\Hv(x+y-1)$; an indexed
-read $y\leftarrow x_{\mathrm{base}+\mathrm{PTR}}$, a copy whose input slot carries
-the index flag; an indexed write $x_{\mathrm{base}+\mathrm{PTR}}\leftarrow y$, a
-copy whose output carries the index flag; and the indexed write of $y\wedge g$, a
-conjunction whose output carries the flag. The cells of several records are the
-following, each changing its destination and its temporaries and nothing else.
-\begin{enumerate}[label=(\roman*),leftmargin=2em]
-\item The exclusive or of $a$ and $b$ writes $t_1=a\vee b$, then
-$t_2=\Hv(1-a-b)=\neg(a\wedge b)$, then $t_1\wedge t_2=a\oplus b$. Its last record
-reads only $t_1$ and $t_2$, so the cell is correct when its destination is $a$ or
-$b$.
-\item The multiplexer $d\leftarrow s\,?\,x_1:x_0$ writes $\neg s$, $x_1\wedge s$,
-$x_0\wedge\neg s$ and their disjunction; its last record reads only the two
-conjunctions, so it is correct when $d$ is $x_0$.
-\item The conjunction of $k$ literals pairs them at the leaves of a balanced tree,
-a single literal left over being copied or negated, and conjoins the results
-level by level; the root writes the destination.
-\item The addition of a constant $c$ to a register $s$ on seven bits treats the bit
-positions from the least significant up, with no carry before the first position
-at which $c$ has a $1$: such a position $k$ writes $d_k=\neg s_k$ and starts the
-carry $s_k$; a later position with a $1$ writes $d_k=\neg(s_k\oplus\gamma)$ and the
-carry $s_k\vee\gamma$; a position with a $0$ writes $d_k=s_k\oplus\gamma$ and the carry
-$s_k\wedge\gamma$, or copies $s_k$ while there is no carry. These are the sum and the
-carry of $s_k+c_k+\gamma$, so $d=(s+c)\bmod128$.
-\item The increment of a seven-bit register $s$ by a bit $g$ first forms the carries
-$\gamma_0=g$ and $\gamma_{k+1}=s_k\wedge\gamma_k$ for $k<6$, and then replaces each
-$s_k$ by $s_k\oplus\gamma_k$, by~(i); the carries are formed before any bit
-changes, so $s$ becomes $(s+g)\bmod128$.
-\end{enumerate}
-
-\subsection*{The pass}
-Let $x$ hold $(M,p,\tau,h,\omega)$ with $p\ne\cell{0x7F}$ as the start of a pass,
-let $(M',p',h',\omega')$ be the result of one step of the hosted transducer, and
-write $\pi(v)$ for the copies of the seven low bits of a register $v$ into the
-low bits of $\mathrm{PTR}$, which set $\mathrm{PTR}$ to $v\bmod128$.
-\begin{enumerate}[label=(\alph*),leftmargin=2em]
-\item Eight constants clear the high bits of $\mathrm{PTR}$, and three additions of
-a constant set $P_1$, $P_2$, $P_3$ to $p+1$, $p+2$ and $p+3$ modulo $128$.
-\item $\pi(\mathrm{PC})$ and eight indexed reads at the bases of the eight memory
-planes set $A=M[p]$, bit $t$ from plane $t$; likewise $\pi(P_1)$ and $\pi(P_2)$
-set $B=M[p+1]$ and $C=M[p+2]$, and $\pi(A)$ and $\pi(B)$ set $X=M[a]$ and $Y=M[b]$,
-where $a$ and $b$ are $A$ and $B$ modulo $128$.
-\item Eight negations form the bits of $\neg X$. Position $0$ forms
-$u=y_0\oplus\neg x_0$, $R_0=\neg u$ and the carry $y_0\vee\neg x_0$, the sum and carry
-of $y_0+\neg x_0+1$; each position $k\ge1$ forms $u=y_k\oplus\neg x_k$,
-$R_k=u\oplus\gamma$ and the carry $(y_k\wedge\neg x_k)\vee(u\wedge\gamma)$, the sum and
-carry of $y_k+\neg x_k+\gamma$. Hence $R=Y+\bar X+1=(Y-X)\bmod256$. A chain of
-disjunctions and a negation form $[R=0]$, and its disjunction with $R_7$ is
-$[R\le0]$ in two's complement, as in Lemma~\ref{lem:branch}.
-\item $\pi(B)$ and eight indexed writes store $R$ at $M[b]$. The memory is now the
-memory after the instruction of Definition~\ref{def:subleq}, which we call $N$.
-\item The device acts on $N$. Three conjunctions of eight literals, bit $0$
-positive and bits $1$ to $7$ negated, form the requests
-$\mathrm{wr}=[N[c_{\mathrm{wr}}]=1]$, $\mathrm{rd}$ and $\mathrm{rw}$; a conjunction of
-the literals of $\mathrm{head}$ against the bits of $64$ forms $[h=64]$, which for
-$h\le64$ is $[h\ge64]$, and $g=\mathrm{rd}\wedge\neg[h=64]$. Then $\pi(\mathrm{head})$
-and eight indexed reads of the tape planes give $\tau_h$ when $h<64$; eight
-multiplexers on $g$ load it into $R_{\mathrm{in}}$; a multiplexer on $\mathrm{rd}$
-sets bit $0$ of $c_{\mathrm{eot}}$ to $[h=64]$ and seven conjunctions clear its
-other bits when $\mathrm{rd}=1$; an increment adds $g$ to $\mathrm{head}$, which
-stays at most $64$, and seven conjunctions with $\neg\mathrm{rw}$ clear it on a
-rewind. Then $\pi(\mathrm{wp})$ and eight indexed writes store
-$R_{\mathrm{out}}\wedge\mathrm{wr}$ at byte $w$ of the output region, eight
-conjunctions with $\neg\mathrm{wr}$ clear $R_{\mathrm{out}}$ when it was emitted, an
-increment adds $\mathrm{wr}$ to $\mathrm{wp}$, and twenty-four constants clear the
-three request cells. These are the clauses of Definition~\ref{def:transducer} on
-$N$: a read at $h<64$ loads $\tau_h$, clears $c_{\mathrm{eot}}$ and advances the
-head, a read at $h=64$ sets $c_{\mathrm{eot}}$ and leaves $R_{\mathrm{in}}$ and the
-head, the rewind follows the read, and a write appends $R_{\mathrm{out}}$ to the
-output word and clears it. The clauses touch disjoint cells apart from the head,
-which the read changes before the rewind, as the definition orders them. When
-$\mathrm{wr}=0$ the indexed writes store $0$ at byte $w$, which was $0$. So the
-memory, the head, the output region and $\mathrm{wp}$ now hold $M'$, $h'$,
-$\omega'$ and the length of $\omega'$.
-\item Seven multiplexers on $[R\le0]$ set $\mathrm{NPC}$ to $C\bmod128$ or to $P_3$,
-which is the counter $p'$ of Definition~\ref{def:subleq} modulo $128$; a
-conjunction of the literals of $\mathrm{NPC}$ against the bits of $\cell{0x7F}$
-writes $[p'=\cell{0x7F}]$ into $\mathrm{HALT}$; and seven copies set $\mathrm{PC}$ to
-$\mathrm{NPC}$.
-\end{enumerate}
-If $p'\ne\cell{0x7F}$ the state after the pass holds $(M',p',\tau,h',\omega')$,
-with $\mathrm{HALT}=0$ and the record counter back at $0$ after the no-op records.
-If $p'=\cell{0x7F}$, the record that writes $\mathrm{HALT}$ is followed by one more
-application, which evaluates the first copy into $\mathrm{PC}$ and sets the halt
-bit, the next halt bit being the disjunction with $x_{\mathrm{HALT}}$; after it the
-state is fixed, with the memory, the head and the output as the step leaves
-them. This proves the first statement of the theorem.
-
-\subsection*{The run}
-Let $r$ be a recipe with $|r|\le64$ and $|\delta(r)|\le63$, and let $\tau$ be $r$
-followed by $64-|r|$ bytes $0$. The program $P^{128}$ is $P$ with the cells it
-names moved to the same offsets from the top of the memory, and the proof of
-Theorem~\ref{thm:univ} uses only the transducer, so it holds for $P^{128}$ on
-$\tau$: the run halts after the number of steps the theorem gives, with output
-$\delta(r)$, and it never reads past the end token, so the bytes after $r$ are
-never read and the head stays at most $|r|\le64$. Its output word is a prefix of
-$\delta(r)$ at every step, so it has at most $63$ bytes. The state holding $P^{128}$
-and $r$ holds the initial hosted state, so by induction over the steps, the
-hypothesis of the first statement holding at each, every pass but the last
-carries out a step and the last carries out the halting step and halts, with the
-output region holding $\delta(r)$.
-
 % =============================================================================
 \section{Program listings and the organism}\label{app:listings}
 % =============================================================================
@@ -2702,12 +2717,14 @@ $63$ bytes of $P$.
 consists of the $133$ records below, in the order a pass evaluates them; record
 $k$ is written $k{:}\;{\pm}a\,{\pm}b\;\beta{\to}o$, reading window cells $a$ and $b$
 with weights $\pm1$ and writing cell $o$, and a record with one slot has weight
-$0$ in the other. Cell $\kappa$ is $0$, $\mathrm{rd}$, $\mathrm{arm}$ and
-$\mathrm{cpy}$ are the cells under the read head, the arm and the copy head,
-$\mathrm{AR}$, $\mathrm{AA}$ and $\mathrm{AC}$ the requests that turn them, $m$
-the mode, $\mathrm{C}$, $\mathrm{G}$ and $\mathrm{A}$ the phases, $c_3c_2c_1c_0$
-the codon register and $z_4\cdots z_0$ the counter, in cells $8$ to $20$, and
-$t_{21}$ to $t_{35}$ the temporaries.
+$0$, written $00$, in the other, which names the sink, cell $7$. Cell $\kappa$ is
+$0$; $\mathrm{rd}$, $\mathrm{arm}$ and $\mathrm{cpy}$ are the cells $1$, $2$ and
+$3$ under the read head, the arm and the copy head, and $\mathrm{AR}$,
+$\mathrm{AA}$ and $\mathrm{AC}$ the requests $4$, $5$ and $6$ that turn them; $m$
+is the mode, in cell $8$, $\mathrm{C}$, $\mathrm{G}$ and $\mathrm{A}$ the phases,
+in cells $9$, $10$ and $11$, $c_i$ bit $i$ of the codon register, in cell $12+i$,
+and $z_i$ bit $i$ of the counter, in cell $16+i$; and $t_k$ is the temporary in
+cell $k$.
 
 {\scriptsize\raggedright\noindent \mbox{$0{:}\;{-}z_0\,{-}z_1\;0{\to}t_{21}$}\hspace{0.7em plus 0.5em}
 \mbox{$1{:}\;{+}t_{21}\,{-}z_2\;{-}1{\to}t_{21}$}\hspace{0.7em plus 0.5em}

rocq/Assumptions.v

@@ -2,7 +2,9 @@
 From TH Require Import PhysMain PhysFacts NetMain Complete Run PassLemma Main SelfRep.
 
 Print Assumptions PhysMain.netlist_step.
+Print Assumptions PhysMain.netlist_step64.
 Print Assumptions PhysFacts.phys_size.
+Print Assumptions PhysFacts.phys_size64.
 Print Assumptions PhysFacts.phys_ternary.
 Print Assumptions NetMain.network_orbit.
 Print Assumptions NetMain.network_reproduces.

rocq/NetMain.v

@@ -2,56 +2,67 @@
    reproduces in every generation. *)
 From Stdlib Require Import List Bool Arith ZArith Lia.
 Import ListNotations.
-From TH Require Import TwoHead Tapes Iter Abstract Organism Net Phys PhysSem PhysMain Main.
+From TH Require Import TwoHead Tapes Iter Abstract Organism Net Phys PhysWF PhysSem PhysMain Main.
+
+(* the machine with a window of 2^al cells, iterated *)
+Fixpoint iterA (al n : nat) (s : st) : st :=
+  match n with O => s | S m => iterA al m (stepA al s) end.
+
+Lemma iterA_6 : forall n s, iterA 6 n s = itern n s.
+Proof. induction n as [|n IH]; intro s; [reflexivity|]. cbn [iterA itern]. rewrite stepA_6. apply IH. Qed.
 
 (* the network iterated on its state bits *)
-Fixpoint netiter (N L n : nat) (x : list bool) : list bool :=
-  match n with O => x | S m => netiter N L m (netstep (nst N L) (phys_units N L) (phys_next N L) x) end.
+Fixpoint netiter (al N L n : nat) (x : list bool) : list bool :=
+  match n with
+  | O => x
+  | S m => netiter al N L m (netstep (nst al N L) (phys_units al N L) (phys_next al N L) x)
+  end.
 
-Definition shaped_st (N L : nat) (s : st) : Prop :=
-  length (win s) = 64 /\ length (contents (q0 s)) = N /\ length (contents (q1 s)) = N
+Definition shaped_st (al N L : nat) (s : st) : Prop :=
+  length (win s) = W al /\ length (contents (q0 s)) = N /\ length (contents (q1 s)) = N
   /\ length (contents (d0 s)) = L /\ length (contents (d1 s)) = L.
 
-Lemma step_shaped : forall N L s, 26 <= N -> 1 <= L -> shaped_st N L s -> shaped_st N L (step s).
+Lemma step_shaped : forall al N L s, 3 <= al -> recw al <= N -> 1 <= L ->
+  shaped_st al N L s -> shaped_st al N L (stepA al s).
 Proof.
-  intros N L s HN HL (Hw & H0 & H1 & H2 & H3).
-  destruct (step_eq N L s HN HL H0 H1 H2 H3 Hw) as (qa' & Hqa & Hst).
-  pose proof (tapes_step N L s HN HL H0 H1 H2 H3 Hw qa' Hqa) as T. cbv zeta in T.
+  intros al N L s Hal HN HL (Hw & H0 & H1 & H2 & H3).
+  destruct (step_eq al N L s Hal HN HL H0 H1 H2 H3 Hw) as (qa' & Hqa & Hst).
+  pose proof (tapes_step al N L s Hal HN HL H0 H1 H2 H3 Hw qa' Hqa) as T. cbv zeta in T.
   rewrite <- Hst in T. destruct T as (T0 & T1 & T2 & T3).
   refine (conj _ (conj _ (conj _ (conj _ _)))).
   - rewrite Hst, win_stepres. unfold clearq. rewrite !upd_length, length_wnext. exact Hw.
-  - rewrite T0. destruct (kk s), (advA s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption.
-  - rewrite T1. destruct (kk s), (advA s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption.
-  - rewrite T2. destruct (kk s), (advC s), (advR s); rewrite ?rot1_length, ?length_wrotec; assumption.
-  - rewrite T3. destruct (kk s), (advC s), (advR s); rewrite ?rot1_length, ?length_wrotec; assumption.
+  - rewrite T0. destruct (kk s), (advA al s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption.
+  - rewrite T1. destruct (kk s), (advA al s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption.
+  - rewrite T2. destruct (kk s), (advC al s), (advR al s); rewrite ?rot1_length, ?length_wrotec; assumption.
+  - rewrite T3. destruct (kk s), (advC al s), (advR al s); rewrite ?rot1_length, ?length_wrotec; assumption.
 Qed.
 
 (* every orbit of the network on encoded states is the encoding of the machine's orbit *)
-Theorem network_orbit : forall N L n s, 26 <= N -> 1 <= L -> shaped_st N L s ->
-  netiter N L n (encode s) = encode (itern n s).
+Theorem network_orbit : forall al N L n s, 3 <= al -> recw al <= N -> 1 <= L -> shaped_st al N L s ->
+  netiter al N L n (encode al s) = encode al (iterA al n s).
 Proof.
-  intros N L n. induction n as [|n IH]; intros s HN HL Hs; [reflexivity|].
-  cbn [netiter itern]. pose proof Hs as (Hw & H0 & H1 & H2 & H3).
-  rewrite (netlist_step N L s HN HL Hw H0 H1 H2 H3).
-  apply IH; [exact HN | exact HL |]. apply step_shaped; [exact HN | exact HL | exact Hs].
+  intros al N L n. induction n as [|n IH]; intros s Hal HN HL Hs; [reflexivity|].
+  cbn [netiter iterA]. pose proof Hs as (Hw & H0 & H1 & H2 & H3).
+  rewrite (netlist_step al N L s Hal HN HL Hw H0 H1 H2 H3).
+  apply IH; [exact Hal | exact HN | exact HL |]. apply step_shaped; assumption.
 Qed.
 
-Lemma s0_shaped : shaped_st (26 * 133) 2930 s0.
+Lemma s0_shaped : shaped_st 6 (26 * 133) 2930 s0.
 Proof.
   unfold shaped_st, s0, tape_of, contents. cbn [win q0 q1 d0 d1 fr bk rev]. rewrite !app_nil_r.
   rewrite !repeat_length, length_rho, length_desc. repeat split; reflexivity.
 Qed.
 
-(* The network on 26 * 133 bank bits and 2930 description bits, started from the encoding of
-   s0, holds after g + 1 generations the encoding of a state in which the bank bit is even g,
-   both banks hold the organism and both description tapes its description. *)
+(* The network of the machine with 64 cells, on 26 * 133 bank bits and 2930 description bits,
+   started from the encoding of s0, holds after g + 1 generations the encoding of a state in which
+   the bank bit is even g, both banks hold the organism and both description tapes its description. *)
 Theorem network_reproduces : forall g,
-  exists t, netiter (26 * 133) 2930 (S g * gen_steps) (encode s0) = encode t
+  exists t, netiter 6 (26 * 133) 2930 (S g * gen_steps) (encode 6 s0) = encode 6 t
     /\ wget (win t) KAPPA = Nat.even g
     /\ contents (q0 t) = rho /\ contents (q1 t) = rho
     /\ contents (d0 t) = desc /\ contents (d1 t) = desc.
 Proof.
   intro g. exists (itern (S g * gen_steps) s0). split.
-  - apply network_orbit; [lia | lia | exact s0_shaped].
+  - rewrite <- iterA_6. apply network_orbit; [lia | unfold recw; lia | lia | exact s0_shaped].
   - exact (every_generation g).
 Qed.

rocq/Phys.v

@@ -1,19 +1,23 @@
 (* The two-head physics as a netlist of ternary threshold units, unit for unit in the order of
-   the generator, for banks of N bits and description tapes of L bits. *)
+   the generator, for a window of 2^al cells, banks of N bits and description tapes of L bits. *)
 From Stdlib Require Import List Bool Arith ZArith Lia.
 Import ListNotations.
 From TH Require Import TwoHead Tapes Net Gates.
 
 Section Phys.
-Variables N L : nat.
+Variables al N L : nat.
 
-(* the state: the 61 window cells other than 1, 2 and 3, then Q0, Q1, D0, D1 *)
+(* the window has W cells; all but cells 1, 2 and 3 are state bits *)
+Definition W : nat := 2 ^ al.
+Definition nwin : nat := W - 3.
+
+(* the state: the window cells other than 1, 2 and 3, then Q0, Q1, D0, D1 *)
 Definition realcell (j : nat) : nat := if Nat.eqb j 0 then 0 else j + 3.
-Definition oq0 : nat := 61.
-Definition oq1 : nat := 61 + N.
-Definition od0 : nat := 61 + 2 * N.
-Definition od1 : nat := 61 + 2 * N + L.
-Definition nst : nat := 61 + 2 * N + 2 * L.
+Definition oq0 : nat := nwin.
+Definition oq1 : nat := nwin + N.
+Definition od0 : nat := nwin + 2 * N.
+Definition od1 : nat := nwin + 2 * N + L.
+Definition nst : nat := nwin + 2 * N + 2 * L.
 
 Definition kap : sref := SIn 0.
 Definition fld (j : nat) : sref := SRef 0 j 2.
@@ -21,7 +25,7 @@ Definition fld (j : nat) : sref := SRef 0 j 2.
 Definition head_src (j : nat) : nat * nat :=
   match j with 0 => (od1, od0) | 1 => (oq0, oq1) | _ => (od0, od1) end.
 
-Definition bitsof (a t : nat) : bool := Nat.testbit a (5 - t).
+Definition bitsof (a t : nat) : bool := Nat.testbit a (al - 1 - t).
 
 Definition cellref (a : nat) : sref :=
   if Nat.eqb a 1 || Nat.eqb a 2 || Nat.eqb a 3 then SRef 1 (a - 1) 2
@@ -35,16 +39,16 @@ Definition hatq (bh base m : nat) : sref := if Nat.eqb m 0 then SRef bh 0 5 else
 Definition hatd (dh base m : nat) : sref := if Nat.eqb m 0 then SRef dh 0 6 else SIn (base + m).
 
 (* 0: the record in front of the active bank *)
-Definition blk_fld : block := Blk 26 3 (fun j => mux3 0 j 0 kap (SIn (oq1 + j)) (SIn (oq0 + j))).
+Definition blk_fld : block := Blk (recw al) 3 (fun j => mux3 0 j 0 kap (SIn (oq1 + j)) (SIn (oq0 + j))).
 (* 1: the cells under the read head, the arm and the copy head *)
 Definition blk_head : block :=
   Blk 3 3 (fun j => mux3 1 j 0 kap (SIn (fst (head_src j))) (SIn (snd (head_src j)))).
 (* 2, 3, 4: the decode lines of the two operand addresses and the output address *)
 Definition blk_dec (o : nat) : block :=
-  Blk 64 1 (fun a => [sAND (map (fun t => (fld (o + t), bitsof a t)) (seq 0 6))]).
+  Blk W 1 (fun a => [sAND (map (fun t => (fld (o + t), bitsof a t)) (seq 0 al))]).
 (* 5 to 8: the two operands *)
-Definition blk_term (bdec : nat) : block := Blk 64 1 (fun a => [sAND [(SRef bdec a 0, true); (cellref a, true)]]).
-Definition blk_xs (bterm : nat) : block := Blk 1 1 (fun _ => [sOR (map (fun a => (SRef bterm a 0, true)) (seq 0 64))]).
+Definition blk_term (bdec : nat) : block := Blk W 1 (fun a => [sAND [(SRef bdec a 0, true); (cellref a, true)]]).
+Definition blk_xs (bterm : nat) : block := Blk 1 1 (fun _ => [sOR (map (fun a => (SRef bterm a 0, true)) (seq 0 W))]).
 (* 9 to 17: the weights, the bias and the threshold *)
 Definition blk_pos : block := Blk 2 1 (fun i => [sAND [(fld (2 * i), false); (fld (2 * i + 1), true)]]).
 Definition blk_neg : block := Blk 2 1 (fun i => [sAND [(fld (2 * i), true); (fld (2 * i + 1), false)]]).
@@ -63,14 +67,14 @@ Definition blk_bge : block :=
 Definition blk_vand : block := Blk 5 1 (fun i => [sAND [(SRef 13 i 0, true); (SRef 15 0 (vand_bge i), true)]]).
 Definition blk_v : block := Blk 1 1 (fun _ => [sOR (map (fun i => (SRef 16 i 0, true)) (seq 0 5))]).
 (* 18, 19: the window after the write, and the cleared request cells *)
-Definition blk_xhat : block := Blk 61 3 (fun j => mux3 18 j 0 (SRef 4 (realcell j) 0) (SRef 17 0 0) (SIn j)).
+Definition blk_xhat : block := Blk nwin 3 (fun j => mux3 18 j 0 (SRef 4 (realcell j) 0) (SRef 17 0 0) (SIn j)).
 Definition blk_zero : block := Blk 1 1 (fun _ => [sOR []]).
 (* 20 to 23: the banks; idlep is the value of kappa for which the bank is idle *)
 Definition blk_bankh (bh : nat) (idlep : bool) (base : nat) : block :=
   Blk 1 6 (fun _ => [sAND [(kap, idlep); (SRef 18 2 2, true)]; sAND [(kap, idlep); (SRef 18 2 2, false)];
                      sAND [(SRef 4 2 0, true); (kap, idlep)]] ++ mux3 bh 0 3 (SRef bh 0 2) (SRef 17 0 0) (SIn base)).
 Definition blk_bank (bb bh : nat) (idlep : bool) (base : nat) : block :=
-  Blk N 4 (fun i => [sAND [(kap, negb idlep); (SIn (base + (i + 26) mod N), true)];
+  Blk N 4 (fun i => [sAND [(kap, negb idlep); (SIn (base + (i + recw al) mod N), true)];
                      sAND [(SRef bh 0 0, true); (hatq bh base ((i + 1) mod N), true)];
                      sAND [(SRef bh 0 1, true); (hatq bh base i, true)];
                      sOR [(SRef bb i 0, true); (SRef bb i 1, true); (SRef bb i 2, true)]]).
@@ -83,14 +87,14 @@ Definition blk_desc (db dh base : nat) : block :=
   Blk L 3 (fun i => mux3 db i 0 (SRef dh 0 2) (hatd dh base ((i + 1) mod L)) (hatd dh base i)).
 
 Definition phys_blocks : list block :=
-  [blk_fld; blk_head; blk_dec 8; blk_dec 14; blk_dec 20; blk_term 2; blk_xs 5; blk_term 3; blk_xs 7;
-   blk_pos; blk_neg; blk_mt; blk_nt; blk_pge; blk_b4; blk_bge; blk_vand; blk_v; blk_xhat; blk_zero;
+  [blk_fld; blk_head; blk_dec 8; blk_dec (8 + al); blk_dec (8 + 2 * al); blk_term 2; blk_xs 5; blk_term 3;
+   blk_xs 7; blk_pos; blk_neg; blk_mt; blk_nt; blk_pge; blk_b4; blk_bge; blk_vand; blk_v; blk_xhat; blk_zero;
    blk_bankh 20 true oq0; blk_bank 21 20 true oq0; blk_bankh 22 false oq1; blk_bank 23 22 false oq1;
    blk_desch 24 true od0; blk_desc 25 24 od0; blk_desch 26 false od1; blk_desc 27 26 od1].
 
 (* the unit computing the next value of each state bit *)
 Definition out_ref (i : nat) : sref :=
-  if i <? 61 then (if Nat.eqb i 1 || Nat.eqb i 2 || Nat.eqb i 3 then SRef 19 0 0 else SRef 18 i 2)
+  if i <? nwin then (if Nat.eqb i 1 || Nat.eqb i 2 || Nat.eqb i 3 then SRef 19 0 0 else SRef 18 i 2)
   else if i <? oq1 then SRef 21 (i - oq0) 3
   else if i <? od0 then SRef 23 (i - oq1) 3
   else if i <? od1 then SRef 25 (i - od0) 2

rocq/PhysFacts.v

@@ -3,14 +3,18 @@ From Stdlib Require Import List Bool Arith ZArith Lia.
 Import ListNotations.
 From TH Require Import TwoHead Net Gates Phys PhysWF.
 
-Lemma phys_size : forall N L, length (phys_units N L) = 647 + 8 * N + 6 * L.
+Lemma phys_size : forall al N L, 3 <= al -> length (phys_units al N L) = 8 * 2 ^ al + 9 * al + 81 + 8 * N + 6 * L.
 Proof.
-  intros N L. unfold phys_units. rewrite length_compile by apply phys_shaped.
+  intros al N L Hal. pose proof (W_ge al Hal) as HW. unfold phys_units. rewrite length_compile by apply phys_shaped.
   rewrite phys_length. cbn [phys_blocks boff bcount bsize blk_fld blk_head blk_dec blk_term blk_xs blk_pos
     blk_neg blk_mt blk_nt blk_pge blk_b4 blk_bge blk_vand blk_v blk_xhat blk_zero blk_bankh blk_bank
-    blk_desch blk_desc]. lia.
+    blk_desch blk_desc]. unfold nwin, recw, W in *. lia.
 Qed.
 
+(* the machine of 64 cells *)
+Corollary phys_size64 : forall N L, length (phys_units 6 N L) = 647 + 8 * N + 6 * L.
+Proof. intros N L. rewrite phys_size by lia. cbn [Nat.pow]. lia. Qed.
+
 Definition ter (u : su) : Prop := forall x w, In (x, w) (sin u) -> w = 1%Z \/ w = (-1)%Z.
 
 Lemma ter_lits : forall b ls, ter (SU b (map lw ls)).
@@ -35,9 +39,9 @@ Proof.
   - destruct r; [exact Hu | apply IH].
 Qed.
 
-Lemma ter_shapes : forall N L b j, Forall ter (bshape (nth b (phys_blocks N L) blk0) j).
+Lemma ter_shapes : forall al N L b j, Forall ter (bshape (nth b (phys_blocks al N L) blk0) j).
 Proof.
-  intros N L b j.
+  intros al N L b j.
   do 28 (destruct b as [|b];
     [ cbn [nth phys_blocks bshape blk_fld blk_head blk_dec blk_term blk_xs blk_pos blk_neg blk_mt blk_nt
            blk_pge blk_b4 blk_bge blk_vand blk_v blk_xhat blk_zero blk_bankh blk_bank blk_desch blk_desc];
@@ -50,10 +54,10 @@ Proof.
 Qed.
 
 (* every unit of the netlist reads its predecessors with weight +1 or -1 *)
-Theorem phys_ternary : forall N L u, In u (phys_units N L) ->
+Theorem phys_ternary : forall al N L u, In u (phys_units al N L) ->
   forall i w, In (i, w) (tin u) -> w = 1%Z \/ w = (-1)%Z.
 Proof.
-  intros N L u Hu i w Hin. unfold phys_units, compile in Hu.
+  intros al N L u Hu i w Hin. unfold phys_units, compile in Hu.
   apply in_concat in Hu as (us & Hus & Hu). apply in_map_iff in Hus as (blk & <- & Hblk).
   unfold flat_block in Hu. apply in_concat in Hu as (us & Hus & Hu).
   apply in_map_iff in Hus as (j & <- & Hj). apply in_map_iff in Hu as (v & <- & Hv).
@@ -61,5 +65,5 @@ Proof.
   cbn [fst snd] in E. injection E as _ <-.
   apply In_nth with (d := blk0) in Hblk as (b & _ & <-).
   apply In_nth with (d := su0) in Hv as (r & _ & <-).
-  exact (ter_nth _ r (ter_shapes N L b j) x w' Hin).
+  exact (ter_nth _ r (ter_shapes al N L b j) x w' Hin).
 Qed.

rocq/PhysMain.v

@@ -3,89 +3,106 @@ From Stdlib Require Import List Bool Arith ZArith Lia.
 Import ListNotations.
 From TH Require Import TwoHead Tapes Abstract Net Gates Phys PhysWF PhysSem.
 
-Lemma F_unfold : forall N L s x,
-  run (phys_units N L) (nst N L) (fun i => nth i (encode s) false) (idx (nst N L) (phys_blocks N L) x) = F N L s x.
+Lemma F_unfold : forall al N L s x,
+  run (phys_units al N L) (nst al N L) (fun i => nth i (encode al s) false) (idx (nst al N L) (phys_blocks al N L) x)
+  = F al N L s x.
 Proof. intros. unfold F, X. reflexivity. Qed.
 
-Lemma wget_clearq_req : forall w a, length w = 64 -> a = 4 \/ a = 5 \/ a = 6 -> wget (clearq w) a = false.
+Lemma wget_clearq_req : forall w a, 7 <= length w -> a = 4 \/ a = 5 \/ a = 6 -> wget (clearq w) a = false.
 Proof.
-  intros w a Hw Ha. unfold clearq, AA, AR, AC. rewrite !wget_upd, !upd_length, Hw.
+  intros w a Hw Ha. unfold clearq, AA, AR, AC. rewrite !wget_upd, !upd_length.
+  replace (Nat.ltb 4 (length w)) with true by (symmetry; apply Nat.ltb_lt; lia).
+  replace (Nat.ltb 5 (length w)) with true by (symmetry; apply Nat.ltb_lt; lia).
+  replace (Nat.ltb 6 (length w)) with true by (symmetry; apply Nat.ltb_lt; lia).
   destruct Ha as [-> | [-> | ->]]; reflexivity.
 Qed.
 
 Lemma win_stepres : forall s k qa' ao v, win (stepres s k qa' ao v) = clearq (wnext (win s) ao v).
 Proof. intros s k qa' ao v. unfold stepres. cbv zeta. destruct k; reflexivity. Qed.
 
-Lemma length_wrote : forall s l h, length (wrote s l h) = length l.
-Proof. intros s l h. unfold wrote. destruct h; [apply wr0_length|reflexivity]. Qed.
+Lemma length_wrote : forall al s l h, length (wrote al s l h) = length l.
+Proof. intros al s l h. unfold wrote. destruct h; [apply wr0_length|reflexivity]. Qed.
 
-Lemma length_wrotec : forall s l h, length (wrotec s l h) = length l.
-Proof. intros s l h. unfold wrotec. destruct h; [apply wr0_length|reflexivity]. Qed.
+Lemma length_wrotec : forall al s l h, length (wrotec al s l h) = length l.
+Proof. intros al s l h. unfold wrotec. destruct h; [apply wr0_length|reflexivity]. Qed.
 
-(* From any state whose banks hold N >= 26 bits, whose description tapes hold L >= 1 bits and
-   whose window has 64 cells, the netlist, evaluated unit by unit on the encoded state, gives
-   the encoding of the next state. *)
-Theorem netlist_step : forall N L s, 26 <= N -> 1 <= L -> length (win s) = 64 ->
+(* From any state of the machine with a window of 2^al cells, al >= 3, whose banks hold
+   N >= 8 + 3 al bits and whose description tapes hold L >= 1 bits, the netlist, evaluated unit
+   by unit on the encoded state, gives the encoding of the next state. *)
+Theorem netlist_step : forall al N L s, 3 <= al -> recw al <= N -> 1 <= L -> length (win s) = W al ->
   length (contents (q0 s)) = N -> length (contents (q1 s)) = N ->
   length (contents (d0 s)) = L -> length (contents (d1 s)) = L ->
-  netstep (nst N L) (phys_units N L) (phys_next N L) (encode s) = encode (step s).
+  netstep (nst al N L) (phys_units al N L) (phys_next al N L) (encode al s) = encode al (stepA al s).
 Proof.
-  intros N L s HN HL Hw H0 H1 H2 H3.
-  destruct (step_eq N L s HN HL H0 H1 H2 H3 Hw) as (qa' & Hqa & Hst).
-  pose proof (tapes_step N L s HN HL H0 H1 H2 H3 Hw qa' Hqa) as T. cbv zeta in T.
+  intros al N L s Hal HN HL Hw H0 H1 H2 H3.
+  pose proof (W_ge al Hal) as HW8. pose proof (nwin_W al Hal) as HnW.
+  destruct (step_eq al N L s Hal HN HL H0 H1 H2 H3 Hw) as (qa' & Hqa & Hst).
+  pose proof (tapes_step al N L s Hal HN HL H0 H1 H2 H3 Hw qa' Hqa) as T. cbv zeta in T.
   rewrite <- Hst in T. destruct T as (T0 & T1 & T2 & T3).
-  assert (L0 : length (contents (q0 (step s))) = N)
-    by (rewrite T0; destruct (kk s), (advA s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption).
-  assert (L1 : length (contents (q1 (step s))) = N)
-    by (rewrite T1; destruct (kk s), (advA s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption).
-  assert (L2 : length (contents (d0 (step s))) = L)
-    by (rewrite T2; destruct (kk s), (advC s), (advR s); rewrite ?rot1_length, ?length_wrotec; assumption).
-  assert (L3 : length (contents (d1 (step s))) = L)
-    by (rewrite T3; destruct (kk s), (advC s), (advR s); rewrite ?rot1_length, ?length_wrotec; assumption).
+  assert (L0 : length (contents (q0 (stepA al s))) = N)
+    by (rewrite T0; destruct (kk s), (advA al s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption).
+  assert (L1 : length (contents (q1 (stepA al s))) = N)
+    by (rewrite T1; destruct (kk s), (advA al s); rewrite ?rot1_length, ?length_wrote, ?rotn_length; assumption).
+  assert (L2 : length (contents (d0 (stepA al s))) = L)
+    by (rewrite T2; destruct (kk s), (advC al s), (advR al s); rewrite ?rot1_length, ?length_wrotec; assumption).
+  assert (L3 : length (contents (d1 (stepA al s))) = L)
+    by (rewrite T3; destruct (kk s), (advC al s), (advR al s); rewrite ?rot1_length, ?length_wrotec; assumption).
   unfold netstep, phys_next. rewrite map_map.
   apply nth_ext with (d := false) (d' := false).
-  { rewrite length_map, length_seq, (length_encode (step s) N L L0 L1 L2 L3). reflexivity. }
+  { rewrite length_map, length_seq, (length_encode al (stepA al s) N L L0 L1 L2 L3). reflexivity. }
   intros i Hi. rewrite length_map, length_seq in Hi.
-  rewrite (nth_map_seq _ (fun i => run (phys_units N L) (nst N L) (fun i0 => nth i0 (encode s) false)
-                                   (idx (nst N L) (phys_blocks N L) (out_ref N L i))) (nst N L) i false Hi).
+  rewrite (nth_map_seq _ (fun i => run (phys_units al N L) (nst al N L) (fun i0 => nth i0 (encode al s) false)
+                                   (idx (nst al N L) (phys_blocks al N L) (out_ref al N L i))) (nst al N L) i false Hi).
   rewrite F_unfold.
-  rewrite (nth_encode (step s) N L i L0 L1 L2 L3).
+  rewrite (nth_encode al (stepA al s) N L i L0 L1 L2 L3).
   unfold out_ref, oq0, oq1, od0, od1, nst in *.
-  destruct (Nat.ltb_spec i 61) as [Hw61|Hw61].
+  destruct (Nat.ltb_spec i (nwin al)) as [Hwi|Hwi].
   - (* the window *)
     rewrite Hst, win_stepres.
     destruct (Nat.eqb i 1 || Nat.eqb i 2 || Nat.eqb i 3) eqn:E.
-    + rewrite (F_zero N L s HN HL H0 H1 H2 H3). symmetry. apply wget_clearq_req; [rewrite length_wnext; exact Hw|].
+    + rewrite (F_zero al N L s Hal HN HL H0 H1 H2 H3). symmetry.
+      apply wget_clearq_req; [rewrite length_wnext; lia|].
       unfold realcell. apply orb_true_iff in E as [E|E]; [apply orb_true_iff in E as [E|E]|];
         apply Nat.eqb_eq in E; subst i; cbn; lia.
-    + rewrite (F_xhat N L s HN HL H0 H1 H2 H3 i Hw61).
+    + rewrite (F_xhat al N L s Hal HN HL H0 H1 H2 H3 i Hwi).
       apply orb_false_iff in E as [E E3]. apply orb_false_iff in E as [E1 E2].
       apply Nat.eqb_neq in E1, E2, E3.
-      assert (Hr : realcell i < 64 /\ realcell i <> 1 /\ realcell i <> 2 /\ realcell i <> 3
+      assert (Hr : realcell i < W al /\ realcell i <> 1 /\ realcell i <> 2 /\ realcell i <> 3
                    /\ realcell i <> AA /\ realcell i <> AR /\ realcell i <> AC)
         by (unfold realcell, AA, AR, AC; destruct (Nat.eqb_spec i 0); lia).
       destruct Hr as (R0 & R1 & R2 & R3 & R4 & R5 & R6).
-      rewrite wget_clearq_other by assumption. rewrite (wget_wn N L s) by assumption. reflexivity.
-  - destruct (Nat.ltb_spec i (61 + N)) as [Hq|Hq].
+      rewrite wget_clearq_other by assumption.
+      rewrite (wget_wn al N L s Hal HN HL H0 H1 H2 H3 Hw) by assumption. reflexivity.
+  - destruct (Nat.ltb_spec i (nwin al + N)) as [Hq|Hq].
     + (* bank 0 *)
-      rewrite (F_bank N L s HN HL H0 H1 H2 H3 20 21 true 61 (q0 s)
-                 ltac:(left; repeat split) (i - 61) ltac:(lia)).
+      rewrite (F_bank al N L s Hal HN HL H0 H1 H2 H3 20 21 true (oq0 al) (q0 s)
+                 ltac:(left; repeat split) (i - nwin al) ltac:(lia)).
       rewrite T0. destruct (kk s); reflexivity.
-    + destruct (Nat.ltb_spec i (61 + 2 * N)) as [Hq'|Hq'].
+    + destruct (Nat.ltb_spec i (nwin al + 2 * N)) as [Hq'|Hq'].
       * (* bank 1 *)
-        replace (i - (61 + N)) with (i - 61 - N) by lia.
-        rewrite (F_bank N L s HN HL H0 H1 H2 H3 22 23 false (oq1 N) (q1 s)
-                   ltac:(right; repeat split) (i - 61 - N) ltac:(lia)).
+        replace (i - (nwin al + N)) with (i - nwin al - N) by lia.
+        rewrite (F_bank al N L s Hal HN HL H0 H1 H2 H3 22 23 false (oq1 al N) (q1 s)
+                   ltac:(right; repeat split) (i - nwin al - N) ltac:(lia)).
         rewrite T1. destruct (kk s); reflexivity.
-      * destruct (Nat.ltb_spec i (61 + 2 * N + L)) as [Hd|Hd].
+      * destruct (Nat.ltb_spec i (nwin al + 2 * N + L)) as [Hd|Hd].
         -- (* description tape 0 *)
-           replace (i - (61 + 2 * N)) with (i - 61 - 2 * N) by lia.
-           rewrite (F_desc N L s HN HL H0 H1 H2 H3 24 25 true (od0 N) (d0 s)
-                      ltac:(left; repeat split) (i - 61 - 2 * N) ltac:(lia)).
+           replace (i - (nwin al + 2 * N)) with (i - nwin al - 2 * N) by lia.
+           rewrite (F_desc al N L s Hal HN HL H0 H1 H2 H3 24 25 true (od0 al N) (d0 s)
+                      ltac:(left; repeat split) (i - nwin al - 2 * N) ltac:(lia)).
            rewrite T2. destruct (kk s); reflexivity.
         -- (* description tape 1 *)
-           replace (i - (61 + 2 * N + L)) with (i - 61 - 2 * N - L) by lia.
-           rewrite (F_desc N L s HN HL H0 H1 H2 H3 26 27 false (od1 N L) (d1 s)
-                      ltac:(right; repeat split) (i - 61 - 2 * N - L) ltac:(lia)).
+           replace (i - (nwin al + 2 * N + L)) with (i - nwin al - 2 * N - L) by lia.
+           rewrite (F_desc al N L s Hal HN HL H0 H1 H2 H3 26 27 false (od1 al N L) (d1 s)
+                      ltac:(right; repeat split) (i - nwin al - 2 * N - L) ltac:(lia)).
            rewrite T3. destruct (kk s); reflexivity.
 Qed.
+
+(* the machine of 64 cells, which runs the organism, is the case al = 6 *)
+Corollary netlist_step64 : forall N L s, 26 <= N -> 1 <= L -> length (win s) = 64 ->
+  length (contents (q0 s)) = N -> length (contents (q1 s)) = N ->
+  length (contents (d0 s)) = L -> length (contents (d1 s)) = L ->
+  netstep (nst 6 N L) (phys_units 6 N L) (phys_next 6 N L) (encode 6 s) = encode 6 (step s).
+Proof.
+  intros N L s HN HL Hw H0 H1 H2 H3. rewrite <- stepA_6.
+  apply netlist_step; first [exact Hw | assumption | unfold recw; lia | lia].
+Qed.

rocq/PhysSem.v

@@ -4,39 +4,124 @@ Import ListNotations.
 From TH Require Import TwoHead Tapes Abstract Net Gates Phys PhysWF.
 
 (* the state bits of a machine state, in the order of the netlist *)
-Definition encode (s : st) : list bool :=
-  map (fun j => wget (win s) (realcell j)) (seq 0 61)
+Definition encode (al : nat) (s : st) : list bool :=
+  map (fun j => wget (win s) (realcell j)) (seq 0 (nwin al))
   ++ contents (q0 s) ++ contents (q1 s) ++ contents (d0 s) ++ contents (d1 s).
 
-Lemma length_encode : forall s N L,
+Lemma length_encode : forall al s N L,
   length (contents (q0 s)) = N -> length (contents (q1 s)) = N ->
   length (contents (d0 s)) = L -> length (contents (d1 s)) = L ->
-  length (encode s) = nst N L.
+  length (encode al s) = nst al N L.
 Proof.
-  intros s N L H1 H2 H3 H4. unfold encode, nst.
+  intros al s N L H1 H2 H3 H4. unfold encode, nst.
   rewrite !length_app, length_map, length_seq, H1, H2, H3, H4. lia.
 Qed.
 
+(* ---- addresses of al bits, most significant first ---------------------------------- *)
+Lemma bits2nat_acc_eq : forall l acc, bits2nat_acc acc l = acc * 2 ^ length l + bits2nat l.
+Proof.
+  unfold bits2nat. induction l as [|b l IH]; intro acc; cbn [bits2nat_acc length Nat.pow].
+  - lia.
+  - rewrite (IH (2 * acc + (if b then 1 else 0))), (IH (2 * 0 + (if b then 1 else 0))). destruct b; nia.
+Qed.
+
+Lemma bits2nat_cons : forall b l, bits2nat (b :: l) = (if b then 2 ^ length l else 0) + bits2nat l.
+Proof.
+  intros b l. unfold bits2nat at 1. cbn [bits2nat_acc]. rewrite bits2nat_acc_eq. destruct b; lia.
+Qed.
+
+Lemma bits2nat_lt : forall l, bits2nat l < 2 ^ length l.
+Proof.
+  induction l as [|b l IH]; [cbn; lia|].
+  rewrite bits2nat_cons. cbn [length Nat.pow]. destruct b; lia.
+Qed.
+
+Lemma testbit_bits2nat : forall l t, t < length l ->
+  Nat.testbit (bits2nat l) (length l - 1 - t) = nth t l false.
+Proof.
+  induction l as [|b l IH]; intros t Ht; cbn [length] in Ht; [lia|].
+  rewrite bits2nat_cons. cbn [length]. pose proof (bits2nat_lt l) as Hlt.
+  destruct t as [|t].
+  - cbn [nth]. replace (S (length l) - 1 - 0) with (length l) by lia.
+    apply Nat.b2n_inj. rewrite Nat.testbit_spec'.
+    destruct b.
+    + replace (2 ^ length l + bits2nat l) with (1 * 2 ^ length l + bits2nat l) by lia.
+      rewrite Nat.div_add_l by (apply Nat.pow_nonzero; lia). rewrite Nat.div_small by exact Hlt. reflexivity.
+    + rewrite Nat.add_0_l, Nat.div_small by exact Hlt. reflexivity.
+  - cbn [nth]. replace (S (length l) - 1 - S t) with (length l - 1 - t) by lia.
+    rewrite <- (Nat.mod_pow2_bits_low _ (length l)) by lia.
+    replace ((if b then 2 ^ length l else 0) + bits2nat l) with (bits2nat l + (if b then 1 else 0) * 2 ^ length l)
+      by (destruct b; lia).
+    rewrite Nat.Div0.mod_add, Nat.mod_small by exact Hlt.
+    apply IH. lia.
+Qed.
+
+Lemma bits_eq_nat : forall x y w, x < 2 ^ w -> y < 2 ^ w ->
+  (forall i, i < w -> Nat.testbit x i = Nat.testbit y i) -> x = y.
+Proof.
+  intros x y w Hx Hy H. apply Nat.bits_inj. intro n.
+  destruct (Nat.lt_ge_cases n w) as [Hn|Hn]; [apply H; exact Hn|].
+  assert (Z0 : forall z, z < 2 ^ w -> Nat.testbit z n = false).
+  { intros z Hz. apply Bool.not_true_is_false. intro E.
+    pose proof (Nat.testbit_spec' z n) as S. rewrite E in S. cbn [Nat.b2n] in S.
+    rewrite Nat.div_small in S; [cbn in S; discriminate|].
+    pose proof (Nat.pow_le_mono_r 2 w n ltac:(lia) Hn). lia. }
+  rewrite !Z0 by assumption. reflexivity.
+Qed.
+
+Lemma dec_okA : forall al f a, length f = al -> a < 2 ^ al ->
+  forallb (fun t => Bool.eqb (nth t f false) (bitsof al a t)) (seq 0 al) = Nat.eqb (bits2nat f) a.
+Proof.
+  intros al f a Hf Ha. unfold bitsof.
+  destruct (forallb (fun t => Bool.eqb (nth t f false) (Nat.testbit a (al - 1 - t))) (seq 0 al)) eqn:E; symmetry.
+  - apply Nat.eqb_eq. apply (bits_eq_nat _ _ al); [rewrite <- Hf; apply bits2nat_lt | exact Ha |].
+    intros i Hi. rewrite forallb_forall in E. specialize (E (al - 1 - i) ltac:(apply in_seq; lia)).
+    apply Bool.eqb_prop in E. replace (al - 1 - (al - 1 - i)) with i in E by lia.
+    rewrite <- E. pose proof (testbit_bits2nat f (al - 1 - i) ltac:(lia)) as T.
+    rewrite Hf in T. replace (al - 1 - (al - 1 - i)) with i in T by lia. exact T.
+  - apply Nat.eqb_neq. intro Eq. subst a.
+    assert (Et : forallb (fun t => Bool.eqb (nth t f false) (Nat.testbit (bits2nat f) (al - 1 - t))) (seq 0 al) = true).
+    { apply forallb_forall. intros t Ht. apply in_seq in Ht.
+      pose proof (testbit_bits2nat f t ltac:(lia)) as T. rewrite Hf in T. rewrite T. apply eqb_reflx. }
+    congruence.
+Qed.
+
+(* the step of the machine with a window of 2^al cells, unfolded *)
+Lemma step_charA : forall al s k bits qa' a0 w0 a1 w1 beta ao v,
+  wget (win s) KAPPA = k ->
+  popn (recw al) (if k then q1 s else q0 s) = (bits, qa') ->
+  decodeA al bits = Rec a0 w0 a1 w1 beta ao ->
+  v = Z.leb 0 (w0 * b2z (cellof s k a0) + w1 * b2z (cellof s k a1) + beta)%Z ->
+  stepA al s = stepres s k qa' ao v.
+Proof.
+  intros al s k bits qa' a0 w0 a1 w1 beta ao v Hk Hp Hd Hv.
+  unfold stepA, stepres, cellof, wnext, clearq. cbv zeta. rewrite Hk, Hp, Hd. subst v. reflexivity.
+Qed.
+
 Section Sem.
-Variables (N L : nat) (s : st).
-Hypotheses (HN : 26 <= N) (HL : 1 <= L)
+Variables (al N L : nat) (s : st).
+Hypotheses (Hal : 3 <= al) (HN : recw al <= N) (HL : 1 <= L)
   (Hq0 : length (contents (q0 s)) = N) (Hq1 : length (contents (q1 s)) = N)
   (Hd0 : length (contents (d0 s)) = L) (Hd1 : length (contents (d1 s)) = L).
 
-Definition X (i : nat) : bool := nth i (encode s) false.
-Definition F (x : sref) : bool := run (phys_units N L) (nst N L) X (idx (nst N L) (phys_blocks N L) x).
+Let HW8 : 8 <= W al := W_ge al Hal.
+Let HnW : nwin al + 3 = W al := nwin_W al Hal.
+Let Hrw : 8 + 3 * al = recw al := eq_refl.
+
+Definition X (i : nat) : bool := nth i (encode al s) false.
+Definition F (x : sref) : bool := run (phys_units al N L) (nst al N L) X (idx (nst al N L) (phys_blocks al N L) x).
 
-Lemma X_win : forall j, j < 61 -> X j = wget (win s) (realcell j).
+Lemma X_win : forall j, j < nwin al -> X j = wget (win s) (realcell j).
 Proof.
   intros j Hj. unfold X, encode. rewrite app_nth1 by (rewrite length_map, length_seq; exact Hj).
-  exact (nth_map_seq _ (fun j => wget (win s) (realcell j)) 61 j false Hj).
+  exact (nth_map_seq _ (fun j => wget (win s) (realcell j)) (nwin al) j false Hj).
 Qed.
 
 Lemma X_tape : forall i,
-  (i < N -> X (oq0 + i) = nth i (contents (q0 s)) false)
-  /\ (i < N -> X (oq1 N + i) = nth i (contents (q1 s)) false)
-  /\ (i < L -> X (od0 N + i) = nth i (contents (d0 s)) false)
-  /\ (i < L -> X (od1 N L + i) = nth i (contents (d1 s)) false).
+  (i < N -> X (oq0 al + i) = nth i (contents (q0 s)) false)
+  /\ (i < N -> X (oq1 al N + i) = nth i (contents (q1 s)) false)
+  /\ (i < L -> X (od0 al N + i) = nth i (contents (d0 s)) false)
+  /\ (i < L -> X (od1 al N L + i) = nth i (contents (d1 s)) false).
 Proof.
   intro i. unfold X, encode, oq0, oq1, od0, od1.
   repeat split; intro Hi; rewrite app_nth2 by (rewrite length_map, length_seq; lia);
@@ -47,32 +132,32 @@ Proof.
   - rewrite app_nth2 by lia. rewrite app_nth2 by lia. rewrite app_nth2 by lia. f_equal. lia.
 Qed.
 
-Lemma F_in : forall i, i < nst N L -> F (SIn i) = X i.
+Lemma F_in : forall i, i < nst al N L -> F (SIn i) = X i.
 Proof. intros i H. unfold F, phys_units. apply net_in. exact H. Qed.
 
 Lemma F_unit : forall b j r, b < 28 ->
-  j < bcount (nth b (phys_blocks N L) blk0) -> r < bsize (nth b (phys_blocks N L) blk0) ->
-  F (SRef b j r) = sfire' (sunit (phys_blocks N L) b j r) F.
+  j < bcount (nth b (phys_blocks al N L) blk0) -> r < bsize (nth b (phys_blocks al N L) blk0) ->
+  F (SRef b j r) = sfire' (sunit (phys_blocks al N L) b j r) F.
 Proof.
   intros b j r Hb Hj Hr. unfold F, phys_units. apply net_unit; [apply phys_wf; assumption| |assumption|assumption].
   rewrite phys_length. exact Hb.
 Qed.
 
 Lemma F_and : forall b j r ls, b < 28 ->
-  j < bcount (nth b (phys_blocks N L) blk0) -> r < bsize (nth b (phys_blocks N L) blk0) ->
-  sunit (phys_blocks N L) b j r = sAND ls -> F (SRef b j r) = forallb (litv F) ls.
+  j < bcount (nth b (phys_blocks al N L) blk0) -> r < bsize (nth b (phys_blocks al N L) blk0) ->
+  sunit (phys_blocks al N L) b j r = sAND ls -> F (SRef b j r) = forallb (litv F) ls.
 Proof. intros b j r ls Hb Hj Hr E. rewrite F_unit, E by assumption. apply sAND_fire. Qed.
 
 Lemma F_or : forall b j r ls, b < 28 ->
-  j < bcount (nth b (phys_blocks N L) blk0) -> r < bsize (nth b (phys_blocks N L) blk0) ->
-  sunit (phys_blocks N L) b j r = sOR ls -> F (SRef b j r) = existsb (litv F) ls.
+  j < bcount (nth b (phys_blocks al N L) blk0) -> r < bsize (nth b (phys_blocks al N L) blk0) ->
+  sunit (phys_blocks al N L) b j r = sOR ls -> F (SRef b j r) = existsb (litv F) ls.
 Proof. intros b j r ls Hb Hj Hr E. rewrite F_unit, E by assumption. apply sOR_fire. Qed.
 
 Lemma F_mux : forall b j r0 sel a c, b < 28 ->
-  j < bcount (nth b (phys_blocks N L) blk0) -> S (S r0) < bsize (nth b (phys_blocks N L) blk0) ->
-  sunit (phys_blocks N L) b j r0 = sAND [(sel, true); (a, true)] ->
-  sunit (phys_blocks N L) b j (S r0) = sAND [(sel, false); (c, true)] ->
-  sunit (phys_blocks N L) b j (S (S r0)) = sOR [(SRef b j r0, true); (SRef b j (S r0), true)] ->
+  j < bcount (nth b (phys_blocks al N L) blk0) -> S (S r0) < bsize (nth b (phys_blocks al N L) blk0) ->
+  sunit (phys_blocks al N L) b j r0 = sAND [(sel, true); (a, true)] ->
+  sunit (phys_blocks al N L) b j (S r0) = sAND [(sel, false); (c, true)] ->
+  sunit (phys_blocks al N L) b j (S (S r0)) = sOR [(SRef b j r0, true); (SRef b j (S r0), true)] ->
   F (SRef b j (S (S r0))) = if F sel then F a else F c.
 Proof.
   intros b j r0 sel a c Hb Hj Hr E0 E1 E2.
@@ -93,10 +178,10 @@ Ltac blk_compute := cbn [nth phys_blocks bcount bsize bshape blk_fld blk_head bl
   blk_desch blk_desc sunit mux3 app].
 
 (* block 0: the record in front of the active bank *)
-Lemma F_fld : forall j, j < 26 -> F (fld j) = nth j qa false.
+Lemma F_fld : forall j, j < recw al -> F (fld j) = nth j qa false.
 Proof.
   intros j Hj. unfold fld.
-  rewrite (F_mux 0 j 0 kap (SIn (oq1 N + j)) (SIn (oq0 + j))) by (blk_compute; first [lia | reflexivity]).
+  rewrite (F_mux 0 j 0 kap (SIn (oq1 al N + j)) (SIn (oq0 al + j))) by (blk_compute; first [lia | reflexivity]).
   rewrite F_kap, !F_in by (unfold nst, oq0, oq1; lia).
   destruct (X_tape j) as (T0 & T1 & _ & _). rewrite T0, T1 by lia.
   unfold qa. destruct kk; reflexivity.
@@ -116,47 +201,22 @@ Proof.
   rewrite <- !plus_n_O in T0, T1, T2, T3.
   repeat split;
     (rewrite F_mux with (sel := kap)
-       (a := SIn (fst (head_src N L _))) (c := SIn (snd (head_src N L _))) by (blk_compute; first [lia | reflexivity]));
+       (a := SIn (fst (head_src al N L _))) (c := SIn (snd (head_src al N L _))) by (blk_compute; first [lia | reflexivity]));
     cbn [head_src fst snd]; rewrite F_kap, !F_in by (unfold nst, oq0, oq1, od0, od1; lia);
     rewrite ?T0, ?T1, ?T2, ?T3 by lia; unfold rdv, armv, cpyv; rewrite <- ?nth0_hd0; destruct kk; reflexivity.
 Qed.
 
 (* ---- blocks 2 to 8: the three addresses and the two operands --------------------- *)
-Lemma bits2nat_nat2bits : forall a, a < 64 -> bits2nat (nat2bits 6 a) = a.
-Proof. intros a Ha. do 64 (destruct a as [|a]; [reflexivity|]). lia. Qed.
-
-Lemma nat2bits_bits2nat : forall f, length f = 6 -> nat2bits 6 (bits2nat f) = f.
-Proof.
-  intros f Hf. destruct f as [|b0 [|b1 [|b2 [|b3 [|b4 [|b5 [|? ?]]]]]]]; cbn [length] in Hf; try lia.
-  destruct b0, b1, b2, b3, b4, b5; reflexivity.
-Qed.
-
-Lemma lbeq_refl : forall l, lbeq l l = true.
-Proof. induction l as [|x l IH]; [reflexivity|]. cbn [lbeq]. rewrite IH, eqb_reflx. reflexivity. Qed.
-
-Lemma dec_ok : forall f a, length f = 6 -> a < 64 ->
-  forallb (fun t => Bool.eqb (nth t f false) (bitsof a t)) (seq 0 6) = Nat.eqb (bits2nat f) a.
-Proof.
-  intros f a Hf Ha.
-  assert (E : forallb (fun t => Bool.eqb (nth t f false) (bitsof a t)) (seq 0 6) = lbeq f (nat2bits 6 a)).
-  { destruct f as [|b0 [|b1 [|b2 [|b3 [|b4 [|b5 [|? ?]]]]]]]; cbn [length] in Hf; try lia.
-    unfold bitsof. cbn - [Nat.testbit Bool.eqb]. rewrite !andb_true_r. reflexivity. }
-  rewrite E. destruct (lbeq f (nat2bits 6 a)) eqn:El; destruct (Nat.eqb (bits2nat f) a) eqn:En; auto.
-  - apply lbeq_true in El. subst f. rewrite bits2nat_nat2bits in En by exact Ha.
-    rewrite Nat.eqb_refl in En. discriminate.
-  - apply Nat.eqb_eq in En. rewrite <- En, nat2bits_bits2nat, lbeq_refl in El by exact Hf. discriminate.
-Qed.
-
 Lemma length_qa : length qa = N.
 Proof. unfold qa. destruct kk; assumption. Qed.
 
-Definition field (o : nat) : list bool := firstn 6 (skipn o qa).
+Definition field (o : nat) : list bool := firstn al (skipn o qa).
 
-Lemma length_field : forall o, o + 6 <= 26 -> length (field o) = 6.
+Lemma length_field : forall o, o + al <= recw al -> length (field o) = al.
 Proof. intros o Ho. unfold field. rewrite length_firstn, length_skipn, length_qa. lia. Qed.
 
-Lemma nth_field : forall o t, t < 6 -> nth t (field o) false = nth (o + t) qa false.
-Proof. intros o t Ht. unfold field. rewrite nth_firstn. destruct (Nat.ltb_spec t 6); [|lia]. apply nth_skipn. Qed.
+Lemma nth_field : forall o t, t < al -> nth t (field o) false = nth (o + t) qa false.
+Proof. intros o t Ht. unfold field. rewrite nth_firstn. destruct (Nat.ltb_spec t al); [|lia]. apply nth_skipn. Qed.
 
 Lemma forallb_map' : forall (A B : Type) (f : B -> bool) (g : A -> B) l, forallb f (map g l) = forallb (fun x => f (g x)) l.
 Proof. intros A B f g l. induction l as [|x l IH]; [reflexivity|]. cbn [map forallb]. rewrite IH. reflexivity. Qed.
@@ -170,15 +230,15 @@ Proof. intros A f g l H. induction l as [|x l IH]; [reflexivity|]. cbn [forallb]
 Lemma existsb_ext_in : forall (A : Type) (f g : A -> bool) l, (forall x, In x l -> f x = g x) -> existsb f l = existsb g l.
 Proof. intros A f g l H. induction l as [|x l IH]; [reflexivity|]. cbn [existsb]. rewrite H, IH; [reflexivity| |left; reflexivity]. intros y Hy. apply H. right. exact Hy. Qed.
 
-Lemma F_dec : forall b o a, (b = 2 /\ o = 8) \/ (b = 3 /\ o = 14) \/ (b = 4 /\ o = 20) -> a < 64 ->
+Lemma F_dec : forall b o a, (b = 2 /\ o = 8) \/ (b = 3 /\ o = 8 + al) \/ (b = 4 /\ o = 8 + 2 * al) -> a < W al ->
   F (SRef b a 0) = Nat.eqb (bits2nat (field o)) a.
 Proof.
   intros b o a Hbo Ha.
-  assert (Hs : sunit (phys_blocks N L) b a 0 = sAND (map (fun t => (fld (o + t), bitsof a t)) (seq 0 6)))
+  assert (Hs : sunit (phys_blocks al N L) b a 0 = sAND (map (fun t => (fld (o + t), bitsof al a t)) (seq 0 al)))
     by (destruct Hbo as [[-> ->]|[[-> ->]|[-> ->]]]; reflexivity).
   rewrite (F_and b a 0 _ ltac:(lia) ltac:(destruct Hbo as [[-> ->]|[[-> ->]|[-> ->]]]; blk_compute; lia)
              ltac:(destruct Hbo as [[-> ->]|[[-> ->]|[-> ->]]]; blk_compute; lia) Hs).
-  rewrite forallb_map'. rewrite <- dec_ok by (try apply length_field; lia).
+  rewrite forallb_map'. rewrite <- (dec_okA al (field o) a) by (try apply length_field; unfold W in Ha; lia).
   apply forallb_ext_in. intros t Ht. apply in_seq in Ht.
   unfold litv. cbn [fst snd]. rewrite F_fld by lia. rewrite nth_field by lia. reflexivity.
 Qed.
@@ -186,7 +246,7 @@ Qed.
 Definition cellv (a : nat) : bool :=
   if Nat.eqb a 1 then rdv else if Nat.eqb a 2 then armv else if Nat.eqb a 3 then cpyv else wget (win s) a.
 
-Lemma F_cellref : forall a, a < 64 -> F (cellref a) = cellv a.
+Lemma F_cellref : forall a, a < W al -> F (cellref a) = cellv a.
 Proof.
   intros a Ha. destruct F_heads as (H1 & H2 & H3). unfold cellref, cellv.
   destruct (Nat.eqb_spec a 1) as [->|E1]; [exact H1|].
@@ -215,43 +275,41 @@ Qed.
 
 Definition fa (o : nat) : nat := bits2nat (field o).
 
-Lemma fa_lt : forall o, o + 6 <= 26 -> fa o < 64.
+Lemma fa_lt : forall o, o + al <= recw al -> fa o < W al.
 Proof.
-  intros o Ho. unfold fa. pose proof (length_field o Ho) as H.
-  rewrite <- (nat2bits_bits2nat (field o) H). remember (field o) as f eqn:Ef. clear Ef.
-  destruct f as [|b0 [|b1 [|b2 [|b3 [|b4 [|b5 [|? ?]]]]]]]; cbn [length] in H; try lia.
-  destruct b0, b1, b2, b3, b4, b5; cbn; lia.
+  intros o Ho. unfold fa, W. rewrite <- (length_field o Ho). apply bits2nat_lt.
 Qed.
 
-Lemma F_xs : forall i, i < 2 -> F (xsref i) = cellv (fa (8 + 6 * i)).
+Lemma F_xs : forall i, i < 2 -> F (xsref i) = cellv (fa (8 + al * i)).
 Proof.
   intros i Hi. unfold xsref.
-  assert (Hlt := fa_lt (8 + 6 * i) ltac:(lia)).
   destruct (Nat.eqb_spec i 0) as [->|E].
-  - rewrite (F_or 6 0 0 (map (fun a => (SRef 5 a 0, true)) (seq 0 64))) by (blk_compute; first [lia | reflexivity]).
+  - assert (Hlt := fa_lt 8 ltac:(lia)).
+    rewrite (F_or 6 0 0 (map (fun a => (SRef 5 a 0, true)) (seq 0 (W al)))) by (blk_compute; first [lia | reflexivity]).
     rewrite existsb_map'.
     rewrite (existsb_ext_in _ _ (fun a => Nat.eqb (fa 8) a && cellv a)).
-    + rewrite existsb_pick. cbn [Nat.mul Nat.add] in Hlt.
+    + rewrite existsb_pick. rewrite Nat.mul_0_r, Nat.add_0_r.
       replace (0 <=? fa 8) with true by (symmetry; apply Nat.leb_le; lia).
-      replace (fa 8 <? 0 + 64) with true by (symmetry; apply Nat.ltb_lt; lia).
+      replace (fa 8 <? 0 + W al) with true by (symmetry; apply Nat.ltb_lt; lia).
       reflexivity.
     + intros a Ha. apply in_seq in Ha. rewrite litv_pos.
       rewrite (F_and 5 a 0 [(SRef 2 a 0, true); (cellref a, true)]) by (blk_compute; first [lia | reflexivity]).
       cbn [forallb]. rewrite !litv_pos, andb_true_r.
       rewrite F_dec with (o := 8) by (lia || (left; split; reflexivity)).
       rewrite F_cellref by lia. reflexivity.
-  - replace i with 1 in * by lia.
-    rewrite (F_or 8 0 0 (map (fun a => (SRef 7 a 0, true)) (seq 0 64))) by (blk_compute; first [lia | reflexivity]).
+  - replace i with 1 in * by lia. rewrite Nat.mul_1_r.
+    assert (Hlt := fa_lt (8 + al) ltac:(lia)).
+    rewrite (F_or 8 0 0 (map (fun a => (SRef 7 a 0, true)) (seq 0 (W al)))) by (blk_compute; first [lia | reflexivity]).
     rewrite existsb_map'.
-    rewrite (existsb_ext_in _ _ (fun a => Nat.eqb (fa 14) a && cellv a)).
-    + rewrite existsb_pick. cbn [Nat.mul Nat.add] in Hlt.
-      replace (0 <=? fa 14) with true by (symmetry; apply Nat.leb_le; lia).
-      replace (fa 14 <? 0 + 64) with true by (symmetry; apply Nat.ltb_lt; lia).
+    rewrite (existsb_ext_in _ _ (fun a => Nat.eqb (fa (8 + al)) a && cellv a)).
+    + rewrite existsb_pick.
+      replace (0 <=? fa (8 + al)) with true by (symmetry; apply Nat.leb_le; lia).
+      replace (fa (8 + al) <? 0 + W al) with true by (symmetry; apply Nat.ltb_lt; lia).
       reflexivity.
     + intros a Ha. apply in_seq in Ha. rewrite litv_pos.
       rewrite (F_and 7 a 0 [(SRef 3 a 0, true); (cellref a, true)]) by (blk_compute; first [lia | reflexivity]).
       cbn [forallb]. rewrite !litv_pos, andb_true_r.
-      rewrite F_dec with (o := 14) by (lia || (right; left; split; reflexivity)).
+      rewrite F_dec with (o := 8 + al) by (lia || (right; left; split; reflexivity)).
       rewrite F_cellref by lia. reflexivity.
 Qed.
 
@@ -275,7 +333,7 @@ Lemma vnet_ok : forall f0 f1 f2 f3 f4 f5 f6 f7 y0 y1,
   = Z.leb 0 (wcode f0 f1 * b2z y0 + wcode f2 f3 * b2z y1 + beta4 f4 f5 f6 f7)%Z.
 Proof. intros. destruct f0, f1, f2, f3, f4, f5, f6, f7, y0, y1; reflexivity. Qed.
 
-Lemma F_fb : forall j, j < 26 -> F (fld j) = fb j.
+Lemma F_fb : forall j, j < recw al -> F (fld j) = fb j.
 Proof. exact F_fld. Qed.
 
 Lemma F_v : F (SRef 17 0 0) =
@@ -331,19 +389,22 @@ Proof.
 Qed.
 
 (* ---- blocks 18 and 19: the window after the write --------------------------------- *)
-Definition vsem : bool := vnet (fb 0) (fb 1) (fb 2) (fb 3) (fb 4) (fb 5) (fb 6) (fb 7) (cellv (fa 8)) (cellv (fa 14)).
-Definition aosem : nat := fa 20.
+Definition vsem : bool :=
+  vnet (fb 0) (fb 1) (fb 2) (fb 3) (fb 4) (fb 5) (fb 6) (fb 7) (cellv (fa 8)) (cellv (fa (8 + al))).
+Definition aosem : nat := fa (8 + 2 * al).
 
 Lemma F_vsem : F (SRef 17 0 0) = vsem.
-Proof. rewrite F_v, (F_xs 0), (F_xs 1) by lia. reflexivity. Qed.
+Proof.
+  rewrite F_v, (F_xs 0), (F_xs 1) by lia. rewrite Nat.mul_0_r, Nat.add_0_r, Nat.mul_1_r. reflexivity.
+Qed.
 
-Lemma F_lo : forall a, a < 64 -> F (SRef 4 a 0) = Nat.eqb aosem a.
+Lemma F_lo : forall a, a < W al -> F (SRef 4 a 0) = Nat.eqb aosem a.
 Proof. intros a Ha. apply F_dec; [right; right; split; reflexivity | exact Ha]. Qed.
 
-Lemma realcell_lt : forall j, j < 61 -> realcell j < 64.
+Lemma realcell_lt : forall j, j < nwin al -> realcell j < W al.
 Proof. intros j Hj. unfold realcell. destruct (Nat.eqb j 0); lia. Qed.
 
-Lemma F_xhat : forall j, j < 61 ->
+Lemma F_xhat : forall j, j < nwin al ->
   F (SRef 18 j 2) = if Nat.eqb aosem (realcell j) then vsem else wget (win s) (realcell j).
 Proof.
   intros j Hj.
@@ -392,30 +453,30 @@ Proof.
   destruct here; destruct m; reflexivity.
 Qed.
 
-Lemma F_bank : forall bh bb idlep base T, (bh = 20 /\ bb = 21 /\ idlep = true /\ base = oq0 /\ T = q0 s)
-                                        \/ (bh = 22 /\ bb = 23 /\ idlep = false /\ base = oq1 N /\ T = q1 s) ->
+Lemma F_bank : forall bh bb idlep base T, (bh = 20 /\ bb = 21 /\ idlep = true /\ base = oq0 al /\ T = q0 s)
+                                        \/ (bh = 22 /\ bb = 23 /\ idlep = false /\ base = oq1 al N /\ T = q1 s) ->
   forall i, i < N ->
   F (SRef bb i 3) =
     if Bool.eqb kk idlep
     then nth i (if advA then rot1 (wrote (contents T) (Nat.eqb aosem 2)) else wrote (contents T) (Nat.eqb aosem 2)) false
-    else nth i (rotn 26 (contents T)) false.
+    else nth i (rotn (recw al) (contents T)) false.
 Proof.
   intros bh bb idlep base T Hsel i Hi.
   assert (HT : length (contents T) = N) by (destruct Hsel as [(_ & _ & _ & _ & ->)|(_ & _ & _ & _ & ->)]; assumption).
   assert (Hx : forall m, m < N -> X (base + m) = nth m (contents T) false).
   { intros m Hm. destruct (X_tape m) as (T0 & T1 & _ & _).
     destruct Hsel as [(_ & _ & _ & -> & ->)|(_ & _ & _ & -> & ->)]; [apply T0|apply T1]; exact Hm. }
-  assert (Hb : base + N <= nst N L) by (destruct Hsel as [(_ & _ & _ & -> & _)|(_ & _ & _ & -> & _)]; unfold nst, oq0, oq1; lia).
-  assert (Hc : forall j r, j < N -> r < 4 -> bb < 28 /\ j < bcount (nth bb (phys_blocks N L) blk0)
-                                          /\ r < bsize (nth bb (phys_blocks N L) blk0))
+  assert (Hb : base + N <= nst al N L) by (destruct Hsel as [(_ & _ & _ & -> & _)|(_ & _ & _ & -> & _)]; unfold nst, oq0, oq1; lia).
+  assert (Hc : forall j r, j < N -> r < 4 -> bb < 28 /\ j < bcount (nth bb (phys_blocks al N L) blk0)
+                                          /\ r < bsize (nth bb (phys_blocks al N L) blk0))
     by (intros; destruct Hsel as [(_ & -> & _)|(_ & -> & _)]; blk_compute; lia).
-  assert (Hh : forall r, r < 6 -> bh < 28 /\ 0 < bcount (nth bh (phys_blocks N L) blk0)
-                                   /\ r < bsize (nth bh (phys_blocks N L) blk0))
+  assert (Hh : forall r, r < 6 -> bh < 28 /\ 0 < bcount (nth bh (phys_blocks al N L) blk0)
+                                   /\ r < bsize (nth bh (phys_blocks al N L) blk0))
     by (intros; destruct Hsel as [(-> & _)|(-> & _)]; blk_compute; lia).
-  assert (Hsu : forall j, sunit (phys_blocks N L) bb j 3 = sOR [(SRef bb j 0, true); (SRef bb j 1, true); (SRef bb j 2, true)]
-                /\ sunit (phys_blocks N L) bb j 0 = sAND [(kap, negb idlep); (SIn (base + (j + 26) mod N), true)]
-                /\ sunit (phys_blocks N L) bb j 1 = sAND [(SRef bh 0 0, true); (hatq bh base ((j + 1) mod N), true)]
-                /\ sunit (phys_blocks N L) bb j 2 = sAND [(SRef bh 0 1, true); (hatq bh base j, true)])
+  assert (Hsu : forall j, sunit (phys_blocks al N L) bb j 3 = sOR [(SRef bb j 0, true); (SRef bb j 1, true); (SRef bb j 2, true)]
+                /\ sunit (phys_blocks al N L) bb j 0 = sAND [(kap, negb idlep); (SIn (base + (j + recw al) mod N), true)]
+                /\ sunit (phys_blocks al N L) bb j 1 = sAND [(SRef bh 0 0, true); (hatq bh base ((j + 1) mod N), true)]
+                /\ sunit (phys_blocks al N L) bb j 2 = sAND [(SRef bh 0 1, true); (hatq bh base j, true)])
     by (intro j; destruct Hsel as [(-> & -> & -> & -> & _)|(-> & -> & -> & -> & _)]; repeat split; reflexivity).
   destruct (Hsu i) as (S3 & S0 & S1 & S2).
   destruct (Hc i 3 Hi ltac:(lia)) as (C1 & C2 & C3).
@@ -430,12 +491,12 @@ Proof.
   { destruct F_adv as (_ & HA & _).
     destruct (Hh 0 ltac:(lia)) as (H01 & H02 & H03). destruct (Hh 1 ltac:(lia)) as (H11 & H12 & H13).
     destruct (Hh 2 ltac:(lia)) as (H21 & H22 & H23). destruct (Hh 5 ltac:(lia)) as (H51 & H52 & H53).
-    assert (U : sunit (phys_blocks N L) bh 0 0 = sAND [(kap, idlep); (SRef 18 2 2, true)]
-                /\ sunit (phys_blocks N L) bh 0 1 = sAND [(kap, idlep); (SRef 18 2 2, false)]
-                /\ sunit (phys_blocks N L) bh 0 2 = sAND [(SRef 4 2 0, true); (kap, idlep)]
-                /\ sunit (phys_blocks N L) bh 0 3 = sAND [(SRef bh 0 2, true); (SRef 17 0 0, true)]
-                /\ sunit (phys_blocks N L) bh 0 4 = sAND [(SRef bh 0 2, false); (SIn base, true)]
-                /\ sunit (phys_blocks N L) bh 0 5 = sOR [(SRef bh 0 3, true); (SRef bh 0 4, true)])
+    assert (U : sunit (phys_blocks al N L) bh 0 0 = sAND [(kap, idlep); (SRef 18 2 2, true)]
+                /\ sunit (phys_blocks al N L) bh 0 1 = sAND [(kap, idlep); (SRef 18 2 2, false)]
+                /\ sunit (phys_blocks al N L) bh 0 2 = sAND [(SRef 4 2 0, true); (kap, idlep)]
+                /\ sunit (phys_blocks al N L) bh 0 3 = sAND [(SRef bh 0 2, true); (SRef 17 0 0, true)]
+                /\ sunit (phys_blocks al N L) bh 0 4 = sAND [(SRef bh 0 2, false); (SIn base, true)]
+                /\ sunit (phys_blocks al N L) bh 0 5 = sOR [(SRef bh 0 3, true); (SRef bh 0 4, true)])
       by (destruct Hsel as [(-> & -> & -> & -> & _)|(-> & -> & -> & -> & _)]; repeat split; reflexivity).
     destruct U as (U0 & U1 & U2 & U3 & U4 & U5).
     split; [|split].
@@ -454,7 +515,7 @@ Proof.
   { intros m Hm. rewrite nth_wrote by lia. unfold hatq. destruct (Nat.eqb_spec m 0) as [->|E].
     - rewrite Hh0. reflexivity.
     - rewrite F_in by lia. apply Hx. exact Hm. }
-  pose proof (Nat.mod_upper_bound (i + 1) N ltac:(lia)). pose proof (Nat.mod_upper_bound (i + 26) N ltac:(lia)).
+  pose proof (Nat.mod_upper_bound (i + 1) N ltac:(lia)). pose proof (Nat.mod_upper_bound (i + recw al) N ltac:(lia)).
   rewrite Hia, Hih, !Hhat by lia. unfold litv. cbn [fst snd]. rewrite F_kap, F_in by lia. rewrite Hx by lia.
   destruct (Bool.eqb kk idlep) eqn:Ek.
   - apply Bool.eqb_prop in Ek. subst idlep. rewrite ?eqb_reflx, ?andb_true_r.
@@ -472,8 +533,8 @@ Qed.
 (* ---- blocks 24 to 27: the description tapes -------------------------------------- *)
 Definition wrotec (l : list bool) (here : bool) : list bool := if here then wr0 l vsem else l.
 
-Lemma F_desc : forall dh db idlep base T, (dh = 24 /\ db = 25 /\ idlep = true /\ base = od0 N /\ T = d0 s)
-                                        \/ (dh = 26 /\ db = 27 /\ idlep = false /\ base = od1 N L /\ T = d1 s) ->
+Lemma F_desc : forall dh db idlep base T, (dh = 24 /\ db = 25 /\ idlep = true /\ base = od0 al N /\ T = d0 s)
+                                        \/ (dh = 26 /\ db = 27 /\ idlep = false /\ base = od1 al N L /\ T = d1 s) ->
   forall i, i < L ->
   F (SRef db i 2) =
     if Bool.eqb kk idlep
@@ -485,18 +546,18 @@ Proof.
   assert (Hx : forall m, m < L -> X (base + m) = nth m (contents T) false).
   { intros m Hm. destruct (X_tape m) as (_ & _ & T2 & T3).
     destruct Hsel as [(_ & _ & _ & -> & ->)|(_ & _ & _ & -> & ->)]; [apply T2|apply T3]; exact Hm. }
-  assert (Hb : base + L <= nst N L)
+  assert (Hb : base + L <= nst al N L)
     by (destruct Hsel as [(_ & _ & _ & -> & _)|(_ & _ & _ & -> & _)]; unfold nst, od0, od1; lia).
-  assert (Hh : forall r, r < 7 -> dh < 28 /\ 0 < bcount (nth dh (phys_blocks N L) blk0)
-                                   /\ r < bsize (nth dh (phys_blocks N L) blk0))
+  assert (Hh : forall r, r < 7 -> dh < 28 /\ 0 < bcount (nth dh (phys_blocks al N L) blk0)
+                                   /\ r < bsize (nth dh (phys_blocks al N L) blk0))
     by (intros; destruct Hsel as [(-> & _)|(-> & _)]; blk_compute; lia).
-  assert (U : sunit (phys_blocks N L) dh 0 0 = sAND [(kap, negb idlep); (SRef 18 1 2, true)]
-              /\ sunit (phys_blocks N L) dh 0 1 = sAND [(kap, idlep); (SRef 18 3 2, true)]
-              /\ sunit (phys_blocks N L) dh 0 2 = sOR [(SRef dh 0 0, true); (SRef dh 0 1, true)]
-              /\ sunit (phys_blocks N L) dh 0 3 = sAND [(SRef 4 3 0, true); (kap, idlep)]
-              /\ sunit (phys_blocks N L) dh 0 4 = sAND [(SRef dh 0 3, true); (SRef 17 0 0, true)]
-              /\ sunit (phys_blocks N L) dh 0 5 = sAND [(SRef dh 0 3, false); (SIn base, true)]
-              /\ sunit (phys_blocks N L) dh 0 6 = sOR [(SRef dh 0 4, true); (SRef dh 0 5, true)])
+  assert (U : sunit (phys_blocks al N L) dh 0 0 = sAND [(kap, negb idlep); (SRef 18 1 2, true)]
+              /\ sunit (phys_blocks al N L) dh 0 1 = sAND [(kap, idlep); (SRef 18 3 2, true)]
+              /\ sunit (phys_blocks al N L) dh 0 2 = sOR [(SRef dh 0 0, true); (SRef dh 0 1, true)]
+              /\ sunit (phys_blocks al N L) dh 0 3 = sAND [(SRef 4 3 0, true); (kap, idlep)]
+              /\ sunit (phys_blocks al N L) dh 0 4 = sAND [(SRef dh 0 3, true); (SRef 17 0 0, true)]
+              /\ sunit (phys_blocks al N L) dh 0 5 = sAND [(SRef dh 0 3, false); (SIn base, true)]
+              /\ sunit (phys_blocks al N L) dh 0 6 = sOR [(SRef dh 0 4, true); (SRef dh 0 5, true)])
     by (destruct Hsel as [(-> & -> & -> & -> & _)|(-> & -> & -> & -> & _)]; repeat split; reflexivity).
   destruct U as (U0 & U1 & U2 & U3 & U4 & U5 & U6).
   destruct F_adv as (HR & _ & HC).
@@ -522,12 +583,12 @@ Proof.
     - rewrite Hh0. destruct (Nat.eqb aosem 3 && Bool.eqb kk idlep); reflexivity.
     - rewrite F_in by lia. rewrite Hx by exact Hm.
       destruct (Nat.eqb aosem 3 && Bool.eqb kk idlep); [destruct m; [lia|]|]; reflexivity. }
-  assert (Hm3 : sunit (phys_blocks N L) db i 0 = sAND [(SRef dh 0 2, true); (hatd dh base ((i + 1) mod L), true)]
-                /\ sunit (phys_blocks N L) db i 1 = sAND [(SRef dh 0 2, false); (hatd dh base i, true)]
-                /\ sunit (phys_blocks N L) db i 2 = sOR [(SRef db i 0, true); (SRef db i 1, true)])
+  assert (Hm3 : sunit (phys_blocks al N L) db i 0 = sAND [(SRef dh 0 2, true); (hatd dh base ((i + 1) mod L), true)]
+                /\ sunit (phys_blocks al N L) db i 1 = sAND [(SRef dh 0 2, false); (hatd dh base i, true)]
+                /\ sunit (phys_blocks al N L) db i 2 = sOR [(SRef db i 0, true); (SRef db i 1, true)])
     by (destruct Hsel as [(-> & -> & _ & -> & _)|(-> & -> & _ & -> & _)]; repeat split; reflexivity).
   destruct Hm3 as (M0 & M1 & M2).
-  assert (Hc : db < 28 /\ i < bcount (nth db (phys_blocks N L) blk0) /\ 2 < bsize (nth db (phys_blocks N L) blk0))
+  assert (Hc : db < 28 /\ i < bcount (nth db (phys_blocks al N L) blk0) /\ 2 < bsize (nth db (phys_blocks al N L) blk0))
     by (destruct Hsel as [(_ & -> & _)|(_ & -> & _)]; blk_compute; lia).
   destruct Hc as (C1 & C2 & C3).
   rewrite (F_mux db i 0 (SRef dh 0 2) (hatd dh base ((i + 1) mod L)) (hatd dh base i) C1 C2 C3 M0 M1 M2).
@@ -541,7 +602,7 @@ Proof.
 Qed.
 
 (* ---- one step of the machine in the same terms ------------------------------------ *)
-Hypothesis Hw : length (win s) = 64.
+Hypothesis Hw : length (win s) = W al.
 
 Lemma firstn_skipn_firstn : forall (l : list bool) a b c, a + b <= c ->
   firstn b (skipn a (firstn c l)) = firstn b (skipn a l).
@@ -554,35 +615,38 @@ Proof.
   reflexivity.
 Qed.
 
-Lemma decode_qa : decode (firstn 26 qa) =
-  Rec (fa 8) (wcode (fb 0) (fb 1)) (fa 14) (wcode (fb 2) (fb 3)) (beta4 (fb 4) (fb 5) (fb 6) (fb 7)) (fa 20).
+Lemma decode_qa : decodeA al (firstn (recw al) qa) =
+  Rec (fa 8) (wcode (fb 0) (fb 1)) (fa (8 + al)) (wcode (fb 2) (fb 3)) (beta4 (fb 4) (fb 5) (fb 6) (fb 7))
+      (fa (8 + 2 * al)).
 Proof.
-  unfold decode. cbv zeta. unfold fa, field, fb, beta4.
-  rewrite !firstn_skipn_firstn by lia. rewrite !nth_firstn. cbn [Nat.ltb Nat.leb].
-  rewrite firstn4_skipn4 by (rewrite length_qa; lia). reflexivity.
+  assert (Hn : forall i, i < 8 -> nth i (firstn (recw al) qa) false = nth i qa false).
+  { intros i Hi. rewrite nth_firstn. destruct (Nat.ltb_spec i (recw al)); [reflexivity | unfold recw in *; lia]. }
+  unfold decodeA. cbv zeta. unfold fa, field, fb, beta4.
+  rewrite !firstn_skipn_firstn by (unfold recw; lia). rewrite !Hn by lia.
+  rewrite firstn4_skipn4 by (rewrite length_qa; unfold recw in *; lia). reflexivity.
 Qed.
 
 Lemma cellof_cellv : forall a, cellof s kk a = cellv a.
 Proof. intro a. unfold cellof, cellv, rdv, armv, cpyv. rewrite !hd_t_contents. reflexivity. Qed.
 
-Lemma step_eq : exists qa', contents qa' = rotn 26 qa /\ step s = stepres s kk qa' aosem vsem.
+Lemma step_eq : exists qa', contents qa' = rotn (recw al) qa /\ stepA al s = stepres s kk qa' aosem vsem.
 Proof.
-  destruct (popn 26 (if kk then q1 s else q0 s)) as [bits qa'] eqn:Ep.
+  destruct (popn (recw al) (if kk then q1 s else q0 s)) as [bits qa'] eqn:Ep.
   exists qa'. split.
-  - pose proof (popn_turns 26 (if kk then q1 s else q0 s)) as P. rewrite Ep in P. exact P.
-  - assert (Hbits : bits = firstn 26 qa).
-    { pose proof (popn_reads 26 (if kk then q1 s else q0 s)) as P. rewrite Ep in P. apply P.
+  - pose proof (popn_turns (recw al) (if kk then q1 s else q0 s)) as P. rewrite Ep in P. exact P.
+  - assert (Hbits : bits = firstn (recw al) qa).
+    { pose proof (popn_reads (recw al) (if kk then q1 s else q0 s)) as P. rewrite Ep in P. apply P.
       fold qa. rewrite length_qa. lia. }
-    apply (step_char s kk bits qa' (fa 8) (wcode (fb 0) (fb 1)) (fa 14) (wcode (fb 2) (fb 3))
-             (beta4 (fb 4) (fb 5) (fb 6) (fb 7)) (fa 20) vsem eq_refl Ep).
+    apply (step_charA al s kk bits qa' (fa 8) (wcode (fb 0) (fb 1)) (fa (8 + al)) (wcode (fb 2) (fb 3))
+             (beta4 (fb 4) (fb 5) (fb 6) (fb 7)) (fa (8 + 2 * al)) vsem eq_refl Ep).
     + rewrite Hbits. apply decode_qa.
     + unfold vsem. rewrite vnet_ok, !cellof_cellv. reflexivity.
 Qed.
 
-Lemma aosem_lt : aosem < 64.
-Proof. apply fa_lt. lia. Qed.
+Lemma aosem_lt : aosem < W al.
+Proof. apply fa_lt. unfold recw. lia. Qed.
 
-Lemma wget_wn : forall a, a < 64 -> a <> 1 -> a <> 2 -> a <> 3 ->
+Lemma wget_wn : forall a, a < W al -> a <> 1 -> a <> 2 -> a <> 3 ->
   wget (wnext (win s) aosem vsem) a = if Nat.eqb aosem a then vsem else wget (win s) a.
 Proof.
   intros a Ha H1 H2 H3. unfold wnext.
@@ -592,7 +656,7 @@ Proof.
     apply orb_true_iff in E as [E|E]; [apply orb_true_iff in E as [E|E]|]; apply Nat.eqb_eq in E; lia.
   - rewrite wget_upd, Hw. pose proof aosem_lt.
     destruct (Nat.eqb_spec aosem a) as [E2|E2].
-    + rewrite E2, Nat.eqb_refl. replace (a <? 64) with true by (symmetry; apply Nat.ltb_lt; lia). reflexivity.
+    + rewrite E2, Nat.eqb_refl. replace (a <? W al) with true by (symmetry; apply Nat.ltb_lt; lia). reflexivity.
     + replace (Nat.eqb a aosem) with false by (symmetry; apply Nat.eqb_neq; lia). reflexivity.
 Qed.
 
@@ -600,12 +664,12 @@ Lemma adv_wn : wget (wnext (win s) aosem vsem) AA = advA /\ wget (wnext (win s)
                /\ wget (wnext (win s) aosem vsem) AC = advC.
 Proof. unfold AA, AR, AC, advA, advR, advC. repeat split; apply wget_wn; lia. Qed.
 
-Lemma tapes_step : forall qa', contents qa' = rotn 26 qa ->
+Lemma tapes_step : forall qa', contents qa' = rotn (recw al) qa ->
   let t := stepres s kk qa' aosem vsem in
   contents (q0 t) = (if kk then (if advA then rot1 (wrote (contents (q0 s)) (Nat.eqb aosem 2))
                                  else wrote (contents (q0 s)) (Nat.eqb aosem 2))
-                     else rotn 26 (contents (q0 s)))
-  /\ contents (q1 t) = (if kk then rotn 26 (contents (q1 s))
+                     else rotn (recw al) (contents (q0 s)))
+  /\ contents (q1 t) = (if kk then rotn (recw al) (contents (q1 s))
                         else (if advA then rot1 (wrote (contents (q1 s)) (Nat.eqb aosem 2))
                               else wrote (contents (q1 s)) (Nat.eqb aosem 2)))
   /\ contents (d0 t) = (if kk then (if advC then rot1 (wrotec (contents (d0 s)) (Nat.eqb aosem 3))
@@ -627,29 +691,28 @@ Qed.
 End Sem.
 
 (* ---- the netlist computes the step -------------------------------------------------- *)
-Lemma nth_encode : forall s N L i,
+Lemma nth_encode : forall al s N L i,
   length (contents (q0 s)) = N -> length (contents (q1 s)) = N ->
   length (contents (d0 s)) = L -> length (contents (d1 s)) = L ->
-  nth i (encode s) false =
-    if i <? 61 then wget (win s) (realcell i)
-    else if i <? 61 + N then nth (i - 61) (contents (q0 s)) false
-    else if i <? 61 + 2 * N then nth (i - 61 - N) (contents (q1 s)) false
-    else if i <? 61 + 2 * N + L then nth (i - 61 - 2 * N) (contents (d0 s)) false
-    else nth (i - 61 - 2 * N - L) (contents (d1 s)) false.
-Proof.
-  intros s N L i H0 H1 H2 H3. unfold encode.
-  destruct (Nat.ltb_spec i 61).
+  nth i (encode al s) false =
+    if i <? nwin al then wget (win s) (realcell i)
+    else if i <? nwin al + N then nth (i - nwin al) (contents (q0 s)) false
+    else if i <? nwin al + 2 * N then nth (i - nwin al - N) (contents (q1 s)) false
+    else if i <? nwin al + 2 * N + L then nth (i - nwin al - 2 * N) (contents (d0 s)) false
+    else nth (i - nwin al - 2 * N - L) (contents (d1 s)) false.
+Proof.
+  intros al s N L i H0 H1 H2 H3. unfold encode.
+  destruct (Nat.ltb_spec i (nwin al)).
   { rewrite app_nth1 by (rewrite length_map, length_seq; lia).
-    exact (nth_map_seq _ (fun j => wget (win s) (realcell j)) 61 i false H). }
+    exact (nth_map_seq _ (fun j => wget (win s) (realcell j)) (nwin al) i false H). }
   rewrite app_nth2 by (rewrite length_map, length_seq; lia). rewrite length_map, length_seq.
-  destruct (Nat.ltb_spec i (61 + N)).
+  destruct (Nat.ltb_spec i (nwin al + N)).
   { rewrite app_nth1 by lia. reflexivity. }
   rewrite app_nth2 by lia. rewrite H0.
-  destruct (Nat.ltb_spec i (61 + 2 * N)).
+  destruct (Nat.ltb_spec i (nwin al + 2 * N)).
   { rewrite app_nth1 by lia. f_equal; lia. }
   rewrite app_nth2 by lia. rewrite H1.
-  destruct (Nat.ltb_spec i (61 + 2 * N + L)).
+  destruct (Nat.ltb_spec i (nwin al + 2 * N + L)).
   { rewrite app_nth1 by lia. f_equal; lia. }
   rewrite app_nth2 by lia. rewrite H2. f_equal; lia.
 Qed.
-

rocq/PhysWF.v

@@ -3,15 +3,24 @@ From Stdlib Require Import List Bool Arith ZArith Lia.
 Import ListNotations.
 From TH Require Import TwoHead Net Gates Phys.
 
-Lemma phys_shaped : forall N L, Forall shaped (phys_blocks N L).
+Lemma phys_shaped : forall al N L, Forall shaped (phys_blocks al N L).
 Proof.
-  intros N L. unfold phys_blocks.
+  intros al N L. unfold phys_blocks.
   repeat apply Forall_cons; try apply Forall_nil; intros j Hj; reflexivity.
 Qed.
 
-Lemma phys_length : forall N L, length (phys_blocks N L) = 28.
+Lemma phys_length : forall al N L, length (phys_blocks al N L) = 28.
 Proof. reflexivity. Qed.
 
+Lemma W_ge : forall al, 3 <= al -> 8 <= W al.
+Proof.
+  intros al H. unfold W. replace al with (3 + (al - 3)) by lia. rewrite Nat.pow_add_r.
+  pose proof (Nat.pow_nonzero 2 (al - 3) ltac:(lia)). cbn [Nat.pow]. lia.
+Qed.
+
+Lemma nwin_W : forall al, 3 <= al -> nwin al + 3 = W al.
+Proof. intros al H. pose proof (W_ge al H). unfold nwin. lia. Qed.
+
 Ltac unfold_layout := unfold nst, oq0, oq1, od0, od1 in *.
 
 (* a reference to an earlier block, or to an earlier unit of the same member, or a state bit *)
@@ -23,17 +32,17 @@ Ltac rb_solve :=
   | left; split; [lia|];
     cbn [nth phys_blocks bcount bsize blk_fld blk_head blk_dec blk_term blk_xs blk_pos blk_neg blk_mt
          blk_nt blk_pge blk_b4 blk_bge blk_vand blk_v blk_xhat blk_zero blk_bankh blk_bank blk_desch blk_desc];
-    split; lia ].
+    unfold recw in *; split; lia ].
 
 Ltac crush_in Hin :=
-  cbn [nth mux3 sin sAND sOR map lw fst snd seq app kap fld xsref vand_bge] in Hin;
+  cbn [nth mux3 sin sAND sOR map lw fst snd app kap fld xsref vand_bge] in Hin;
   repeat (destruct Hin as [Hin|Hin]; [injection Hin as <- <-|]); try destruct Hin.
 
 (* open the helpers that name signals, splitting on the cases they distinguish *)
 Ltac open_refs :=
   unfold kap, hatq, hatd, cellref, xsref, realcell in *;
   try match goal with |- context [vand_bge ?j] => destruct j as [|[|[|[|j]]]]; cbn [vand_bge] end;
-  try match goal with |- context [head_src _ _ ?j] => destruct j as [|[|j]]; cbn [head_src fst snd] end;
+  try match goal with |- context [head_src _ _ _ ?j] => destruct j as [|[|j]]; cbn [head_src fst snd] end;
   repeat match goal with |- context [if ?c then _ else _] => destruct c eqn:? end;
   repeat match goal with
          | H : (_ =? _) = true |- _ => apply Nat.eqb_eq in H
@@ -49,14 +58,67 @@ Ltac split_blocks b :=
          blk_desch blk_desc] in *
   | first [lia | split_blocks b] ].
 
-Lemma phys_wf : forall N L, 26 <= N -> 1 <= L -> wf (phys_blocks N L) (nst N L).
+(* the decode lines and the disjunctions of the operands read lists of symbolic length *)
+Lemma in_dec_lits : forall al o a x w,
+  In (x, w) (sin (sAND (map (fun t => (fld (o + t), bitsof al a t)) (seq 0 al)))) ->
+  exists t, t < al /\ x = fld (o + t).
+Proof.
+  intros al o a x w Hin. cbn [sin sAND] in Hin.
+  apply in_map_iff in Hin as (l & El & Hl). apply in_map_iff in Hl as (t & <- & Ht).
+  apply in_seq in Ht. unfold lw in El. cbn [fst] in El. injection El as Ex _.
+  exists t. split; [lia | symmetry; exact Ex].
+Qed.
+
+Lemma in_xs_lits : forall bterm al x w,
+  In (x, w) (sin (sOR (map (fun a => (SRef bterm a 0, true)) (seq 0 (W al))))) ->
+  exists a, a < W al /\ x = SRef bterm a 0.
+Proof.
+  intros bterm al x w Hin. cbn [sin sOR] in Hin.
+  apply in_map_iff in Hin as (l & El & Hl). apply in_map_iff in Hl as (a & <- & Ha).
+  apply in_seq in Ha. unfold lw in El. cbn [fst] in El. injection El as Ex _.
+  exists a. split; [lia | symmetry; exact Ex].
+Qed.
+
+Lemma phys_wf : forall al N L, 3 <= al -> recw al <= N -> 1 <= L -> wf (phys_blocks al N L) (nst al N L).
 Proof.
-  intros N L HN HL. split; [apply phys_shaped|].
+  intros al N L Hal HN HL. split; [apply phys_shaped|].
   intros b j r x w Hb Hj Hr Hin. unfold sunit in Hin. rewrite phys_length in Hb.
-  assert (M1 : forall i, (i + 26) mod N < N) by (intro i; apply Nat.mod_upper_bound; lia).
-  assert (M2 : forall i, (i + 1) mod N < N) by (intro i; apply Nat.mod_upper_bound; lia).
+  pose proof (nwin_W al Hal) as HW. pose proof (W_ge al Hal) as HW8.
+  assert (M1 : forall i, (i + recw al) mod N < N) by (intro i; apply Nat.mod_upper_bound; unfold recw in *; lia).
+  assert (M2 : forall i, (i + 1) mod N < N) by (intro i; apply Nat.mod_upper_bound; unfold recw in *; lia).
   assert (M3 : forall i, (i + 1) mod L < L) by (intro i; apply Nat.mod_upper_bound; lia).
+  (* blocks 2, 3, 4: the decode lines *)
+  assert (Hdec : forall o, o <= 8 + 2 * al -> b <> 0 -> b < 5 ->
+            In (x, w) (sin (sAND (map (fun t => (fld (o + t), bitsof al j t)) (seq 0 al)))) ->
+            reads_back (phys_blocks al N L) (nst al N L) b j r x).
+  { intros o Ho Hb0 Hb5 Hin'. destruct (in_dec_lits al o j x w Hin') as (t & Ht & ->).
+    unfold fld. cbn [reads_back]. left. split; [lia|].
+    cbn [nth phys_blocks bcount bsize blk_fld]. unfold recw. split; lia. }
+  (* blocks 6 and 8: the operands *)
+  assert (Hxs : forall bterm, bterm < b -> bcount (nth bterm (phys_blocks al N L) blk0) = W al ->
+            bsize (nth bterm (phys_blocks al N L) blk0) = 1 ->
+            In (x, w) (sin (sOR (map (fun a => (SRef bterm a 0, true)) (seq 0 (W al))))) ->
+            reads_back (phys_blocks al N L) (nst al N L) b j r x).
+  { intros bterm Hbt Hc Hs Hin'. destruct (in_xs_lits bterm al x w Hin') as (a & Ha & ->).
+    cbn [reads_back]. left. rewrite Hc, Hs. lia. }
+  destruct (Nat.eq_dec b 2) as [->|N2].
+  { cbn [nth phys_blocks bcount bsize bshape blk_dec] in *. destruct r as [|r]; [|lia].
+    apply (Hdec 8); [lia | lia | lia | exact Hin]. }
+  destruct (Nat.eq_dec b 3) as [->|N3].
+  { cbn [nth phys_blocks bcount bsize bshape blk_dec] in *. destruct r as [|r]; [|lia].
+    apply (Hdec (8 + al)); [lia | lia | lia | exact Hin]. }
+  destruct (Nat.eq_dec b 4) as [->|N4].
+  { cbn [nth phys_blocks bcount bsize bshape blk_dec] in *. destruct r as [|r]; [|lia].
+    apply (Hdec (8 + 2 * al)); [lia | lia | lia | exact Hin]. }
+  destruct (Nat.eq_dec b 6) as [->|N6].
+  { cbn [nth phys_blocks bcount bsize bshape blk_xs] in *. destruct r as [|r]; [|lia].
+    apply (Hxs 5); [lia | reflexivity | reflexivity | exact Hin]. }
+  destruct (Nat.eq_dec b 8) as [->|N8].
+  { cbn [nth phys_blocks bcount bsize bshape blk_xs] in *. destruct r as [|r]; [|lia].
+    apply (Hxs 7); [lia | reflexivity | reflexivity | exact Hin]. }
+  clear Hdec Hxs.
   split_blocks b.
+  all: try (exfalso; lia).
   all: repeat (destruct r as [|r]; [crush_in Hin | try (exfalso; lia)]).
   all: try lia.
   all: try rb_solve.

rocq/TwoHead.v

@@ -121,6 +121,60 @@ Fixpoint iterp (p : positive) (s : st) : st :=
   | xI q => step (iterp q (iterp q s))
   end.
 
+(* ---- a window of 2^al cells: records of 8 + 3 al bits ------------------------ *)
+Definition recw (al : nat) : nat := 8 + 3 * al.
+
+Definition decodeA (al : nat) (bs : list bool) : rec :=
+  let g i := nth i bs false in
+  let braw := Z.of_nat (bits2nat (firstn 4 (skipn 4 bs))) in
+  Rec (bits2nat (firstn al (skipn 8 bs))) (wcode (g 0%nat) (g 1%nat))
+      (bits2nat (firstn al (skipn (8 + al) bs))) (wcode (g 2%nat) (g 3%nat))
+      (if Z.leb 8 braw then braw - 16 else braw)%Z
+      (bits2nat (firstn al (skipn (8 + 2 * al) bs))).
+
+Definition enc_recA (al : nat) (r : rec) : list bool :=
+  match r with
+  | Rec a0 w0 a1 w1 beta ao =>
+      enc_w w0 ++ enc_w w1 ++ nat2bits 4 (Z.to_nat (Z.modulo beta 16))
+        ++ nat2bits al a0 ++ nat2bits al a1 ++ nat2bits al ao
+  end.
+
+Definition stepA (al : nat) (s : st) : st :=
+  let k := wget (win s) KAPPA in
+  let qa := if k then q1 s else q0 s in
+  let qi := if k then q0 s else q1 s in
+  let da := if k then d1 s else d0 s in
+  let di := if k then d0 s else d1 s in
+  let (bits, qa') := popn (recw al) qa in
+  match decodeA al bits with
+  | Rec a0 w0 a1 w1 beta ao =>
+      let cell a :=
+        if Nat.eqb a RD then hd_t da
+        else if Nat.eqb a ARM then hd_t qi
+        else if Nat.eqb a CPY then hd_t di
+        else wget (win s) a in
+      let v := Z.leb 0 (w0 * b2z (cell a0) + w1 * b2z (cell a1) + beta)%Z in
+      let wn := if Nat.eqb ao RD || Nat.eqb ao ARM || Nat.eqb ao CPY then win s
+                else upd (win s) ao v in
+      let qi1 := if Nat.eqb ao ARM then wr_t qi v else qi in
+      let di1 := if Nat.eqb ao CPY then wr_t di v else di in
+      let qi2 := if wget wn AA then turn1 qi1 else qi1 in
+      let da2 := if wget wn AR then turn1 da else da in
+      let di2 := if wget wn AC then turn1 di1 else di1 in
+      let w2 := upd (upd (upd wn AA false) AR false) AC false in
+      if k then mkS w2 qi2 qa' di2 da2 else mkS w2 qa' qi2 da2 di2
+  end.
+
+(* the machine with 64 cells is the case al = 6 *)
+Lemma stepA_6 : forall s, stepA 6 s = step s.
+Proof. intro s. reflexivity. Qed.
+
+Lemma decodeA_6 : forall bs, decodeA 6 bs = decode bs.
+Proof. intro bs. reflexivity. Qed.
+
+Lemma enc_recA_6 : forall r, enc_recA 6 r = enc_rec r.
+Proof. intro r. reflexivity. Qed.
+
 (* ---- the code of descriptions ----------------------------------------- *)
 (* kind 0 AND, 1 OR, 2 COPY; s0, s1 the polarities of the two literals. *)
 Definition gate_bits (kind : nat) (s0 s1 : bool) : list bool :=

rocq/extract/dump.ml

@@ -1,14 +1,14 @@
 (* writes the netlist defined in Phys.v, extracted by Extract.v, in the layout of the netlist file of
-   src/twohead_net.py: dump N L PATH *)
+   src/twohead_net.py, for a window of 2^AL cells: dump AL N L PATH *)
 let () =
-  let n = int_of_string Sys.argv.(1) and l = int_of_string Sys.argv.(2) in
-  let us = Physnet.phys_units n l and nx = Physnet.phys_next n l in
-  let oc = open_out_bin Sys.argv.(3) in
+  let al = int_of_string Sys.argv.(1) and n = int_of_string Sys.argv.(2) and l = int_of_string Sys.argv.(3) in
+  let us = Physnet.phys_units al n l and nx = Physnet.phys_next al n l in
+  let oc = open_out_bin Sys.argv.(4) in
   let put x = (* little-endian int32 *)
     let b = Bytes.create 4 in
     Bytes.set_int32_le b 0 (Int32.of_int x); output_bytes oc b in
   let edges = List.fold_left (fun a (u : Physnet.tu) -> a + List.length u.tin) 0 us in
-  put (Physnet.nst n l); put (List.length us); put edges;
+  put (Physnet.nst al n l); put (List.length us); put edges;
   List.iter (fun (u : Physnet.tu) -> put u.tb) us;
   List.iter (fun (u : Physnet.tu) -> put (List.length u.tin)) us;
   List.iter (fun (u : Physnet.tu) -> List.iter (fun (s, wt) -> put (wt * (s + 1))) u.tin) us;

src/check_interp.py

@@ -1,117 +0,0 @@
-"""The one-record semantics of the interpreter, on its netlist.
-
-For the member U of the paper the netlist, followed by the output clause that
-the runtime applies, is compared with the reference of Definition 9.1 and its
-device; the pointer clause is part of the netlist:
-
-    fields   every weight pair, every bias and both input values of a record
-             evaluated at record counter 0, 576 configurations;
-    random   uniformly random full states, stored records, pointer, PTR_ADV
-             and record counter included, with the halt bit clear;
-    halted   uniformly random states with the halt bit set are fixed points;
-    counter  the record counter advances modulo G from every value.
-
-    python src/check_interp.py [--states N] [--device cuda]
-"""
-import argparse
-import json
-import os
-import sys
-import time
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import torch
-from reflect import (Cfg, SparseLeveled, apply_output, build_net, encode_netlist,
-                     ref_step, state_to_vec, vec_to_state)
-
-REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-
-def runs_path(name: str) -> str:
-    d = os.path.join(REPO, "paper", "runs")
-    os.makedirs(d, exist_ok=True)
-    return os.path.join(d, name)
-
-
-def check_member(cfg, n_states, device, seed):
-    t0 = time.perf_counter()
-    net, inputs, outputs = build_net(cfg)
-    lev = SparseLeveled(net, inputs, outputs, device=device)
-    res = {"A": cfg.A, "S": cfg.S, "G": cfg.G, "banks": cfg.banks,
-           "units": len(net.gates)}
-
-    def compare(states):
-        X = torch.stack([state_to_vec(cfg, st) for st in states]).to(device)
-        Y = lev.step(X).cpu()
-        bad = 0
-        for st, y in zip(states, Y):
-            e = ref_step(cfg, st)
-            g = vec_to_state(cfg, y)
-            if st["halt"] == 0:            # the output clause, applied by the runtime
-                apply_output(cfg, g["sig"])
-            if (g["sig"], g["gp"], g["halt"]) != (e["sig"], e["gp"], e["halt"]):
-                bad += 1
-        return bad
-
-    ra, rb, ro = cfg.WORK_BASE, cfg.WORK_BASE + 1, cfg.WORK_BASE + 2
-    states = []
-    for w0 in (-1, 0, 1):
-        for w1 in (-1, 0, 1):
-            for bias in range(-(1 << (cfg.BB - 1)), 1 << (cfg.BB - 1)):
-                nl = encode_netlist(cfg, [([(ra, w0, 0), (rb, w1, 0)], bias, (ro, 0))])
-                for va in (0, 1):
-                    for vb in (0, 1):
-                        sig = [0] * cfg.S
-                        sig[cfg.NET0:cfg.NET0 + len(nl)] = nl
-                        sig[ra], sig[rb] = va, vb
-                        states.append({"sig": sig, "gp": 0, "halt": 0})
-    res["fields"] = len(states)
-    res["fields_wrong"] = compare(states)
-
-    gen = torch.Generator().manual_seed(seed)
-    wrong = 0
-    for lo in range(0, n_states, 256):
-        k = min(256, n_states - lo)
-        sig = (torch.rand(k, cfg.S, generator=gen) < 0.5).long().tolist()
-        gp = torch.randint(0, cfg.G, (k,), generator=gen).tolist()
-        wrong += compare([{"sig": s, "gp": g, "halt": 0} for s, g in zip(sig, gp)])
-    res["random"] = n_states
-    res["random_wrong"] = wrong
-
-    sig = (torch.rand(256, cfg.S, generator=gen) < 0.5).float()
-    gp = torch.randint(0, cfg.G, (256,), generator=gen)
-    X = torch.stack([state_to_vec(cfg, {"sig": s.long().tolist(), "gp": int(g), "halt": 1})
-                     for s, g in zip(sig, gp)]).to(device)
-    res["halted_not_fixed"] = int((lev.step(X) != X).any(dim=1).sum())
-
-    cbad = 0
-    for g in range(cfg.G):
-        st = {"sig": [0] * cfg.S, "gp": g, "halt": 0}
-        y = vec_to_state(cfg, lev.step(state_to_vec(cfg, st).unsqueeze(0).to(device))[0].cpu())
-        cbad += y["gp"] != (g + 1) % cfg.G
-    res["counter_wrong"] = cbad
-    res["ok"] = (res["fields_wrong"] == 0 and wrong == 0 and res["halted_not_fixed"] == 0
-                 and cbad == 0)
-    res["seconds"] = time.perf_counter() - t0
-    print(f"  A = {cfg.A}, S = {cfg.S}, G = {cfg.G}, {res['units']:,} units: "
-          f"{res['fields']} record configurations, {res['fields_wrong']} wrong; "
-          f"{n_states:,} random states, {wrong} wrong; halted states fixed: "
-          f"{'yes' if res['halted_not_fixed'] == 0 else 'NO'}; counter modulo G: "
-          f"{'yes' if cbad == 0 else 'NO'} ({res['seconds']:.0f} s)", flush=True)
-    return res
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--states", type=int, default=4096)
-    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
-    args = ap.parse_args()
-    out = [check_member(Cfg(), args.states, args.device, 1)]
-    ok = all(r["ok"] for r in out)
-    json.dump({"members": out, "ok": ok}, open(runs_path("paper_interp.json"), "w"), indent=1)
-    print("INTERPRETER:", "PASS" if ok else "FAIL")
-    return 0 if ok else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

src/check_lev.py

@@ -106,30 +106,13 @@ def main() -> int:
           f"{len(D.W)} layers: {worst:.6f}")
     print(f"  maximum distance of a pre-activation from an integer: {frac:.3e}")
 
-    # The same check for the interpreter of Construction 9.2, whose levelization
-    # Section 9 executes.
-    from reflect import Cfg, build_net, Leveled
-    cfg = Cfg()
-    unet, uin, uout = build_net(cfg)
-    UL = Leveled(unet, uin, uout, device="cpu")
-    BU = 64
-    VU = (torch.rand(BU, len(uin), generator=gen) < 0.5).float()
-    udirect = gate_by_gate(unet, uin, uout, VU)
-    ulev = UL.step(VU)
-    uagree = bool((udirect == ulev).all())
-    print(f"  interpreter netlist has {len(unet.gates):,} gates on "
-          f"{len(uin):,} state bits")
-    print(f"  gate-by-gate evaluation equals Lev(N_U) on {BU} uniformly random "
-          f"states: {'yes' if uagree else 'NO'}")
-
-    ok = (agree and agree_net and uagree and same_dense and not nonternary
+    ok = (agree and agree_net and same_dense and not nonternary
           and not nonint and abs(worst - 0.5) < 1e-9)
     json.dump({"states": B, "gates": len(net.gates), "agree": agree,
                "agree_grouped": agree_net,
                "dense_agree": same_dense, "nonternary_layers": len(nonternary),
                "noninteger_bias_layers": len(nonint),
-               "min_margin": worst, "max_noninteger": frac,
-               "u_states": BU, "u_gates": len(unet.gates), "u_agree": uagree},
+               "min_margin": worst, "max_noninteger": frac},
               open(runs_path("paper_lev.json"), "w"), indent=1)
     return 0 if ok else 1
 

src/fanin2.py

@@ -1,220 +0,0 @@
-"""Bringing a ternary threshold netlist to effective fan-in at most two.
-
-The interpreter evaluates records with two input slots, so a netlist it is to
-interpret must have units of fan-in at most two. Every ternary unit is a
-threshold over its literals: H(sum_P x - sum_N x + b) is 1 exactly when at
-least t = |N| - b of the literals x_i (i in P) and not x_i (i in N) are true.
-A disjunction (t = 1) or a conjunction (t = k) of k > 2 literals becomes a
-balanced binary tree of k - 1 two-input units, a literal carried by the sign
-of its weight and never by a unit of its own, so a leaf unit is a conjunction
-or disjunction of two literals and every inner unit one of two signals. Any
-other threshold, which in the host is a majority of three literals or two of
-four, follows the recursion T(t, x_1..x_k) = T(t, x_2..x_k) or (x_1 and
-T(t-1, x_2..x_k)), four units for a majority of three and eight for two of
-four. The rewriting preserves the computed function exactly, which is checked
-against the original netlist on random inputs.
-"""
-from __future__ import annotations
-
-import os
-import sys
-from typing import Dict, List, Tuple
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from matrix8 import Net
-
-
-def classify(ins: List[Tuple[str, int]], bias: int) -> str:
-    """Which shape a unit has, by its weights and bias: a disjunction of
-    literals, a conjunction of literals, or a threshold of t of its k literals."""
-    pos = [s for s, w in ins if w == 1]
-    neg = [s for s, w in ins if w == -1]
-    if len(pos) + len(neg) != len(ins):
-        return "other"
-    t = len(neg) - bias
-    if t == 1:
-        return "or"
-    if t == len(ins):
-        return "and"                      # conjunction of literals
-    return "threshold"
-
-
-def threshold_of(ins: List[Tuple[str, int]], bias: int) -> int:
-    """The number t of true literals the unit requires."""
-    return sum(1 for _, w in ins if w == -1) - bias
-
-
-def _tree(net: Net, tag: str, kind: str, items: List[Tuple[str, int]],
-          counter: List[int] = None) -> str:
-    """A balanced binary tree of k - 1 two-input units over k literals.
-
-    `items` are (signal, weight) pairs; weight -1 marks a negated literal,
-    which a unit reads with weight -1, so negation costs no unit: a
-    disjunction of two literals is H(+-a +-b + |N| - 1) and a conjunction
-    H(+-a +-b - |P|). Every unit of the tree outputs a positive signal, so
-    the levels above the leaves combine signals.
-    """
-    level = list(items)
-    counter = counter if counter is not None else [0]
-    while len(level) > 1:
-        nxt = []
-        for i in range(0, len(level) - 1, 2):
-            (a, wa), (b, wb) = level[i], level[i + 1]
-            name = f"{tag}#{kind}{counter[0]}"
-            counter[0] += 1
-            pos = (wa == 1) + (wb == 1)
-            if kind == "or":
-                nxt.append((net.g(name, [(a, wa), (b, wb)], (2 - pos) - 1), 1))
-            else:
-                nxt.append((net.g(name, [(a, wa), (b, wb)], -pos), 1))
-        if len(level) % 2:
-            nxt.append(level[-1])
-        level = nxt
-    s, w = level[0]
-    if w != 1:                            # a single negated literal: one unit
-        name = f"{tag}#{kind}{counter[0]}"
-        counter[0] += 1
-        return net.g(name, [(s, -1)], 0)
-    return s
-
-
-def _thresh(net: Net, tag: str, t: int, items: List[Tuple[str, int]],
-            counter: List[int]) -> Tuple[str, int]:
-    """t of the k literals, by T(t, x_1..x_k) = T(t, rest) or (x_1 and T(t-1, rest)).
-
-    Returns a (signal, weight) pair: a positive signal, or a constant."""
-    k = len(items)
-    if t <= 0:
-        return ("#1", 1)
-    if t > k:
-        return ("#0", 1)
-    if k == 1:
-        return items[0]
-    if t == 1:
-        return (_tree(net, tag, "or", items, counter), 1)
-    if t == k:
-        return (_tree(net, tag, "and", items, counter), 1)
-    x, rest = items[0], items[1:]
-    a = _thresh(net, tag, t, rest, counter)
-    b = _thresh(net, tag, t - 1, rest, counter)
-    name = f"{tag}#and{counter[0]}"
-    counter[0] += 1
-    c = (net.g(name, [x, b], -((x[1] == 1) + 1)), 1)
-    name = f"{tag}#or{counter[0]}"
-    counter[0] += 1
-    return (net.g(name, [a, c], -1), 1)
-
-
-def expand(net: Net, inputs: List[str], outputs: List[str]
-           ) -> Tuple[Net, List[str], List[str]]:
-    """An equivalent netlist whose units have effective fan-in at most two."""
-    out = Net()
-    sub: Dict[str, str] = {s: s for s in inputs}
-    sub["#0"] = "#0"
-    sub["#1"] = "#1"
-
-    gates = net.gates
-    indeg, cons = {}, {}
-    for g, (ins, _) in gates.items():
-        indeg[g] = len([s for s, _ in ins if s in gates])
-        for s, _ in ins:
-            cons.setdefault(s, []).append(g)
-    order = [g for g, d in indeg.items() if d == 0]
-    i = 0
-    while i < len(order):
-        for c in cons.get(order[i], []):
-            indeg[c] -= 1
-            if indeg[c] == 0:
-                order.append(c)
-        i += 1
-    if len(order) != len(gates):
-        raise ValueError("cycle")
-
-    for g in order:
-        ins, bias = gates[g]
-        kind = classify(ins, bias)
-        src = [(sub[s], w) for s, w in ins]
-        if len(src) <= 2:                 # already within the slot budget
-            sub[g] = out.g(g, src, bias)
-            continue
-        if kind in ("or", "and"):
-            sub[g] = _tree(out, g, kind, src)
-        elif kind == "threshold":
-            assert len(src) <= 6, f"unit {g}: a threshold of {len(src)} literals"
-            sig, w = _thresh(out, g, threshold_of(ins, bias), src, [0])
-            assert w == 1
-            sub[g] = sig
-        else:
-            raise ValueError(f"unit {g} carries a weight outside {{-1, 0, 1}}: "
-                             f"{src[:4]} bias {bias}")
-    return out, list(inputs), [sub[s] for s in outputs]
-
-
-def check(net, inputs, outputs, trials: int = 64, seed: int = 5) -> bool:
-    """The expansion computes the same function as the original netlist."""
-    import torch
-    from check_lev import gate_by_gate
-    two, tin, tout = expand(net, inputs, outputs)
-    fan = max(len(ins) for ins, _ in two.gates.values())
-    assert fan <= 2, fan
-    gen = torch.Generator().manual_seed(seed)
-    V = (torch.rand(trials, len(inputs), generator=gen) < 0.5).float()
-    a = gate_by_gate(net, inputs, outputs, V)
-    b = gate_by_gate(two, tin, tout, V)
-    return bool((a == b).all())
-
-
-def main() -> int:
-    """The rewriting on the host and the interpreter, and on every ternary unit
-    of three to five inputs with every bias, against the truth tables."""
-    import itertools
-    import json
-    import time
-    import torch
-    from check_lev import gate_by_gate
-    from host_family import build
-    from reflect import Cfg, build_net
-    REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    t0 = time.perf_counter()
-    tot = bad = 0
-    for k in (3, 4, 5):
-        names = [f"i{j}" for j in range(k)]
-        V = torch.tensor(list(itertools.product((0.0, 1.0), repeat=k)))
-        for signs in itertools.product((1, -1), repeat=k):
-            for bias in range(-k - 1, k + 2):
-                n1 = Net()
-                n1.g("u", [(names[j], signs[j]) for j in range(k)], bias)
-                e, _, o = expand(n1, names, ["u"])
-                a = gate_by_gate(n1, names, ["u"], V)
-                if o[0] in ("#0", "#1"):
-                    b = torch.full_like(a, 1.0 if o[0] == "#1" else 0.0)
-                else:
-                    b = gate_by_gate(e, names, o, V)
-                tot += 1
-                bad += not bool((a == b).all())
-    print(f"  every ternary unit of 3 to 5 inputs with every bias, {tot} units, against "
-          f"its truth table: {'all exact' if bad == 0 else f'{bad} FAILED'}")
-    rec = {"small_units": tot, "small_unit_failures": bad, "netlists": {}}
-    for label, (net, inp, out) in (("N_host", build(8)), ("N_U", build_net(Cfg()))):
-        two, _, _ = expand(net, inp, out)
-        ok = check(net, inp, out, trials=32)
-        shapes = {}
-        for ins, b in net.gates.values():
-            if len(ins) > 2:
-                shapes[classify(ins, b)] = shapes.get(classify(ins, b), 0) + 1
-        rec["netlists"][label] = {"units": len(net.gates), "units_fanin2": len(two.gates),
-                                  "shapes_above_two": shapes, "agrees_on_random_inputs": ok}
-        bad += not ok
-        print(f"  {label}: {len(net.gates):,} units become {len(two.gates):,}; shapes above "
-              f"fan-in two {shapes}; agrees with the original on 32 random states: {ok}")
-    rec["seconds"] = time.perf_counter() - t0
-    rec["ok"] = bad == 0
-    d = os.path.join(REPO, "paper", "runs")
-    os.makedirs(d, exist_ok=True)
-    json.dump(rec, open(os.path.join(d, "paper_fanin2.json"), "w"), indent=1)
-    print("FAN-IN TWO:", "PASS" if bad == 0 else "FAIL")
-    return 0 if bad == 0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

src/hierarchy.py

@@ -1,148 +0,0 @@
-"""The interpreters form a hierarchy: a larger one runs a smaller one.
-
-The size proposition rules out U interpreting a netlist realizing itself. It
-does not rule out one member of the family running another, and that is what
-is established here. Writing U_S for the interpreter on S signals, a netlist
-realizing U_S is brought to effective fan-in two and laid out as records of
-U_{S'} in topological order, followed by one record per state coordinate that
-copies the next value back onto the coordinate. One pass of U_{S'} is then one
-transition of U_S carried out in place, and k passes are k transitions: the
-larger interpreter runs the smaller one, stored netlist and all, on every
-state tested.
-
-    python src/hierarchy.py [--transitions K] [--device cuda]
-"""
-import argparse
-import json
-import os
-import sys
-import time
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import torch
-from fanin2 import expand
-from reflect import (Cfg, Leveled, SparseLeveled, build_net, compile_to_reflect,
-                     encode_netlist, state_to_vec)
-
-REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-SMALL = dict(A=7, G=3, banks=1, self_mod=False)
-
-
-def runs_path(name: str) -> str:
-    d = os.path.join(REPO, "paper", "runs")
-    os.makedirs(d, exist_ok=True)
-    return os.path.join(d, name)
-
-
-def host_config(n2: int, signals: int, slack: int = 64):
-    """The smallest A' whose interpreter has room for n2 records and the
-    signals of the interpreted netlist, with G' chosen to make the addressed
-    span as small as the layout allows."""
-    for Ap in range(8, 28):
-        Sp = 1 << Ap
-        Rp = 3 * Ap + 11
-        Gp = (Sp - signals - slack) // Rp
-        if Gp >= n2:
-            return Cfg(A=Ap, G=Gp, banks=1, self_mod=False)
-    raise ValueError("no configuration is large enough")
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--transitions", type=int, default=4)
-    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
-    args = ap.parse_args()
-    t_start = time.perf_counter()
-    small = Cfg(**SMALL)
-    net, inputs, outputs = build_net(small)
-    two, tin, tout = expand(net, inputs, outputs)
-    n2 = len(two.gates)
-    signals = len(inputs) + n2
-    # coordinates whose next value is a different signal need a copy record;
-    # a coordinate the netlist passes through unchanged needs none
-    moved = [(s, t) for s, t in zip(inputs, tout) if t != s]
-    assert all(t in two.gates for _, t in moved), "a next value is another input"
-    print(f"  U_S: S = {small.S}, G = {small.G}, {len(net.gates):,} units; "
-          f"at fan-in two {n2:,} units on {signals:,} signals; "
-          f"{len(moved)} of {len(inputs)} coordinates change", flush=True)
-
-    big = host_config(n2 + len(moved), signals)
-    print(f"  U_S': S' = {big.S}, G' = {big.G}, b' = {big.R}, addressed span "
-          f"{big.span}; a record region of {big.G * big.R:,} bits", flush=True)
-
-    base = big.WORK_BASE
-    in_addr = {s: base + i for i, s in enumerate(inputs)}
-    rg, addr, top = compile_to_reflect(big, two, in_addr, tout,
-                                       base + len(inputs))
-    assert len(rg) == n2
-    assert top <= big.span, (top, big.span)
-    copies = [([(addr[t], 1, 0)], -1, (in_addr[s], 0)) for s, t in moved]
-    rg = rg + copies
-    assert len(rg) <= big.G
-    print(f"  compiled to {n2:,} records and {len(copies)} copy records; "
-          f"highest signal used {top}, span {big.span}", flush=True)
-
-    t0 = time.perf_counter()
-    bnet, bin_, bout = build_net(big)
-    print(f"  U_S' netlist: {len(bnet.gates):,} units "
-          f"({time.perf_counter() - t0:.0f}s)", flush=True)
-    t0 = time.perf_counter()
-    lev = SparseLeveled(bnet, bin_, bout, device=args.device)
-    print(f"  levelized into {len(lev.plan)} layers "
-          f"({time.perf_counter() - t0:.0f}s)", flush=True)
-
-    nl = encode_netlist(big, rg)
-    sig0 = [0] * big.S
-    sig0[big.NET0:big.NET0 + len(nl)] = nl
-    base_vec = state_to_vec(big, {"sig": sig0, "gp": 0, "halt": 0})
-
-    # The states of U_S: random signal vectors, stored records included, a
-    # random record counter, and the halt bit clear.
-    B = 48
-    gen = torch.Generator().manual_seed(20260910)
-    small_lev = Leveled(net, inputs, outputs, device="cpu")
-    V = (torch.rand(B, len(inputs), generator=gen) < 0.5).float()
-    V[:, small.S + small.GPW] = 0.0                       # halt bit clear
-    V[:, :small.S][:, small.HALT_SIG] = 0.0               # and the halt signal
-    X = base_vec.unsqueeze(0).repeat(B, 1)
-    for i, s in enumerate(inputs):
-        X[:, in_addr[s]] = V[:, i]
-    X = X.to(args.device)
-    in_idx = torch.tensor([in_addr[s] for s in inputs], device=args.device)
-    t0 = time.perf_counter()
-    exact = True
-    wrong = 0
-    per = []
-    for k in range(args.transitions):
-        V = small_lev.step(V)
-        for _ in range(big.G):
-            X = lev.step(X)
-        got = X[:, in_idx].cpu()
-        w = int((got != V).sum())
-        per.append(w)
-        wrong += w
-        exact &= w == 0
-        print(f"  transition {k + 1}: U_S' state after {k + 1} passes "
-              f"{'equals' if w == 0 else 'DIFFERS FROM'} U_S after {k + 1} "
-              f"transitions on {B} random states "
-              f"({(time.perf_counter() - t0) / 60:.1f} min)", flush=True)
-    dt = time.perf_counter() - t0
-    out = {"small": {"S": small.S, "G": small.G, "units": len(net.gates),
-                     "units_fanin2": n2, "signals": signals,
-                     "state_bits": len(inputs)},
-           "big": {"S": big.S, "G": big.G, "b": big.R, "span": big.span,
-                   "units": len(bnet.gates), "layers": len(lev.plan),
-                   "Q_bits": big.G * big.R},
-           "records": len(rg), "copy_records": len(copies), "states": B,
-           "pass_steps": big.G, "transitions": args.transitions,
-           "mismatches_per_transition": per,
-           "exact": exact, "mismatched_coordinates": wrong,
-           "seconds": time.perf_counter() - t_start}
-    json.dump(out, open(runs_path("paper_hierarchy.json"), "w"), indent=1)
-    print("HIERARCHY:", "PASS" if exact else "FAIL")
-    return 0 if exact else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

src/hosted_constructor.py

@@ -1,653 +0,0 @@
-"""The universal constructor as a netlist stored in the interpreter's state.
-
-Section 9 of the paper interprets stored netlists; this module stores the
-paper's own construction. A microprogram of records implements the SUBLEQ
-transducer of Definitions 2.8 and 3.1 over a 128-byte memory, with the tape,
-the output word, the head and the write pointer all held in signals of the
-interpreter, and runs the constructor P on a recipe. One pass of the record
-region is one SUBLEQ step: fetch, subtract, write back, apply the device,
-branch. Nothing outside U takes part, not even U's own output device.
-
-The program is P with its variable and device cells moved from the top of a
-256-byte memory to the top of a 128-byte one, which is the same program: every
-address it names is a datum, and the branch targets are unchanged.
-
-    python src/hosted_constructor.py [--target-bytes N]
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-import time
-from typing import Dict, List, Tuple
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import torch
-from reflect import (Cfg, Leveled, SparseLeveled, build_net, encode_netlist,
-                     state_to_vec, to_bits)
-from selfrep import P, describe, decode
-
-REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-
-MEM_BYTES = 128
-ADDR = 7                                   # address bits of the hosted machine
-
-
-def remap(x: int) -> int:
-    """Move a cell of the 256-byte memory to the same offset from the top of a
-    128-byte one."""
-    return x - 0x80 if x >= 0xF0 else x
-
-
-P128 = [(remap(a), remap(b), remap(c)) for a, b, c in P]
-Z, ONE, T1, T2, NEG1, EOK = 0x70, 0x71, 0x72, 0x73, 0x74, 0x75
-C_WR, C_EOT, C_RW, C_RD, R_IN, R_OUT = 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E
-HALT_PC = 0x7F
-
-
-def image128() -> List[int]:
-    mem = [0] * MEM_BYTES
-    for idx, (a, b, c) in enumerate(P128):
-        mem[idx * 3] = a
-        mem[idx * 3 + 1] = b
-        mem[idx * 3 + 2] = c
-    mem[ONE] = 1
-    mem[NEG1] = 0xFF
-    mem[EOK] = 1
-    return mem
-
-
-def reference128(mem0: List[int], tape: bytes, max_steps: int = 1 << 22):
-    """The transducer of Definitions 2.8 and 3.1 on a 128-byte memory."""
-    mem = list(mem0)
-    out = bytearray()
-    h = 0
-    pc = 0
-    n = 0
-    while pc != HALT_PC and n < max_steps:
-        A = mem[pc % MEM_BYTES]
-        B = mem[(pc + 1) % MEM_BYTES]
-        C = mem[(pc + 2) % MEM_BYTES]
-        r = (mem[B % MEM_BYTES] - mem[A % MEM_BYTES]) & 0xFF
-        mem[B % MEM_BYTES] = r
-        pc = C % MEM_BYTES if (r == 0 or r >= 0x80) else (pc + 3) % MEM_BYTES
-        if mem[C_WR] == 1:
-            out.append(mem[R_OUT])
-            mem[R_OUT] = 0
-        if mem[C_RD] == 1:
-            if h < len(tape):
-                mem[R_IN] = tape[h]
-                mem[C_EOT] = 0
-                h += 1
-            else:
-                mem[C_EOT] = 1
-        if mem[C_RW] == 1:
-            h = 0
-        mem[C_WR] = mem[C_RD] = mem[C_RW] = 0
-        n += 1
-    return bytes(out), n, mem, h
-
-
-# =============================================================================
-# the microprogram
-# =============================================================================
-
-class Micro:
-    """Records, with work signals allocated as they are named."""
-
-    def __init__(self, cfg, work_base: int, work_max: int):
-        self.cfg = cfg
-        self.recs: List[Tuple[List[Tuple[int, int, int]], int, Tuple[int, int]]] = []
-        self.next = work_base
-        self.limit = work_base + work_max
-        self.named: Dict[str, int] = {}
-
-    def sig(self, name: str = None) -> int:
-        s = self.next
-        self.next += 1
-        if self.next > self.limit:
-            raise ValueError("work signals exhausted")
-        if name:
-            self.named[name] = s
-        return s
-
-    def reg(self, name: str, width: int) -> List[int]:
-        r = [self.sig() for _ in range(width)]
-        self.named[name] = r[0]
-        return r
-
-    def emit(self, slots, bias, out):
-        self.recs.append((slots, bias, out))
-
-    # --- one-record primitives ------------------------------------------
-    def const(self, dst, v):
-        self.emit([], 0 if v else -1, (dst, 0))
-
-    def copy(self, dst, src):
-        self.emit([(src, 1, 0)], -1, (dst, 0))
-
-    def not_(self, dst, src):
-        self.emit([(src, -1, 0)], 0, (dst, 0))
-
-    def and2(self, dst, a, b, na=False, nb=False):
-        wa, wb = (-1 if na else 1), (-1 if nb else 1)
-        bias = -((0 if na else 1) + (0 if nb else 1))
-        self.emit([(a, wa, 0), (b, wb, 0)], bias, (dst, 0))
-
-    def or2(self, dst, a, b):
-        self.emit([(a, 1, 0), (b, 1, 0)], -1, (dst, 0))
-
-    def read_idx(self, dst, base):
-        """dst <- sig[base + PTR]."""
-        self.emit([(base, 1, 1)], -1, (dst, 0))
-
-    def write_idx(self, base, src):
-        """sig[base + PTR] <- src."""
-        self.emit([(src, 1, 0)], -1, (base, 1))
-
-    def write_idx_and(self, base, src, gate, ngate=False):
-        """sig[base + PTR] <- src AND gate (or src AND NOT gate)."""
-        wg = -1 if ngate else 1
-        bias = -1 if ngate else -2
-        self.emit([(src, 1, 0), (gate, wg, 0)], bias, (base, 1))
-
-    # --- small cells ------------------------------------------------------
-    def xor(self, dst, a, b):
-        t1, t2 = self.sig(), self.sig()
-        self.or2(t1, a, b)
-        self.emit([(a, -1, 0), (b, -1, 0)], 1, (t2, 0))      # NAND
-        self.and2(dst, t1, t2)
-
-    def mux(self, dst, sel, x1, x0):
-        ns, a1, a0 = self.sig(), self.sig(), self.sig()
-        self.not_(ns, sel)
-        self.and2(a1, x1, sel)
-        self.and2(a0, x0, ns)
-        self.or2(dst, a1, a0)
-
-    def and_lits(self, dst, lits):
-        """dst <- conjunction of literals (signal, want) via a binary tree."""
-        level = []
-        i = 0
-        while i < len(lits):
-            if i + 1 < len(lits):
-                (sa, wa), (sb, wb) = lits[i], lits[i + 1]
-                t = self.sig()
-                self.and2(t, sa, sb, na=not wa, nb=not wb)
-                level.append(t)
-                i += 2
-            else:
-                sa, wa = lits[i]
-                t = self.sig()
-                if wa:
-                    self.copy(t, sa)
-                else:
-                    self.not_(t, sa)
-                level.append(t)
-                i += 1
-        while len(level) > 1:
-            nxt = []
-            for j in range(0, len(level) - 1, 2):
-                last = len(level) == 2
-                t = dst if last else self.sig()
-                self.and2(t, level[j], level[j + 1])
-                nxt.append(t)
-            if len(level) % 2:
-                nxt.append(level[-1])
-            level = nxt
-        if level[0] != dst:
-            self.copy(dst, level[0])
-
-    def incr_gated(self, reg, gate):
-        """reg <- reg + gate, on len(reg) bits, least significant first."""
-        carries = [gate]
-        for k in range(len(reg) - 1):
-            c = self.sig()
-            self.and2(c, reg[k], carries[k])
-            carries.append(c)
-        for k in range(len(reg)):
-            self.xor(reg[k], reg[k], carries[k])
-
-    def add_const(self, dst, src, c):
-        """dst <- src + c on len(src) bits, least significant first."""
-        carry = None
-        for k in range(len(src)):
-            bit = (c >> k) & 1
-            if bit and carry is None:
-                self.not_(dst[k], src[k])
-                carry = src[k]
-            elif bit:
-                t = self.sig()
-                self.xor(t, src[k], carry)
-                self.not_(dst[k], t)
-                nc = self.sig()
-                self.or2(nc, src[k], carry)
-                carry = nc
-            elif carry is None:
-                self.copy(dst[k], src[k])
-            else:
-                nc = self.sig()
-                self.and2(nc, src[k], carry)
-                self.xor(dst[k], src[k], carry)
-                carry = nc
-
-
-def build_microprogram(cfg, mem_base, tape_base, out_base, tape_len,
-                       work_base, work_max):
-    """The records implementing one SUBLEQ step with its device."""
-    m = Micro(cfg, work_base, work_max)
-    PC = m.reg("PC", ADDR)                       # least significant first
-    P1 = m.reg("P1", ADDR)
-    P2 = m.reg("P2", ADDR)
-    P3 = m.reg("P3", ADDR)
-    Ab = m.reg("A", 8)
-    Bb = m.reg("B", 8)
-    Cb = m.reg("C", 8)
-    X = m.reg("X", 8)
-    Y = m.reg("Y", 8)
-    Rb = m.reg("R", 8)
-    NPC = m.reg("NPC", ADDR)
-    head = m.reg("head", ADDR)
-    wp = m.reg("wp", ADDR)
-
-    def cell(addr, bit):
-        """The signal holding bit `bit` of memory cell `addr`."""
-        return mem_base + bit * MEM_BYTES + addr
-
-    def ptr_set(src):
-        """PTR <- src, on ADDR bits; the pointer is stored most significant
-        first, so bit k of the value is coordinate PTR_BASE + A - 1 - k."""
-        for k in range(ADDR):
-            m.copy(cfg.PTR_BASE + cfg.A - 1 - k, src[k])
-
-    # the pointer's high bits stay zero
-    for k in range(ADDR, cfg.A):
-        m.const(cfg.PTR_BASE + cfg.A - 1 - k, 0)
-
-    m.add_const(P1, PC, 1)
-    m.add_const(P2, PC, 2)
-    m.add_const(P3, PC, 3)
-
-    for reg, src in ((Ab, PC), (Bb, P1), (Cb, P2)):
-        ptr_set(src)
-        for b in range(8):
-            m.read_idx(reg[b], mem_base + b * MEM_BYTES)
-    for reg, src in ((X, Ab), (Y, Bb)):
-        ptr_set(src[:ADDR])
-        for b in range(8):
-            m.read_idx(reg[b], mem_base + b * MEM_BYTES)
-
-    # R = Y - X, and the branch decision
-    nx = [m.sig() for _ in range(8)]
-    for b in range(8):
-        m.not_(nx[b], X[b])
-    carry = None
-    for b in range(8):
-        t = m.sig()
-        if carry is None:                                  # carry in is 1
-            m.xor(t, Y[b], nx[b])
-            m.not_(Rb[b], t)
-            c = m.sig()
-            m.or2(c, Y[b], nx[b])
-        else:
-            m.xor(t, Y[b], nx[b])
-            m.xor(Rb[b], t, carry)
-            c1, c2, c = m.sig(), m.sig(), m.sig()
-            m.and2(c1, Y[b], nx[b])
-            m.and2(c2, t, carry)
-            m.or2(c, c1, c2)
-        carry = c
-    nz = m.sig()
-    tree = Rb[0]
-    for b in range(1, 8):
-        t = m.sig()
-        m.or2(t, tree, Rb[b])
-        tree = t
-    m.not_(nz, tree)
-    leq = m.sig()
-    m.or2(leq, Rb[7], nz)
-
-    # write back to M[B]
-    ptr_set(Bb[:ADDR])
-    for b in range(8):
-        m.write_idx(mem_base + b * MEM_BYTES, Rb[b])
-
-    # --- the device ------------------------------------------------------
-    wr, rd, rw = m.sig(), m.sig(), m.sig()
-    m.and_lits(wr, [(cell(C_WR, 0), 1)] + [(cell(C_WR, b), 0) for b in range(1, 8)])
-    m.and_lits(rd, [(cell(C_RD, 0), 1)] + [(cell(C_RD, b), 0) for b in range(1, 8)])
-    m.and_lits(rw, [(cell(C_RW, 0), 1)] + [(cell(C_RW, b), 0) for b in range(1, 8)])
-
-    # read: R_IN <- tape[head] when the head is inside the tape
-    ateot = m.sig()
-    m.and_lits(ateot, [(head[k], (tape_len >> k) & 1) for k in range(ADDR)])
-    inrange = m.sig()
-    m.not_(inrange, ateot)
-    g = m.sig()
-    m.and2(g, rd, inrange)
-    ptr_set(head)
-    tb = [m.sig() for _ in range(8)]
-    for b in range(8):
-        m.read_idx(tb[b], tape_base + b * tape_len)
-    for b in range(8):
-        m.mux(cell(R_IN, b), g, tb[b], cell(R_IN, b))
-    # end-of-tape status: set by a read at the end, cleared by a read inside
-    m.mux(cell(C_EOT, 0), rd, ateot, cell(C_EOT, 0))
-    for b in range(1, 8):
-        m.and2(cell(C_EOT, b), cell(C_EOT, b), rd, nb=True)
-    m.incr_gated(head, g)
-    for k in range(ADDR):                     # rewind sets the head to zero
-        m.and2(head[k], head[k], rw, nb=True)
-
-    # write: append R_OUT to the output word, then clear R_OUT
-    ptr_set(wp)
-    for b in range(8):
-        m.write_idx_and(out_base + b * tape_len, cell(R_OUT, b), wr)
-    for b in range(8):
-        m.and2(cell(R_OUT, b), cell(R_OUT, b), wr, nb=True)
-    m.incr_gated(wp, wr)
-
-    # the request cells are cleared at the end of every step
-    for b in range(8):
-        m.const(cell(C_WR, b), 0)
-        m.const(cell(C_RD, b), 0)
-        m.const(cell(C_RW, b), 0)
-
-    # --- branch and halt --------------------------------------------------
-    for k in range(ADDR):
-        m.mux(NPC[k], leq, Cb[k], P3[k])
-    m.and_lits(cfg.HALT_SIG, [(NPC[k], (HALT_PC >> k) & 1) for k in range(ADDR)])
-    for k in range(ADDR):
-        m.copy(PC[k], NPC[k])
-    return m
-
-
-def step128(mem, pc, tape, h, out, wp):
-    """One step of the transducer of Definitions 2.8 and 3.1 on a 128-byte
-    memory whose tape is the whole tape region: the SUBLEQ instruction, then
-    the write, read, rewind and clear clauses of the device."""
-    A = mem[pc % MEM_BYTES]
-    B = mem[(pc + 1) % MEM_BYTES]
-    C = mem[(pc + 2) % MEM_BYTES]
-    r = (mem[B % MEM_BYTES] - mem[A % MEM_BYTES]) & 0xFF
-    mem[B % MEM_BYTES] = r
-    pc = C % MEM_BYTES if (r == 0 or r >= 0x80) else (pc + 3) % MEM_BYTES
-    if mem[C_WR] == 1:
-        out[wp] = mem[R_OUT]
-        wp += 1
-        mem[R_OUT] = 0
-    if mem[C_RD] == 1:
-        if h < len(tape):
-            mem[R_IN] = tape[h]
-            mem[C_EOT] = 0
-            h += 1
-        else:
-            mem[C_EOT] = 1
-    if mem[C_RW] == 1:
-        h = 0
-    mem[C_WR] = mem[C_RD] = mem[C_RW] = 0
-    return pc, h, wp
-
-
-def random_pass_check(cfg, m, nl, mem_base, tape_base, out_base, tape_len,
-                      n_ref: int, n_net: int, device: str, seed: int = 11):
-    """One pass of the microprogram against one step of the transducer, from
-    random states: random memory, counter, tape, head, write pointer, output
-    below the write pointer and scratch registers; the output region above the
-    write pointer is clear, as it is along every run."""
-    import random as _r
-    rng = _r.Random(seed)
-    regs = {k: m.named[k] for k in ("PC", "head", "wp")}
-
-    def make():
-        sig = [rng.randint(0, 1) for _ in range(cfg.S)]
-        sig[cfg.NET0:cfg.NET0 + len(nl)] = nl
-        for c in (cfg.PTR_ADV, cfg.OUT_STROBE, cfg.HALT_SIG, cfg.BANK_SIG):
-            sig[c] = 0
-        mem = [rng.randrange(256) for _ in range(MEM_BYTES)]
-        tape = [rng.randrange(256) for _ in range(tape_len)]
-        pc = rng.choice([x for x in range(MEM_BYTES) if x != HALT_PC])
-        h = rng.randint(0, tape_len)
-        wp = rng.randint(0, tape_len - 2)
-        out = [rng.randrange(256) if j < wp else 0 for j in range(tape_len)]
-        for j in range(MEM_BYTES):
-            for b in range(8):
-                sig[mem_base + b * MEM_BYTES + j] = (mem[j] >> b) & 1
-        for j in range(tape_len):
-            for b in range(8):
-                sig[tape_base + b * tape_len + j] = (tape[j] >> b) & 1
-                sig[out_base + b * tape_len + j] = (out[j] >> b) & 1
-        for name, val in (("PC", pc), ("head", h), ("wp", wp)):
-            for k in range(ADDR):
-                sig[regs[name] + k] = (val >> k) & 1
-        return sig, mem, tape, pc, h, out, wp
-
-    def expect(mem, tape, pc, h, out, wp):
-        mem, out = list(mem), list(out)
-        pc, h, wp = step128(mem, pc, tape, h, out, wp)
-        return mem, pc, h, out, wp
-
-    def observe(sig):
-        byte = lambda base, stride, j: sum(int(sig[base + b * stride + j]) << b for b in range(8))
-        val = lambda name: sum(int(sig[regs[name] + k]) << k for k in range(ADDR))
-        return ([byte(mem_base, MEM_BYTES, j) for j in range(MEM_BYTES)], val("PC"),
-                val("head"), [byte(out_base, tape_len, j) for j in range(tape_len)],
-                val("wp"), int(sig[cfg.HALT_SIG]))
-
-    def agrees(got, e_mem, e_pc, e_h, e_out, e_wp):
-        g_mem, g_pc, g_h, g_out, g_wp, g_halt = got
-        if e_pc == HALT_PC:
-            # the counter is copied after the halt signal is raised, and the
-            # interpreter stops within the copy, so a halting step is judged
-            # on everything but the counter
-            return (g_mem, g_h, g_out, g_wp, g_halt) == (e_mem, e_h, e_out, e_wp, 1)
-        return got == (e_mem, e_pc, e_h, e_out, e_wp, 0)
-
-    bad_ref = 0
-    for _ in range(n_ref):
-        sig, mem, tape, pc, h, out, wp = make()
-        e = expect(mem, tape, pc, h, out, wp)
-        run_records(m.recs, sig, cfg, 1)
-        if not agrees(observe(sig), *e):
-            bad_ref += 1
-    if n_net == 0:
-        return bad_ref, 0
-    states = [make() for _ in range(n_net)]
-    lev = SparseLeveled(*build_net(cfg), device=device)
-    X = torch.stack([state_to_vec(cfg, {"sig": st[0], "gp": 0, "halt": 0})
-                     for st in states]).to(device)
-    for _ in range(cfg.G):
-        X = lev.step(X)
-    X = X.cpu()
-    bad_net = 0
-    for i, (sig, mem, tape, pc, h, out, wp) in enumerate(states):
-        e = expect(mem, tape, pc, h, out, wp)
-        if not agrees(observe(X[i].tolist()), *e):
-            bad_net += 1
-    return bad_ref, bad_net
-
-
-def run_records(recs, sig, cfg, max_passes):
-    """Definition 9.1 applied record by record, in place.
-
-    Identical in semantics to reflect.ref_gate, and used here so that the
-    microprogram can be checked against the reference machine without
-    evaluating the interpreter's netlist.
-    """
-    S, PB, A = cfg.S, cfg.PTR_BASE, cfg.A
-    for p in range(max_passes):
-        for slots, bias, (oa, oidx) in recs:
-            ptr = 0
-            for k in range(A):
-                ptr = (ptr << 1) | sig[PB + k]
-            acc = bias
-            for (a, w, idx) in slots:
-                acc += w * sig[(a + (ptr if idx else 0)) & (S - 1)]
-            sig[(oa + (ptr if oidx else 0)) & (S - 1)] = 1 if acc >= 0 else 0
-            if sig[cfg.HALT_SIG]:
-                return p + 1, True
-    return max_passes, False
-
-
-def layout(tape_len: int, out_len: int, work_max: int = 700,
-           min_records: int = 1):
-    """The smallest configuration with room for the microprogram and the
-    regions it addresses."""
-    for A in range(12, 22):
-        S = 1 << A
-        R = 3 * A + 11
-        work_base = A + 6
-        mem_base = work_base + work_max
-        tape_base = mem_base + 8 * MEM_BYTES
-        out_base = tape_base + 8 * tape_len
-        top = out_base + 8 * out_len
-        for G in range((S - top) // R, min_records - 1, -1):
-            span = S - G * R
-            if span >= top + 8:
-                return A, G, span, mem_base, tape_base, out_base, work_base
-    raise ValueError("no configuration is large enough")
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--target", default="ABCCCCCCCCDE")
-    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
-    ap.add_argument("--random-states", type=int, default=2000)
-    ap.add_argument("--net-states", type=int, default=256)
-    args = ap.parse_args()
-
-    target = args.target.encode()
-    tape = describe(target)
-    assert decode(tape) == target
-    tape_len = out_len = 64
-    assert len(tape) < tape_len and len(target) < out_len
-
-    A, G, span, mem_base, tape_base, out_base, work_base = layout(
-        tape_len, out_len, min_records=520)
-    cfg = Cfg(A=A, G=G, banks=1, self_mod=False)
-    assert cfg.span == span, (cfg.span, span)
-    m = build_microprogram(cfg, mem_base, tape_base, out_base, tape_len,
-                           work_base, 700)
-    n = len(m.recs)
-    assert n <= G, (n, G)
-    print(f"  hosted machine: SUBLEQ over {MEM_BYTES} bytes with the tape, the "
-          f"output word, the head and the write pointer in signals", flush=True)
-    print(f"  microprogram: {n} records; interpreter U_S': S = {cfg.S}, "
-          f"G = {cfg.G}, b = {cfg.R}, addressed span {cfg.span}", flush=True)
-    print(f"  regions: work {work_base}..{m.next - 1}, memory {mem_base}, "
-          f"tape {tape_base}, output {out_base}", flush=True)
-
-    exp_out, exp_steps, exp_mem, exp_head = reference128(image128(), tape)
-    assert exp_out == target, (exp_out, target)
-    print(f"  the reference runs P on a {len(tape)}-byte recipe in "
-          f"{exp_steps} instructions, emitting {len(exp_out)} bytes", flush=True)
-
-    nl = encode_netlist(cfg, m.recs)
-
-    def initial_signals():
-        sig = [0] * cfg.S
-        sig[cfg.NET0:cfg.NET0 + len(nl)] = nl
-        mem0 = image128()
-        for j in range(MEM_BYTES):
-            for b in range(8):
-                sig[mem_base + b * MEM_BYTES + j] = (mem0[j] >> b) & 1
-        for j, byte in enumerate(tape):
-            for b in range(8):
-                sig[tape_base + b * tape_len + j] = (byte >> b) & 1
-        return sig
-
-    def readout(sig):
-        def byte_at(base, stride, j):
-            return sum(int(sig[base + b * stride + j]) << b for b in range(8))
-        return (bytes(byte_at(out_base, tape_len, j) for j in range(len(target))),
-                [byte_at(mem_base, MEM_BYTES, j) for j in range(MEM_BYTES)],
-                sum(int(sig[m.named["wp"] + k]) << k for k in range(ADDR)),
-                sum(int(sig[m.named["head"] + k]) << k for k in range(ADDR)))
-
-    # first at the level of Definition 9.1, record by record
-    t0 = time.perf_counter()
-    rsig = initial_signals()
-    rpasses, rhalted = run_records(m.recs, rsig, cfg, exp_steps + 3)
-    r_out, r_mem, r_wp, r_head = readout(rsig)
-    rec_ok = (rhalted and rpasses == exp_steps and r_out == target
-              and r_mem == exp_mem and r_head == exp_head)
-    print(f"  record semantics: halted after {rpasses} passes, emitted "
-          f"{r_wp} bytes {r_out!r}, memory and head match the reference: "
-          f"{'yes' if rec_ok else 'NO'} ({time.perf_counter() - t0:.1f}s)",
-          flush=True)
-
-    t0 = time.perf_counter()
-    unet, uin, uout = build_net(cfg)
-    lev = Leveled(unet, uin, uout, device=args.device)
-    print(f"  U_S' netlist: {len(unet.gates):,} units, {len(lev.plan)} layers "
-          f"({time.perf_counter() - t0:.0f}s)", flush=True)
-
-    V = state_to_vec(cfg, {"sig": initial_signals(), "gp": 0, "halt": 0}
-                     ).unsqueeze(0).to(args.device)
-
-    t0 = time.perf_counter()
-    halted_at = None
-    for inst in range(exp_steps + 2):
-        for _ in range(cfg.G):
-            V = lev.step(V)
-        if int(V[0, cfg.S + cfg.GPW]) == 1:
-            halted_at = inst + 1
-            break
-        if inst and inst % 20 == 0:
-            print(f"      {inst}/{exp_steps} instructions "
-                  f"({inst * cfg.G / (time.perf_counter() - t0):.0f} steps/s)",
-                  flush=True)
-    dt = time.perf_counter() - t0
-    got, got_mem, wp_val, head_val = readout(V[0].cpu())
-
-    exact = got == target
-    mem_same = got_mem == exp_mem
-    print(f"  ran to a halt after {halted_at} instructions "
-          f"({halted_at * cfg.G:,} interpreter steps, {dt / 60:.1f} min, "
-          f"{halted_at * cfg.G / dt:.0f} steps/s)", flush=True)
-    print(f"  emitted {wp_val} bytes: {got!r}")
-    print(f"  equals the target: {'yes' if exact else 'NO'}; final memory "
-          f"equals the reference: {'yes' if mem_same else 'NO'}; head "
-          f"{head_val} of {len(tape)}: "
-          f"{'yes' if head_val == exp_head else 'NO'}")
-
-    t0 = time.perf_counter()
-    dev_rand = "cuda" if torch.cuda.is_available() else args.device
-    bad_ref, bad_net = random_pass_check(cfg, m, nl, mem_base, tape_base, out_base,
-                                         tape_len, args.random_states,
-                                         args.net_states, dev_rand)
-    print(f"  one pass against one step of the transducer from random states: "
-          f"{args.random_states:,} on the record semantics, "
-          f"{'all exact' if bad_ref == 0 else f'{bad_ref} WRONG'}; "
-          f"{args.net_states:,} on the netlist, "
-          f"{'all exact' if bad_net == 0 else f'{bad_net} WRONG'} "
-          f"({time.perf_counter() - t0:.0f}s)", flush=True)
-
-    ok = (rec_ok and exact and mem_same and halted_at == exp_steps
-          and head_val == exp_head and bad_ref == 0 and bad_net == 0)
-    d = os.path.join(REPO, "paper", "runs")
-    os.makedirs(d, exist_ok=True)
-    json.dump({"records": n, "record_semantics_ok": rec_ok,
-               "S": cfg.S, "G": cfg.G, "b": cfg.R,
-               "span": cfg.span, "units": len(unet.gates),
-               "layers": len(lev.plan), "memory_bytes": MEM_BYTES,
-               "tape_bytes": len(tape), "target_bytes": len(target),
-               "target": target.decode(), "instructions": halted_at,
-               "reference_instructions": exp_steps,
-               "interpreter_steps": halted_at * cfg.G,
-               "emitted": got.decode(errors="replace"), "exact": exact,
-               "memory_matches_reference": mem_same, "head": head_val,
-               "random_states_records": args.random_states,
-               "random_states_records_wrong": bad_ref,
-               "random_states_netlist": args.net_states,
-               "random_states_netlist_wrong": bad_net,
-               "seconds": dt, "ok": ok},
-              open(os.path.join(d, "paper_hosted.json"), "w"), indent=1)
-    print("HOSTED CONSTRUCTOR:", "PASS" if ok else "FAIL")
-    return 0 if ok else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

src/independent/interpreter.py

@@ -1,495 +0,0 @@
-"""Definition 9.1 transcribed afresh, and the two runs of Section 9 on it.
-
-    python src/independent/interpreter.py
-
-The artifact supplies only the objects under test: the 494 stored records of
-Theorem 9.10 with the register addresses they use, and the netlist of U_128 that
-Proposition 9.8 stores. Record decoding, the interpreter, the fan-in-two
-compilation, the layout of Proposition 9.8, the SUBLEQ machine on 128 bytes, the
-device and the constructor P (from Table 9 of the paper) are written here.
-"""
-import json
-import os
-import random
-import sys
-import time
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-RUNS = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), 'paper', 'runs')
-
-# ---------------------------------------------------------------------------
-# Definition 9.1
-# ---------------------------------------------------------------------------
-
-
-class Member:
-    def __init__(self, A, G, span, banks=1):
-        self.A, self.G, self.span = A, G, span
-        self.S = 1 << A
-        self.b = 3 * A + 11
-        self.OUT_DATA, self.OUT_STROBE, self.ADV, self.KAPPA, self.HALT = A, A + 1, A + 2, A + 3, A + 4
-        self.Q0 = self.S - banks * G * self.b
-
-
-def decode_record(bits, A):
-    """(a0, w0, i0, a1, w1, i1, beta, ao, io), addresses most significant bit first."""
-    pos = 0
-
-    def take(n):
-        nonlocal pos
-        v = 0
-        for k in range(n):
-            v = (v << 1) | bits[pos + k]
-        pos += n
-        return v
-    wmap = {0b01: 1, 0b10: -1, 0b00: 0, 0b11: 0}
-    a0 = take(A); w0 = wmap[take(2)]; i0 = take(1)
-    a1 = take(A); w1 = wmap[take(2)]; i1 = take(1)
-    beta = take(4); beta = beta - 16 if beta >= 8 else beta
-    ao = take(A); io = take(1)
-    assert pos == 3 * A + 11
-    return a0, w0, i0, a1, w1, i1, beta, ao, io
-
-
-def encode_record(rec, A):
-    a0, w0, i0, a1, w1, i1, beta, ao, io = rec
-    out = []
-    put = lambda v, n: out.extend((v >> (n - 1 - k)) & 1 for k in range(n))
-    wc = {1: 0b01, -1: 0b10, 0: 0b00}
-    put(a0, A); put(wc[w0], 2); put(i0, 1)
-    put(a1, A); put(wc[w1], 2); put(i1, 1)
-    put(beta & 15, 4); put(ao, A); put(io, 1)
-    return out
-
-
-class Interp:
-    """The interpreter on a state x of S coordinates, with record counter and halt bit."""
-    def __init__(self, M, x):
-        self.M, self.x, self.g, self.halt, self.out = M, x, 0, 0, []
-        self.recs = [decode_record(x[M.Q0 + k * M.b: M.Q0 + (k + 1) * M.b], M.A) for k in range(M.G)]
-
-    def ptr(self):
-        v = 0
-        for k in range(self.M.A):
-            v = (v << 1) | self.x[k]
-        return v
-
-    def apply(self):
-        M, x = self.M, self.x
-        if self.halt:
-            return
-        a0, w0, i0, a1, w1, i1, beta, ao, io = self.recs[self.g]
-        p = self.ptr()
-        eff = lambda a, i: (a + i * p) % M.S
-        rd = lambda a: x[a] if a < M.span else 0
-        v = 1 if w0 * rd(eff(a0, i0)) + w1 * rd(eff(a1, i1)) + beta >= 0 else 0
-        nhalt = self.halt | x[M.HALT]
-        dst = eff(ao, io)
-        if dst < M.span:
-            x[dst] = v
-        if x[M.ADV]:                                   # the pointer clause
-            q = (p + 1) % M.S
-            for k in range(M.A):
-                x[k] = (q >> (M.A - 1 - k)) & 1
-            x[M.ADV] = 0
-        if x[M.OUT_STROBE]:                            # the output clause, by the runtime
-            self.out.append(x[M.OUT_DATA])
-            x[M.OUT_STROBE] = 0
-        self.g = (self.g + 1) % M.G
-        self.halt = nhalt
-
-
-# ---------------------------------------------------------------------------
-# The hosted transducer: SUBLEQ on 128 bytes (Definition 3.1 with addresses
-# modulo 128, halting at 0x7F) and the device of Definition 2.8 at the top cells
-# ---------------------------------------------------------------------------
-
-Z, ONE, T1, T2, NEG1, EOK = 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5
-C_WR, C_EOT, C_RW, C_RD, R_IN, R_OUT = 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE
-TABLE9 = [  # Table 9 of the paper
-    (T2, T2, 0x03), (T1, T1, 0x06), (NEG1, C_RD, 0x09), (R_IN, T1, 0x0C), (T1, T2, 0x0F),
-    (Z, T2, 0x15), (Z, Z, 0x1B), (Z, T1, 0x3C), (Z, Z, 0x2D), (NEG1, C_RD, 0x1E),
-    (R_IN, R_OUT, 0x21), (NEG1, C_WR, 0x24), (ONE, T2, 0x2A), (Z, Z, 0x1B), (Z, Z, 0x00),
-    (NEG1, C_RD, 0x30), (R_IN, R_OUT, 0x33), (NEG1, C_WR, 0x36), (ONE, T1, 0x2A), (Z, Z, 0x30),
-    (Z, Z, 0xFF)]
-mv = lambda c: c - 0x80 if c >= 0xF0 else c
-
-
-def p128_image():
-    mem = [0] * 128
-    for k, (a, b, c) in enumerate(TABLE9):
-        mem[3 * k:3 * k + 3] = [mv(a), mv(b), mv(c)]
-    mem[mv(ONE)] = 1
-    mem[mv(NEG1)] = 255
-    mem[mv(EOK)] = 1
-    return mem
-
-
-def hosted_step(mem, p, tau, h, omega):
-    """One step of the hosted transducer; returns (mem, p, h, omega)."""
-    mem = list(mem)
-    a, b, c = mem[p], mem[(p + 1) % 128], mem[(p + 2) % 128]
-    a, b = a % 128, b % 128
-    r = (mem[b] - mem[a]) % 256
-    mem[b] = r
-    p2 = c % 128 if (r == 0 or r >= 128) else (p + 3) % 128
-    cwr, crd, crw = mem[mv(C_WR)] == 1, mem[mv(C_RD)] == 1, mem[mv(C_RW)] == 1
-    omega = list(omega)
-    if cwr:
-        omega.append(mem[mv(R_OUT)])
-        mem[mv(R_OUT)] = 0
-    if crd:
-        if h < len(tau):
-            mem[mv(R_IN)] = tau[h]
-            mem[mv(C_EOT)] = 0
-            h += 1
-        else:
-            mem[mv(C_EOT)] = 1
-    if crw:
-        h = 0
-    mem[mv(C_WR)] = mem[mv(C_RD)] = mem[mv(C_RW)] = 0
-    return mem, p2, h, omega
-
-
-def run_hosted(tau, max_steps=100000):
-    mem, p, h, omega = p128_image(), 0, 0, []
-    for k in range(1, max_steps + 1):
-        mem, p, h, omega = hosted_step(mem, p, tau, h, omega)
-        if p == 0x7F:
-            return k, mem, h, omega
-    raise RuntimeError('no halt')
-
-
-def nu(x):
-    return (-x) % 256
-
-
-def delta(r):
-    out, i = [], 0
-    while True:
-        t = r[i]
-        if t == 0:
-            return bytes(out)
-        if 1 <= t <= 127:
-            out += [nu(b) for b in r[i + 1:i + 1 + t]]
-            i += 1 + t
-        elif t >= 129:
-            out += [nu(r[i + 1])] * (256 - t)
-            i += 2
-        else:
-            raise ValueError('tag 128')
-
-
-def describe(f):
-    """The encoder of Lemma 4.4."""
-    out, i = [], 0
-    while i < len(f):
-        ell = 1
-        while i + ell < len(f) and f[i + ell] == f[i] and ell < 127:
-            ell += 1
-        if ell >= 4:
-            out += [256 - ell, nu(f[i])]
-            i += ell
-            continue
-        k = i + 1
-        while k < len(f) and k < i + 127:
-            if k + 3 < len(f) and f[k] == f[k + 1] == f[k + 2] == f[k + 3]:
-                break
-            k += 1
-        out += [k - i] + [nu(c) for c in f[i:k]]
-        i = k
-    return bytes(out + [0])
-
-
-def census_steps(r):
-    """Theorem 4.6: 5 f_lit + 4 f_rep + 7L + 9R + 8."""
-    i, steps = 0, 8
-    while r[i] != 0:
-        t = r[i]
-        if t <= 127:
-            steps += 5 * t + 7
-            i += 1 + t
-        else:
-            steps += 4 * (256 - t) + 9
-            i += 2
-    return steps
-
-
-def random_recipe(rng, max_len=64, max_out=63):
-    while True:
-        toks, out_len = [], 0
-        for _ in range(rng.randint(0, 6)):
-            if rng.random() < 0.5:
-                n = rng.randint(1, 12)
-                toks += [n] + [rng.randrange(256) for _ in range(n)]
-                out_len += n
-            else:
-                ell = rng.randint(1, 20)
-                toks += [256 - ell, rng.randrange(256)]
-                out_len += ell
-        r = toks + [0]
-        if len(r) <= max_len and out_len <= max_out:
-            return bytes(r)
-
-
-# ---------------------------------------------------------------------------
-# Theorem 9.10
-# ---------------------------------------------------------------------------
-
-
-def hosted_check(recipes_n=40, random_n=2000, seed=11):
-    import hosted_constructor as HC
-    from reflect import Cfg, encode_netlist
-    A, G, span, mem_base, tape_base, out_base, work_base = HC.layout(64, 64, min_records=520)
-    cfg = Cfg(A=A, G=G, banks=1, self_mod=False)
-    m = HC.build_microprogram(cfg, mem_base, tape_base, out_base, 64, work_base, 700)
-    bits = encode_netlist(cfg, m.recs)
-    M = Member(A, G, span)
-    assert (A, G, span, mem_base, tape_base, out_base) == (15, 535, 2808, 721, 1745, 2257)
-    named = m.named
-    PC, HEAD, WP = named['pc'] if 'pc' in named else named['PC'], named['head'], named['wp']
-    n_real = len(m.recs)
-
-    def blank():
-        x = [0] * M.S
-        x[M.Q0:M.Q0 + len(bits)] = bits
-        return x
-
-    def put_reg(x, base, v):
-        for k in range(7):
-            x[base + k] = (v >> k) & 1
-
-    def get_reg(x, base):
-        return sum(x[base + k] << k for k in range(7))
-
-    def put_bytes(x, base, stride, data):
-        for j, byte in enumerate(data):
-            for t in range(8):
-                x[base + t * stride + j] = (byte >> t) & 1
-
-    def get_bytes(x, base, stride, n):
-        return [sum(x[base + t * stride + j] << t for t in range(8)) for j in range(n)]
-
-    res = dict(records=n_real, noops=G - n_real)
-    # every record after the 494th is a no-op writing the sink
-    tail = [decode_record(bits[k * M.b:(k + 1) * M.b], A) for k in range(n_real, G)]
-    res['tail_noops'] = all(r[1] == 0 and r[4] == 0 and r[6] == -1 and r[7] == A + 5 and r[8] == 0 for r in tail)
-    # the decoded records equal the artifact's own description of them
-    same = True
-    for k, (slots, bias, (oa, oi)) in enumerate(m.recs):
-        sl = list(slots) + [(0, 0, 0)] * (2 - len(slots))
-        rec = decode_record(bits[k * M.b:(k + 1) * M.b], A)
-        same &= rec == (sl[0][0], sl[0][1], sl[0][2], sl[1][0], sl[1][1], sl[1][2], bias, oa, oi)
-    res['decode_matches'] = same
-    # recipes run to the halt
-    rng = random.Random(seed)
-    tests = [b'ABCCCCCCCCDE']
-    runs = []
-    for k in range(recipes_n + 1):
-        if k == 0:
-            target = tests[0]
-            r = describe(target)
-            assert delta(r) == target and r == bytes([2, nu(65), nu(66), 248, nu(67), 2, nu(68), nu(69), 0])
-        else:
-            r = random_recipe(rng)
-        tau = list(r) + [0] * (64 - len(r))
-        steps, emem, eh, eomega = run_hosted(tau)
-        assert steps == census_steps(r) and bytes(eomega) == delta(r)
-        x = blank()
-        put_bytes(x, mem_base, 128, p128_image())
-        put_bytes(x, tape_base, 64, tau)
-        I = Interp(M, x)
-        apps = 0
-        while not I.halt and apps < (steps + 2) * G:
-            I.apply()
-            apps += 1
-        passes = -(-apps // G)
-        got_out = bytes(get_bytes(x, out_base, 64, 64))
-        ok = (I.halt and passes == steps and got_out[:len(eomega)] == bytes(eomega)
-              and not any(got_out[len(eomega):]) and get_bytes(x, mem_base, 128, 128) == emem
-              and get_reg(x, HEAD) == eh == len(r) and get_reg(x, WP) == len(eomega) and not I.out)
-        runs.append(dict(recipe_len=len(r), out_len=len(eomega), steps=steps, passes=passes,
-                         applications=apps, ok=ok))
-    res['recipes'] = len(runs)
-    res['recipes_ok'] = sum(r['ok'] for r in runs)
-    res['first'] = runs[0]
-    # one pass from random held states
-    bad = 0
-    halting = 0
-    for _ in range(random_n):
-        x = blank()
-        for c in range(M.A + 6, mem_base):                 # the work region, temporaries included, random
-            x[c] = rng.randrange(2)
-        for c in range(M.A):
-            x[c] = rng.randrange(2)
-        x[M.OUT_DATA] = rng.randrange(2)
-        x[M.ADV] = x[M.OUT_STROBE] = x[M.HALT] = 0
-        mem = [rng.randrange(256) for _ in range(128)]
-        p = rng.randrange(127)
-        u = rng.random()
-        if u < 0.125:
-            p = 0x7C                                       # p + 3 is the halt address
-        elif u < 0.25:
-            mem[(p + 2) % 128] = 0x7F                      # the branch target is the halt address
-        tau = [rng.randrange(256) for _ in range(64)]
-        h = rng.randint(0, 64)
-        w = rng.randint(0, 63)
-        omega = [rng.randrange(256) for _ in range(w)]
-        put_bytes(x, mem_base, 128, mem)
-        put_bytes(x, tape_base, 64, tau)
-        put_bytes(x, out_base, 64, omega + [0] * (64 - w))
-        put_reg(x, PC, p); put_reg(x, HEAD, h); put_reg(x, WP, w)
-        emem, ep, eh, eomega = hosted_step(mem, p, tau, h, omega)
-        I = Interp(M, x)
-        for _ in range(G):
-            I.apply()
-        got_out = get_bytes(x, out_base, 64, 64)
-        common = (get_bytes(x, mem_base, 128, 128) == emem and get_reg(x, HEAD) == eh
-                  and get_reg(x, WP) == len(eomega) and got_out[:len(eomega)] == eomega
-                  and not any(got_out[len(eomega):]) and get_bytes(x, tape_base, 64, 64) == tau
-                  and not I.out)
-        if ep == 0x7F:
-            halting += 1
-            ok = common and I.halt
-        else:
-            ok = common and not I.halt and get_reg(x, PC) == ep and I.g == 0
-        bad += not ok
-    res['random_states'] = random_n
-    res['random_halting_steps'] = halting
-    res['random_disagree'] = bad
-    return res
-
-
-# ---------------------------------------------------------------------------
-# Proposition 9.8
-# ---------------------------------------------------------------------------
-
-
-def hierarchy_check(states=48, passes=4, seed=5):
-    from reflect import Cfg, build_net, encode_netlist
-    small = Cfg(A=7, G=3, banks=1, self_mod=False)
-    net, inputs, outputs = build_net(small)
-    # the netlist as units over named signals; inputs are the state coordinates in order
-    gates = net.gates
-    order, seen = [], set(inputs) | {'#0', '#1'}
-    pending = dict(gates)
-    while pending:                                     # a topological order of the units
-        prog = [g for g, (ins, _) in pending.items() if all(s in seen for s, _ in ins)]
-        assert prog
-        for g in prog:
-            order.append(g); seen.add(g); del pending[g]
-    # fan-in two (Corollary 9.6): every unit of fan-in > 2 must be a conjunction or a disjunction
-    units2 = []                                        # (name, [(sig, w)], bias)
-    cnt = [0]
-
-    def fresh():
-        cnt[0] += 1
-        return f'_t{cnt[0]}'
-
-    def kind(ins, b):
-        pos = sum(1 for _, w in ins if w > 0)
-        neg = len(ins) - pos
-        if b == -pos:
-            return 'and'
-        if b == neg - 1:
-            return 'or'
-        return None
-
-    def tree(name, k, lits):
-        """lits: [(sig, polarity)], a balanced tree of two-input units, the root named name."""
-        level = list(lits)
-        while len(level) > 2:
-            nxt = []
-            for i in range(0, len(level) - 1, 2):
-                t = fresh()
-                (s1, p1), (s2, p2) = level[i], level[i + 1]
-                pos = p1 + p2
-                b = -pos if k == 'and' else (2 - pos) - 1
-                units2.append((t, [(s1, 1 if p1 else -1), (s2, 1 if p2 else -1)], b))
-                nxt.append((t, 1))
-            if len(level) % 2:
-                nxt.append(level[-1])
-            level = nxt
-        if len(level) == 2:
-            (s1, p1), (s2, p2) = level
-            pos = p1 + p2
-            b = -pos if k == 'and' else (2 - pos) - 1
-            units2.append((name, [(s1, 1 if p1 else -1), (s2, 1 if p2 else -1)], b))
-        else:
-            (s1, p1), = level
-            units2.append((name, [(s1, 1 if p1 else -1)], -1 if p1 else 0))
-    for g in order:
-        ins, b = gates[g]
-        if len(ins) <= 2:
-            units2.append((g, list(ins), b))
-        else:
-            k = kind(ins, b)
-            assert k is not None, (g, ins, b)
-            tree(g, k, [(s, 1 if w > 0 else 0) for s, w in ins])
-    # constants are wired as units
-    consts = {}
-    # the coordinates whose next value is not the coordinate itself
-    changed = [i for i, o in enumerate(outputs) if o != inputs[i]]
-    nstate = len(inputs)
-    n2 = len(units2)
-    # the larger member: A' = 17, one bank, G' = 2088, span 1616
-    big = Member(17, 2088, 1616)
-    base = big.A + 6
-    addr = {s: base + i for i, s in enumerate(inputs)}
-    for i, (name, _, _) in enumerate(units2):
-        addr[name] = base + nstate + i
-    recs = []
-    for name, ins, b in units2:
-        sl = [(addr[s] if s not in ('#0', '#1') else None, w) for s, w in ins]
-        assert all(a is not None for a, _ in sl)
-        sl += [(0, 0)] * (2 - len(sl))
-        recs.append((sl[0][0], sl[0][1], 0, sl[1][0], sl[1][1], 0, b, addr[name], 0))
-    for i in changed:
-        src = outputs[i]
-        if src == '#0':
-            recs.append((0, 0, 0, 0, 0, 0, -1, addr[inputs[i]], 0))
-        elif src == '#1':
-            recs.append((0, 0, 0, 0, 0, 0, 0, addr[inputs[i]], 0))
-        else:
-            recs.append((addr[src], 1, 0, 0, 0, 0, -1, addr[inputs[i]], 0))
-    assert len(recs) <= big.G and base + nstate + n2 <= big.span
-    noop = (0, 0, 0, 0, 0, 0, -1, big.A + 5, 0)
-    recs += [noop] * (big.G - len(recs))
-    bits = sum((encode_record(r, big.A) for r in recs), [])
-    rng = random.Random(seed)
-
-    def eval_small(vals):
-        v = dict(zip(inputs, vals)); v['#0'], v['#1'] = 0, 1
-        for g in order:
-            ins, b = gates[g]
-            v[g] = 1 if b + sum(w * v[s] for s, w in ins) >= 0 else 0
-        return [v[o] for o in outputs]
-    bad = 0
-    for _ in range(states):
-        y = [rng.randrange(2) for _ in range(nstate)]
-        x = [0] * big.S
-        x[big.Q0:big.Q0 + len(bits)] = bits
-        for i, s in enumerate(inputs):
-            x[addr[s]] = y[i]
-        I = Interp(big, x)
-        for _ in range(passes):
-            for _ in range(big.G):
-                I.apply()
-            y = eval_small(y)
-            got = [x[addr[s]] for s in inputs]
-            bad += got != y
-    return dict(small_units=len(gates), small_state_bits=nstate, fanin2_units=n2,
-                signals=nstate + n2, changed=len(changed), records=len(recs) - recs.count(noop),
-                big=dict(A=big.A, G=big.G, b=big.b, span=big.span), states=states, passes=passes,
-                disagree=bad)
-
-
-if __name__ == '__main__':
-    out = {}
-    for which, fn in (('hierarchy', hierarchy_check), ('hosted', hosted_check)):
-        t0 = time.time()
-        res = fn()
-        res['seconds'] = round(time.time() - t0, 1)
-        print(which, json.dumps(res), flush=True)
-        out[which] = res
-    json.dump(out, open(os.path.join(RUNS, 'independent_interpreter.json'), 'w'), indent=1)

src/paper_stats.py

@@ -1,4 +1,4 @@
-"""Structural statistics for the host, its levelization, and the interpreter.
+"""Structural statistics for the host and its levelization.
 
 Reproduces the level assignment of matrix8.compile_net without materialising the
 dense matrices, so the layer widths, the number of identity units, the total
@@ -208,33 +208,6 @@ def main() -> int:
     print(f"  widths                    {lev['widths']}")
     out["lev_host"] = lev
 
-    print()
-    print("=" * 74)
-    print(" Interpreter U (reflect.Cfg default)")
-    print("=" * 74)
-    from reflect import Cfg, build_net
-    cfg = Cfg()
-    unet, uin, uout = build_net(cfg)
-    ulev = levelize(unet, uin, uout)
-    for k in ("depth", "gates", "netlist_gates", "state_bits", "M",
-              "dense_entries", "identity_units",
-              "new_units", "max_fanin_netlist", "nonzero_weights_netlist",
-              "bias_min", "bias_max"):
-        print(f"  {k:<26} {ulev[k]:,}" if isinstance(ulev[k], int) else f"  {k:<26} {ulev[k]}")
-    print(f"  fan-in histogram          {ulev['fanin_hist']}")
-    print(f"  cfg: S={cfg.S} G={cfg.G} F={cfg.F} BB={cfg.BB} banks={cfg.banks} "
-          f"record_bits={cfg.R} acc_bits={cfg.ACC} slot={cfg.SLOT}")
-    print(f"  regions: PTR@{cfg.PTR_BASE} width {cfg.A}; control {cfg.OUT_DATA}..{cfg.WORK_BASE-1}; "
-          f"data {cfg.WORK_BASE}..{cfg.NET0-1} ({cfg.NET0-cfg.WORK_BASE} bits); "
-          f"Q0 {cfg.NET0}..{cfg.NET1-1}; Q1 {cfg.NET1}..{cfg.S-1}; "
-          f"|Q|={cfg.G*cfg.R} b={cfg.R}")
-    out["lev_U"] = ulev
-    out["U_cfg"] = {"S": cfg.S, "G": cfg.G, "F": cfg.F, "BB": cfg.BB,
-                    "banks": cfg.banks, "R": cfg.R, "ACC": cfg.ACC,
-                    "SLOT": cfg.SLOT, "A": cfg.A, "NET0": cfg.NET0,
-                    "NET1": cfg.NET1, "WORK_BASE": cfg.WORK_BASE,
-                    "span": cfg.span, "STATE_BITS": cfg.STATE_BITS}
-
     path = runs_path("paper_stats.json")
     json.dump(out, open(path, "w"), indent=1)
     print(f"\nwrote {path}")

src/paper_verify.py

@@ -1,7 +1,5 @@
-"""Fast verification for the paper: codec, framing, serialization, interpreter.
-
-Everything here finishes in minutes. The long generation runs are in
-paper_runs.py.
+"""The recipe codec, the framing, the serialization, the host's datapath and the
+levelization, each against its definition; the record is paper/runs/paper_verify.json.
 """
 
 from __future__ import annotations
@@ -229,63 +227,10 @@ def check_host_datapath():
                      "counter_pairs": 65536, "counter_failures": bad_ctr}
 
 
-# ---------------------------------------------------------------------------
-def check_interpreter():
-    """One-record semantics exhaustively over record fields, and the record counter."""
-    print("[5] Interpreter U")
-    import torch
-    from reflect import (Cfg, build_net, Leveled, encode_netlist, state_to_vec,
-                         vec_to_state)
-    cfg = Cfg()
-    net, inputs, outputs = build_net(cfg)
-    lev = Leveled(net, inputs, outputs, device="cpu")
-
-    def U(sig, gp, halt=0):
-        v = state_to_vec(cfg, {"sig": sig, "gp": gp, "halt": halt}).unsqueeze(0)
-        out = lev.step(v[:, :len(inputs)])[0]
-        return vec_to_state(cfg, out)
-
-    ra, rb, ro = cfg.WORK_BASE, cfg.WORK_BASE + 1, cfg.WORK_BASE + 2
-    bad = total = 0
-    for w0 in (-1, 0, 1):
-        for w1 in (-1, 0, 1):
-            for bias in range(-(1 << (cfg.BB - 1)), 1 << (cfg.BB - 1)):
-                nl = encode_netlist(cfg, [([(ra, w0, 0), (rb, w1, 0)], bias, (ro, 0))])
-                for va in (0, 1):
-                    for vb in (0, 1):
-                        sig = [0] * cfg.S
-                        sig[cfg.NET0:cfg.NET0 + len(nl)] = nl
-                        sig[ra], sig[rb] = va, vb
-                        g = U(sig, 0)
-                        exp = 1 if w0 * va + w1 * vb + bias >= 0 else 0
-                        total += 1
-                        if g["sig"][ro] != exp or g["gp"] != 1:
-                            bad += 1
-    print(f"    one-record semantics over all {total} (w0,w1,bias,x0,x1) "
-          f"configurations: {'exact' if bad == 0 else f'{bad} FAILED'}")
-
-    # record counter advances modulo G
-    cbad = 0
-    nl = encode_netlist(cfg, [])
-    for gp in range(cfg.G):
-        sig = [0] * cfg.S
-        sig[cfg.NET0:cfg.NET0 + len(nl)] = nl
-        g = U(sig, gp)
-        if g["gp"] != (gp + 1) % cfg.G:
-            cbad += 1
-    print(f"    record counter advances mod G on all {cfg.G} values: "
-          f"{'exact' if cbad == 0 else 'FAILED'}")
-
-    R["interpreter"] = {
-        "onerecord_cases": total, "onerecord_failures": bad,
-        "counter_failures": cbad, "S": cfg.S, "G": cfg.G, "b": cfg.R,
-    }
-
-
 # ---------------------------------------------------------------------------
 def check_lev_sparse_dense():
     """The sparse and dense evaluations of Lev(N_host) agree."""
-    print("[6] Lev(N_host): sparse vs dense")
+    print("[5] Lev(N_host): sparse vs dense")
     import torch
     from selfrep import LevEvaluator, NetEvaluator, read_host
     sigma = read_host()
@@ -313,7 +258,6 @@ def main() -> int:
     check_framing()
     check_serialization()
     check_host_datapath()
-    check_interpreter()
     check_lev_sparse_dense()
     R["seconds"] = time.perf_counter() - t0
     path = runs_path("paper_verify.json")

src/stored_host.py

@@ -0,0 +1,694 @@
+"""The host as a stored network of the two-head machine.
+
+The two-head machine T_{G,L} of Section 7 is taken with a window of W = 2^ALPHA cells,
+so that a record (w0 code, w1 code, beta, a0, a1, ao) has 8 + 3 ALPHA bits. The host
+H_8, read from its serialization sigma(N_host), is compiled into records of two
+literals each, evaluated in an order in which every unit follows its inputs and the
+next value of each state bit is written over that bit after the last record that
+reads the old one; temporaries share window cells by live interval. One pass of the
+records is one step of H_8 followed by the device of Definition 2.8 acting on the
+tape under the read head, the idle bank under the arm and the copy tape under the
+copy head. A startup block, active in the first pass after a hand-over, loads the
+memory image m* of P*; the hand-over flips the bank bit when the host halts.
+
+Run from the image of these records in the active bank and tau* = describe(image) on
+the read tape, P* writes the image into the idle bank, copies tau* onto the copy
+tape and halts, and the hand-over starts the copy.
+
+    python src/stored_host.py check              one pass against H_8 and the device
+    python src/stored_host.py build              the image, tau*, sizes and digests
+    python src/stored_host.py run [GENERATIONS]  generations on the machine, in C
+"""
+import hashlib
+import json
+import os
+import random
+import struct
+import subprocess
+import sys
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import selfrep as SR
+
+REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+RECORD = os.path.join(REPO, 'paper', 'runs', 'paper_stored_host.json')
+
+ALPHA = 12
+W = 1 << ALPHA
+B = 8 + 3 * ALPHA
+KAPPA, RD, ARM, CPY, AR, AA, AC, SINK = range(8)
+CW = 20                                         # width of the device's byte counters
+
+
+# ---------------------------------------------------------------------------
+# the host netlist from its serialization
+# ---------------------------------------------------------------------------
+
+def host_units():
+    data = SR.read_host()
+    hlen = struct.unpack('<Q', data[:8])[0]
+    head = json.loads(data[8:8 + hlen])
+    T = {}
+    import array
+    for k, spec in head.items():
+        if k == '__metadata__':
+            continue
+        lo, hi = spec['data_offsets']
+        a = array.array({'I8': 'b', 'I16': 'h', 'I32': 'i'}[spec['dtype']])
+        a.frombytes(data[8 + hlen + lo:8 + hlen + hi])
+        T[k] = list(a)
+    bias, fanin, pred, nxt = T['net.bias'], T['net.fanin'], T['net.pred'], T['net.next']
+    units, p = [], 0
+    for j in range(len(bias)):
+        units.append((bias[j], [(abs(e) - 1, 1 if e > 0 else -1) for e in pred[p:p + fanin[j]]]))
+        p += fanin[j]
+    return len(nxt), units, nxt
+
+
+# state layout of sigma: pc bits 0..7 most significant first, halt 8, memory byte j bit k at 9 + 8 j + k,
+# k = 0 the most significant
+def mem_bit(j, t):
+    """State index of bit t (value 2^t) of memory byte j."""
+    return 9 + 8 * j + (7 - t)
+
+
+PC_BIT = lambda t: 7 - t                         # bit t of the counter
+HALT = 8
+
+
+# ---------------------------------------------------------------------------
+# records over named cells
+# ---------------------------------------------------------------------------
+
+class Prog:
+    def __init__(self):
+        self.recs = []                           # (a0, w0, a1, w1, beta, ao), cells by name
+        self.uid = 0
+
+    def tmp(self):
+        self.uid += 1
+        return ('t', self.uid)
+
+    def emit(self, a0, w0, a1, w1, beta, ao):
+        assert -8 <= beta <= 7
+        self.recs.append((a0 if w0 else ('c', SINK), w0, a1 if w1 else ('c', SINK), w1, beta, ao))
+
+    def AND(self, x, y, dst):
+        (a, pa), (b, pb) = x, y
+        self.emit(a, 1 if pa else -1, b, 1 if pb else -1, -(pa + pb), dst)
+
+    def OR(self, x, y, dst):
+        (a, pa), (b, pb) = x, y
+        self.emit(a, 1 if pa else -1, b, 1 if pb else -1, 1 - pa - pb, dst)
+
+    def COPY(self, x, dst):
+        a, pa = x
+        self.emit(a, 1 if pa else -1, None, 0, -1 if pa else 0, dst)
+
+    def CONST(self, v, dst):
+        # a gate of one literal and its negation: OR is 1, AND is 0
+        x = ('c', SINK)
+        (self.OR if v else self.AND)((x, True), (x, False), dst)
+
+    def XOR(self, x, y, dst):
+        t1, t2 = self.tmp(), self.tmp()
+        self.OR(x, y, t1)
+        self.OR((x[0], not x[1]), (y[0], not y[1]), t2)
+        self.AND((t1, True), (t2, True), dst)
+
+    def MUX(self, s, a, b, dst):
+        """dst <- s ? a : b, s a cell, a and b literals."""
+        t1, t2 = self.tmp(), self.tmp()
+        self.AND((s, True), a, t1)
+        self.AND((s, False), b, t2)
+        self.OR((t1, True), (t2, True), dst)
+
+    def chain(self, kind, lits, dst, before=None):
+        """kind 'and' or 'or' of the literals into dst; before(i) emits literal i's signal
+        just ahead of its use. dst receives one write, the last."""
+        assert lits
+        if len(lits) == 1:
+            if before:
+                before(0)
+            self.COPY(lits[0], dst)
+            return
+        g = self.AND if kind == 'and' else self.OR
+        acc = self.tmp()
+        if before:
+            before(0); before(1)
+        if len(lits) == 2:
+            g(lits[0], lits[1], dst)
+            return
+        g(lits[0], lits[1], acc)
+        for i in range(2, len(lits)):
+            if before:
+                before(i)
+            g((acc, True), lits[i], dst if i == len(lits) - 1 else acc)
+
+    def threshold(self, t, lits, dst):
+        """at least t of the literals, by T_t(x1..xk) = T_t(x2..xk) or (x1 and T_{t-1}(x2..xk))."""
+        k = len(lits)
+        if t <= 0:
+            self.CONST(1, dst); return
+        if t > k:
+            self.CONST(0, dst); return
+        if t == 1:
+            self.chain('or', lits, dst); return
+        if t == k:
+            self.chain('and', lits, dst); return
+        a, b = self.tmp(), self.tmp()
+        self.threshold(t, lits[1:], a)
+        self.threshold(t - 1, lits[1:], b)
+        c = self.tmp()
+        self.AND(lits[0], (b, True), c)
+        self.OR((a, True), (c, True), dst)
+
+
+def compile_host(P):
+    """The records of one step of H_8; state bits are cells ('s', i). A unit read by a single
+    unit is emitted just ahead of its use; the next value of each state bit is written over
+    the bit after every record that reads the old value."""
+    n, units, nxt = host_units()
+    cons = {}
+    for u, (_, ins) in enumerate(units):
+        for s, _w in ins:
+            if s >= n:
+                cons.setdefault(s - n, []).append(u)
+    is_next = {nxt[i] - n: i for i in range(n)}
+    assert len(is_next) == n and all(v >= n for v in nxt)
+    fusable = {u for u, c in cons.items() if len(c) == 1}
+    done, cell = set(), {}
+
+    def cell_of(s):
+        return ('s', s) if s < n else cell[s - n]
+
+    def ensure_ancestors(u):
+        for s, _w in units[u][1]:
+            if s >= n:
+                v = s - n
+                if v in fusable:
+                    ensure_ancestors(v)
+                else:
+                    need(v)
+
+    def need(u):
+        if u in done:
+            return
+        assert u not in is_next, 'a next value is read before the state is written'
+        ensure_ancestors(u)
+        cell[u] = P.tmp()
+        emit_unit(u, cell[u])
+        done.add(u)
+
+    def fused(v):
+        if v not in done:
+            cell[v] = P.tmp()
+            emit_unit(v, cell[v])
+            done.add(v)
+
+    def emit_unit(u, dst):
+        b, ins = units[u]
+        k = len(ins)
+        t = sum(1 for _, w in ins if w < 0) - b
+        lits = [None] * k
+
+        def before(i):
+            s = ins[i][0]
+            if s >= n and (s - n) in fusable:
+                fused(s - n)
+            lits[i] = (cell_of(s), ins[i][1] > 0)
+        if t <= 0 or t > k:
+            P.CONST(1 if t <= 0 else 0, dst)
+        elif 1 < t < k:
+            for i in range(k):
+                before(i)
+            P.threshold(t, lits, dst)
+        else:
+            _chain_lazy(P, 'and' if t == k else 'or', lits, dst, before)
+
+    order_next = [nxt[PC_BIT(t)] - n for t in range(8)] + [nxt[HALT] - n] + \
+                 [nxt[mem_bit(j, t)] - n for j in range(256) for t in range(8)]
+    for u in order_next:                         # stage A: everything the next values read
+        ensure_ancestors(u)
+    for u in order_next:                         # stage B: the next values, in place
+        emit_unit(u, ('s', is_next[u]))
+        done.add(u)
+    return n, units, nxt
+
+
+def _chain_lazy(P, kind, lits, dst, before):
+    k = len(lits)
+    if k == 1:
+        before(0)
+        P.COPY(lits[0], dst)
+        return
+    g = P.AND if kind == 'and' else P.OR
+    before(0); before(1)
+    if k == 2:
+        g(lits[0], lits[1], dst)
+        return
+    acc = P.tmp()
+    g(lits[0], lits[1], acc)
+    for i in range(2, k):
+        before(i)
+        g((acc, True), lits[i], dst if i == k - 1 else acc)
+
+
+# ---------------------------------------------------------------------------
+# the device, the startup block and the hand-over
+# ---------------------------------------------------------------------------
+
+def mem_cell(j, t):
+    return ('s', mem_bit(j, t))
+
+
+def byte_is_one(P, j):
+    """[memory byte j == 1]"""
+    dst = P.tmp()
+    lits = [(mem_cell(j, 0), True)] + [(mem_cell(j, t), False) for t in range(1, 8)]
+    P.chain('and', lits, dst)
+    return dst
+
+
+def compile_device(P):
+    cnt = [('d', 'cnt', i) for i in range(CW)]
+    lim = [('d', 'lim', i) for i in range(CW)]
+    dest = ('d', 'dest')
+    wr, rd, rw = byte_is_one(P, SR.C_WR), byte_is_one(P, SR.C_RD), byte_is_one(P, SR.C_RW)
+    # [cnt == lim]
+    eq = P.tmp()
+    xs = []
+    for i in range(CW):
+        e = P.tmp()
+        a1, a0 = P.tmp(), P.tmp()
+        P.AND((cnt[i], True), (lim[i], True), a1)
+        P.AND((cnt[i], False), (lim[i], False), a0)
+        P.OR((a1, True), (a0, True), e)
+        xs.append((e, True))
+    P.chain('and', xs, eq)
+    eot = P.tmp()                                # the end of the tape is known after the rewind
+    P.AND((eq, True), (dest, True), eot)
+    # (i) R_out, most significant bit first, under the arm or under the copy head
+    ca, cc = P.tmp(), P.tmp()
+    P.AND((wr, True), (dest, False), ca)
+    P.AND((wr, True), (dest, True), cc)
+    for t in range(7, -1, -1):
+        P.MUX(ca, (mem_cell(SR.R_OUT, t), True), (('c', ARM), True), ('c', ARM))
+        P.COPY((ca, True), ('c', AA))
+        P.MUX(cc, (mem_cell(SR.R_OUT, t), True), (('c', CPY), True), ('c', CPY))
+        P.COPY((cc, True), ('c', AC))
+    for t in range(8):
+        P.AND((mem_cell(SR.R_OUT, t), True), (wr, False), mem_cell(SR.R_OUT, t))
+    g = P.tmp()
+    P.AND((rd, True), (eot, False), g)
+    # (ii) the byte under the read head into R_in, most significant bit first, each bit turning the tape
+    for t in range(7, -1, -1):
+        P.MUX(g, (('c', RD), True), (mem_cell(SR.R_IN, t), True), mem_cell(SR.R_IN, t))
+        P.COPY((g, True), ('c', AR))
+    # c_eot: bit 0 <- [cnt == lim] on a read, the other bits cleared on a read
+    P.MUX(rd, (eot, True), (mem_cell(SR.C_EOT, 0), True), mem_cell(SR.C_EOT, 0))
+    for t in range(1, 8):
+        P.AND((mem_cell(SR.C_EOT, t), True), (rd, False), mem_cell(SR.C_EOT, t))
+    # the counter of bytes read: carries first, then the sum bits
+    car = [g]
+    for i in range(CW - 1):
+        c = P.tmp()
+        P.AND((car[-1], True), (cnt[i], True), c)
+        car.append(c)
+    for i in range(CW):
+        P.XOR((cnt[i], True), (car[i], True), cnt[i])
+    # (iii) a rewind: the limit takes the count, the count returns to 0, the writes go to the copy tape
+    for i in range(CW):
+        P.MUX(rw, (cnt[i], True), (lim[i], True), lim[i])
+        P.AND((cnt[i], True), (rw, False), cnt[i])
+    P.OR((dest, True), (rw, True), dest)
+    # (iv) the request cells cleared
+    for j in (SR.C_WR, SR.C_RD, SR.C_RW):
+        for t in range(8):
+            P.CONST(0, mem_cell(j, t))
+
+
+def compile_startup(P, mem_image):
+    """Active while 'booted' is 0: the memory image, a zero counter and halt bit, the device
+    registers cleared; then 'booted' is set."""
+    b = ('d', 'booted')
+    for j in range(256):
+        for t in range(8):
+            c = mem_cell(j, t)
+            if (mem_image[j] >> t) & 1:
+                P.OR((c, True), (b, False), c)           # b ? c : 1
+            else:
+                P.AND((c, True), (b, True), c)           # b ? c : 0
+    for t in range(8):
+        P.AND((('s', PC_BIT(t)), True), (b, True), ('s', PC_BIT(t)))
+    P.AND((('s', HALT), True), (b, True), ('s', HALT))
+    for i in range(CW):
+        P.AND((('d', 'cnt', i), True), (b, True), ('d', 'cnt', i))
+        P.AND((('d', 'lim', i), True), (b, True), ('d', 'lim', i))
+    P.AND((('d', 'dest'), True), (b, True), ('d', 'dest'))
+    P.CONST(1, b)
+
+
+def compile_handover(P):
+    """When the host has halted: the next pass starts up, and the bank bit flips at the last
+    record of the pass."""
+    h = ('s', HALT)
+    P.AND((('d', 'booted'), True), (h, False), ('d', 'booted'))
+    P.XOR((('c', KAPPA), True), (h, True), ('c', KAPPA))
+
+
+# ---------------------------------------------------------------------------
+# allocation and encoding
+# ---------------------------------------------------------------------------
+
+def allocate(recs):
+    """Window addresses: the special cells, the state, the device registers, then the
+    temporaries by live interval. Every temporary is written before it is read."""
+    fixed = {}
+    nxt_addr = 8
+    names = []
+    for r in recs:
+        for a in (r[0], r[2], r[5]):
+            if a is not None and a[0] in ('s', 'd') and a not in fixed:
+                names.append(a)
+                fixed[a] = None
+    for a in sorted(names, key=lambda x: (x[0], x[1:] if x[0] == 'd' else x[1])) :
+        fixed[a] = nxt_addr
+        nxt_addr += 1
+    first_w, last_r = {}, {}
+    for i, (a0, w0, a1, w1, be, ao) in enumerate(recs):
+        for a, w in ((a0, w0), (a1, w1)):
+            if w and a[0] == 't':
+                assert a in first_w, ('read before written', a)
+                last_r[a] = i
+        if ao[0] == 't':
+            first_w.setdefault(ao, i)
+    base = nxt_addr
+    free_at = {}                                 # cell -> index after which it is free
+    addr = dict(fixed)
+    for name in sorted(first_w, key=lambda x: first_w[x]):
+        start, end = first_w[name], last_r.get(name, first_w[name])
+        cand = [c for c, f in free_at.items() if f < start]
+        c = min(cand) if cand else base + len(free_at)
+        addr[name] = c
+        free_at[c] = end
+    top = base + len(free_at)
+    assert top <= W, ('window too small', top)
+
+    def res(a):
+        if a is None:
+            return SINK
+        if a[0] == 'c':
+            return a[1]
+        return addr[a]
+    out = [(res(a0), w0, res(a1), w1, be, res(ao)) for (a0, w0, a1, w1, be, ao) in recs]
+    return out, addr, top
+
+
+def encode_record(r):
+    a0, w0, a1, w1, beta, ao = r
+    bits = []
+    put = lambda v, w: bits.extend((v >> (w - 1 - j)) & 1 for j in range(w))
+    wc = {1: 1, -1: 2, 0: 0}
+    put(wc[w0], 2); put(wc[w1], 2); put(beta & 15, 4)
+    put(a0, ALPHA); put(a1, ALPHA); put(ao, ALPHA)
+    return bits
+
+
+def decode_record(bits):
+    it = iter(bits)
+    get = lambda w: sum(next(it) << (w - 1 - j) for j in range(w))
+    c0 = get(2); c1 = get(2); beta = get(4)
+    a0 = get(ALPHA); a1 = get(ALPHA); ao = get(ALPHA)
+    wd = {1: 1, 2: -1, 0: 0, 3: 0}
+    return a0, wd[c0], a1, wd[c1], beta - 16 if beta >= 8 else beta, ao
+
+
+def bits_to_bytes(bits):
+    assert len(bits) % 8 == 0
+    return bytes(sum(bits[i + k] << (7 - k) for k in range(8)) for i in range(0, len(bits), 8))
+
+
+def bytes_to_bits(data):
+    return [(b >> (7 - k)) & 1 for b in data for k in range(8)]
+
+
+def check_schedule(recs, lo, hi, n):
+    """Within the host block recs[lo:hi], every state bit is written once, by the record of its
+    next value, and read by no later record; in all records, no temporary is written after
+    its last read, so that temporaries with disjoint live intervals may share a cell."""
+    written = {}
+    for i in range(lo, hi):
+        ao = recs[i][5]
+        if ao[0] == 's':
+            assert ao not in written, ('state bit written twice', ao)
+            written[ao] = i
+    assert len(written) == n, 'a state bit without its next value'
+    for i in range(lo, hi):
+        a0, w0, a1, w1, _, _ = recs[i]
+        for a, w in ((a0, w0), (a1, w1)):
+            if w and a[0] == 's':
+                assert i <= written[a], ('state bit read after it is written', a)
+    last_r, last_w = {}, {}
+    for i, (a0, w0, a1, w1, _, ao) in enumerate(recs):
+        for a, w in ((a0, w0), (a1, w1)):
+            if w and a[0] == 't':
+                last_r[a] = i
+        if ao[0] == 't':
+            last_w[ao] = i
+    assert all(last_w[t] < last_r.get(t, last_w[t] + 1) or t not in last_r for t in last_w), \
+        'a temporary written after its last read'
+    return dict(state_bits_written=len(written))
+
+
+def build():
+    P = Prog()
+    compile_startup(P, SR.M_STAR)
+    lo = len(P.recs)
+    n, units, nxt = compile_host(P)
+    n_host = len(P.recs) - lo
+    check_schedule(P.recs, lo, len(P.recs), n)
+    compile_device(P)
+    compile_handover(P)
+    recs, addr, top = allocate(P.recs)
+    if len(recs) % 2:                            # an image of whole bytes
+        recs.insert(len(recs) - 3, (SINK, 0, SINK, 0, -1, SINK))
+    image_bits = [b for r in recs for b in encode_record(r)]
+    image = bits_to_bytes(image_bits)
+    tau = SR.describe(image)
+    assert SR.decode(tau) == image
+    return dict(recs=recs, addr=addr, top=top, image=image, image_bits=image_bits, tau=tau,
+                n_host_records=n_host, host=(n, units, nxt))
+
+
+# ---------------------------------------------------------------------------
+# the machine, transcribed
+# ---------------------------------------------------------------------------
+
+class Machine:
+    """T_{G,L} with a window of W cells; banks and tapes listed from their heads."""
+    def __init__(self, Q0, Q1, D0, D1, window):
+        self.Q = [list(Q0), list(Q1)]
+        self.D = [list(D0), list(D1)]
+        self.h = [[0, 0], [0, 0]]                # heads of the banks and of the tapes
+        self.w = list(window)
+        self.N, self.L = len(Q0), len(D0)
+
+    def cell(self, a):
+        k = self.w[KAPPA]
+        if a == RD:
+            return self.D[k][self.h[1][k]]
+        if a == ARM:
+            return self.Q[1 - k][self.h[0][1 - k]]
+        if a == CPY:
+            return self.D[1 - k][self.h[1][1 - k]]
+        return self.w[a]
+
+    def step(self, rec=None):
+        k = self.w[KAPPA]
+        if rec is None:
+            hq = self.h[0][k]
+            rec = decode_record([self.Q[k][(hq + i) % self.N] for i in range(B)])
+        a0, w0, a1, w1, beta, ao = rec
+        v = 1 if w0 * self.cell(a0) + w1 * self.cell(a1) + beta >= 0 else 0
+        if ao == ARM:
+            self.Q[1 - k][self.h[0][1 - k]] = v
+        elif ao == CPY:
+            self.D[1 - k][self.h[1][1 - k]] = v
+        elif ao != RD:
+            self.w[ao] = v
+        self.h[0][k] = (self.h[0][k] + B) % self.N
+        if self.w[AA]:
+            self.h[0][1 - k] = (self.h[0][1 - k] + 1) % self.N
+        if self.w[AR]:
+            self.h[1][k] = (self.h[1][k] + 1) % self.L
+        if self.w[AC]:
+            self.h[1][1 - k] = (self.h[1][1 - k] + 1) % self.L
+        self.w[AA] = self.w[AR] = self.w[AC] = 0
+
+
+# ---------------------------------------------------------------------------
+# one pass against H_8 and the device
+# ---------------------------------------------------------------------------
+
+def host_step(n, units, nxt, x):
+    sig = list(x) + [0] * len(units)
+    for u, (b, ins) in enumerate(units):
+        sig[n + u] = 1 if b + sum(w * sig[s] for s, w in ins) >= 0 else 0
+    return [sig[v] for v in nxt]
+
+
+def check(trials=40, seed=3, verbose=False):
+    S = build()
+    recs, addr = S['recs'], S['addr']
+    n, units, nxt = S['host']
+    G = len(recs)
+    rng = random.Random(seed)
+    bad = 0
+    image_bits = [b for r in recs for b in encode_record(r)]
+    x0 = [0] * n                                 # the state x_0(m*)
+    for j in range(256):
+        for t in range(8):
+            x0[mem_bit(j, t)] = (SR.M_STAR[j] >> t) & 1
+    for trial in range(trials):
+        # a random host state with random device registers, temporaries and tapes; every fifth
+        # state not yet booted, and in every third the requests hold random bytes
+        x = [rng.randrange(2) for _ in range(n)]
+        x[HALT] = 0 if trial % 4 else 1
+        booted = 0 if trial % 5 == 0 else 1
+        for j in (SR.C_WR, SR.C_RD, SR.C_RW):
+            v = rng.randrange(256) if trial % 3 == 0 else rng.choice((0, 1))
+            for t in range(8):
+                x[mem_bit(j, t)] = (v >> t) & 1
+        L = 64
+        cnt, lim = rng.randrange(8), rng.randrange(8)
+        dest = rng.randrange(2)
+        win = [rng.randrange(2) for _ in range(W)]
+        win[KAPPA] = 0
+        for i in range(n):
+            win[addr[('s', i)]] = x[i]
+        for i in range(CW):
+            win[addr[('d', 'cnt', i)]] = (cnt >> i) & 1
+            win[addr[('d', 'lim', i)]] = (lim >> i) & 1
+        win[addr[('d', 'dest')]] = dest
+        win[addr[('d', 'booted')]] = booted
+        win[AR] = win[AA] = win[AC] = 0
+        D0 = [rng.randrange(2) for _ in range(L)]
+        Q1 = [rng.randrange(2) for _ in range(len(image_bits))]
+        D1 = [rng.randrange(2) for _ in range(L)]
+        M = Machine(image_bits, Q1, D0, D1, win)
+        for g in range(G):
+            M.step(recs[g])
+        # expected: the startup if not booted, one step of H_8, then the device on the ring tapes
+        if not booted:
+            x, cnt, lim, dest = list(x0), 0, 0, 0
+        y = host_step(n, units, nxt, x)
+        get = lambda j: sum(y[mem_bit(j, t)] << t for t in range(8))
+
+        def put(j, v):
+            for t in range(8):
+                y[mem_bit(j, t)] = (v >> t) & 1
+        e_q1, e_d1, hq1, hd0, hd1 = list(Q1), list(D1), 0, 0, 0
+        e_cnt, e_lim, e_dest = cnt, lim, dest
+        if get(SR.C_WR) == 1:
+            byte = get(SR.R_OUT)
+            for kk in range(8):
+                bit = (byte >> (7 - kk)) & 1
+                if e_dest:
+                    e_d1[hd1] = bit; hd1 += 1
+                else:
+                    e_q1[hq1] = bit; hq1 += 1
+            put(SR.R_OUT, 0)
+        if get(SR.C_RD) == 1:
+            if not (e_dest and e_cnt == e_lim):
+                put(SR.R_IN, sum(D0[hd0 + kk] << (7 - kk) for kk in range(8)))
+                hd0 += 8
+                put(SR.C_EOT, 0)
+                e_cnt = (e_cnt + 1) % (1 << CW)
+            else:
+                put(SR.C_EOT, 1)
+        if get(SR.C_RW) == 1:
+            e_lim, e_cnt, e_dest = e_cnt, 0, 1
+        put(SR.C_WR, 0); put(SR.C_RD, 0); put(SR.C_RW, 0)
+        e_kappa = 1 if y[HALT] else 0
+        got = [M.w[addr[('s', i)]] for i in range(n)]
+        g_cnt = sum(M.w[addr[('d', 'cnt', i)]] << i for i in range(CW))
+        g_lim = sum(M.w[addr[('d', 'lim', i)]] << i for i in range(CW))
+        parts = dict(state=got == y, cnt=g_cnt == e_cnt, lim=g_lim == e_lim,
+                     dest=M.w[addr[('d', 'dest')]] == e_dest, bank=M.Q[1] == e_q1, copy=M.D[1] == e_d1,
+                     arm=M.h[0][1] == hq1, read=M.h[1][0] == hd0, copyhead=M.h[1][1] == hd1,
+                     kappa=M.w[KAPPA] == e_kappa, tape=M.D[0] == D0,
+                     booted=M.w[addr[('d', 'booted')]] == 1 - y[HALT],
+                     requests=M.w[AR] == M.w[AA] == M.w[AC] == 0, active=M.Q[0] == image_bits)
+        ok = all(parts.values())
+        if not ok and verbose:
+            print(trial, [k for k, v in parts.items() if not v], 'reqs',
+                  [get(j) for j in (SR.C_WR, SR.C_RD, SR.C_RW)], 'dest', dest, 'cnt', cnt, 'lim', lim,
+                  'halt', x[HALT], [i for i in range(n) if got[i] != y[i]][:10])
+        bad += not ok
+    return dict(trials=trials, disagreements=bad, records=G, window_cells=S['top'])
+
+
+def update_record(key, value):
+    rec = json.load(open(RECORD)) if os.path.exists(RECORD) else {}
+    rec[key] = value
+    json.dump(rec, open(RECORD, 'w'), indent=1)
+
+
+def run(generations):
+    """Generations from the image in the active bank and tau* on the read tape, on the
+    machine in C, against the reference run of P* on tau*."""
+    S = build()
+    recs, image_bits, tau = S['recs'], S['image_bits'], S['tau']
+    G = len(recs)
+    out, steps = SR.run_reference(SR.M_STAR, tau)
+    assert out == S['image'] + tau
+    tau_bits = bytes_to_bits(tau)
+    work = os.path.join(REPO, 'variants')
+    inp, exe = os.path.join(work, '.stored_host.bin'), os.path.join(work, '.stored_host_run')
+    with open(inp, 'wb') as f:
+        f.write(struct.pack('<4i', W, ALPHA, G, len(tau_bits)))
+        f.write(bytes(image_bits) + bytes(tau_bits) + bytes(W))
+    subprocess.run(['gcc', '-O3', '-march=native', '-o', exe, os.path.join(REPO, 'src', 'stored_host_run.c')], check=True)
+    t0 = time.time()
+    p = subprocess.run([exe, inp, str(generations)], capture_output=True, text=True)
+    os.remove(inp); os.remove(exe)
+    lines = [json.loads(l) for l in p.stdout.split('\n') if l.strip()]
+    gens = [l for l in lines if 'generation' in l]
+    res = dict(records=G, window_cells=S['top'], record_bits=B, bank_bits=len(image_bits),
+               image_bytes=len(S['image']), tau_bytes=len(tau), passes_expected=steps,
+               generations=gens, seconds=round(time.time() - t0, 1),
+               sha256_image=hashlib.sha256(S['image']).hexdigest(),
+               sha256_tau=hashlib.sha256(tau).hexdigest())
+    for l in lines:
+        if 'state_after_3_equals_after_1' in l:
+            res['state_after_3_equals_after_1'] = l['state_after_3_equals_after_1']
+    res['every_generation_exact'] = all(g['passes'] == steps and g['steps'] == steps * G and g['bank_holds_image']
+                                        and g['tape_holds_tau'] for g in gens) and len(gens) == generations
+    update_record('run', res)
+    return res
+
+
+if __name__ == '__main__':
+    cmd = sys.argv[1] if len(sys.argv) > 1 else 'build'
+    if cmd == 'check':
+        t0 = time.time()
+        res = check(int(sys.argv[2]) if len(sys.argv) > 2 else 40)
+        res['seconds'] = round(time.time() - t0, 1)
+        update_record('pass_check', res)
+        print(json.dumps(res))
+        sys.exit(0 if res['disagreements'] == 0 else 1)
+    elif cmd == 'run':
+        gens = int(sys.argv[2]) if len(sys.argv) > 2 else 3
+        res = run(gens)
+        print(json.dumps(res, indent=1))
+        sys.exit(0 if res['every_generation_exact'] and (gens < 3 or res.get('state_after_3_equals_after_1') == 1)
+                 else 1)
+    elif cmd == 'build':
+        t0 = time.time()
+        S = build()
+        print(json.dumps(dict(records=len(S['recs']), host_records=S['n_host_records'],
+                              window_cells=S['top'], record_bits=B, bank_bits=len(S['image_bits']),
+                              image_bytes=len(S['image']), tau_bytes=len(S['tau']),
+                              seconds=round(time.time() - t0, 1))))

src/stored_host_run.c

@@ -0,0 +1,130 @@
+/* Generations of the stored host on the two-head machine T_{G,L} with a window of W cells.
+ *
+ *   stored_host_run IN.bin GENERATIONS
+ *
+ * IN.bin holds little-endian int32 W, ALPHA, G, L, then the G * (8 + 3 ALPHA) bits of the
+ * image, the L bits of tau*, and the W cells of the initial window, one byte per bit. The
+ * banks start with the image in Q0 and Q1 clear, the tapes with tau* on D0 and D1 clear.
+ * A step reads the record in front of the active bank, writes v = H(w0 x0 + w1 x1 + beta)
+ * into the window, under the arm or under the copy head, turns the active bank by one
+ * record and the other three by one cell on request, and clears the requests. The active
+ * bank is never written, so its records are decoded once each time the bank bit changes.
+ * After every generation, at the step that changes the bank bit, the program reports the
+ * steps it took, whether the new active bank holds the image and the new read tape holds
+ * tau*, the positions of the heads and a digest of the window.
+ */
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct { int a0, w0, a1, w1, beta, ao; } rec_t;
+
+static int W, ALPHA, B, G, N, L;
+
+static rec_t decode(const unsigned char *bits) {
+    int p = 0;
+#define GET(w) ({ int v_ = 0; for (int j_ = 0; j_ < (w); j_++) v_ = (v_ << 1) | bits[p++]; v_; })
+    int c0 = GET(2), c1 = GET(2), beta = GET(4);
+    int a0 = GET(ALPHA), a1 = GET(ALPHA), ao = GET(ALPHA);
+#undef GET
+    rec_t r;
+    r.w0 = c0 == 1 ? 1 : c0 == 2 ? -1 : 0;
+    r.w1 = c1 == 1 ? 1 : c1 == 2 ? -1 : 0;
+    r.beta = beta >= 8 ? beta - 16 : beta;
+    r.a0 = a0; r.a1 = a1; r.ao = ao;
+    return r;
+}
+
+static uint64_t fnv(const unsigned char *p, size_t n) {
+    uint64_t h = 1469598103934665603ULL;
+    for (size_t i = 0; i < n; i++) { h ^= p[i]; h *= 1099511628211ULL; }
+    return h;
+}
+
+int main(int argc, char **argv) {
+    FILE *f = fopen(argv[1], "rb");
+    int gens = atoi(argv[2]);
+    int hdr[4];
+    if (fread(hdr, 4, 4, f) != 4) return 1;
+    W = hdr[0]; ALPHA = hdr[1]; G = hdr[2]; L = hdr[3];
+    B = 8 + 3 * ALPHA; N = G * B;
+    unsigned char *image = malloc(N), *tau = malloc(L), *win = malloc(W);
+    if (fread(image, 1, N, f) != (size_t)N || fread(tau, 1, L, f) != (size_t)L || fread(win, 1, W, f) != (size_t)W) return 1;
+    fclose(f);
+    unsigned char *Q[2] = { malloc(N), calloc(N, 1) }, *D[2] = { malloc(L), calloc(L, 1) };
+    memcpy(Q[0], image, N); memcpy(D[0], tau, L);
+    long hq[2] = {0, 0}, hd[2] = {0, 0};
+    rec_t *recs = malloc(sizeof(rec_t) * G);
+    int k = win[0];
+    for (int g = 0; g < G; g++) recs[g] = decode(Q[k] + (size_t)g * B);
+    long ridx = 0;                                /* the record in front of the active bank */
+    if (gens == 0) {                              /* a fixed number of steps, for comparison */
+        long long n = atoll(argv[3]);
+        for (long long s = 0; s < n; s++) {
+            k = win[0];
+            const rec_t *r = &recs[ridx];
+            int ki = 1 - k;
+            int x0 = r->w0 ? (r->a0 == 1 ? D[k][hd[k]] : r->a0 == 2 ? Q[ki][hq[ki]] : r->a0 == 3 ? D[ki][hd[ki]] : win[r->a0]) : 0;
+            int x1 = r->w1 ? (r->a1 == 1 ? D[k][hd[k]] : r->a1 == 2 ? Q[ki][hq[ki]] : r->a1 == 3 ? D[ki][hd[ki]] : win[r->a1]) : 0;
+            int v = r->w0 * x0 + r->w1 * x1 + r->beta >= 0;
+            if (r->ao == 2) Q[ki][hq[ki]] = v; else if (r->ao == 3) D[ki][hd[ki]] = v; else if (r->ao != 1) win[r->ao] = v;
+            ridx = ridx + 1 == G ? 0 : ridx + 1;
+            hq[k] = (hq[k] + B) % N;
+            if (win[5]) hq[ki] = (hq[ki] + 1) % N;
+            if (win[4]) hd[k] = (hd[k] + 1) % L;
+            if (win[6]) hd[ki] = (hd[ki] + 1) % L;
+            win[4] = win[5] = win[6] = 0;
+            if (win[0] != k) { k = win[0]; for (int g = 0; g < G; g++) recs[g] = decode(Q[k] + (size_t)g * B); }
+        }
+        printf("{\"win\": \"%016llx\", \"q0\": \"%016llx\", \"q1\": \"%016llx\", \"d0\": \"%016llx\", \"d1\": \"%016llx\", \"heads\": [%ld, %ld, %ld, %ld]}\n",
+               (unsigned long long)fnv(win, W), (unsigned long long)fnv(Q[0], N), (unsigned long long)fnv(Q[1], N),
+               (unsigned long long)fnv(D[0], L), (unsigned long long)fnv(D[1], L), hq[0], hq[1], hd[0], hd[1]);
+        return 0;
+    }
+    unsigned char *first_state = NULL; size_t state_size = 0;
+    for (int gen = 1; gen <= gens; gen++) {
+        long long steps = 0;
+        for (;;) {
+            k = win[0];
+            const rec_t *r = &recs[ridx];
+            int ki = 1 - k;
+#define CELL(a) ((a) == 1 ? D[k][hd[k]] : (a) == 2 ? Q[ki][hq[ki]] : (a) == 3 ? D[ki][hd[ki]] : win[(a)])
+            int x0 = r->w0 ? CELL(r->a0) : 0, x1 = r->w1 ? CELL(r->a1) : 0;
+            int v = r->w0 * x0 + r->w1 * x1 + r->beta >= 0;
+            int ao = r->ao;
+            if (ao == 2) Q[ki][hq[ki]] = v;
+            else if (ao == 3) D[ki][hd[ki]] = v;
+            else if (ao != 1) win[ao] = v;
+            ridx = ridx + 1 == G ? 0 : ridx + 1;  /* the active bank turns by one record */
+            if (win[5]) hq[ki] = hq[ki] + 1 == N ? 0 : hq[ki] + 1;
+            if (win[4]) hd[k] = hd[k] + 1 == L ? 0 : hd[k] + 1;
+            if (win[6]) hd[ki] = hd[ki] + 1 == L ? 0 : hd[ki] + 1;
+            win[4] = win[5] = win[6] = 0;
+            steps++;
+            if (win[0] != k) break;
+        }
+        k = win[0];
+        /* the bank that was active turned by whole passes and is back at its first record */
+        if (ridx != 0) { fprintf(stderr, "hand-over inside a pass\n"); return 1; }
+        int bank_ok = memcmp(Q[k], image, N) == 0 && hq[k] == 0;
+        int tape_ok = memcmp(D[k], tau, L) == 0 && hd[k] == 0;
+        printf("{\"generation\": %d, \"steps\": %lld, \"passes\": %lld, \"kappa\": %d, \"bank_holds_image\": %d, "
+               "\"tape_holds_tau\": %d, \"heads\": [%ld, %ld, %ld, %ld], \"window_fnv\": \"%016llx\"}\n",
+               gen, steps, steps / G, k, bank_ok, tape_ok, hq[0], hq[1], hd[0], hd[1],
+               (unsigned long long)fnv(win, W));
+        fflush(stdout);
+        /* the full state after the first and the third generation */
+        size_t sz = (size_t)W + 2 * (size_t)N + 2 * (size_t)L;
+        unsigned char *st = malloc(sz);
+        memcpy(st, win, W); memcpy(st + W, Q[0], N); memcpy(st + W + N, Q[1], N);
+        memcpy(st + W + 2 * (size_t)N, D[0], L); memcpy(st + W + 2 * (size_t)N + L, D[1], L);
+        if (gen == 1) { first_state = st; state_size = sz; }
+        else {
+            if (gen == 3) printf("{\"state_after_3_equals_after_1\": %d}\n", memcmp(st, first_state, state_size) == 0);
+            free(st);
+        }
+        for (int g = 0; g < G; g++) recs[g] = decode(Q[k] + (size_t)g * B);
+    }
+    return 0;
+}

src/twohead.py

@@ -116,20 +116,20 @@ class Asm:
         return self
 
 
-def encode_record(r):
-    """r = (a0, w0, a1, w1, beta, ao), laid out gate first."""
+def encode_record(r, alpha=ALPHA):
+    """r = (a0, w0, a1, w1, beta, ao), laid out gate first, with addresses of alpha bits."""
     a0, w0, a1, w1, beta, ao = r
     bits = []
     put = lambda val, w: bits.extend((val >> (w - 1 - j)) & 1 for j in range(w))
     wc = {1: 1, -1: 2, 0: 0}
-    put(wc[w0], 2); put(wc[w1], 2); put(beta & 15, 4); put(a0, ALPHA); put(a1, ALPHA); put(ao, ALPHA)
+    put(wc[w0], 2); put(wc[w1], 2); put(beta & 15, 4); put(a0, alpha); put(a1, alpha); put(ao, alpha)
     return bits
 
 
-def decode_record(bits):
+def decode_record(bits, alpha=ALPHA):
     it = iter(bits)
     get = lambda w: sum(next(it) << (w - 1 - j) for j in range(w))
-    c0 = get(2); c1 = get(2); beta = get(4); a0 = get(ALPHA); a1 = get(ALPHA); ao = get(ALPHA)
+    c0 = get(2); c1 = get(2); beta = get(4); a0 = get(alpha); a1 = get(alpha); ao = get(alpha)
     wd = {1: 1, 2: -1, 0: 0, 3: 0}
     return a0, wd[c0], a1, wd[c1], beta - 16 if beta >= 8 else beta, ao
 
@@ -182,12 +182,14 @@ def translate(desc):
 
 
 class Machine:
-    """The physics, transcribed: tapes listed from their heads."""
-    def __init__(self, G, L, Q0, Q1, D0, D1, window):
-        self.G, self.N, self.L = G, G * B, L
+    """The physics, transcribed: tapes listed from their heads; a window of 2^alpha cells."""
+    def __init__(self, G, L, Q0, Q1, D0, D1, window, alpha=ALPHA):
+        self.alpha, self.B = alpha, 8 + 3 * alpha
+        self.G, self.N, self.L = G, G * self.B, L
         self.Q = [list(Q0), list(Q1)]
         self.D = [list(D0), list(D1)]
         self.w = list(window)
+        assert len(self.w) == 1 << alpha
         self.steps = 0
 
     def cell(self, a):
@@ -202,7 +204,7 @@ class Machine:
 
     def step(self):
         k = self.w[KAPPA]
-        a0, w0, a1, w1, beta, ao = decode_record(self.Q[k][:B])
+        a0, w0, a1, w1, beta, ao = decode_record(self.Q[k][:self.B], self.alpha)
         val = 1 if w0 * self.cell(a0) + w1 * self.cell(a1) + beta >= 0 else 0
         if ao == ARM:
             self.Q[1 - k][0] = val
@@ -211,7 +213,7 @@ class Machine:
         elif ao != RD:
             self.w[ao] = val
         rot = lambda t, s: t[s:] + t[:s]
-        self.Q[k] = rot(self.Q[k], B)
+        self.Q[k] = rot(self.Q[k], self.B)
         if self.w[AA]:
             self.Q[1 - k] = rot(self.Q[1 - k], 1)
         if self.w[AR]:

src/twohead_net.py

@@ -1,14 +1,15 @@
 """The two-head physics as a netlist of ternary threshold units.
 
-The state bits are the 61 window cells other than 1, 2 and 3, then Q0, Q1, D0 and
-D1, each listed from its head. The netlist selects the record in front of the
-active bank by a multiplexer on kappa, decodes its three addresses, reads the two
-operands through the decode lines, forms v = H(w0 x0 + w1 x1 + beta) from the
-weight codes and the bias bits, writes v into the window, and computes every
-tape bit's next value: the active bank turned by 26 cells, the idle bank written
-under the arm and turned by one cell on request, and the two description tapes
-likewise. The unit order is the order of construction, which rocq/Phys.v follows
-unit for unit.
+For a window of 2^alpha cells and records of 8 + 3 alpha bits, the state bits are
+the window cells other than 1, 2 and 3, then Q0, Q1, D0 and D1, each listed from its
+head. The netlist selects the record in front of the active bank by a multiplexer
+on kappa, decodes its three addresses, reads the two operands through the decode
+lines, forms v = H(w0 x0 + w1 x1 + beta) from the weight codes and the bias bits,
+writes v into the window, and computes every tape bit's next value: the active bank
+turned by one record, the idle bank written under the arm and turned by one cell on
+request, and the two description tapes likewise. The unit order is the order of
+construction, which rocq/Phys.v follows unit for unit. The organism runs on the
+member with alpha = 6, a window of 64 cells.
 
     python src/twohead_net.py check            one step against the transcription on random states
     python src/twohead_net.py export [PATH]    the netlist file (default variants/twohead_physics.bin)
@@ -59,7 +60,10 @@ class Net:
         return self.OR((self.AND((s, True), (a, True)), True), (self.AND((s, False), (b, True)), True))
 
 
-def build(G, L):
+def build(G, L, alpha=ALPHA):
+    """The netlist N_{G,L} of the machine with a window of 2^alpha cells and records of
+    8 + 3 alpha bits."""
+    W, B = 1 << alpha, 8 + 3 * alpha
     N = G * B
     real = [0] + list(range(4, W))                 # window cells held in the state
     wpos = {a: i for i, a in enumerate(real)}
@@ -70,7 +74,8 @@ def build(G, L):
     kap = wpos[KAPPA]
     # the record in front of the active bank
     f = [net.MUX(kap, q1 + j, q0 + j) for j in range(B)]
-    c0, c1, be, a0, a1, ao = f[0:2], f[2:4], f[4:8], f[8:14], f[14:20], f[20:26]
+    c0, c1, be = f[0:2], f[2:4], f[4:8]
+    a0, a1, ao = f[8:8 + alpha], f[8 + alpha:8 + 2 * alpha], f[8 + 2 * alpha:8 + 3 * alpha]
     # the cells under the three heads
     rd = net.MUX(kap, d1, d0)
     armv = net.MUX(kap, q0, q1)
@@ -81,8 +86,8 @@ def build(G, L):
     def decode(field):
         lines = []
         for a in range(W):
-            bits = [(a >> (ALPHA - 1 - j)) & 1 for j in range(ALPHA)]
-            lines.append(net.u(-sum(bits), [(field[j], 1 if bits[j] else -1) for j in range(ALPHA)]))
+            bits = [(a >> (alpha - 1 - j)) & 1 for j in range(alpha)]
+            lines.append(net.u(-sum(bits), [(field[j], 1 if bits[j] else -1) for j in range(alpha)]))
         return lines
 
     l0, l1, lo = decode(a0), decode(a1), decode(ao)
@@ -142,7 +147,16 @@ def build(G, L):
         for i in range(L):
             nxt[base + i] = net.MUX(rot, hat((i + 1) % L), hat(i))
     assert all(x is not None for x in nxt)
-    return net, nxt, dict(real=real, q0=q0, q1=q1, d0=d0, d1=d1, n=n, N=N, L=L)
+    return net, nxt, dict(real=real, q0=q0, q1=q1, d0=d0, d1=d1, n=n, N=N, L=L, alpha=alpha)
+
+
+def sizes(alpha, N, L):
+    """The units and edges of N_{G,L} for a window of 2^alpha cells and banks of N bits,
+    counted block by block."""
+    W = 1 << alpha
+    return dict(units=8 * W + 9 * alpha + 81 + 8 * N + 6 * L,
+                edges=3 * alpha * W + 12 * W + 18 * alpha + 170 + 18 * N + 12 * L,
+                state_bits=W - 3 + 2 * N + 2 * L)
 
 
 def stats(net, nxt):
@@ -165,19 +179,22 @@ def encode(M, lay):
     return [M.w[a] for a in lay['real']] + M.Q[0] + M.Q[1] + M.D[0] + M.D[1]
 
 
-def check(G, L, trials, seed=7):
-    """One step of the netlist against the transcription from uniformly random full states."""
-    net, nxt, lay = build(G, L)
+def check(G, L, trials, seed=7, alpha=ALPHA):
+    """One step of the netlist against the transcription from uniformly random full states;
+    returns the number of disagreements and the netlist's statistics."""
+    net, nxt, lay = build(G, L, alpha)
     rnd = random.Random(seed)
     bad = 0
+    N = G * (8 + 3 * alpha)
     for _ in range(trials):
-        N = G * B
         bits = lambda k: [rnd.randint(0, 1) for _ in range(k)]
-        M = T.Machine(G, L, bits(N), bits(N), bits(L), bits(L), bits(W))
+        M = T.Machine(G, L, bits(N), bits(N), bits(L), bits(L), bits(1 << alpha), alpha)
         y = evaluate(net, nxt, encode(M, lay))
         M.step()
         bad += y != encode(M, lay)
-    return bad
+    st = stats(net, nxt)
+    assert {k: st[k] for k in ('units', 'edges', 'state_bits')} == sizes(alpha, N, L)
+    return bad, st
 
 
 def netfile_bytes(net, nxt):
@@ -207,11 +224,13 @@ def main():
     cmd = sys.argv[1] if len(sys.argv) > 1 else 'check'
     if cmd == 'check':
         t0 = time.time()
-        small = check(5, 40, 300)
+        small, _ = check(5, 40, 300)
         A, rho, desc, net, nxt, lay = organism_netlist()
-        full = check(len(A.recs), len(desc), 20)
+        full, _ = check(len(A.recs), len(desc), 20)
+        wide, st_wide = check(5, 40, 40, alpha=12)
         res = dict(small=dict(G=5, L=40, states=300, disagreements=small),
                    full=dict(G=len(A.recs), L=len(desc), states=20, disagreements=full),
+                   wide=dict(alpha=12, G=5, L=40, states=40, disagreements=wide, netlist=st_wide),
                    netlist=stats(net, nxt), seconds=round(time.time() - t0, 1))
         update_record('random_states', res)
         print(json.dumps(res, indent=1))
@@ -249,15 +268,24 @@ def main():
         subprocess.run(['ocamlfind', 'ocamlopt', '-package', 'stdlib', 'physnet.mli', 'physnet.ml', 'dump.ml',
                         '-o', 'dump'], cwd=ex, check=True)
         A, rho, desc, net, nxt, lay = organism_netlist()
-        ours = netfile_bytes(net, nxt)
         out = os.path.join(ex, 'phys_rocq.bin')
-        subprocess.run([os.path.join(ex, 'dump'), str(len(A.recs) * B), str(len(desc)), out], check=True)
-        theirs = open(out, 'rb').read()
+        members = []
+        # the member that carries the organism, and a member with a window of 4096 cells
+        for alpha, G, L, built in ((ALPHA, len(A.recs), len(desc), (net, nxt)), (12, 5, 40, None)):
+            if built is None:
+                n2, x2, _ = build(G, L, alpha)
+                built = (n2, x2)
+            ours = netfile_bytes(*built)
+            N = G * (8 + 3 * alpha)
+            subprocess.run([os.path.join(ex, 'dump'), str(alpha), str(N), str(L), out], check=True)
+            theirs = open(out, 'rb').read()
+            members.append(dict(alpha=alpha, N=N, L=L, identical=ours == theirs,
+                                sha256_generator=hashlib.sha256(ours).hexdigest(),
+                                sha256_rocq=hashlib.sha256(theirs).hexdigest()))
         for f in os.listdir(ex):
             if f not in ('dump.ml', 'physnet.ml', 'physnet.mli'):
                 os.remove(os.path.join(ex, f))
-        res = dict(N=len(A.recs) * B, L=len(desc), identical=ours == theirs,
-                   sha256_generator=hashlib.sha256(ours).hexdigest(), sha256_rocq=hashlib.sha256(theirs).hexdigest())
+        res = dict(members=members, identical=all(m['identical'] for m in members))
         update_record('extraction', res)
         print(json.dumps(res, indent=1))
 

src/verify.py

@@ -1,161 +0,0 @@
-"""Every statement of the paper, checked, with the time each check takes.
-
-The checks are in three tiers, and the checks of a tier run concurrently. The
-first establishes the statements: each one is an exhaustive or near-exhaustive
-audit of a definition, a lemma or a proposition, and none of them runs the full
-instance; it covers the host family H_A for every word width from 3 to 12, the
-fan-in-two rewriting, and the amplified host N_3 of Section 6.3. The second
-executes every construction end to end: the instances on the integer reference,
-four machines on the netlist that sigma denotes, the hierarchy, the constructor
-inside the interpreter, the host on the evaluator in C, which runs three
-generations of the self-reproducing instance, the translating organism on the
-two-head machine and on its netlist in C, and the Rocq development, which needs
-rocq and ocamlfind on the PATH.
-
-The third runs the complete instance on the threshold evaluators, the
-perturbation experiments, the orbit certificate, and the amplified host: its
-exact self-reproduction on the evaluator in C, the self-reproducing instance of
-the host on it under read noise, its deviation curve split by layer, and the
-correction of single wrong copies along a noisy run. Its cost belongs to
-the object: one generation is 1,664,939 steps of a map of 41,967 units, and
-the amplified host reproduces itself in 33,796,449 steps of 125,901 units.
-The rate of each evaluator is in paper/runs/paper_throughput.json, so the cost
-of any one line below is a multiplication.
-
-    python src/verify.py                # the statements
-    python src/verify.py --tier 2       # and every construction, end to end
-    python src/verify.py --tier 3       # and the full-scale runs
-"""
-from __future__ import annotations
-
-import argparse
-import concurrent.futures as cf
-import json
-import os
-import subprocess
-import sys
-import time
-
-REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-SRC = os.path.join(REPO, "src")
-PY = sys.executable
-
-TIER1 = [
-    ("check_sigma.py", [], "the canonical serialization, Definition 2.10"),
-    ("check_device.py", [], "the device, Definition 2.8"),
-    ("check_framing.py", [], "the framing, Definition 2.12"),
-    ("check_host.py", [], "the machine, Definition 3.1"),
-    ("check_lev.py", [], "the levelization, Lemma 2.6"),
-    ("check_ternarity.py", [], "ternary depth, Proposition 3.4"),
-    ("check_codec.py", [], "the recipe codec, Lemma 4.4"),
-    ("check_optimal.py", [], "optimality of the bound, Proposition 4.3"),
-    ("check_steps.py", [], "the step counts, Theorem 4.6 and Proposition 5.4"),
-    ("check_environment.py", [], "the environment, Proposition 2.15"),
-    ("check_interp.py", [], "the interpreter netlist, Construction 9.2"),
-    ("check_host_family.py", [], "the host family H_A against SUBLEQ_A, Remark 3.10"),
-    ("check_host_fold.py", [], "the folded host family, depth 11, Remark 3.11"),
-    ("fanin2.py", [], "the fan-in-two rewriting, Corollary 9.6"),
-    ("redundant.py", ["build"], "the amplified host N_3, Construction 6.12"),
-    ("twohead_net.py", ["check"], "one step of the two-head netlist, Theorem 7.2"),
-]
-
-TIER2 = [
-    ("hosted_constructor.py", [], "the constructor inside the interpreter, Theorem 9.10"),
-    ("hierarchy.py", [], "a larger interpreter runs a smaller one, Proposition 9.8"),
-    ("check_family_gate.py", [], "four machines on the netlist of sigma"),
-    ("check_c.py", [], "the host on the evaluator in C"),
-    ("paper_runs.py", ["reference"], "the constructions on the integer reference"),
-    ("twohead.py", ["run", "--generations", "3"], "the translating organism, three generations, Theorem 8.6"),
-    ("twohead_net.py", ["lockstep", "3"], "the organism on the two-head netlist in C, three generations"),
-    ("check_rocq.py", [], "the Rocq development, its assumptions and the extracted netlist"),
-]
-
-TIER3 = [
-    ("paper_verify.py", [], "the codec over the whole artifact, 971 MB"),
-    ("check_family.py", [], "all 29 machines on the integer reference"),
-    ("paper_runs.py", ["lockstep", "--device", "cuda"],
-     "four evaluators in lockstep"),
-    ("paper_runs.py", ["net", "--device", "cuda"],
-     "three generations on the netlist of sigma"),
-    ("paper_runs.py", ["lev", "--device", "cuda", "--generations", "1"],
-     "one generation on Lev(N_host)"),
-    ("throughput.py", [], "the rate of each evaluator"),
-    ("noise.py", ["margin"], "the margin along the trajectory, Theorem 6.2"),
-    ("noise.py", ["curve"], "the deviation rate against the union bound"),
-    ("noise.py", ["leak", "--steps", "10000"],
-     "static weight error with the zeros leaking"),
-    ("noise.py", ["omega"], "the instance under read noise, to completion"),
-    ("noise.py", ["profile"], "the pre-activation profile and its bound"),
-    ("noise.py", ["certify"], "the active-input counts along the orbits, Proposition 6.4"),
-    ("redundant.py", ["selfrep"], "exact self-reproduction of N_3 on the evaluator in C"),
-    ("redundant.py", ["omega"], "Omega* on N_3 under read noise, to completion"),
-    ("redundant.py", ["curve"], "the deviation rate of N_3 against the bounds"),
-    ("redundant.py", ["restore", "--batch", "64", "--steps", "20000"],
-     "the failure rate of the state of N_3 read by majority"),
-    ("redundant.py", ["bound"], "the restoration bound of N_3"),
-    ("redundant.py", ["layers"], "the profile bound of N_3 split by layer"),
-]
-
-
-def run(entry, quiet, threads=None):
-    name, args, what = entry
-    t0 = time.perf_counter()
-    env = dict(os.environ)
-    if threads:
-        env["OMP_NUM_THREADS"] = str(threads)
-    p = subprocess.run([PY, os.path.join(SRC, name)] + args,
-                       capture_output=True, text=True, cwd=REPO, env=env)
-    dt = time.perf_counter() - t0
-    ok = p.returncode == 0
-    label = f"{name} {' '.join(args)}".strip()
-    print(f"  {'ok  ' if ok else 'FAIL'} {label:<34} {dt:7.1f} s   {what}",
-          flush=True)
-    if not ok and not quiet:
-        print(p.stdout[-1500:])
-        print(p.stderr[-1500:])
-    return ok, dt
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--tier", type=int, default=1)
-    ap.add_argument("--quiet", action="store_true")
-    ap.add_argument("--jobs", type=int, default=os.cpu_count() or 1,
-                    help="checks of a tier run concurrently")
-    args = ap.parse_args()
-
-    plan = [("statements", TIER1)]
-    if args.tier >= 2:
-        plan.append(("constructions", TIER2))
-    if args.tier >= 3:
-        plan.append(("full scale", TIER3))
-
-    total = 0.0
-    bad = 0
-    record = {}
-    for title, entries in plan:
-        print(f"[{title}]", flush=True)
-        t0 = time.perf_counter()
-        jobs = max(1, min(args.jobs, len(entries)))
-        threads = max(1, (os.cpu_count() or 1) // jobs)
-        with cf.ThreadPoolExecutor(max_workers=jobs) as ex:
-            futs = {ex.submit(run, e, args.quiet, threads): e for e in entries}
-            for f in cf.as_completed(futs):
-                e = futs[f]
-                ok, dt = f.result()
-                bad += not ok
-                record[f"{e[0]} {' '.join(e[1])}".strip()] = {"ok": ok, "seconds": dt}
-        sub = time.perf_counter() - t0
-        total += sub
-        print(f"  {title}: {sub / 60:.1f} min wall time", flush=True)
-    print(f"total {total / 60:.1f} min; failures: {bad}")
-    d = os.path.join(REPO, "paper", "runs")
-    os.makedirs(d, exist_ok=True)
-    json.dump({"tier": args.tier, "total_seconds": total, "failures": bad,
-               "checks": record},
-              open(os.path.join(d, "paper_verify_times.json"), "w"), indent=1)
-    return 0 if bad == 0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())