# paper

*Universal Construction and Exact Self-Reproduction in Ternary McCulloch–Pitts
Networks.* The manuscript and the records of the runs it reports.

```
universal_construction_ternary.tex    source
universal_construction_ternary.pdf    typeset
runs/                                 the record written by each command
```

## What each command establishes

Each command is `python src/<file>.py <command>` and writes its record to `runs/`;
`paper.py rocq` needs Rocq 9.1 with the opam packages `coq-coquelicot` and
`coq-interval`, and ocamlfind, on the PATH; the development was checked on OCaml 4.14.2 with
these versions:

```bash
opam install rocq-core.9.1.1 rocq-stdlib.9.2.0 coq-coquelicot.3.4.5 coq-interval.4.11.4 \
  rocq-mathcomp-ssreflect.2.4.0 coq-flocq.4.2.2 rocq-bignums.9.0.0+rocq9.1 ocamlfind.1.9.8
```

| Command | Record | Establishes |
|---|---|---|
| `host.py` | — | the host family H_A, the serialization sigma and its inverse, the device, the constructor P and the program P*, and the evaluators |
| `paper.py host-family` | `paper_host_family.json` | one step of H_A against SUBLEQ_A for A = 3 to 12, on the evaluator in C |
| `paper.py host-fold` | `paper_host_fold.json` | the folded host family, depth 11, against SUBLEQ_A for A = 3 to 12 |
| `paper.py stats` | `paper_stats.json` | unit counts, levelization sizes, fan-in |
| `paper.py verify` | `paper_verify.json` | codec, framing, serialization, datapath, levelization |
| `paper.py runs` | `paper_runs_*.json` | self-description, three generations, lockstep |
| `paper.py codec` | `paper_codec.json` | the recipe codec at every boundary of the token format |
| `paper.py optimal` | `paper_optimal.json` | the length bound is optimal on run-free strings |
| `paper.py steps` | `paper_steps.json` | the closed forms for the step counts |
| `paper.py device` | `paper_device.json` | the device against its definition |
| `paper.py host` | `paper_host.json` | the reference machine against its definition |
| `paper.py lev` | `paper_lev.json` | the levelization against gate-by-gate evaluation |
| `paper.py framing` | `paper_framing.json` | `ser` injective, `inst` partial and inverse |
| `paper.py ternarity` | `paper_ternarity.json` | no ternary unit computes the branch predicate |
| `paper.py environment` | `paper_environment.json` | the cost of the environment against the cost of the network |
| `paper.py sigma` | — | sigma is a function, injective, and inverted by the parser |
| `paper.py family` | `paper_runs_family.json` | the constructor emits all 29 machines |
| `paper.py family-gate` | `paper_runs_family_gate.json` | four of them on the netlist of sigma |
| `paper.py c` | `paper_c_evaluator.json` | the host on the evaluator in C, `src/netlist_eval.c` |
| `paper.py throughput` | `paper_throughput.json` | the rate of each evaluator |
| `paper.py rocq` | `paper_rocq.json` | the Rocq development of `rocq/`, its assumptions, the host family extracted from it for A = 8, 9, 10 against sigma(N_host) and the generator, the stored host extracted for A = 8, 9 against the image `twohead.py stored` builds, the memory images of P and P*, and the ring netlist extracted for three members |
| `twohead.py organism` | `paper_twohead.json` | the organism on the ring machine M_{3,160,3200}, six generations with the copies and the period (`organism run --generations 6 --S 160 --L 3200`); `organism rocq` writes `rocq/Organism.v` |
| `twohead.py net` | `paper_twohead_net.json` | the netlist N_{K,S,L} against the machine on random states of three members (`net check`), one generation of the organism on it in C beside the machine (`net lockstep`), the netlists extracted from Rocq (`net extract`), and the rows of its levelization with the noise a generation of the stored host survives (`net lev`) |
| `twohead.py stored` | `paper_stored_host.json` | the host compiled into records of the ring machine: one pass against the host's step and its device on random states (`stored check`), the startup, step, device and hand-over records on decision diagrams (`stored symbolic`), and six generations in C in a ring of three banks (`stored run 6`); `--width A` checks H_A in place of H_8, and `stored widths` tabulates A = 8 to 12 |
| `noise.py host` | `paper_noise_*.json` | the margin, the profile bound in sum and product form, read noise, the deviation curve, the exact Poisson intervals of the measured rates (`host intervals`), weight error with leakage, the active-input counts of the orbit certificate, and the steps in which some row fails against the product form b' with the fraction the state masks (`host masked`) |
| `noise.py amplified` | `paper_redundant_*.json` | the amplified host N_3: one step 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` |
| `independent.py` | `independent_*.json` | code written from the paper's definitions alone: H_A rebuilt from Construction 5.8 for A = 3 to 12, Lev(N_host) from sigma and the measurements of Section 8.1 and Appendix E with the noise simulator `src/nsim.c` |

Rebuild the typeset paper with any TeX installation:

```bash
tectonic -X compile universal_construction_ternary.tex
```