Add the restoration bound for the amplified host with its proof, the batched failure-rate runs that test it, and the per-step table

README.md

@@ -583,9 +583,10 @@ interpreter's state. 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,
-which multiplies every margin by r, reproduces itself exactly, and completes the
-self-reproducing run under read noise at levels where the host fails within its
-first bytes.
+which multiplies every margin by r, reproduces itself exactly, fails only when two
+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

paper/README.md

@@ -72,7 +72,7 @@ the cost of any one run is a multiplication.
 | `src/hosted_constructor.py` | `paper_hosted.json` | the constructor as a netlist stored in the interpreter |
 | `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, wrong copies and the state read by majority |
+| `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 |
 | `src/neuromorphic.py` | `paper_neuromorphic.json` | the datapath on the Loihi and Akida neuron models |
 
 `src/neuromorphic.py run` needs Lava, which requires Python 3.10; everything

paper/runs/paper_redundant_bound_r3.json

@@ -0,0 +1,134 @@
+{
+ "r": 3,
+ "rows": [
+  {
+   "sigma": 0.1,
+   "p": 3.6709661993128594e-51,
+   "sigma_link": 2.866515718791946e-07,
+   "converged": true,
+   "second_term_uncapped": 2.13025075311841e-57,
+   "a_max": 3.671774358064498e-51,
+   "a_state_max": 3.670975669925945e-51,
+   "first_term": 1.657595730962774e-94,
+   "second_term": 2.130250753116143e-57,
+   "per_step": 2.130250753116143e-57,
+   "one_step_map_norm": 1.1207102716990636e-69,
+   "G_max": 2.177572163092903e-08,
+   "first_order_per_step": 9.243566309193767e-46,
+   "seconds": 44.994851198003744
+  },
+  {
+   "sigma": 0.15,
+   "p": 7.619853024160593e-24,
+   "sigma_link": 0.00042906033319683735,
+   "converged": true,
+   "second_term_uncapped": 9.96281774740883e-24,
+   "a_max": 1.0137246671296701e-23,
+   "a_state_max": 7.649365999909047e-24,
+   "first_term": 7.1820241657899036e-40,
+   "second_term": 9.962793936252263e-24,
+   "per_step": 9.962793936252263e-24,
+   "one_step_map_norm": 2.121416036030206e-28,
+   "G_max": 0.048788884933895625,
+   "first_order_per_step": 1.9186942311896616e-18,
+   "seconds": 44.644577098995796
+  },
+  {
+   "sigma": 0.2,
+   "p": 3.19089167291092e-14,
+   "sigma_link": 0.006209665325776139,
+   "converged": true,
+   "second_term_uncapped": 9.84392269671024e-12,
+   "a_max": 1.9232583156861574e-13,
+   "a_state_max": 3.3772509678220235e-14,
+   "first_term": 1.3839563909399713e-20,
+   "second_term": 2.284341310002908e-12,
+   "per_step": 2.284341323842472e-12,
+   "one_step_map_norm": 2.5928274635601137e-13,
+   "G_max": 10.318938219834262,
+   "first_order_per_step": 8.034729050223154e-09,
+   "seconds": 44.76692351400561
+  },
+  {
+   "sigma": 0.22,
+   "p": 4.6099955192965596e-12,
+   "sigma_link": 0.011521310043880927,
+   "converged": true,
+   "second_term_uncapped": 6.1655968721159675e-09,
+   "a_max": 5.2390139649676e-11,
+   "a_state_max": 5.1292274254447534e-12,
+   "first_term": 3.3417127781326887e-16,
+   "second_term": 1.7924312135933292e-09,
+   "per_step": 1.7924315477646071e-09,
+   "one_step_map_norm": 8.005921428622896e-10,
+   "G_max": 36.378198953846095,
+   "first_order_per_step": 1.1608060917499123e-06,
+   "seconds": 44.5916818560072
+  },
+  {
+   "sigma": 0.25,
+   "p": 9.865876450377012e-10,
+   "sigma_link": 0.02275013194817922,
+   "converged": true,
+   "second_term_uncapped": 1.2221903683727557e-05,
+   "a_max": 3.464062637574069e-08,
+   "a_state_max": 1.2256411202374905e-09,
+   "first_term": 2.955875675535229e-11,
+   "second_term": 2.101305150682518e-06,
+   "per_step": 2.101334709439273e-06,
+   "one_step_map_norm": 5.554923106754895e-06,
+   "G_max": 160.96107083907205,
+   "first_order_per_step": 0.00024842474219578326,
+   "seconds": 44.780106067002635
+  },
+  {
+   "sigma": 0.27,
+   "p": 1.3836508957768842e-08,
+   "sigma_link": 0.03202354974072154,
+   "converged": true,
+   "second_term_uncapped": 0.0008325628286829023,
+   "a_max": 1.2542660971875762e-06,
+   "a_state_max": 1.896662835974905e-08,
+   "first_term": 1.5422649474591534e-08,
+   "second_term": 9.280154361716902e-05,
+   "per_step": 9.28169662666436e-05,
+   "one_step_map_norm": 0.0004731405980891133,
+   "G_max": 502.241185749977,
+   "first_order_per_step": 0.00348406062858411,
+   "seconds": 44.378902162992745
+  },
+  {
+   "sigma": 0.3,
+   "p": 2.866515718791946e-07,
+   "sigma_link": 0.0477903522728147,
+   "converged": true,
+   "second_term_uncapped": 0.26158463232188245,
+   "a_max": 0.00011903221609335197,
+   "a_state_max": 5.40858095381371e-07,
+   "first_term": 5.502587076206081e-05,
+   "second_term": 0.01129871498942794,
+   "per_step": 0.011353740860190002,
+   "one_step_map_norm": 0.08616087624087705,
+   "G_max": 9637.91625882214,
+   "first_order_per_step": 0.07217943910232472,
+   "seconds": 45.34780544799287
+  },
+  {
+   "sigma": 0.33,
+   "p": 2.740841326345048e-06,
+   "sigma_link": 0.06486701914733445,
+   "converged": false,
+   "first_order_per_step": 0.6901493276563357,
+   "seconds": 0.13191196900152136
+  },
+  {
+   "sigma": 0.36,
+   "p": 1.5454296882296004e-05,
+   "sigma_link": 0.08243326987395455,
+   "converged": false,
+   "one_step_map_norm": 103.09080918475902,
+   "first_order_per_step": 3.8914228635558983,
+   "seconds": 45.01266609299637
+  }
+ ]
+}

