En02-B Resource-Limited Holographic Reconstruction Boundary Access, Decoder Memory, and Certified Operational Recovery

Algebraic reconstruction from a boundary region does not specify the resources needed to execute a recovery. We formulate observable readout, subsystem recovery, and instrument recovery as distinct finite-dimensional channel tasks, with correctness including arbitrary external references. Under specified Born semantics, we construct explicit decoders for the five-qubit perfect-code building block used in holographic tensor networks. For the accessible triple $\{1,2,3\}$, a nine-gate Clifford decoder uses three batch input qubits and no additional workspace. A streaming decoder uses two live qubits, two classical record bits, and no ancillary quantum register. An intrinsic uniqueness argument identifies the recovery channel on its entire three-qubit input space. Its Choi operator has a negative partial transpose across the first input, proving that one-live-qubit streaming recovery is impossible even with unrestricted classical memory. Thus the streaming optimum is exactly two, whereas batch access forces three. The same recovery channel has coherent environment dimension four; this is compatible with, but does not bound, instantaneous adaptive memory. For a rooted perfect-code tree, we prove batch peak $3^h$ and a streaming bound $h+1$, the latter optimal within a declared serial decoder-module class. A finite schedule recurrence prices that class without claiming unrestricted decoder optimality. We also prove a two-bit lower bound for a specified one-way distributed implementation and give a matching decoder. Half-diamond error budgets compose at the channel level. Exact Gaussian-integer checks and a finite schedule explorer are supplied as independently inspectable artefacts, not universal proof certificates. The results concern finite perfect-tensor code models, not an entanglement-wedge identification, spacetime emergence, or a gravitational memory bound.

The quantum-error-correction formulation of holographic subregion reconstruction is established, rather than introduced here. Almheiri, Dong, and Harlow connected bulk locality with quantum error correction; perfect-tensor networks subsequently supplied explicit finite encoders and reconstruction examples ADH,HaPPY. Operator-algebra quantum error correction separates correctable observables and subsystems BKK. Approximate reconstruction can be studied using approximate-correction and universal-recovery methods BenyApprox,Cotler. These results concern correctability or recovery maps. They do not, by themselves, specify the live-register ledger of an executable decoder.

The question addressed here is:

When a logical subsystem is reconstructible from an accessible boundary region, what quantum storage, records, scheduling, and communication are required to execute a declared recovery task?

Our contribution is a resource-certified finite construction. We give the code, gates, measurement branches, output conventions, and lower bounds together. We make no claim that the underlying five-qubit code, perfect tensor, or quantum-error-correction interpretation is new.

En02-A supplies a finite-resource accounting vocabulary and separates specified Born semantics from conditional characterization of an unknown measurement strategy En02A. Here the primary decoder theorems use ordinary quantum channels and specified destructive Born readout from the outset.

The encoding, access sets, recovery channels, and decoder schedules below are new mathematical data of this paper. They are not furnished by En02-A, manuscript I, or X-Enter. The finite-program path-map convention agrees with the specified Born interface described in I and X-Enter I,XEnter; its completeness is proved again in Theorem thm:B1.

Our laboratory count excludes inaccessible boundary systems and external references, while retaining them in the correctness specification. It is therefore not automatically En02-A's global capacity convention.

The identifier En02-B is distinct from Em02-B. No field-theoretic, characteristic-map, gravitational-insertion, or microsphere-readout result is used as a holographic-code premise. In particular, our instruments do not instantiate the separately represented scalar-field Models 1, 2, or 3 of manuscript IV.

The principal results are:

1. an explicit batch decoder and a reference-preserving channel certificate;

2. an exact streaming decoder and a nontrivial one-qubit-memory obstruction;

3. an intrinsic recovery-channel ledger, avoiding arbitrary off-code lower bounds;

4. a proved decoder-module scheduling bound for a finite perfect-code tree;

5. a matching upper and lower bound for a declared one-way distributed implementation;

6. channel-level implementation-error budgets.

The tree model is a rooted concatenation of the perfect-code isometry. It is not asserted to be a hyperbolic tessellation, a continuum holographic dual, or a model of gravitational dynamics.

All Hilbert spaces are finite dimensional. Channels act linearly on operator spaces and are completely positive and trace preserving, abbreviated CPTP.

Fix an isometry

The accessible-boundary channel is

An external reference $R$ is arbitrary and may be entangled with $ab$.

The following tasks have different output specifications.

readout. For a specified logical POVM $\{F_y\}$ on $a$, a boundary measurement must implement the quantum-to-classical channel

Its output is classical. No quantum preservation of $a$ is required.

recovery. A channel ${\mathcal{D}}_A:\mathcal{B}({\mathcal{H}}_A)\to \mathcal{B}({\mathcal{H}}_a)$ must satisfy

recovery. For specified completely positive maps $\{{\mathcal{I}}_y:\mathcal{B}({\mathcal{H}}_a)\to \mathcal{B}({\mathcal{H}}_{a^{\prime }})\}$, whose sum is trace preserving, the required output channel is

A boundary programme must implement $\hat{\mathcal{I}}{\mathrm{Tr}}_b$, including its conditional quantum outputs, not only its outcome probabilities.

Equation (eq:recovery) is an equality of linear maps. Consequently,

for every reference and every input.

For approximate recovery we use

The diamond norm is the completely bounded trace norm. For channel differences, it controls every input entangled with a reference; standard finite-dimensional channel conventions are those of Watrous (Chapters 2–3).

Agreement on $|0⟩$ and $|1⟩$ does not determine the action on $|0⟩⟨1|$. An exact certificate must determine all matrix units, or equivalently the Choi operator. Numerical fidelity on selected states is not a diamond-norm certificate.

For a finite decoder programme $\pi$,

The count includes:

• accessible input qubits already delivered;

• working ancillas;

• recovered output until its final return;

• retained syndrome and quantum-record registers.

Inaccessible boundary systems, undelivered streaming inputs, and external references are outside laboratory occupancy. They remain inside the channel specification.

Every laboratory qubit is either destructively measured or returned. There is no silent quantum deletion or uncounted external quantum scratch space. Classical records may be forgotten explicitly.

We record