paper/runs/paper_redundant_r3.json

@@ -25,7 +25,7 @@
  "bias_min": -23,
  "bias_max": 4,
  "max_fanin": 768,
- "build_seconds": 0.6454255809949245,
+ "build_seconds": 0.3552343150076922,
  "sigma_roundtrip": true,
  "c_random": "random states: 65536 tested, 0 disagree with SUBLEQ, 0 halt-latch mismatches, 0 halted batches not fixed",
  "c_random_ok": true,

paper/runs/paper_redundant_restore_r3.json

@@ -1,66 +1,323 @@
 {
  "r": 3,
- "steps": 20000,
+ "copies": 64,
+ "cap": 20000,
  "rows": [
-  {
-   "sigma": 0.24,
-   "steps": 20000,
-   "copy_errors": 0,
-   "steps_with_copy_errors": 0,
-   "max_copy_errors_in_a_step": 0,
-   "copy_errors_carried_to_next_step": 0,
-   "decoded_first_deviation": null,
-   "bytes": 3950,
-   "bytes_equal": true,
-   "seconds": 54.976982238003984
-  },
   {
    "sigma": 0.27,
+   "copies": 64,
    "steps": 20000,
-   "copy_errors": 2,
-   "steps_with_copy_errors": 2,
-   "max_copy_errors_in_a_step": 1,
-   "copy_errors_carried_to_next_step": 0,
-   "decoded_first_deviation": null,
-   "bytes": 3950,
-   "bytes_equal": true,
-   "seconds": 80.73841675600852
+   "failed": 5,
+   "median_first_failure": 11406,
+   "exposure": 1237505,
+   "failure_rate_per_step": 4.04038771560519e-06,
+   "steps_with_wrong_copies": 126,
+   "wrong_copies": 136,
+   "max_wrong_copies_in_a_step": 3,
+   "first_failure": [
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    11406,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    16645,
+    null,
+    12976,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    10094,
+    null,
+    null,
+    null,
+    6384,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null,
+    null
+   ],
+   "seconds": 207.45457119197818
   },
   {
    "sigma": 0.3,
-   "steps": 288,
-   "copy_errors": 6,
-   "steps_with_copy_errors": 4,
-   "max_copy_errors_in_a_step": 3,
-   "copy_errors_carried_to_next_step": 1,
-   "decoded_first_deviation": 288,
-   "bytes": 54,
-   "bytes_equal": true,
-   "seconds": 1.0162241850048304
+   "copies": 64,
+   "steps": 20000,
+   "failed": 63,
+   "median_first_failure": 2915,
+   "exposure": 295163,
+   "failure_rate_per_step": 0.00021344138662366218,
+   "steps_with_wrong_copies": 662,
+   "wrong_copies": 795,
+   "max_wrong_copies_in_a_step": 15,
+   "first_failure": [
+    1289,
+    1699,
+    1009,
+    13088,
+    8295,
+    8217,
+    865,
+    887,
+    4749,
+    376,
+    332,
+    2307,
+    2054,
+    2915,
+    3220,
+    410,
+    10239,
+    10535,
+    5621,
+    8143,
+    18583,
+    2592,
+    15730,
+    6922,
+    6739,
+    3364,
+    2861,
+    711,
+    701,
+    11579,
+    755,
+    3925,
+    1298,
+    5957,
+    4032,
+    null,
+    259,
+    261,
+    2632,
+    3171,
+    12493,
+    11725,
+    7126,
+    5570,
+    7546,
+    3554,
+    494,
+    1364,
+    4900,
+    2511,
+    5602,
+    1506,
+    362,
+    11745,
+    7285,
+    4452,
+    413,
+    2186,
+    339,
+    76,
+    1551,
+    684,
+    3044,
+    313
+   ],
+   "seconds": 381.3582687800226
   },
   {
    "sigma": 0.33,
-   "steps": 110,
-   "copy_errors": 5,
-   "steps_with_copy_errors": 3,
-   "max_copy_errors_in_a_step": 3,
-   "copy_errors_carried_to_next_step": 0,
-   "decoded_first_deviation": 110,
-   "bytes": 18,
-   "bytes_equal": true,
-   "seconds": 0.3773938849917613
+   "copies": 64,
+   "steps": 1280,
+   "failed": 64,
+   "median_first_failure": 198,
+   "exposure": 17472,
+   "failure_rate_per_step": 0.003663003663003663,
+   "steps_with_wrong_copies": 450,
+   "wrong_copies": 574,
+   "max_wrong_copies_in_a_step": 3,
+   "first_failure": [
+    153,
+    73,
+    68,
+    129,
+    391,
+    48,
+    198,
+    535,
+    92,
+    261,
+    210,
+    912,
+    597,
+    65,
+    315,
+    29,
+    140,
+    172,
+    685,
+    199,
+    62,
+    53,
+    396,
+    97,
+    1,
+    264,
+    59,
+    707,
+    82,
+    175,
+    51,
+    544,
+    498,
+    787,
+    293,
+    230,
+    258,
+    146,
+    45,
+    130,
+    355,
+    280,
+    238,
+    153,
+    422,
+    60,
+    186,
+    228,
+    64,
+    146,
+    290,
+    34,
+    1280,
+    241,
+    27,
+    178,
+    332,
+    78,
+    39,
+    74,
+    226,
+    1046,
+    747,
+    598
+   ],
+   "seconds": 25.771730831998866
   },
   {
    "sigma": 0.36,
-   "steps": 38,
-   "copy_errors": 5,
-   "steps_with_copy_errors": 3,
-   "max_copy_errors_in_a_step": 3,
-   "copy_errors_carried_to_next_step": 0,
-   "decoded_first_deviation": 38,
-   "bytes": 5,
-   "bytes_equal": true,
-   "seconds": 0.13369095901725814
+   "copies": 64,
+   "steps": 166,
+   "failed": 64,
+   "median_first_failure": 25,
+   "exposure": 2188,
+   "failure_rate_per_step": 0.029250457038391225,
+   "steps_with_wrong_copies": 301,
+   "wrong_copies": 453,
+   "max_wrong_copies_in_a_step": 9,
+   "first_failure": [
+    10,
+    96,
+    22,
+    14,
+    32,
+    2,
+    166,
+    27,
+    8,
+    14,
+    10,
+    39,
+    17,
+    14,
+    21,
+    26,
+    61,
+    54,
+    2,
+    16,
+    40,
+    36,
+    11,
+    29,
+    18,
+    19,
+    58,
+    23,
+    55,
+    7,
+    54,
+    1,
+    8,
+    82,
+    11,
+    3,
+    40,
+    34,
+    39,
+    12,
+    84,
+    4,
+    38,
+    19,
+    94,
+    7,
+    32,
+    58,
+    45,
+    10,
+    3,
+    84,
+    106,
+    45,
+    16,
+    24,
+    47,
+    16,
+    89,
+    40,
+    25,
+    2,
+    57,
+    12
+   ],
+   "seconds": 3.35292315701372
   }
  ]
 }