Here $G$ is the worst-history number of elementary unitary gates. The depth $D$ counts rounds of gates and destructive readouts; operations on disjoint qubits may share a round. Waiting for a streaming delivery is not a gate round. $C_{\mathrm{cl}}$ counts retained outcome bits, not the fixed programme description. Communication is zero in the local model and specified separately in the distributed model.

Classical storage is initially unrestricted. Its reported upper bounds are nevertheless part of each programme's ledger.

All qubits of $A$ are present in the laboratory at the initial time. Thus

Ignoring or measuring a supplied qubit does not erase this initial occupancy cost.

The accessible input is an arbitrary joint state on an ordered list of carriers $q_1,\dots ,q_n$. A passive supplier retains the undelivered carriers and transfers them, one at a time, on request in that order.

The supplier performs no decoding, measurement, or state-dependent selection. The laboratory may pause delivery but may not return intermediate quantum data to the supplier, use another quantum buffer, or export a quantum output before completion. The target quantum output is returned only at the end.

This convention changes the storage interface; it does not compress the total quantum state of the supplier and laboratory.

For the explicit benchmarks, ${\mathfrak{L}}_{\mathrm{Cl}}$ contains:

zero-state allocation, destructive computational readout, finite classical control, and quantum return. Any pair of laboratory qubits may interact. All these gates are exact.

The matrices are

with the usual Pauli, CNOT, and controlled-$Z$ conventions. A controlled Pauli chosen from $I,X,Y,Z$ costs at most one elementary gate. Global phases are irrelevant.

No gate-count optimality or geometric locality follows from this all-to-all library.

For a linear map $\Phi :\mathcal{B}({\mathcal{H}}_{\mathrm{in}})\to \mathcal{B}({\mathcal{H}}_{\mathrm{out}})$, use the unnormalized Choi operator

Its blocks determine $\Phi$ on every matrix unit.

A certificate for $\pi$ comprises:

1. its finite instruction tree and its input/output names;

2. the branch path maps $K_h$;

3. the complete selective channel

   $${{\Phi }_y}^{\pi }(\rho )=\sum _{h:\mathrm{out}(h)=y}{K}_h\rho {K_h}^{†};$$

4. an equality of the task channel composed with ${\mathcal{N}}_A$, certified on all matrix units;

5. a live-name ledger at every instruction and branch.

All outcomes are retained in the branch sum. A successful branch alone is not a deterministic recovery.

Under specified Born semantics, a finite legal programme with the above certificate implements its declared channel on arbitrary reference-entangled inputs and obeys its declared peak bound.

Proof. Along a history, compose allocation isometries, gates, and destructive measurement bras. The resulting linear map is $K_h$. Branch normalizations cancel against the product of branch probabilities, leaving the unnormalized output $K_h\rho {K_h}^{†}$.

Completeness follows by backward induction on the finite instruction tree. Gates and allocations are isometric. At a readout, ${\sum }_{\kappa }{M_{\kappa }}^{†}{M}_{\kappa }=I$. Every subsequent branch is complete by induction, so

The programme therefore defines a CPTP output channel, or a complete instrument if outcomes are reported.

Equality of Choi blocks is equality on all matrix units and hence equality of the linear maps. Tensoring this equality with ${\mathrm{id}}_R$ proves correctness with every reference.

Finally, the live-name ledger counts every allocated, surviving, and returned quantum factor on each branch. Its maximum is the claimed bound by Definition def:peak. Consumption and return ensure there is no unpriced quantum output.

For a fixed task, access interface, and implementation library, define

over legal programmes satisfying the subsystem recovery requirement within $\epsilon$. The value is $+\infty$ if none exists. Because finite peaks are integers, a finite infimum is attained as a minimum of the achievable peak values.

With the task and access convention fixed:

1. increasing $\epsilon$ cannot increase $Q_{\mathfrak{L}}^{\ast }$;

2. enlarging $\mathfrak{L}$ cannot increase $Q_{\mathfrak{L}}^{\ast }$;

3. increasing a laboratory capacity cannot destroy feasibility.

Proof. Each change enlarges the relevant feasible set or leaves an already legal programme legal. Taking infima gives the first two statements.

There is no analogous general decrease in total batch peak when the accessible region grows: its enlarged input already occupies more qubits.

The five-qubit code is a standard quantum-error-correction benchmark Laflamme. We use the stabilizer convention in the perfect-tensor construction HaPPY (Appendix A.1) and give the finite algebra needed here.

Let

Tensor positions are $1,\dots ,5$. Define

The generators commute. The following table gives every nonidentity stabilizer product, with its overall sign omitted only because this table is used to inspect support.

All fifteen words have weight four. Their distinct supports and words also show that the sixteen stabilizer products are distinct and that $-I$ is absent. Thus $P$ is an orthogonal projector of trace $32/16=2$.

No nonidentity stabilizer product is diagonal in the computational basis. Hence $⟨00000|P|00000⟩=1/16$. Fix the encoding explicitly by

These vectors are normalized, have opposite $\overline{Z}$ eigenvalues, and obey

In this benchmark $b$ is trivial.

For a Pauli error, its syndrome is the four-bit vector recording anticommutation with $g_1,\dots ,g_4$. The single-qubit syndromes are:

They are precisely the fifteen distinct nonzero four-bit vectors. Every nonidentity Pauli of weight one or two therefore has nonzero syndrome. For weight two, this follows because its syndrome is the sum of two distinct single-site syndromes.

For $C\subseteq \{1,\dots ,5\}$ with $\left|C\right|\le 2$,

If $A=\bar{C}$, and $E_e=(I_A\otimes ⟨e{|}_C)V$, then

Proof. A nonzero syndrome supplies a stabilizer $g_j$ anticommuting with the Pauli $Q$. Since $g_{j}V=V$,

so it vanishes. Expanding operators on $C$ in the Pauli basis gives (eq:privacy), including off-diagonal logical matrix units. Equation (eq:KL) follows by applying the same identity to $I_A\otimes |e⟩⟨f{|}_C$.

Equation (eq:KL) is the erasure form of a Knill–Laflamme certificate KL; here it has been evaluated explicitly rather than inferred from a distance label.

Every boundary set of at least three qubits can recover the logical qubit algebraically. Every set of at most two qubits is independent of the logical input and cannot recover it exactly.

For an unauthorized set, the optimal subsystem recovery error, over arbitrary channels, is

Proof. For an accessible triple, $\left|C\right|=2$. The eight vectors

are orthonormal by (eq:KL). They form a basis of ${\mathcal{H}}_A$. The unitary sending them to $|i⟩|e⟩$, followed by tracing the last two factors, is an exact decoder. For a larger accessible set, select a triple and explicitly consume the other accessible qubits by unreported destructive measurement.

For an unauthorized set, (eq:privacy) makes every decoded channel a constant preparation channel. On a logical Bell state with a reference, its output has the form $\sigma \otimes I_R/2$, whose Bell overlap is $1/4$. The Bell-projector test gives trace distance at least $3/4$.

This bound is achieved by the completely depolarizing logical output $\mathcal{T}$. Indeed,

so

The Bell-state lower bound supplies equality.

The proposition classifies algebraic access. The explicit gate and memory theorems below concern the particular authorized triple $A=\{1,2,3\}$.

The normalized state

has maximally mixed reduction on every set of three of its six qubits. Its tensor therefore gives, up to normalization, an isometry across every bipartition with at most three input legs.

Proof. For three physical qubits, their reduction is the reduction of $P/2$. The stabilizer expansion contains no nonidentity term supported on three qubits, so the reduction is $I_8/8$.

For $R$ and two physical qubits, apply (eq:privacy) to the logical half of the Bell state: the reduction is $I_R/2\otimes I_4/4$. These are all kinds of three-qubit subsets. Smaller subsets follow by tracing. The Schmidt coefficients across each three-versus-three cut are equal, which is precisely the stated isometry property.

Set $A=\{1,2,3\}$ and $E=\{4,5\}$. Multiplication by stabilizers gives supported logical representatives

For example,

Thus $X_{A}V=VX$ and $Z_{A}V=VZ$.

Define the following unitary, with the rightmost gate applied first:

Its chronological gate list is:

There are nine elementary gates and seven gate rounds.

Proof. The two controlled-$Z$ gates map $Z_1{X}_2{Z}_3$ to $X_2$ and leave $Y_1{Z}_2{Y}_3$ unchanged. On positions 1 and 3, $H{S}^{†}$ maps $Y$ to $Z$. The two CNOTs then map $Z_1{Z}_2{Z}_3$ to $Z_2$, leaving $X_2$ unchanged. The final $Y_2$ reverses the signs of both $X_2$ and $Z_2$. This cancels the two minus signs in (eq:reps).

Let $F=\{1,3\}$ denote the two syndrome factors after decoding.

For a fixed normalized vector $\chi \in {\mathcal{H}}_F\otimes {\mathcal{H}}_E$,

for every logical vector $\psi$. Moreover,

Proof. Write $W=(U_A\otimes I_E)V$. Lemma lem:conjugation gives $X_{2}W=WX$ and $Z_{2}W=WZ$. The $Z$ identity makes $W|0⟩=|0⟩|{\chi }_0⟩$ and $W|1⟩=|1⟩|{\chi }_1⟩$. The $X$ identity gives ${\chi }_0={\chi }_1=\chi$. Isometry of $W$ gives normalization.

The encoded maximally mixed logical input is $P/2$. Its reduction on $A$ is $I_A/8$, by the weight-four stabilizer table. Equation (eq:factor) therefore gives

proving the syndrome statement.

Consequently,

The programme

implements

and satisfies $\mathcal{D}{\mathcal{N}}_A={\mathrm{id}}_2$, including every reference.

Its resource vector has

It allocates no ancilla and is peak-optimal for batch access.

Proof. Destructively measuring $F$ and summing its outcomes is precisely the partial trace over $F$. Equation (eq:normalform) proves recovery. Alternatively, (eq:factor) proves it before tracing and therefore with every reference.

The syndrome outcomes are uniform over four values and independent of the logical-reference state. Each normalized positive branch returns the original logical state with its reference correlations.

Three input names are initially live. Gates preserve that count. The two readout names are then consumed, leaving one returned qubit. The two readouts share the eighth round. No quantum record or environment remains unconsumed. Batch access forces the initial lower bound three.

The cost of an arbitrary off-code extension need not be an intrinsic reconstruction cost. In this benchmark the ambiguity can be removed.

Let $d\ge 1$. If a CPTP channel $\mathcal{R}:\mathcal{B}({\mathcal{H}}_a\otimes {\mathbb{C}}^d)\to \mathcal{B}({\mathcal{H}}_a)$ satisfies

for every $\rho$, then $\mathcal{R}={\mathrm{Tr}}_{{\mathbb{C}}^d}$.

Proof. Take Kraus operators $K_{\ell }$ of $\mathcal{R}$. The operators

are a Kraus family for ${\mathrm{id}}_a$. The Choi operator of the identity has rank one. Since it is a sum of positive rank-one operators, every $\mathrm{vec}(L_{\ell j})$ is proportional to $\mathrm{vec}(I_a)$. Thus $L_{\ell j}=c_{\ell j}{I}_a$, and

for some vectors $w_{\ell }$. Trace preservation gives ${\sum }_{\ell }|w_{\ell }⟩⟨w_{\ell }|=I_d$. Substitution yields the partial trace on every operator.

Every CPTP exact recovery channel on $A=\{1,2,3\}$ equals $\mathcal{D}$ in (eq:D) on its entire input space. Its Choi rank is four.

In the pure-environment, one-shot dilation model, its minimum environment dimension is four. The output-plus-environment peak is three qubits, with no additional workspace beyond the batch input.

Proof. For another exact decoder ${\mathcal{D}}^{\prime }$, define $\mathcal{R}={\mathcal{D}}^{\prime }{\mathrm{Ad}}_{U^{†}}$. Equation (eq:normalform) and exact recovery give $\mathcal{R}(\rho \otimes I_4/4)=\rho$. Lemma lem:unique identifies $\mathcal{R}={\mathrm{Tr}}_F$, hence ${\mathcal{D}}^{\prime }=\mathcal{D}$.

The four Kraus maps

are Hilbert–Schmidt orthogonal: $\mathrm{tr}({K_f}^{†}{K}_g)=2{\delta }_{fg}$. Their Choi vectors are independent, so the Choi rank is four.