paper/universal_construction_ternary.pdf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b7d5d0db83aea194995f36ddcbb899845b6a449a4fee151b585480f5d3a9b154
-size 342177
+oid sha256:65149cc8b925e0925a8d0ffd77a3d607204e0f41545b6c4c1a926cc32310a581
+size 350216

paper/universal_construction_ternary.tex

@@ -165,7 +165,10 @@ and its probability of leaving an orbit within $T$ steps under read noise of
 deviation $s$ is at most $T\,rM\erfc(r/2\sqrt2 s)$, so any noise level is
 survived with redundancy $O(s\sqrt{\log(TM/\delta)})$, and with
 $O(\sigma^2\log(TM/\delta))$ when the noise sits on every synapse
-(Theorem~\ref{thm:amplify}, Corollary~\ref{cor:synapse}). The threefold host
+(Theorem~\ref{thm:amplify}, Corollary~\ref{cor:synapse}). The state read by
+majority fails only when two wrong copies meet, an event of second order whose
+probability certifies the complete run of the threefold host where the
+first-order bound exceeds one (Proposition~\ref{prop:restore}), and that host
 completes the self-reproducing run at noise levels at which the host fails within
 its first bytes (Section~\ref{sec:amplify}).
 \end{enumerate}
@@ -1527,12 +1530,69 @@ self-reproducing instance $\Omega^\ast$ of the host emits the whole instance at
 $s=0.10$, $0.15$, $0.20$ and $0.25$, where the host itself fails at $s=0.10$
 after $143$ bytes and at $s=0.15$ and $0.20$ before emitting one
 (Table~\ref{tab:noise3}). The replicated state leaves its orbit far more often
-than the computation fails. A single wrong copy is outvoted in the next layer,
+than the computation fails: a single wrong copy is outvoted in the next layer,
 so the measured rate at which the state deviates is close to the bound of
 Theorem~\ref{thm:amplify}(ii) restricted to the last layer, between a tenth and