For completeness, an environment of dimension $r$ yields at most $r$ Kraus operators by expanding its dilation in a basis. Conversely, a minimum Kraus family defines the isometry $\psi \mapsto {\sum }_j{K}_j\psi \otimes |j⟩$. Thus the minimum environment dimension equals Choi rank Watrous (Chapter 2). Here the two environment qubits are the original syndrome factors, and the total output dimension is $2\cdot 4=8$.

This is an application of the one-shot model also priced in En02-A. It is not a bound on every adaptive instantaneous memory.

Consider the restricted encoding $\rho \mapsto \rho \otimes |0⟩⟨0|$. Partial trace over the second qubit is a valid decoder of Choi rank two.

Another valid decoder acts as identity when the second qubit is zero, and depolarizes the first when it is one:

It has the five independent Kraus operators

Its Choi rank is five, despite identical recovery on the restricted encoding. Its larger dilation cost is not an intrinsic recovery lower bound.

Theorem thm:B3 avoids this error because the syndrome in (eq:normalform) is faithful and forces uniqueness.

Define commuting operators on the first two carriers:

They are independent and have one-dimensional joint eigenspaces. Let

Direct conjugation gives

Write the computational readout of positions 1 and 2 after $B$ as $(t,s)$, so

are the eigenvalues of $Q_{12}$ and $P_{12}$, respectively.

After the third carrier arrives, put

The product $C_{ts}$ is implemented by one Pauli gate, up to phase.

The programme is:

1. receive $q_1,q_2$;

2. apply $H_2,{\mathrm{CX}}_{1\to 2},{S_1}^{†},H_1$;

3. destructively read both qubits, retaining bits $t,s$;

4. receive $q_3$;

5. apply ${S_3}^{†},H_3,C_{ts}$;

6. forget $t,s$, and return $q_3$.

The programme implements the same channel $\mathcal{D}$ as the batch decoder. On encoded inputs each of its four histories has probability $1/4$, independent of the logical-reference input.

Its resources satisfy

Proof. Let $⟨{\beta }_{ts}|=⟨t,s|B_{12}$. The branch map on the full encoded state is

Since $X_A=-P_{12}{Z}_3$ and $Z_A=-Q_{12}{Y}_3$, the eigenvalue equations imply

and similarly $W_{ts}Z=Z_3{W}_{ts}$. Here $R_3{Z}_3{R_3}^{†}=X_3$, $R_3{Y}_3{R_3}^{†}=Z_3$, and the correction supplies the required signs.

The same intertwining argument as in Lemma lem:factor gives

for a fixed branch vector. The first-two-qubit reduction is $I_4/4$, so ${\Vert {\chi }_{ts}\Vert }^2=1/4$. Thus every branch preserves the logical-reference state, and the complete channel is exact recovery. Theorem thm:B3 then identifies it with $\mathcal{D}$ on the whole accessible input space.

Before the first readout two qubits are live. They are both consumed before the third arrives. Thereafter only one qubit is live. Four early gates, two late basis-change gates, and at most one correction give $G\le 7$. The early readout adds one round to the seven sequential gate rounds. No ancilla or retained quantum record is used.

Let ${\omega }_{\mathcal{D}}$ be the normalized Choi state of $\mathcal{D}$, ordered as output $0$ and input-reference positions $1,2,3$. From (eq:reps),

Set

They commute and $S_1{S}_3=Y_0{X}_1{Y}_2{X}_3$. Partial transpose on position 1 therefore gives

On the simultaneous eigenspace $S_1=-1,S_3=+1$, its eigenvalue is $-1/8$. That eigenspace is nonzero because the two commuting Paulis are independent.

Under Definition def:stream, exact subsystem recovery from the authorized triple requires at least two live laboratory qubits, even with unrestricted classical storage and arbitrary local single-qubit operations. Hence

Proof. Suppose the peak were one. Before the second carrier can be delivered, the first carrier must cease to be a live laboratory qubit. There is no early quantum output, return to the supplier, or other quantum storage. Its only possible continuing influence is therefore a classical record.

The implemented channel consequently has the form

with positive effects $E_h$ on position 1 and subsequent completely positive maps on positions 2 and 3. Its Choi operator is a sum of positive products across input-reference position 1 versus all remaining systems. It is separable across that cut and has positive partial transpose.

Exact recovery on the code would force $\Lambda =\mathcal{D}$ by Theorem thm:B3. Equation (eq:choi) has a negative partial transpose, a contradiction. Theorem thm:streamupper attains peak two.

In the restricted streaming model that retains every delivered carrier coherently until all three have arrived, peak occupancy is at least three. The batch unitary $U$, followed by terminal syndrome readout, attains it.

The adaptive streaming programme and this coherent programme implement the same complete channel $\mathcal{D}$. Their streaming peaks are two and three. For batch access both peaks are three, because the input itself already occupies three qubits.

In the ordered streaming interface, logical $X$-readout and logical $Z$-readout each admit peak one.

The rank-one logical $Z$ Lüders instrument, with its quantum post-measurement output, also admits peak one. None of these programmes is subsystem recovery.

Proof. For $X$, measure the physical observables $Z_1,X_2,Z_3$ sequentially and report the negative of their product. For $Z$, measure $Y_1,Z_2,Y_3$ and report the negative product. Equation (eq:reps) gives the required logical effects. An $X$-measurement uses $H$ before destructive readout; a $Y$-measurement uses $H{S}^{†}$. Each carrier is consumed before the next arrives.

For the logical $Z$ instrument, let the reported logical outcome be $\kappa \in \{0,1\}$. After consuming all boundary carriers, allocate $|0⟩$, apply $X^{\kappa }$, and return it. The resulting selective map has the correct effect and prepares the fixed state $|\kappa ⟩$. For a rank-one projector this is exactly

including its action on an external reference.

Forgetting the outcome instead gives logical $Z$-dephasing, not the identity channel. A logical Bell input detects the lost coherence.

Define the rooted encoders recursively:

There are $5^h$ physical leaves and one root logical qubit. At every node choose child positions $1,2,3$ as accessible and discard positions $4,5$ into the inaccessible complement. The accessible set $A_h$ has

leaves.

For $h=2$, the network has one root tensor and five child tensors, with twenty-five physical leaves. The accessible nine are

This is the small multi-tensor benchmark.

Streaming deliveries use depth-first order: all accessible leaves of child 1, then child 2, then child 3, recursively.

There is an ancilla-free unitary $U_h$ on $A_h$ such that

Every exact recovery channel on $A_h$ is therefore the same channel

whose Choi rank is $2^{n_h-1}$.

Proof. At $h=1$, use (eq:normalform). For the induction, apply the three child unitaries without yet measuring their syndrome factors. Each child outputs its intermediate logical qubit tensored with a maximally mixed syndrome independent of that qubit and every reference. The three intermediate qubits have the root accessible channel ${\mathcal{N}}_A(\rho )$. Apply $U$ to them. The root contributes two further maximally mixed syndrome qubits. All syndrome factors are independent, giving (eq:treenormal).

The faithful-syndrome lemma proves uniqueness. Partial trace over $n_h-1$ qubits has exactly $2^{n_h-1}$ independent Kraus maps, and unitary precomposition does not change this rank.

This proof also establishes correctness when the intermediate logical inputs are entangled with other nodes. No product-input assumption is used.

Let

be the number of decoded nodes in the accessible ternary subtree.

A node may use the batch programme $U$, or the streaming programme of Theorem thm:streamupper. For an internal node:

1. child subprogrammes execute serially in order $1,2,3$;

2. a completed child returns one intermediate quantum qubit to its parent, retained in the same laboratory;

3. a parent may consume its first two intermediate qubits using its early two-input streaming stage;

4. the parent performs its final one-input stage only after child 3 has completed;

5. subprogrammes are not otherwise interleaved, and no intermediate quantum output is exported.

All child syndrome outcomes may be forgotten after their corrections. Parent record bits are retained until the parent correction.

For every $h\ge 1$:

1. batch recovery has optimal peak $3^h$, with no additional workspace, and an explicit implementation with

   $$G=9m_h,D\le 8h;$$

2. the serial streaming module class has optimal peak

   $${Q_{\mathrm{module}}}^{(h)}=h+1,$$

   with an implementation satisfying

   $$G\le 7m_h,D\le 8m_h,C_{\mathrm{cl}}\le 2h;$$

3. both implement the same channel ${\mathcal{D}}_h$.

All programmes consume $n_h-1$ syndrome qubits and return one quantum output.

Proof. For batch input, decode all child nodes at one level in parallel, measure their syndrome factors, and continue upward. There are $m_h$ decoded nodes and $h$ levels. Every node uses nine gates and at most eight rounds. Occupancy decreases after each local syndrome readout and never exceeds the initial $3^h$. The initial batch occupancy proves optimality.

For streaming, let $p_h$ be the peak in the prescribed module class. The base optimum is $p_1=2$ by Theorem thm:B5. Decode child 1, retaining its output. Decode child 2 while retaining that one qubit; this costs at most $p_{h-1}+1$. Perform the parent's early two-qubit stage and consume those two intermediate inputs, retaining only two classical bits. Decode child 3 with no other parent quantum register live. Apply the parent's late stage. Thus

For the matching module lower bound, the first child's quantum output must remain live until the second child has returned its output: neither allowed parent programme consumes a single first input alone. The serial second-child subprogramme requires at least $p_{h-1}$ live qubits on one of its histories. The retained first output is an additional qubit. Therefore $p_h\ge p_{h-1}+1$. This is a lower bound within Definition def:moduleclass, not among all possible decoders.

Every decoded node uses at most seven unitary gates and eight instruction rounds in the serial construction. At most two record bits per ancestor are retained, giving $2h$. Each local recovery is a channel identity on its logical input, including all reference systems, so composition proves recovery. Lemma lem:treenormal identifies both programmes with ${\mathcal{D}}_h$.

For the twenty-five-leaf, nine-accessible-leaf patch:

The batch record bound allows all local syndrome records to be retained; forgetting them earlier can reduce classical storage.

In the streaming model that forbids destruction of any delivered carrier until all $n_h$ have arrived, the optimal peak for ${\mathcal{D}}_h$ is $n_h=3^h$. The adaptive module construction implements that same channel with peak $h+1$.

Proof. The retained-coherent convention forces all input carriers to remain live at the last arrival. The unitary $U_h$ and terminal syndrome readout attain that peak. The adaptive bound is Theorem thm:tree. Channel uniqueness prevents a change of the off-code task.

The unrestricted adaptive streaming optimum for $h>1$ is not determined by the module lower bound.

A declared decomposition is a finite acyclic collection of modules. Module $v$ consumes $i_v$ named input qubits, produces $o_v$ named output qubits, and has a certified local peak $c_v$. Classical dependencies are specified separately. There is no quantum fanout.

For a legal completed-module set $J$ and delivered input prefix $k$, let $F(J,k)$ be the live quantum frontier. Executing an enabled module has laboratory peak at most

and replaces its input names by its output names. A delivery increases the frontier by one.

The least certified frontier bound over all legal schedules of a finite declared decomposition is obtained by the recurrence

with terminal value $\left|F(J,k)\right|$. Here $w$ is the module peak in Definition def:frontier, or $\left|F\right|+1$ for a delivery.

The recurrence is a finite search and proves schedule optimality within that decomposition.

Proof. Each action increases the delivered prefix or completed-module set. There are finitely many states and no cycle in the recurrence. For a fixed first action, the overall bound is the maximum of its local peak and the optimal remaining bound. Minimizing over all legal first actions exhausts all schedules. Backward induction proves the formula.

Memory optimization for multi-step quantum strategies is an established subject; classical memory and global consistency matter Bisio. Our frontier recurrence instead optimizes named-register schedules of a fixed compiled decomposition. It does not identify this restricted quantity with the unrestricted memory cost of a quantum strategy.

Suppose an ideal decoder satisfies

and its implementation satisfies

Then

If a finite implementation is a composition of complete channels ${\Phi }_m\cdots {\Phi }_1$, with corresponding implementations ${\tilde{\Phi }}_j$ and local errors $d_{\diamond }({\tilde{\Phi }}_j,{\Phi }_j)\le {\delta }_j$, then

Proof. CPTP pre- and postcomposition contract the diamond distance. Apply the triangle inequality to

For the second statement, telescope the channel products, replacing one factor at a time. Each intervening channel has diamond norm one. The sum of the resulting bounds is the displayed expression.

For adaptive programmes, include the classical history register in each complete channel. A controlled operation is blockwise on that classical register; a uniform bound over its possible histories bounds the controlled step. No postselected normalization is used.