-a twentieth of the whole bound (Table~\ref{tab:curve3}), and the computation
-fails only when two copies of one signal are wrong together, which in runs of
-$20{,}000$ steps first happened at $s=0.30$ (Appendix~\ref{app:measure}).
+a twentieth of the whole bound (Table~\ref{tab:curve3}), while the computation
+fails only when two wrong copies meet. The probability of that event is of
+second order in the probability of a flip.
+
+\begin{proposition}[Restoration]\label{prop:restore}
+Let the perturbations of $N_3$ be independent centred Gaussians of standard
+deviation $s$ on every pre-activation, and put $p=Q(3/(2s))$ and
+$\sigma=Q(1/(2s))$. Unroll $\Lev(\Nhost)$ over the steps, the rows of layer~$1$ of
+each step reading the rows of layer~$L$ of the step before, and write $u\to v$
+when row $v$ reads row $u$. For values $x$ on the rows of a layer, every copy of a
+row $w$ carrying $x_w$, let $\pi(x)$ be the sum of $x_wx_{w'}$ over the unordered
+pairs of distinct copies that some row of the next layer reads, together with
+the pairs of copies of one row when the layer is the last. Let $a$ be the least
+solution of $a_v=p+3\sigma\sum_{u\to v}a_u$; for a row $u$ let $V^u$ be the least
+solution of $V^u_v=\sigma[u\to v]+3\sigma\sum_{w\to v}V^u_w$, let $G_u$ be the sum of
+$\pi(V^u)$ over the layers after $u$, and let $X_u=G_u-3\sigma^2\sum_{u\to v}G_v$.
+Then the probability that the state of $N_3$ read by majority differs from the
+orbit at some step $t\le T$ is at most
+\[
+T\Bigl(\sum_{\ell}\pi(a)+3\sum_{u}a_u\min(1,X_u)\Bigr),
+\]
+the sums over the layers and the rows of one step.
+\end{proposition}
+
+\begin{proof}
+Call a copy wrong when its output differs from the replicated orbit. By
+Proposition~\ref{prop:amplify}(ii) and~(iii), a copy that reads no wrong copy is
+wrong only if its perturbation carries it across its distance
+$3|z+\tfrac12|\ge\tfrac32$ from the comparator, and a copy that reads one wrong
+copy only if its perturbation carries it across a distance of at least $\tfrac12$;
+the first event has probability at most $p$, the second at most $\sigma$, and each
+depends on the perturbation of that copy alone. Call two wrong copies that some
+row reads, or two wrong copies of one row of the last layer, a \emph{collision};
+the device reads and writes every register by majority, so the state read by
+majority is wrong only after a collision. Before the first collision every row
+reads at most one wrong copy, so a wrong copy either reads none, and its first
+event occurred, or reads exactly one, its parent, and its second event occurred;
+following parents gives a chain from a copy of the first kind. The two copies of
+the first collision therefore end two chains that are disjoint or share an
+initial segment up to a last common copy $z$, after which they continue as two
+paths through distinct copies. Distinct copies have independent perturbations,
+so such a configuration occurs with probability at most the product of $p$ for
+the first copy of each chain and $\sigma$ for every other copy.
+
+The sum of these products over the chains ending at a copy of $v$ is $a_v$, and
+over the paths from one copy of $u$ to a copy of $v$ it is $V^u_v$, every copy of a
+row reading all three copies of its inputs. Pairs of disjoint chains whose ends
+collide in one step therefore contribute at most $\sum_\ell\pi(a)$. For a
+configuration parting at a copy $z$ of $u$, the chain to $z$ and the paths after
+it involve disjoint copies, so its probability is at most $a_u$ times the
+probability that two paths leaving $z$ through distinct copies reach a collision.
+The pairs of paths from $z$ that reach a collision number $G_u$ in expectation,
+and those that leave $z$ through the same copy of a consumer $v$ number
+$\sigma^2G_v$ for each of its three copies, so the pairs that part at $z$ number at
+most $X_u$ in expectation and occur with probability at most $\min(1,X_u)$.
+Summing over the three copies of every row and over the $T$ steps at which the
+first collision can occur gives the bound.
+\end{proof}
+
+For the self-reproducing run, $T=1{,}664{,}939$, the bound of Proposition~\ref{prop:restore} is $3.80\times10^{-6}$ at $s=0.20$, where Theorem~\ref{thm:amplify}(ii) gives $1.34\times10^{-2}$, and $2.98\times10^{-3}$ at $s=0.22$, where that bound exceeds one; from $s=0.25$ on it exceeds one as well, and from $s=0.33$ its sums diverge (Table~\ref{tab:bound3}). Along the orbit, over $64$ noisy copies, the state read by majority failed at $4.04\times10^{-6}$ per step at $s=0.27$ and $2.13\times10^{-4}$ at $s=0.30$, below the bound by factors of $23$ and $53$, and $21$ and $12$ times less often than the replicated state left its orbit.
 
 
 % =============================================================================
@@ -2354,19 +2414,37 @@ by at most a factor of $1.6$ up to $s=0.36$, where errors meeting in the last tw
 layers add to it.
 
 A copy of the state that deviates is not a failure of the computation, since a
-single wrong copy of a state bit is outvoted at the next step. One exact and one
-noisy copy of $N_3$ were stepped together from the initial state of the
-self-describing instance for up to $20{,}000$ steps, every copy of every state
-bit of the noisy run compared with the exact run after each step. At $s=0.24$ no
-copy was wrong; at $s=0.27$ one copy of one bit was wrong at each of two steps
-and right again at the next, and the state read by majority was exact
-throughout; at $s=0.30$, $0.33$ and $0.36$ the state read by majority was first
-wrong at steps $288$, $110$ and $38$. The computation fails when a flip halves the
-margin of the rows reading it and two copies of one of those rows then fail
-together, an event of second order in the probability of a flip, which is why
-the complete run survives $s=0.25$ although the replicated state leaves its
-orbit there at about $6\times10^{-6}$ per step, the last-layer rate, some ten
-times over the run.
+single wrong copy of a state bit is outvoted at the next step.
+Table~\ref{tab:bound3} measures the failure itself: one exact and $64$ noisy
+copies of $N_3$ were stepped together from the initial state of the
+self-describing instance for up to $20{,}000$ steps, the state of each noisy copy
+read by majority and compared with the exact state after every step, and each
+noisy copy stopped at its first wrong majority-read state. The restoration bound
+of Proposition~\ref{prop:restore} is computed with the worst margins, every row
+at distance $\tfrac12$ from the comparator, so it holds along every orbit; along
+this one most rows of the decoders sit at distance at least $\tfrac32$, which is
+why it lies one to two orders of magnitude above the measured rate.
+
+\begin{table}[ht]
+\centering\small
+\begin{tabular}{@{}lrrlll@{}}
+\toprule
+$s$ & Failed & Exposure & Measured rate & Restoration bound & $rM\erfc(r/2\sqrt2s)$\\
+\midrule
+$0.10$ & --- & --- & --- & $2.13\times10^{-57}$ & $9.24\times10^{-46}$\\
+$0.15$ & --- & --- & --- & $9.96\times10^{-24}$ & $1.92\times10^{-18}$\\
+$0.20$ & --- & --- & --- & $2.28\times10^{-12}$ & $8.03\times10^{-9}$\\
+$0.22$ & --- & --- & --- & $1.79\times10^{-9}$ & $1.16\times10^{-6}$\\
+$0.25$ & --- & --- & --- & $2.10\times10^{-6}$ & $2.48\times10^{-4}$\\
+$0.27$ & 5/64 & 1{,}237{,}505 & $4.04\times10^{-6}$ & $9.28\times10^{-5}$ & $3.48\times10^{-3}$\\
+$0.30$ & 63/64 & 295{,}163 & $2.13\times10^{-4}$ & $1.14\times10^{-2}$ & $7.22\times10^{-2}$\\
+$0.33$ & 64/64 & 17{,}472 & $3.66\times10^{-3}$ & diverges & $6.90\times10^{-1}$\\
+$0.36$ & 64/64 & 2{,}188 & $2.93\times10^{-2}$ & diverges & $3.89$\\
+\bottomrule
+\end{tabular}
+\caption{The per-step probability that the state of $N_3$ read by majority leaves the orbit under read noise of standard deviation $s$: $64$ noisy copies stepped beside an exact one from the initial state of the self-describing instance for up to $20{,}000$ steps, each stopped at its first wrong majority-read state, against the bound of Proposition~\ref{prop:restore} per step and the first-order bound of Theorem~\ref{thm:amplify}(ii). From $s=0.33$ the sums defining the restoration bound diverge.}
+\label{tab:bound3}
+\end{table}
 
 \begin{table}[ht]
 \centering\small

src/redundant.py

@@ -129,7 +129,7 @@ class Amplified:
                 if ell == 1:
                     idx = [c * n + k for k, w in ins for c in range(r)]
                 else:
-                    idx = [r * (k - base[ell - 1]) + c for k, w in ins for c in range(r)]
+                    idx = [r * (k - base[ell - 2]) + c for k, w in ins for c in range(r)]
                 w = [wt for k, wt in ins for c in range(r)]
                 for c in range(r):
                     rows_of.append((m * r + c, idx, w, r * b + (r - 1) // 2))
@@ -590,31 +590,35 @@ def cmd_curve(args) -> int:
 
 
 def cmd_restore(args) -> int:
-    """Restoration along the orbit: one exact and one noisy copy of N_r from the
-    initial state of the self-describing instance. After every step the copies
-    of every state bit of the noisy run are compared with the exact run: a
-    wrong copy is counted, and the state read by majority over the r copies is
-    compared with the exact state. The run stops at the first step whose
-    majority-read state is wrong, or after the given number of steps."""
+    """Restoration along the orbit: one exact and B noisy copies of N_r stepped
+    together from the initial state of the self-describing instance. After every
+    step the copies of every state bit of each noisy run are compared with the
+    exact run, and the state read by majority over the r copies is compared with
+    the exact state; a run is stopped at its first step whose majority-read state
+    is wrong, and the rate of that event per step of exposure is recorded with
+    the counts of wrong copies seen before it."""
     import torch
     amp = build_amplified(args.r)
     sigma = read_host()
     r_H = describe(sigma)
     E = Evaluator(amp, device=args.device, pad=False)
     n, r = amp.n, args.r
+    B = args.batch
     grid = [float(x) for x in args.grid.split(",")]
     rows = []
-    print(f"[restore] N_{r}: {args.steps:,} steps per level", flush=True)
+    print(f"[restore] N_{r}: {B} noisy copies, up to {args.steps:,} steps per level", flush=True)
     for s in grid:
         gen = torch.Generator(device=args.device).manual_seed(31 + int(1000 * s))
-        v = E.vec(0, M_P, copies=2)
-        tapes = [Tape(r_H) for _ in range(2)]
-        shadow = [[0] * 256 for _ in range(2)]
-        copy_errors = steps_with = worst = 0
-        carried = 0
-        prev = None
-        decoded_first = None
+        v = E.vec(0, M_P, copies=B + 1)
+        tapes = [Tape(r_H) for _ in range(B + 1)]
+        shadow = [[0] * 256 for _ in range(B + 1)]
+        first = [None] * B
+        wrong_copy_steps = 0
+        wrong_copies = 0
+        worst = 0
+        live = torch.ones(B, dtype=torch.bool)
         t0 = time.perf_counter()
+        ran = args.steps
         for t in range(args.steps):
             x = v
             for width, groups in E.plan:
@@ -626,38 +630,234 @@ def cmd_restore(args) -> int:
                     y[:, rws] = ((pre + noise) >= -0.5).float()
                 x = y
             v = x[:, E.perm]
-            wrong = (v[1] != v[0]).reshape(r, n)
-            k = int(wrong.sum())
-            if k:
-                copy_errors += k
-                steps_with += 1
-                worst = max(worst, k)
-                if prev is not None:
-                    carried += int((wrong & prev).sum())
-            prev = wrong
-            maj = (v[1].reshape(r, n).sum(0) * 2 > r)
-            if bool((maj != (v[0, :n] > 0.5)).any()):
-                decoded_first = t + 1
+            ex = v[0].reshape(r, n)
+            wrong = (v[1:].reshape(B, r, n) != ex.unsqueeze(0))
+            k = wrong.sum(dim=(1, 2)).cpu()
+            maj = (v[1:].reshape(B, r, n).sum(1) * 2 > r)
+            bad = (maj != (ex[0] > 0.5).unsqueeze(0)).any(1).cpu()
+            for i in range(B):
+                if live[i]:
+                    if int(k[i]):
+                        wrong_copy_steps += 1
+                        wrong_copies += int(k[i])
+                        worst = max(worst, int(k[i]))
+                    if bool(bad[i]):
+                        first[i] = t + 1
+                        live[i] = False
+            if not bool(live.any()):
+                ran = t + 1
                 break
             E.device_step(v, tapes, shadow)
         dt = time.perf_counter() - t0
-        ran = decoded_first or args.steps
-        rows.append({"sigma": s, "steps": ran, "copy_errors": copy_errors,
-                     "steps_with_copy_errors": steps_with, "max_copy_errors_in_a_step": worst,
-                     "copy_errors_carried_to_next_step": carried,
-                     "decoded_first_deviation": decoded_first,
-                     "bytes": len(tapes[1].out), "bytes_equal": tapes[1].out == tapes[0].out,
-                     "seconds": dt})
-        print(f"    s={s:.2f}: {ran:,} steps; {steps_with:,} steps with a wrong copy, "
-              f"{copy_errors:,} wrong copies in all, at most {worst} in one step, {carried} still "
-              f"wrong a step later; majority-read state "
-              f"{'exact throughout' if decoded_first is None else f'wrong at step {decoded_first:,}'} "
-              f"({dt / 60:.1f} min)", flush=True)
-        json.dump({"r": r, "steps": args.steps, "rows": rows},
+        failed = [f for f in first if f is not None]
+        exposure = sum(f if f is not None else ran for f in first)
+        rows.append({"sigma": s, "copies": B, "steps": ran, "failed": len(failed),
+                     "median_first_failure": sorted(failed)[len(failed) // 2] if failed else None,
+                     "exposure": exposure, "failure_rate_per_step": len(failed) / exposure,
+                     "steps_with_wrong_copies": wrong_copy_steps, "wrong_copies": wrong_copies,
+                     "max_wrong_copies_in_a_step": worst, "first_failure": first, "seconds": dt})
+        print(f"    s={s:.2f}: {len(failed)}/{B} majority-read failures within {ran:,} steps, "
+              f"exposure {exposure:,}, rate {len(failed) / exposure:.3e} per step; "
+              f"{wrong_copies:,} wrong copies in {wrong_copy_steps:,} copy-steps before the "
+              f"failures ({dt / 60:.1f} min)", flush=True)
+        json.dump({"r": r, "copies": B, "cap": args.steps, "rows": rows},
                   open(runs_path(f"paper_redundant_restore_r{r}.json"), "w"), indent=1)
     return 0
 
 
+class _Inc:
+    """The 0/1 incidence of one layer, applied by gathering and adding."""
+
+    def __init__(self, rows, cols, shape, device):
+        import torch
+        self.rows = torch.tensor(rows, dtype=torch.long, device=device)
+        self.cols = torch.tensor(cols, dtype=torch.long, device=device)
+        self.shape = shape
+
+    def mm(self, V):
+        import torch
+        out = torch.zeros((self.shape[0],) + tuple(V.shape[1:]), dtype=V.dtype, device=V.device)
+        out.index_add_(0, self.rows, V[self.cols])
+        return out
+
+    def column_block(self, cols):
+        """The dense block of the columns `cols`, as a matrix."""
+        import torch
+        pos = torch.full((self.shape[1],), -1, dtype=torch.long, device=self.rows.device)
+        pos[cols] = torch.arange(len(cols), device=self.rows.device)
+        keep = pos[self.cols] >= 0
+        out = torch.zeros(self.shape[0], len(cols), dtype=torch.float64, device=self.rows.device)
+        out[self.rows[keep], pos[self.cols[keep]]] = 1.0
+        return out
+
+
+def incidence(amp: "Amplified", device: str):
+    """The 0/1 incidence of every layer of Lev(N_host): entry (i, j) of layer l
+    is 1 when row i of layer l reads row j of layer l-1, layer 0 being the
+    state."""
+    n = amp.n
+    base = [n]
+    for L in amp.layers:
+        base.append(base[-1] + L)
+    mats, j0 = [], 0
+    for ell, L in enumerate(amp.layers, start=1):
+        rows, cols = [], []
+        for m in range(L):
+            _, ins = amp.lev_units[j0 + m]
+            for k, w in ins:
+                rows.append(m)
+                cols.append(k if ell == 1 else k - base[ell - 2])
+        j0 += L
+        width_prev = n if ell == 1 else amp.layers[ell - 2]
+        mats.append(_Inc(rows, cols, (L, width_prev), device))
+    return mats
+
+
+def consumer_sharing(mats, device):
+    """For every layer l, the indicator B_l over the rows of layer l-1 of
+    reading by a common row of layer l: B_l[j, k] = 1 when some row of layer l
+    reads both j and k, B_l[j, j] = 1 when row j has a consumer. Stored as
+    booleans."""
+    import torch
+    out = []
+    for A in mats:
+        D = A.column_block(torch.arange(A.shape[1], device=device)).float()
+        out.append((D.T @ D) > 0)
+        del D
+    return out
+
+
+def restoration_bound(mats, shares, n: int, s: float, device: str, chunk: int = 1024):
+    """The bound of Proposition 6.14 on the per-step probability that the state
+    of N_3 read by majority leaves the orbit, for Gaussian perturbations of
+    deviation s on every pre-activation.
+
+    p bounds the probability that a copy with exact inputs fails and sigma the
+    probability that a copy with one wrong input copy fails. a_i is the sum over
+    chains of perturbations ending at one copy of row i, stationary over the
+    steps. A failure needs two wrong copies that one row reads or that one
+    bundle of the last layer holds; each such pair of copies is counted once.
+    The first term takes the two copies from separate chains, and the second,
+    for every copy z at which two chains part, weighs by a_z the number of such
+    pairs its cascade reaches, the cascade continued into later steps through
+    the quadratic form of one step."""
+    import torch
+    q = lambda u: 0.5 * math.erfc(u / math.sqrt(2.0))
+    p, sg = q(1.5 / s), q(0.5 / s)
+    L = len(mats)
+
+    def pairs(ell, V):
+        """Pairs of distinct copies among the values V on the rows of layer
+        ell-1 that some row of layer ell reads, counted once: three per row with
+        a consumer, nine per pair of rows with a common consumer."""
+        B = shares[ell - 1].to(torch.float64)
+        d = torch.diagonal(B).unsqueeze(1) if V.dim() == 2 else torch.diagonal(B)
+        return 4.5 * (V * (B @ V)).sum(0) - 1.5 * (d * V ** 2).sum(0)
+
+    a_state = torch.zeros(n, dtype=torch.float64, device=device)
+    for it in range(400):
+        a = [a_state]
+        for A in mats:
+            a.append(p + 3 * sg * A.mm(a[-1]))
+        change = float((a[-1] - a_state).abs().max())
+        a_state = a[-1]
+        if change <= 1e-13 * float(a_state.abs().max()) + 1e-300:
+            break
+    else:
+        return {"sigma": s, "p": p, "sigma_link": sg, "converged": False}
+    first = sum(float(pairs(ell, a[ell - 1])) for ell in range(1, L + 1)) + 3 * float((a[L] ** 2).sum())
+
+    def through(V, start):
+        """Collisions of per-copy values V held at layer start-1, carried
+        through layers start..L, and the values reaching the last layer."""
+        G = torch.zeros(V.shape[1], dtype=torch.float64, device=device)
+        for ell in range(start, L + 1):
+            G += pairs(ell, V)
+            V = 3 * sg * mats[ell - 1].mm(V)
+        return G + 3 * (V ** 2).sum(0), V
+
+    # the quadratic form of one step entered with per-copy values x on the state
+    V = torch.eye(n, dtype=torch.float64, device=device)
+    Qm = torch.zeros(n, n, dtype=torch.float64, device=device)
+    for ell in range(1, L + 1):
+        B = shares[ell - 1].to(torch.float64)
+        dg = torch.diagonal(B)
+        Qm += 4.5 * V.T @ (B @ V) - 1.5 * V.T @ (dg.unsqueeze(1) * V)
+        del B
+        V = 3 * sg * mats[ell - 1].mm(V)
+    Qm += 3 * V.T @ V
+    T = V
+    Qtot, M = Qm.clone(), T.clone()
+    for k in range(200):
+        add = M.T @ Qm @ M
+        Qtot += add
+        if float(add.abs().max()) <= 1e-14 * float(Qtot.abs().max()):
+            break
+        M = T @ M
+    rho = float(torch.linalg.matrix_norm(T, ord=2))
+    if not (rho < 1.0 and math.isfinite(float(Qtot.abs().max())) and math.isfinite(float(a_state.max()))):
+        return {"sigma": s, "p": p, "sigma_link": sg, "converged": False, "one_step_map_norm": rho}
+
+    # G[ell][u]: colliding pairs reached from one copy of row u of layer ell
+    Gs = [None] * (L + 1)
+    for ell in range(1, L + 1):
+        width = mats[ell - 1].shape[0]
+        out = torch.empty(width, dtype=torch.float64, device=device)
+        for c0 in range(0, width, chunk):
+            cols = torch.arange(c0, min(width, c0 + chunk), device=device)
+            if ell < L:
+                V = sg * mats[ell].column_block(cols)       # consumers of one copy
+                G, V = through(V, ell + 2)
+            else:
+                V = sg * mats[0].column_block(cols)         # the next step's first layer
+                G, V = through(V, 2)
+            out[cols] = G + (V * (Qtot @ V)).sum(0)
+        Gs[ell] = out
+    # X[ell][u]: the pairs whose two paths part at the copy itself, which is
+    # G less the pairs whose paths leave through one child c, sigma^2 G(c)
+    second, second_uncapped = 0.0, 0.0
+    for ell in range(1, L + 1):
+        nxt = mats[ell] if ell < L else mats[0]
+        Gc = Gs[ell + 1] if ell < L else Gs[1]
+        child = torch.zeros(Gs[ell].shape[0], dtype=torch.float64, device=device)
+        child.index_add_(0, nxt.cols, Gc[nxt.rows])
+        X = (Gs[ell] - 3 * sg ** 2 * child).clamp(min=0.0)
+        second += float((3 * a[ell] * X.clamp(max=1.0)).sum())
+        second_uncapped += float((3 * a[ell] * Gs[ell]).sum())
+    return {"sigma": s, "p": p, "sigma_link": sg, "converged": True,
+            "second_term_uncapped": second_uncapped,
+            "a_max": float(max(float(x.max()) for x in a[1:])),
+            "a_state_max": float(a_state.max()),
+            "first_term": first, "second_term": second, "per_step": first + second,
+            "one_step_map_norm": rho, "G_max": float(max(float(g.max()) for g in Gs[1:]))}
+
+
+def cmd_bound(args) -> int:
+    """The restoration bound of Proposition 6.14 over a grid of noise levels,
+    beside the first-order bound of Theorem 6.9(ii)."""
+    import torch
+    amp = build_amplified(3)
+    mats = incidence(amp, args.device)
+    shares = consumer_sharing(mats, args.device)
+    M3 = 3 * sum(amp.layers)
+    rows = []
+    for s in [float(x) for x in args.grid.split(",")]:
+        t0 = time.perf_counter()
+        b = restoration_bound(mats, shares, amp.n, s, args.device)
+        b["first_order_per_step"] = M3 * math.erfc(3 / (2 * math.sqrt(2) * s))
+        b["seconds"] = time.perf_counter() - t0
+        rows.append(b)
+        if b["converged"]:
+            print(f"    s={s:.2f}: p {b['p']:.3e}, sigma {b['sigma_link']:.3e}; restoration bound "
+                  f"{b['per_step']:.3e} per step ({b['first_term']:.2e} + {b['second_term']:.2e}), "
+                  f"first-order {b['first_order_per_step']:.3e}; one-step map norm "
+                  f"{b['one_step_map_norm']:.3f} ({b['seconds']:.0f} s)", flush=True)
+        else:
+            print(f"    s={s:.2f}: the chain sums do not converge", flush=True)
+        json.dump({"r": 3, "rows": rows}, open(runs_path("paper_redundant_bound_r3.json"), "w"), indent=1)
+    return 0
+
+
 def cmd_layers(args) -> int:
     """The profile bound of N_r split by layer.
 
@@ -720,7 +920,7 @@ def cmd_layers(args) -> int:
 
 def main() -> int:
     ap = argparse.ArgumentParser()
-    ap.add_argument("mode", choices=["build", "selfrep", "omega", "curve", "restore", "layers"])
+    ap.add_argument("mode", choices=["build", "selfrep", "omega", "curve", "restore", "layers", "bound"])
     ap.add_argument("--r", type=int, default=3)
     ap.add_argument("--cc", default="gcc")
     ap.add_argument("--device", default="cuda")
@@ -735,10 +935,12 @@ def main() -> int:
     if args.grid is None:
         args.grid = {"omega": "0.10,0.15,0.20,0.25",
                      "curve": "0.06,0.12,0.18,0.24,0.27,0.30,0.33,0.36,0.45,0.60",
-                     "restore": "0.24,0.27,0.30,0.33,0.36",
-                     "layers": "0.06,0.12,0.18,0.24,0.27,0.30,0.33,0.36,0.45,0.60"}.get(args.mode, "")
+                     "restore": "0.27,0.30,0.33,0.36",
+                     "layers": "0.06,0.12,0.18,0.24,0.27,0.30,0.33,0.36,0.45,0.60",
+                     "bound": "0.10,0.15,0.20,0.22,0.25,0.27,0.30,0.33,0.36"}.get(args.mode, "")
     return {"build": cmd_build, "selfrep": cmd_selfrep, "omega": cmd_omega,
-            "curve": cmd_curve, "restore": cmd_restore, "layers": cmd_layers}[args.mode](args)
+            "curve": cmd_curve, "restore": cmd_restore, "layers": cmd_layers,
+            "bound": cmd_bound}[args.mode](args)
 
 
 if __name__ == "__main__":

src/verify.py

@@ -91,7 +91,9 @@ TIER3 = [
     ("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"], "wrong copies of N_3 under noise, and the state read by majority"),
+    ("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"),
 ]