If

then $d_{\diamond }({\mathrm{Ad}}_{\tilde{U}},{\mathrm{Ad}}_U)\le \eta$. Indeed, expanding $\tilde{U}X{\tilde{U}}^{†}-UX{U}^{†}$ into two terms bounds its trace norm by $2\eta {\Vert X\Vert }_1$, also after tensoring a reference.

For the streaming tree, a uniform elementary-gate error ${\delta }_g$ and destructive single-qubit-readout error ${\delta }_m$ give

An error in the supplied encoding/access channel can be added in the same half-diamond metric.

Approximate-QEC and universal-recovery results motivate possible choices of $\mathcal{D}$ BenyApprox,Cotler. No state-specific recovery guarantee is silently promoted here to a worst-case diamond bound.

Fix an encoding, a collection of target subsystems, an access interface, and an implementation library. Define

This is a region of executable recovery tasks under the specified budget. It is not automatically an entanglement wedge.

Proposition prop:B2 gives monotonicity in budget, error tolerance, and library inclusion.

For the single-block target and authorized triple:

The first statement is a genuine lower bound from Theorem thm:B5, not the failure of one proposed decoder.

For batch access:

For the second equality, destructively consume qubit 4 without reporting its outcome, then apply the triple decoder. The resulting unconditioned channel is the partial trace over 4 followed by $\mathcal{D}$. The initial occupancy proves the lower bound.

The code-theoretic price of a logical algebra concerns the smallest physical support for its representatives PastawskiPreskill. For this block the full logical-qubit price is three. Our execution cost additionally specifies delivery, output, workspace, schedule, and operations. The streaming optimum two therefore does not change the algebraic price or contradict its support bound.

This section is an extension of, not a premise for, the local results.

Alice holds positions $1,2$; Bob holds position $3$, where the logical output is required. They may perform arbitrary local operations. There is no auxiliary shared entanglement, no quantum transfer, and no Bob-to-Alice message. Alice consumes her two input qubits and sends one classical message to Bob. Timing is not a free communication channel.

The streaming programme already gives a distributed decoder: Alice applies $B_{12}$, reads $(t,s)$, and sends those two bits. Bob applies $R_3,C_{ts}$ and returns position 3.

In the stated one-way implementation model, exact recovery requires at least four distinguishable messages, hence at least two fixed-length classical bits. The distributed programme above attains the bound.

Proof. By Theorem thm:B3, any exact code recovery must implement $\mathcal{D}$ on the entire three-qubit input space. A minimum Kraus family is

The four ${\beta }_j$ are an orthonormal basis, and the four $C_j{R}_3$ are nonproportional unitaries.

A one-way protocol has a POVM effect $E_m$ for each message and a Bob channel with Kraus operators $B_{m\ell }$. Diagonalize $E_m={\sum }_r|{\eta }_{mr}⟩⟨{\eta }_{mr}|$. The full channel has product-form Kraus maps

Every such Kraus map lies in the span of the four $K_j$: the Choi operator is a positive sum of its Kraus-vector projectors, so no vector can have a component outside its support.

Expand $⟨\eta |={\sum }_j{a}_j⟨{\beta }_j|$. Membership of a nonzero product map $B⟨\eta |$ in that span requires

for every $j$. If two coefficients $a_j$ were nonzero, two distinct correction unitaries would be proportional, which they are not. Thus each nonzero $\eta$ is supported on one basis vector ${\beta }_j$.

For one fixed message, the same nonzero Bob Kraus operator cannot serve two distinct basis vectors. Hence each nonzero $E_m$ is supported on one ${\beta }_j$. POVM completeness requires all four basis directions. There must therefore be at least four messages. The two-bit construction is complete and correct by Theorem thm:streamupper.

Suppose an identified link has the following operational service: after legal activation, it transmits one classical bit once in its prepared orientation and is then deleted. A latent link activates at most once. An initially active link also has at most one unspent service. No such link transfers a qubit or supplies entanglement.

Let ${\sigma }_{A\mid B}$ count crossing latent and active identifiers, as in En02-A. The number of one-bit services across the cut is at most its initial value: activation converts one unspent latent service into one active service; transmission consumes it; no update adds an identifier.

In the one-way model of Theorem thm:communication, if each crossing link supplies only the one-bit service above and ${\sigma }_{A\mid B}(g_0)<2$, exact recovery is impossible.

Proof. The grammar permits fewer than two transmitted bits, while Theorem thm:communication requires at least two.

An unpriced identified edge would not support this corollary. The statement depends on the service, orientation, consumption, and communication conventions. It is not a gravitational causal or Noether identity.

The preceding proofs use specified Born readout and its projective residuals. They do not solve En02-A's unrestricted finite-capacity measurement-uniqueness problem.

A sufficient conditional transfer can nevertheless be stated.

Purify the complete finite decoder experiment, including undelivered carriers, inaccessible boundary systems, and its reference. Suppose it is represented inside En02-A's global structural class at capacity $N_{\mathrm{glob}}$, with its admissibility requirements and global diagonal faithfulness.

If every actual readout of $s$ qubits, on a global configuration of $g$ live qubits, satisfies

then the decoder's histories and quantum outputs agree with the specified Born programme.

Proof. En02-A's global diagonal-faithfulness theorem identifies all outcome laws. Its continuation-record corollary identifies positive projective residual rays whenever the displayed record budget fits. Apply these statements at each actual readout. Gates and allocations already have the specified meanings. Induction over the finite instruction tree gives the same branch weights and residuals as the Born execution. Zero branches contribute nothing.

The count $N_{\mathrm{glob}}$ is not the local decoder peak. For example, a Bell-purified single-block input has six global qubits before decoding: five physical code qubits and one reference. A two-qubit record comparison can require eight global slots even when the streaming laboratory peak is two. Arbitrary larger references require their own global accounting.

The mathematical proofs are in the main text. The appendix supplies exact finite checks of selected certificates and a complete finite search of one specified schedule class. Neither its success nor its failure certifies statements outside that scope.

1. Unauthorized recovery. For two-qubit access, the channel is constant and its best logical half-diamond error is $3/4$.

2. Uncounted workspace. A module's local peak must be added to the unaffected frontier. Counting only its returned output omits its live input or ancilla.

3. Premature destructive readout. Measuring $Z_1$ before applying the batch decoder removes the logical $Z$ and $Y$ components because their representatives anticommute with $Z_1$. Logical $X$ survives. The induced logical channel is $X$-dephasing, not recovery.

4. Readout substituted for quantum recovery. The programme of Proposition prop:observable correctly realizes a logical measurement instrument. Its unreported logical output is dephased and fails the identity task on a Bell input.

5. Hidden postselection. Keeping one syndrome branch retains probability $1/4$. Its selective logical map is $\rho \mapsto \rho /4$, not a trace-preserving decoder. Renormalization does not make it deterministic.

6. Off-code rank used as an intrinsic obstruction. Example ex:offcode gives correct restricted decoders with different Choi ranks. Only the faithful-syndrome uniqueness theorem justifies an intrinsic rank claim in our benchmark.

For $h>1$, determine the minimum peak among all exact streaming programmes for ${\mathcal{D}}_h$, allowing interleavings outside Definition def:moduleclass. The module optimum $h+1$ is an upper bound for this larger class, not its proved lower bound.

For an explicitly embedded multi-tensor network and a local, precision-limited gate library, determine gate, depth, communication, and memory trade-offs with a certified diamond-error target. The all-to-all Clifford results do not solve this problem.

This paper does not identify an entanglement wedge, derive spacetime, model black-hole evaporation, or prove a universal gravitational memory bound. No field-theoretic insertion or symmetry status in another manuscript is changed. In particular, no closing of O.1, restoration of bulk symmetry, release of a frozen insertion, or opening of XV-B is claimed.

The gate translations here are mathematical programme constructions. No external package compilation, laboratory implementation, local LaTeX compilation, or formal proof-checker execution is asserted. A finite test is evidence for its stated finite assertion, not a certificate of a larger quantified claim.

Copy the following standard-library Python source to 02_b_checks.py and run:

python en02_b_checks.py

The code uses Gaussian integers, represented by pairs of integers. Hadamards are applied without their $1/\sqrt{2}$ factors, and those factors are accounted for explicitly in the checked norms. There is no floating-point state simulation.

The checks cover the supplied code projector, all physical Pauli operators of weight at most two, the batch and streaming branch factorizations, and a finite two-level schedule class. The tree channel theorem itself follows by composition in the main text; no dense twenty-five-qubit simulation is needed or claimed.

"""En02-B: exact finite checks, not a universal proof certificate.

Standard library only. Gaussian integers are pairs (real, imag). No execution log is supplied by the manuscript. """

from itertools import combinations, product from functools import lru_cache from dataclasses import dataclass

class CheckFailure(Exception): pass

def need(condition, message): if not condition: raise CheckFailure(message)

ZERO = (0, 0) ONE = (1, 0) II = (0, 1)

def add(a, b): return (a[0] + b[0], a[1] + b[1])

def neg(a): return (-a[0], -a[1])

def mul(a, b): return (a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0])

def conj(a): return (a[0], -a[1])

def norm_sq(a): return a[0] * a[0] + a[1] * a[1]

def inner(v, w): out = ZERO for a, b in zip(v, w): out = add(out, mul(conj(a), b)) return out

def vadd(v, w): return [add(a, b) for a, b in zip(v, w)]

def bits(index, n): return tuple((index >> (n - 1 - j)) & 1 for j in range(n))

def index_of(bs): out = 0 for b in bs: out = 2 * out + b return out

def nqubits(v): size = len(v) need(size >= 1 and (size & (size - 1)) == 0, "state size is not a power of two") return size.bit_length() - 1

def pauli_action(v, word, phase=0): """Apply i**phase times a Pauli word exactly.""" n = nqubits(v) need(len(word) == n, "wrong Pauli arity") units = (ONE, II, (-1, 0), (0, -1)) out = [ZERO] * len(v) for k, amp in enumerate(v): bs = list(bits(k, n)) factor = units[phase for j, letter in enumerate(word): b = bs[j] if letter == "X": bs[j] ^= 1 elif letter == "Z": if b: factor = neg(factor) elif letter == "Y": factor = mul(factor, II if b == 0 else (0, -1)) bs[j] ^= 1 elif letter != "I": raise CheckFailure("invalid Pauli letter") target = index_of(bs) out[target] = add(out[target], mul(factor, amp)) return out

LOCAL_PRODUCT = ("X", "Y"): (1, "Z"), ("Y", "Z"): (1, "X"), ("Z", "X"): (1, "Y"), ("Y", "X"): (3, "Z"), ("Z", "Y"): (3, "X"), ("X", "Z"): (3, "Y"),

def multiply_paulis(a, b): pa, wa = a pb, wb = b need(len(wa) == len(wb), "Pauli lengths differ") phase = (pa + pb) word = [] for x, y in zip(wa, wb): if x == "I": word.append(y) elif y == "I": word.append(x) elif x == y: word.append("I") else: p, z = LOCAL_PRODUCT[x, y] phase = (phase + p) word.append(z) return phase, "".join(word)

GENERATORS = ("XZZXI", "IXZZX", "XIXZZ", "ZXIXZ")

def stabilizer_group(): out = [] for selected in product((0, 1), repeat=4): p = (0, "IIIII") for use, word in zip(selected, GENERATORS): if use: p = multiply_paulis(p, (0, word)) out.append(p) need(len(set(out)) == 16, "stabilizers are dependent") need((2, "IIIII") not in out, "minus identity is a stabilizer") for phase, word in out: need(phase in (0, 2), "stabilizer is not Hermitian") if word != "IIIII": need(sum(x != "I" for x in word) == 4, "nonidentity stabilizer is not weight four") return tuple(out)

def encoded_integer_vectors(): """True code vectors are these Gaussian-integer vectors / 4.""" v = [ZERO] * 32 v[0] = ONE for g in GENERATORS: v = vadd(v, pauli_action(v, g)) w = pauli_action(v, "XXXXX") need(inner(v, v) == (16, 0), "wrong code-zero norm") need(inner(w, w) == (16, 0), "wrong code-one norm") need(inner(v, w) == ZERO, "codewords not orthogonal") need(pauli_action(v, "ZZZZZ") == v, "wrong logical Z zero") need(pauli_action(w, "ZZZZZ") == [neg(x) for x in w], "wrong logical Z one") for g in GENERATORS: need(pauli_action(v, g) == v, "zero not stabilized") need(pauli_action(w, g) == w, "one not stabilized") return v, w

def apply_gate(v, gate): """H is unnormalized: the omitted factor is 1/sqrt(2).""" n = nqubits(v) kind = gate[0] if kind in ("X", "Y", "Z"): q = gate[1] word = ["I"] * n word[q] = kind return pauli_action(v, "".join(word))

out = [ZERO] * len(v) if kind == "H": q = gate[1] for k, amp in enumerate(v): bs = list(bits(k, n)) old = bs[q] for new in (0, 1): bs[q] = new term = neg(amp) if old == 1 and new == 1 else amp target = index_of(bs) out[target] = add(out[target], term) return out

if kind == "SD": q = gate[1] for k, amp in enumerate(v): out[k] = mul(amp, (0, -1)) if bits(k, n)[q] else amp return out

if kind in ("CX", "CZ"): q, r = gate[1], gate[2] for k, amp in enumerate(v): bs = list(bits(k, n)) if kind == "CX": if bs[q]: bs[r] ^= 1 out[index_of(bs)] = amp else: out[k] = neg(amp) if bs[q] and bs[r] else amp return out

raise CheckFailure("unknown gate")

def apply_circuit(v, gates): out = list(v) h_count = 0 for gate in gates: out = apply_gate(out, gate) h_count += gate[0] == "H" return out, h_count

BATCH = ( ("CZ", 0, 1), ("CZ", 1, 2), ("SD", 0), ("SD", 2), ("H", 0), ("H", 2), ("CX", 0, 1), ("CX", 2, 1), ("Y", 1), )

EARLY = ( ("H", 1), ("CX", 0, 1), ("SD", 0), ("H", 0), )

def select_coordinates(v, fixed, survivors): """Unnormalized bra projection and factor deletion.""" n = nqubits(v) need(set(fixed).isdisjoint(survivors), "fixed and surviving positions overlap") need(set(fixed) | set(survivors) == set(range(n)), "coordinates are not completely accounted for") out = [ZERO] * (1 << len(survivors)) for k, amp in enumerate(v): bs = bits(k, n) if all(bs[j] == b for j, b in fixed.items()): out[index_of(tuple(bs[j] for j in survivors))] = amp return out

def check_low_weight_privacy(code): v0, v1 = code for weight in (1, 2): for sites in combinations(range(5), weight): for letters in product("XYZ", repeat=weight): word = ["I"] * 5 for q, letter in zip(sites, letters): word[q] = letter images = [pauli_action(v, "".join(word)) for v in code] for i in (0, 1): for j in (0, 1): need(inner(code[i], images[j]) == ZERO, "low-weight logical compression is nonzero")

def check_batch_certificate(code): decoded = [] for v in code: out, h_count = apply_circuit(v, BATCH) need(h_count == 2, "batch Hadamard count changed") decoded.append(out)

chi0 = select_coordinates(decoded[0], 1: 0, (0, 2, 3, 4)) chi1 = select_coordinates(decoded[1], 1: 1, (0, 2, 3, 4)) wrong0 = select_coordinates(decoded[0], 1: 1, (0, 2, 3, 4)) wrong1 = select_coordinates(decoded[1], 1: 0, (0, 2, 3, 4))

need(all(x == ZERO for x in wrong0 + wrong1), "batch decoder mixes logical basis values") need(chi0 == chi1, "batch decoder loses logical coherence") # True chi is chi0 / (4 * sqrt(2)**2) = chi0 / 8. need(inner(chi0, chi0) == (64, 0), "wrong decoded norm")

# Syndrome positions are the first two coordinates of chi. for f in range(4): for g in range(4): value = ZERO for e in range(4): value = add(value, mul(chi0[4 * f + e], conj(chi0[4 * g + e]))) expected = (16, 0) if f == g else ZERO need(value == expected, "syndrome is not I_4/4")

# A single syndrome branch has probability 16/64 = 1/4. need(sum(norm_sq(x) for x in chi0[:4]) == 16, "postselection probability certificate failed")

def check_stream_certificate(code): early = [apply_circuit(v, EARLY) for v in code] need(all(h == 2 for _, h in early), "early H count changed")

for t, s in product((0, 1), repeat=2): branch_vectors = [] for raw, _ in early: # Remaining order: physical 3, physical 4, physical 5. branch = select_coordinates(raw, 0: t, 1: s, (2, 3, 4)) branch, late_h = apply_circuit( branch, (("SD", 0), ("H", 0)) ) need(late_h == 1, "late H count changed") # Apply Z^(1-s), then X^(1-t). # This equals the manuscript's product up to branch phase. if 1 - s: branch = apply_gate(branch, ("Z", 0)) if 1 - t: branch = apply_gate(branch, ("X", 0)) branch_vectors.append(branch)

c0 = select_coordinates(branch_vectors[0], 0: 0, (1, 2)) c1 = select_coordinates(branch_vectors[1], 0: 1, (1, 2)) w0 = select_coordinates(branch_vectors[0], 0: 1, (1, 2)) w1 = select_coordinates(branch_vectors[1], 0: 0, (1, 2)) need(all(x == ZERO for x in w0 + w1), "streaming branch has wrong logical output") need(c0 == c1, "streaming branch loses coherence")

# True branch vector is raw / (4 * sqrt(2)**3). # Squared denominator is 16 * 8 = 128. need(inner(c0, c0) == (32, 0), "streaming branch probability is not 1/4")

def check_npt_symbolic_certificate(): # Ordered as output 0, input-reference 1,2,3. S1 = (2, "XZXZ") S3 = (2, "ZYZY") S2 = (0, "YXYX") need(multiply_paulis(S1, S3) == S2, "Choi stabilizer product is wrong") need(multiply_paulis(S3, S1) == S2, "Choi stabilizers do not commute") need(S1[1][1] == "Z" and S2[1][1] == "X" and S3[1][1] == "Y", "partial-transpose signs changed") # PT on input-reference position 1 changes only S3's sign. numerator = 1 + (-1) + (-1) * (+1) - (+1) need(numerator == -2, "negative eigenvalue certificate failed") # Eigenvalue = -2/16 = -1/8.

@dataclass(frozen=True) class Module: name: str inputs: frozenset outputs: frozenset depends: frozenset peak: int