%=====================================================================
% En02-E.tex
%
% Version 2: correctness, archival, and acceptance-policy revision.
%
% Self-contained source for pdfLaTeX.
%
% Build:
%   pdflatex -interaction=nonstopmode -halt-on-error En02-E.tex
%   pdflatex -interaction=nonstopmode -halt-on-error En02-E.tex
%
% No external bibliography, figures, generated data, or shell escape
% are required. The Python listing is not a compilation dependency.
%
% EVIDENCE BOUNDARY
% The analytical arguments and the unexecuted implementation are
% distinguished throughout. No Python, SDP, or pdfLaTeX execution;
% numerical dataset; passing archive; or formal certificate is claimed.
%=====================================================================

\documentclass[11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[margin=1in]{geometry}
\usepackage{microtype}
\usepackage{amsmath,amssymb,amsthm,mathtools}
\usepackage{array,booktabs,longtable}
\usepackage{enumitem}
\usepackage{fvextra}
\usepackage[hidelinks]{hyperref}

\hypersetup{
  pdftitle={From Schwarzschild Radiation to Finite Recovery Channels},
  pdfauthor={Ngo Cheung},
  pdfsubject={Selected Gaussian radiation states, finite occupation
              cutoffs, scattering errors, and calibrated recovery}
}

\setcounter{secnumdepth}{3}
\setcounter{tocdepth}{2}
\numberwithin{equation}{section}
\allowdisplaybreaks
\setlength{\emergencystretch}{3em}
\setlength{\parskip}{0.15em}

\theoremstyle{plain}
\newtheorem{theorem}{Theorem}[section]
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{proposition}[theorem]{Proposition}
\newtheorem{corollary}[theorem]{Corollary}

\theoremstyle{definition}
\newtheorem{definition}[theorem]{Definition}
\newtheorem{assumption}[theorem]{Assumption}

\theoremstyle{remark}
\newtheorem{remark}[theorem]{Remark}
\newtheorem{example}[theorem]{Example}

\DefineVerbatimEnvironment{CodeBlock}{Verbatim}{
  fontsize=\scriptsize,
  breaklines=true,
  breakanywhere=true,
  frame=single,
  framesep=3mm,
  numbers=left,
  numbersep=6pt
}
\DefineVerbatimEnvironment{ShellBlock}{Verbatim}{
  fontsize=\small,
  breaklines=true,
  breakanywhere=true,
  frame=single,
  framesep=3mm
}

\newcommand{\ket}[1]{\lvert #1\rangle}
\newcommand{\bra}[1]{\langle #1\rvert}
\newcommand{\ketbra}[2]{\lvert #1\rangle\!\langle #2\rvert}
\newcommand{\norm}[1]{\left\lVert #1\right\rVert}
\newcommand{\abs}[1]{\left\lvert #1\right\rvert}
\newcommand{\ceil}[1]{\left\lceil #1\right\rceil}
\newcommand{\code}[1]{\texttt{\detokenize{#1}}}
\newcommand{\HH}{\mathcal H}
\newcommand{\FF}{\mathcal F}
\newcommand{\id}{\mathrm{id}}
\newcommand{\ii}{\mathrm i}
\newcommand{\dd}{\,\mathrm d}
\newcommand{\vac}{\mathrm{vac}}
\newcommand{\fail}{\perp}
\newcommand{\dist}{d_{\mathrm{tr}}}
\newcommand{\ddiam}{d_\diamond}
\newcommand{\Qpeak}{Q_{\mathrm{peak}}}
\newcommand{\epsIT}{\varepsilon_{\mathrm{IT}}}
\newcommand{\epsop}{\varepsilon_{\mathrm{op}}}
\newcommand{\Tdep}{\mathcal T}
\newcommand{\CX}[2]{\mathrm{CX}_{#1\to #2}}
\newcommand{\CZ}[2]{\mathrm{CZ}_{#1,#2}}
\newcommand{\Ch}{\mathsf J}
\newcommand{\rh}{r_{\mathrm h}}
\newcommand{\nH}{n_{\mathrm H}}
\newcommand{\qout}{q_{\mathrm{out}}}
\newcommand{\Pcut}{P_N}
\newcommand{\Qcut}{Q_N}
\newcommand{\tail}{t_N}
\newcommand{\bGamma}{\Gamma_{\mathrm s}}
\newcommand{\bdGamma}{\mathrm d\Gamma_{\mathrm s}}

\DeclareMathOperator{\tr}{tr}
\DeclareMathOperator{\Tr}{Tr}
\DeclareMathOperator{\Ad}{Ad}
\DeclareMathOperator{\Span}{span}
\DeclareMathOperator{\diag}{diag}
\DeclareMathOperator{\per}{per}

\title{\textbf{En02-E}\\[1mm]
\textbf{From Schwarzschild Radiation to Finite Recovery Channels}\\[2mm]
\large Selected packet states, controlled truncation,
and nonvacuum-calibrated memory benchmarks}

\author{Ngo Cheung\\
Independent Researcher\\
Hong Kong SAR, China\\
\texttt{info@cheungngomedical.com}}

\date{Version 2 --- 8 October 2026}

\begin{document}

\maketitle

\begin{abstract}
We construct a controlled finite representation of selected radiation
modes in a specified stationary Schwarzschild free-field model.
A finite orthonormal packet family has a normal, zero-mean,
gauge-invariant Gaussian state determined by its full packet covariance.
We retain complex off-diagonal correlations, derive its thermal
normal-mode representation and occupation generating function, and
construct a deterministic flagged total-occupation cutoff.
For this state, the cutoff trace-distance error is exactly the
discarded probability.

We prove covariance-to-state continuity, reference-compatible cutoff
bounds for general inputs, bandwidth-dependent energy estimates,
and occupation-dependent scattering-channel bounds that retain
complex amplitudes. A common ancillary interface supplies a precise
condition under which a state approximation controls an encoded
channel. Separately, a declared Clifford message channel is calibrated
by the selected state's nonvacuum probability. Its unrestricted and
atomic-delivery memory-limited recovery errors are evaluated exactly.
This benchmark transfers one field statistic; its decoder does not
access the selected field state's full correlations.

The implementation appendix specifies phase-sensitive covariance
regressions, complete decoder extensions, basis dictionaries,
event-wise resource ledgers, radial boundary bounds, and
failure-preserving SDP residual checks. It is not reported as executed.
The analytical results concern selected stationary radiation states
and explicitly declared finite channels, not collapse, backreaction,
complete evaporation, or a microscopic Hawking information-release
mechanism.
\end{abstract}

\tableofcontents

%=====================================================================
\section{Scope, dependencies, and evidence}
\label{sec:scope}
%=====================================================================

The construction separates the following objects:
\[
\begin{gathered}
\text{specified field state}
\longrightarrow
\text{selected packet state}
\longrightarrow
\text{finite flagged representation},\\
\text{declared encoding interface}
\longrightarrow
\text{message channel}
\longrightarrow
\text{complete recovery protocol}.
\end{gathered}
A field state does not determine the second line.
Connections between the lines are proved only for explicitly stated
interfaces.

\paragraph{Route A.}
We construct and approximate the full selected radiation state,
including multiparticle occupation and packet correlations.

\paragraph{Route B.}
We transfer its vacuum/nonvacuum probability to an independently
specified logical benchmark. This is a nonvacuum-calibrated recovery
model, not a derived microscopic evaporation channel.

The stationary field formulation is the one specified in the supplied
Em03-A manuscript \cite{Em03A}, with the external Unruh-state
construction retained \cite{DMP}. The operational benchmark is a
specialization of the supplied En02-D model \cite{En02D}; its needed
claims are proved here.

\begin{center}
\renewcommand{\arraystretch}{1.13}
\begin{tabular}{@{}p{0.26\textwidth}p{0.27\textwidth}p{0.38\textwidth}@{}}
\toprule
Ingredient & Dependency & Status in this paper\\
\midrule
Stationary boundary covariance
& Em03-A; standard Hawking model
& Explicitly stated analytical input\\
Bulk state identification
& Dappiaggi--Moretti--Pinamonti
& External construction and Hadamard theorem\\
Radial scattering
& Specified Schwarzschild ODE
& Flux-normalized construction; approximation bounds\\
Selected density operator
& Quasifree field restriction
& Proved finite-mode representation\\
Occupation cutoff
& This paper
& Deterministic CPTP map and explicit errors\\
Message encoding and core
& Operational specification
& Additional model inputs\\
Recovery performance
& Specified channel and interface
& Analytical optima; numerical checks unexecuted\\
\bottomrule
\end{tabular}
\end{center}

\paragraph{Evidence status.}
No Python, solver, or pdfLaTeX execution is asserted.
The numerical appendix is an implementation specification, not a
results section. Analytical examples are explicitly identified.
An executed incorporation study requires actual archived runs and
inspection of their numerical and compilation records.

We use \(c=\hbar=k_B=1\), \(G>0\), and base-two entropy.
For states and channels,
\[
\dist(\rho,\sigma)=\frac12\norm{\rho-\sigma}_1,\qquad
\ddiam(\Phi,\Psi)=\frac12\norm{\Phi-\Psi}_\diamond.
\]
Channel comparisons include arbitrary references.
Matrix \(\norm{\cdot}_\infty\) denotes operator norm and
\(\norm{\cdot}_{\mathrm F}\) denotes Frobenius norm.

%=====================================================================
\section{Specified stationary radiation model}
\label{sec:field}
%=====================================================================

Fix \(M_*>0\), \(\rh=2GM_*\), and one real angular harmonic of
degree \(\ell\). The exterior metric and tortoise coordinate are
\[
\mathrm g=-F(r)\dd t^2+F(r)^{-1}\dd r^2+r^2\dd\Omega^2,
\quad
F(r)=1-\frac{\rh}{r},
\quad
x=r+\rh\log(r/\rh-1).
\]
The Killing field \(\partial_t\) is normalized at infinity.
For the massless minimally coupled scalar, the radial equation is
\begin{equation}
q''(x)+\bigl(\omega^2-V_\ell(x)\bigr)q(x)=0,\qquad
V_\ell(x)=F(r(x))
\left(\frac{\ell(\ell+1)}{r(x)^2}+\frac{\rh}{r(x)^3}\right).
\label{eq:radial}
\end{equation}
Surface gravity and inverse horizon temperature are
\[
\kappa=\frac12F'(\rh)=\frac1{2\rh},\qquad
\beta=\frac{2\pi}{\kappa}=8\pi GM_*.
\]

The state is the quasifree product prescription with the affine
vacuum on the complete past horizon and the Killing-frequency
vacuum on past null infinity. On the exterior half-horizon,
\[
u=t-x,\qquad U=-\kappa^{-1}e^{-\kappa u}.
\]
The bulk-to-boundary construction and the Hadamard property on the
stated Schwarzschild domain are external inputs \cite{DMP}.
They are not a finite-core construction.

\subsection{Normalization and outgoing covariance}

The current convention is
\[
j(u)=-\ii\int_0^\infty\sqrt{\frac{\omega}{4\pi}}
\left(a(\omega)e^{-\ii\omega u}
-a(\omega)^\dagger e^{\ii\omega u}\right)\dd\omega,
\quad
[a(\omega),a(\omega')^\dagger]=\delta(\omega-\omega').
\]
The affine vacuum current covariance pulls back to
\[
C_\kappa(s)=-\frac{\kappa^2}{16\pi}
\operatorname{csch}^2\!\left(\frac{\kappa(s-\ii0)}2\right),
\qquad
\widehat C_\kappa(\nu)=\frac{\nu}{2(1-e^{-\beta\nu})}.
\]
These are the stationary boundary identities imported from Em03-A.
The positive- and negative-frequency current coefficients are
\(\omega(1+\nH)/(4\pi)\) and \(\omega\nH/(4\pi)\), respectively;
Fourier transformation contributes \(2\pi\). Hence
\[
\nH(\omega)=\frac1{e^{\beta\omega}-1}.
\]
In particular, a normalized packet covariance has no extra
\(1/(2\pi)\) factor.

Let \(S_\ell(\omega)\) be the unitary, flux-normalized two-channel
scattering matrix of \eqref{eq:radial}. Write its
horizon-to-infinity transmission amplitude as \(\tau_\ell\), and
put \(\Gamma_\ell=|\tau_\ell|^2\). For \(\omega>0\),
\(0<\Gamma_\ell\le1\). The outgoing annihilator is
\[
a_{\rm out}(\omega)=
\tau_\ell(\omega)a_{\rm H}(\omega)
+\rho_{{\rm I},\ell}(\omega)a_{\rm I}(\omega).
\]
The incoming channels are independent and have zero means.
Their number covariances give
\begin{equation}
\begin{split}
\langle a_{\rm out}(\omega)^\dagger a_{\rm out}(\omega')\rangle
&=\qout(\omega)\delta(\omega-\omega'),\\
\qout(\omega)&=\frac{\Gamma_\ell(\omega)}{e^{\beta\omega}-1},\\
\langle a_{\rm out}(\omega)a_{\rm out}(\omega')\rangle&=0.
\end{split}
\label{eq:outcov}
\end{equation}
Quasifreeness is part of the input. Number covariance alone would
not determine a general non-Gaussian state.

The associated time--frequency mode-window convention is
\[
\mathcal N_{B,T}=\frac{T}{2\pi}\int_B\qout(\omega)\dd\omega.
\]
It is distinct from a normalized packet occupation and from a
specified detector instrument.

Hawking's fixed-background calculation motivates this model
\cite{Hawking}. A collapse scaling-limit analysis
\cite{FredenhagenHaag}, renormalized backreaction
\cite{HollandsWald}, and a dynamical mass-loss model are separate
programmes.

%=====================================================================
\section{The complete finite packet state}
\label{sec:packets}
%=====================================================================

Fix \(B=[\omega_-,\omega_+]\subset(0,\infty)\) and an orthonormal
family \(h_1,\ldots,h_J\in L^2(B,\dd\omega)\). Define
\[
b_i=a_{\rm out}(h_i)
=\int_B\overline{h_i(\omega)}a_{\rm out}(\omega)\dd\omega.
\]
Bounded covariance on \(B\) extends the smooth-test formulas to these
\(L^2\) packets.

We distinguish
\begin{align}
C_{ij}&=\langle b_i^\dagger b_j\rangle
=\int_B h_i\overline{h_j}\qout\,\dd\omega,\\
K_{ij}&=C_{ji}
=\int_B\overline{h_i}h_j\qout\,\dd\omega.
\label{eq:K}
\end{align}
Thus \(K=C^{\mathsf T}\). We use \(K\) as the ordinary
one-particle operator matrix.
Put
\[
\mu=\tr K,\qquad q_{\max}=\sup_B\qout<\infty;
\quad 0\preceq K\preceq q_{\max}I_J.
\]

\begin{theorem}[Finite-packet restriction]
\label{thm:gaussian}
The selected packet algebra has a unique normal, zero-mean,
gauge-invariant Gaussian state \(\rho_K\) on
\(\FF(\mathbb C^J)\). Its number covariance is \(K^{\mathsf T}\)
and its anomalous covariance vanishes.

If \(K=W\diag(\lambda_a)W^\dagger\) and
\(z_a=\lambda_a/(1+\lambda_a)\), then
\begin{equation}
\rho_K=\mathcal U_W
\left[\bigotimes_{a=1}^J
(1-z_a)\sum_{n=0}^\infty z_a^n\ketbra n n\right]
\mathcal U_W^\dagger,
\label{eq:thermalmodes}
\end{equation}
where \(\mathcal U_W\ket\alpha=\ket{W\alpha}\).
Equivalently,
\begin{equation}
\rho_K=\det(I+K)^{-1}\bGamma\bigl(K(I+K)^{-1}\bigr),
\label{eq:density}
\end{equation}
where \(\bGamma(T)=\bigoplus_{n\ge0}T^{\otimes_{\rm s}n}\)
is bosonic second quantization. The state commutes with
\(N_{\rm tot}=\sum_i b_i^\dagger b_i\), but need not factor in
the declared packet basis.
\end{theorem}

\begin{proof}
The restricted quasifree characteristic function is
\[
\langle D(\xi)\rangle
=\exp[-\xi^\dagger(K+I/2)\xi],
\quad
D(\xi)=\exp\left(\sum_i\xi_i b_i^\dagger-\overline{\xi_i}b_i\right).
\]
The transpose in \eqref{eq:K} follows directly by expanding the
second moment.

For \(c=W^\dagger b\),
\[
\langle c_a^\dagger c_b\rangle
=(W^{\mathsf T}C\overline W)_{ab}
=\lambda_a\delta_{ab}.
\]
A geometric oscillator density with parameter \(z_a\) has the
required Gaussian characteristic function and mean \(\lambda_a\).
Its trace is one, including the vacuum case \(\lambda_a=0\).
The product and passive rotation therefore yield the restricted
characteristic function. Uniqueness of finite-mode Weyl
characteristic functions identifies the state.

In the eigenbasis, \(\bGamma(\diag z_a)\) has eigenvalues
\(\prod_a z_a^{n_a}\), and trace
\(\prod_a(1-z_a)^{-1}=\det(I+K)\).
This proves \eqref{eq:density}. Passive transformations preserve
total number.
\end{proof}

These formulas are finite-mode Gaussian normal-mode methods
\cite{Weedbrook,Caruso}, with conventions fixed by the proof.

\begin{corollary}[Statistics and generating-function domain]
\label{cor:stats}
The vacuum probability, total-number moments, and entropy are
\[
p_0=\det(I+K)^{-1},\quad
\mathbb EN_{\rm tot}=\mu,\quad
\operatorname{Var}N_{\rm tot}=\mu+\tr K^2,\quad
S(\rho_K)=\sum_a g(\lambda_a),
\]
where
\(g(x)=(x+1)\log_2(x+1)-x\log_2x\), \(g(0)=0\).

If \(\lambda_{\max}>0\), then the absolutely convergent
probability-generating function is
\begin{equation}
G_K(s)=\mathbb E s^{N_{\rm tot}}
=\prod_a[1+\lambda_a(1-s)]^{-1},
\qquad |s|<1+\lambda_{\max}^{-1}.
\label{eq:pgf}
\end{equation}
Here \(s\) may be complex and \(0^0=1\).
If \(K=0\), \(G_K(s)=1\) for every \(s\).
Positivity of rational denominators alone is not a convergence
criterion for negative \(s\).
\end{corollary}

\begin{proof}
For each nonvacuum normal mode the geometric series converges
absolutely precisely when \(|sz_a|<1\). Multiplying finitely
many such series gives \eqref{eq:pgf}. Their elementary moments
and entropy give the remaining formulas.
\end{proof}

\subsection{Covariance-to-state continuity}

\begin{theorem}[Gaussian continuity]
\label{thm:continuity}
For positive semidefinite \(K,L\in\mathbb C^{J\times J}\),
\[
\dist(\rho_K,\rho_L)
\le\min\left\{1,\norm{\sqrt K-\sqrt L}_{\mathrm F},
                    \sqrt{J\norm{K-L}_\infty}\right\}.
\]
If \(K,L\succeq mI\), \(m>0\), then also
\[
\dist(\rho_K,\rho_L)\le
\frac{\norm{K-L}_{\mathrm F}}{2\sqrt m}.
\]
\end{theorem}

\begin{proof}
Let \(Z\) be a standard circular complex Gaussian vector.
The coherent-state mixtures with amplitudes \(\sqrt KZ\) and
\(\sqrt LZ\) have the characteristic functions of \(\rho_K\)
and \(\rho_L\); degenerate Gaussian measures cover singular
matrices. Since
\[
\dist(\ketbra\alpha\alpha,\ketbra\gamma\gamma)
=\sqrt{1-e^{-\norm{\alpha-\gamma}^2}}
\le\norm{\alpha-\gamma},
\]
convexity and Cauchy--Schwarz give the Frobenius bound.

Set \(\delta=\norm{K-L}_\infty\).
Operator monotonicity of the square root gives
\[
\sqrt K\preceq\sqrt{L+\delta I}\preceq\sqrt L+\sqrt\delta I,
\]
and the reverse inequality follows by interchanging \(K,L\).
Thus
\(\norm{\sqrt K-\sqrt L}_\infty\le\sqrt\delta\).

For strictly positive matrices, \(X=\sqrt K-\sqrt L\) solves
\(\sqrt KX+X\sqrt L=K-L\), and
\[
X=\int_0^\infty e^{-t\sqrt K}(K-L)e^{-t\sqrt L}\dd t.
\]
The integral's Frobenius norm is bounded by
\(\norm{K-L}_{\mathrm F}/(2\sqrt m)\).
\end{proof}

Replacing \(K\) by \(\diag K\) therefore requires an error budget:
\[
\dist(\rho_K,\rho_{\diag K})
\le\min\{1,\sqrt{J\norm{K-\diag K}_\infty}\}.
\]
Disjoint frequency supports make \(K\) diagonal.
Temporal translations of overlapping packets generally do not.

\subsection{Exact selection versus continuum approximation}

Let \(E=\Span\{h_i\}\), with projector \(P_E\).
Theorem~\ref{thm:gaussian} is an exact restriction, not a state
approximation to all outgoing modes.

For a normalized target \(g\in L^2(B)\), set
\(e=\norm{(I-P_E)g}\). With \(Q\) multiplication by \(\qout\),
expansion into selected and unselected parts gives
\begin{equation}
|\langle g,Qg\rangle-\langle P_Eg,QP_Eg\rangle|
\le q_{\max}(2e+e^2).
\label{eq:subspace}
\end{equation}
This controls the named occupation observable, not a global
continuum-state distance.

%=====================================================================
\section{Deterministic flagged Fock approximation}
\label{sec:cutoff}
%=====================================================================

For integer \(N\ge0\), let
\[
\Pcut=\mathbf1_{\{N_{\rm tot}\le N\}},\quad
\Qcut=I-\Pcut,\quad
d_N=\binom{J+N}{N}.
\]
The finite physical representation is
\[
\HH_N=\Pcut\FF(\mathbb C^J)\oplus\mathbb C\ket\fail,
\quad d_{\rm physical}=d_N+1,\quad
q_{\rm raw}=\ceil{\log_2(d_N+1)}.
\]

\begin{theorem}[Flagged cutoff and exact Gaussian error]
\label{thm:cutoff}
The map
\[
\mathcal E_N(X)=\Pcut X\Pcut+\tr(\Qcut X)\ketbra\fail\fail
\]
is deterministic and CPTP. Put
\[
\rho_{K,N}=\mathcal E_N(\rho_K),\qquad
\tail(K)=\tr(\Qcut\rho_K).
\]
In the common space
\(\FF(\mathbb C^J)\oplus\mathbb C\ket\fail\),
\[
\dist(\rho_K\oplus0,\rho_{K,N})=\tail(K).
\]
The retained block is unnormalized; the failure flag carries its
actual probability.
\end{theorem}

\begin{proof}
The low-block Kraus map is \(\Pcut\) followed by inclusion.
For a high-block orthonormal basis \(e_\alpha\), add Kraus maps
\(\ket\fail\bra{e_\alpha}\). Their effects sum strongly to \(I\).

The number of occupation vectors with total at most \(N\) is
\(\sum_{n=0}^N\binom{J+n-1}{n}=\binom{J+N}{N}\).
Since \([\rho_K,N_{\rm tot}]=0\), no low--high coherence remains.
The difference of the two states is a positive high block of trace
\(\tail(K)\) minus an orthogonal flag block of the same trace.
\end{proof}

\subsection{Tails and discarded moments}

Write \(\pi_n(K)=\Pr(N_{\rm tot}=n)\), reserving
\(\tail(K)\) for the cutoff tail. Then
\[
\pi_n(K)=
\prod_a(1-z_a)
\sum_{n_1+\cdots+n_J=n}\prod_a z_a^{n_a},
\quad
\tail(K)=1-\sum_{n=0}^N\pi_n(K).
\]

\begin{proposition}[Tail estimates]
\label{prop:tails}
For every \(N\ge0\),
\[
\tail(K)\le\min\{1,\mu/(N+1)\}.
\]
For \(\lambda_{\max}>0\),
\[
\tail(K)\le
\inf_{1<s<1+\lambda_{\max}^{-1}}s^{-(N+1)}G_K(s).
\]
The discarded mean occupation
\[
m_N(K)=\mathbb E[N_{\rm tot}\mathbf1_{\{N_{\rm tot}>N\}}]
=\mu-\sum_{n=0}^Nn\pi_n(K)
\]
satisfies
\[
m_N(K)\le\frac{\mu^2+\mu+\tr K^2}{N+1},
\qquad
m_N(K)\le s^{-(N+1)}sG_K'(s)
\]
on the same positive \(s\)-domain.
All these tails vanish for \(K=0\).
\end{proposition}

\begin{proof}
Use Markov's inequality, then
\(\mathbf1_{\{n>N\}}\le s^{n-(N+1)}\).
For the first moment, use \(n\le n^2/(N+1)\) on the tail and
\(\mathbb EN_{\rm tot}^2=\mu^2+\mu+\tr K^2\).
The derivative bound follows from the differentiated convergent
generating series.
\end{proof}

\subsection{Phase-sensitive finite-state formulas}

Let \(T=K(I+K)^{-1}\). In the normalized occupation basis,
\begin{equation}
\langle\mathbf n|\rho_K|\mathbf m\rangle=
\begin{cases}
p_0\,\per(T[\mathbf n,\mathbf m])/
 \sqrt{\prod_i n_i!\prod_i m_i!},&|\mathbf n|=|\mathbf m|,\\
0,&|\mathbf n|\ne|\mathbf m|.
\end{cases}
\label{eq:permanent}
\end{equation}
The repeated-row and repeated-column matrix
\(T[\mathbf n,\mathbf m]\) contains row \(i\) exactly \(n_i\)
times and column \(i\) exactly \(m_i\) times. The empty permanent
is one.

\begin{lemma}[Orientation-sensitive blocks and moments]
\label{lem:orientation}
For the one-particle block,
\[
\langle1_i|\rho_K|1_j\rangle=p_0T_{ij}.
\]
Extend compressed annihilators by zero on the flag:
\(b_{i,N}=\Pcut b_i\Pcut\oplus0\).
If
\[
\eta_a^{(N)}
=\sum_{|\mathbf n|\le N}
n_a\prod_b(1-z_b)z_b^{n_b},
\]
then the truncated number covariance is
\begin{equation}
\tr(\rho_{K,N}b_{i,N}^\dagger b_{j,N})
=
\left[W\diag(\eta_a^{(N)})W^\dagger\right]_{ji}.
\label{eq:truncatedmoments}
\end{equation}
It need not equal \(K_{ji}\); the discarded moments are absent.
\end{lemma}

\begin{proof}
Equation~\eqref{eq:permanent} is the matrix element of the
symmetric tensor power in \eqref{eq:density}; symmetrization sums
over permutations and occupation normalization supplies the
factorials. Its one-particle specialization is immediate.

The cutoff is invariant under passive mode rotation.
In the normal-mode basis the retained, unnormalized state is
diagonal, and its mean in mode \(a\) is \(\eta_a^{(N)}\).
Rotating its one-particle matrix back and applying
\eqref{eq:K} proves \eqref{eq:truncatedmoments}.
\end{proof}

These formulas permit regressions that distinguish \(K\) from
\(K^{\mathsf T}\), unlike eigenvalues, vacuum probability, or
total-number tails.

\subsection{General referenced inputs}

\begin{proposition}[Reference-compatible cutoff]
\label{prop:generalcut}
For any state \(\sigma_{AR}\), with arbitrary reference \(R\), put
\(p=\tr(\Qcut\sigma_A)\). Then
\[
\dist\bigl(\sigma_{AR}\oplus0,
(\mathcal E_N\otimes\id_R)(\sigma_{AR})\bigr)
\le\min\{1,\sqrt p+p/2\}.
\]
If \(\tr(N_{\rm tot}\sigma_A)\le E\), then \(p\le E/(N+1)\).
Without an input constraint, the cutoff's half-diamond distance
from the identity embedding is one for every finite \(N\).
\end{proposition}

\begin{proof}
Purify \(\sigma_{AR}\) to \(\ket\psi\) and set
\(\ket\phi=(\Pcut\otimes I)\ket\psi\).
The trace norm of
\(\ketbra\psi\psi-\ketbra\phi\phi\) is
\(\sqrt{4p-3p^2}\le2\sqrt p\).
Partial trace contracts it. The additional flag block has trace
norm \(p\). Markov's inequality gives the constraint estimate.
A high-block input is sent to an orthogonal flag and attains
distance one.
\end{proof}

This explicitly realizes an occupation-constrained approximation;
energy-constrained channel topologies are discussed in
\cite{Shirokov}.

\subsection{Combining errors and binary embedding}

For a positive approximation \(L\), define
\(\delta_{K,L}=\min\{1,\sqrt{J\norm{K-L}_\infty}\}\).
In the common embedding,
\begin{equation}
\dist(\rho_K\oplus0,\mathcal E_N(\rho_L))
\le\delta_{K,L}+\tail(L).
\label{eq:combined}
\end{equation}
Entrywise errors at most \(\eta\) imply
\(\delta_{K,L}\le\min\{1,J\sqrt\eta\}\).
A numerical convergence difference is not automatically a justified
entrywise error bound.

Choose an ordered occupation basis, append the flag, and map these
\(d_N+1\) states to the first computational basis states of
\(q_{\rm raw}\) qubits. Unused binary states have zero prepared
weight. A reverse representation map pinches valid versus invalid
binary subspaces and sends invalid weight to the flag; it is CPTP
by the same Kraus construction as the cutoff. Its action on valid
encoded states is exact.

The representation does not realize bosonic CCR exactly in finite
dimension. For bounded embedded observables the expectation error
is at most \(2\tail(K)\norm A_\infty\); number and energy require
the separate moment estimates.

%=====================================================================
\section{Scattering, energy, and observer interfaces}
\label{sec:scattering}
%=====================================================================

\subsection{Barrier convention}

Either start with the horizon state and apply its scattering map,
or start with outgoing covariance \(\Gamma_\ell\nH\).
Route A uses the latter and does not apply the greybody barrier
twice.

An additional detector amplitude \(d(\omega)\), with an independent
vacuum loss environment, would give
\(q_{\rm detected}=|d|^2\qout\). This is separately labelled
detector loss. Beamsplitter vacuum dilations are appropriate under
those input assumptions \cite{Weedbrook,Caruso}.

\subsection{Exact finite scattering for declared incoming preparations}

\begin{theorem}[Finite communication representation]
\label{thm:finitescatter}
Let \(E\subset L^2(B)\) have dimension \(J\). Prepare arbitrary
inputs in \(E\oplus E\) in the two incoming channels, with
orthogonal incoming modes in vacuum.
The restriction of multiplication by \(S_\ell(\omega)\) is an
isometry into \(E_D'\oplus E_F'\), where each output space is
spanned by the relevant output components of the \(2J\) incoming
packet functions and has dimension at most \(2J\).

On total input occupation at most \(N\), its bosonic lift is an
exact finite isometry into at most \(4J\) output modes with total
occupation at most \(N\). Tracing one output gives a finite CPTP
communication channel.
\end{theorem}

\begin{proof}
Restriction of a unitary one-particle operator is isometric.
Its output components lie in the specified spans.
On the \(n\)-particle sector, the symmetric tensor power is
isometric and preserves total number.
Take the direct sum for \(0\le n\le N\), then partial trace.
\end{proof}

This is a communication problem after a declared preparation.
It does not replace unselected horizon modes by vacuum in the
stationary Unruh-state calculation.

\begin{theorem}[Amplitude-to-channel bound]
\label{thm:scattererror}
For unitary two-channel multiplication matrices \(S,\widetilde S\)
on \(B\), suppose
\[
\operatorname*{ess\,sup}_B\norm{S-\widetilde S}_\infty
\le\epsilon_S.
\]
Their cutoff lifted isometries satisfy
\[
\norm{V_N-\widetilde V_N}_\infty\le\min\{2,N\epsilon_S\},
\]
and their complete channels, before or after the same partial trace,
satisfy
\[
\ddiam(\mathcal V_N,\widetilde{\mathcal V}_N)
\le\min\{1,N\epsilon_S\}.
\]
\end{theorem}

\begin{proof}
Telescope the \(n\)-fold tensor-power difference.
Every factor is an isometry, giving \(n\epsilon_S\).
Symmetric restriction and direct sum preserve the bound.
For referenced pure inputs, trace distance of the two isometric
outputs is at most their vector-norm difference.
Purification, convexity, and partial-trace contraction finish.
\end{proof}

For mean occupation at most \(E\), using a common cutoff and common
flag extension gives the additional bound
\[
\min\left\{1,N\epsilon_S+
2\min\left(1,\sqrt{\frac E{N+1}}+\frac E{2(N+1)}\right)\right\}.
\]
It is not inferred from matching mean counts.

Frequency-dependent amplitudes generally leave the selected packet
span:
\[
a_{\rm out}(h)=
a_{\rm H}(\overline{\tau_\ell}h)
+a_{\rm I}(\overline{\rho_{{\rm I},\ell}}h).
\]
A piecewise-constant unitary \(S_a\) on subbands preserves the packet
span when each packet belongs to one subband.
Its discrepancy must include phases and be bounded as above.

For covariance only, contraction-valued amplitudes with
\(\sup|\tau-\widetilde\tau|\le\epsilon_\tau\) imply
\[
\sup|\Gamma-\widetilde\Gamma|\le2\epsilon_\tau,\qquad
\norm{K-\widetilde K}_\infty\le2n_{\max}\epsilon_\tau,
\quad n_{\max}=(e^{\beta\omega_-}-1)^{-1}.
\]
This does not control coherent scattering phases.

\subsection{Compressed energy}

Let \(\Omega\) be multiplication by \(\omega\), and let
\[
H_{ij}=\langle h_i,\Omega h_j\rangle,\qquad
H_E=\bdGamma(H).
\]
The selected span need not be invariant under \(\Omega\).

\begin{proposition}[Energy and bandwidth errors]
\label{prop:energy}
Compression of field energy to states with particles only in \(E\)
is \(H_E\), with selected Gaussian expectation \(\tr(HK)\).

Suppose packets lie in pairwise disjoint subbands whose halfwidths
are at most \(\Delta\). Several packets may belong to the same
subband. Let \(H_0\) assign its midpoint to each such packet.
Then
\[
\norm{H-H_0}_\infty\le\Delta,\qquad
\norm{\Pcut(H_E-\bdGamma(H_0))\Pcut}_\infty\le N\Delta.
\]
Assigning the flag zero energy omits selected energy between zero
and \(\omega_+m_N(K)\).
\end{proposition}

\begin{proof}
On each \(n\)-particle sector, energy is the sum of \(n\)
one-particle operators; compression gives \(H\).
Using \(C_{ij}=K_{ji}\) gives \(\tr(HK)\).
Multiplication by frequency minus the subband midpoint has norm at
most \(\Delta\); compression and the \(n\)-fold sum give the
first two estimates.
Finally \(0\preceq H_E\preceq\omega_+N_{\rm tot}\), and both
commute with the cutoff projector.
\end{proof}

The compressed observable is not the energy of all radiation.
It need not commute with the selected state.
A surrogate's exact energy conservation is not exact conservation
of the continuum field energy.

On the full band,
\[
\norm{e^{-\ii t\Omega}-e^{-\ii t\Omega_0}}_\infty
\le\min\{2,|t|\Delta\};
\]
the cutoff Fock evolution error is at most
\(\min\{2,N|t|\Delta\}\).

Route A represents the entire flagged finite state as one raw block.
Frequency orthogonality does not establish sharply localized
arrivals. Any demultiplexing or streaming implementation needs its
own delivery convention and resource ledger.

%=====================================================================
\section{State-to-channel transfer under a common interface}
%=====================================================================

\begin{theorem}[Independent ancillary interface]
\label{thm:ancilla}
Let \(\rho,\sigma\) be ancillary states in a common space,
independent of the message and its reference.
For a fixed CPTP map \(\Lambda:M\otimes A\to B\), define
\(\mathcal N_\rho(X)=\Lambda(X\otimes\rho)\) and similarly
\(\mathcal N_\sigma\). Then
\[
\ddiam(\mathcal N_\rho,\mathcal N_\sigma)
\le\dist(\rho,\sigma).
\]
The bound also holds after any common deterministic decoder.
\end{theorem}

\begin{proof}
For a referenced message state \(\xi_{MR}\), the input difference
is \(\xi_{MR}\otimes(\rho-\sigma)\), with trace norm
\(\norm{\rho-\sigma}_1\). Apply CPTP contraction and take the
supremum over references.
\end{proof}

Thus \eqref{eq:combined} supplies a complete-channel bound when
this interface is supplied. It does not identify the encoding
from radiation covariance or justify changing a purification,
message correlation, or internal dynamics without a new comparison.

%=====================================================================
\section{Nonvacuum-calibrated recovery benchmark}
\label{sec:benchmark}
%=====================================================================

\subsection{What is transferred}

Define
\[
a(K)=1-\det(I+K)^{-1}.
\]
This is the selected nonvacuum probability, not a rate or a mean.
It is preserved exactly by the flagged cutoff when the flag is
classified as nonvacuum. A binary vacuum measurement gives
\[
|a(K)-a(L)|\le\dist(\rho_K,\rho_L).
\]
Also
\[
0\le\mu-a(K)\le\tfrac12(\mu^2+\tr K^2),
\]
because \(n-\mathbf1_{\{n>0\}}\le n(n-1)/2\).

Only \(a(K)\) is transferred to the benchmark.
Different correlated Gaussian states may give the same parameter.
The benchmark decoder is not given their covariance or full finite
state.

\subsection{Declared encoder and dilation}

The message is a qubit. On five qubits, define
\[
\ket{\Phi_2}_{ij}=(\ket{00}_{ij}+\ket{11}_{ij})/\sqrt2,
\]
\begin{align}
U&=Y_2\CX{3}{2}\CX{1}{2}
(H_1S_1^\dagger)(H_3S_3^\dagger)
\CZ{1}{2}\CZ{2}{3},\\
V\ket\psi&=(U^\dagger_{123}\otimes I_{45})
\left(\ket\psi_2\otimes\ket{\Phi_2}_{14}
\otimes\ket{\Phi_2}_{35}\right),\\
F&=\CZ{1}{2},\quad V_L=F^LV,\quad
\mathcal A_L(X)=\Tr_{45}(V_LXV_L^\dagger).
\end{align}
Gate products act rightmost first.

A physical operational packet has basis
\(\{\ket\vac,\ket{1,0},\ket{1,1}\}\), represented by
\(\ket{00},\ket{10},\ket{11}\).
Its atomic raw width is two qubits.
The unused binary state \(\ket{01}\) is assigned an invalid-input
failure treatment.

At horizon three,
\begin{equation}
\mathcal N_{a,L}(X)=
(1-a)\tr X\,\ketbra{\vac^3}{\vac^3}
+a\,\iota\mathcal A_L(X)\iota^\dagger.
\label{eq:Nbench}
\end{equation}
A coherent dilation retains a branch label in the core, with
amplitudes \(\sqrt{1-a},\sqrt a\), and extracts encoded factors
\(1,2,3\) on the occupied branch.
Tracing the labelled core gives \eqref{eq:Nbench}.
This is a declared operational purification, not the physical
purifier of the selected Unruh state.

A surrogate occupied-rail energy \(\epsilon>0\) and source energy
\(E_{\rm in}>3\epsilon\) give core energies
\(E_{\rm in}-j\epsilon\) after \(j\) occupied extractions.
This finite conservation law is not identified with the
Schwarzschild mass.

\subsection{Atomic resource model}

\begin{assumption}[Single-pass atomic delivery]
\label{ass:atomic}
Three raw width-two packets arrive once, in order.
A supplier may buffer, but may not measure, demultiplex, select,
or decode them. Every arrival occupies its full width atomically.

All laboratory quantum data, work, records, and output count toward
\(\Qpeak\). Classical storage is unrestricted.
There is no uncounted storage, auxiliary shared entanglement,
return of intermediate quantum data, or quantum export before
all horizon packets have been consumed.
\end{assumption}

Let \(\epsIT\) optimize over all CPTP decoders.
Let \(\epsop(n,3)\) optimize over deterministic protocols obeying
Assumption~\ref{ass:atomic} with \(\Qpeak\le n\).
Protocol memory is a global execution constraint \cite{Bisio}.

\begin{lemma}[Bell and Pauli witnesses]
\label{lem:bell}
A decoded constant qubit channel has Bell-input overlap \(1/4\).
A separable reference--output state has Bell overlap at most \(1/2\).
For a Pauli channel \(\Lambda=\sum_Pp_P\Ad_P\),
\[
\ddiam(\Lambda,\id)=1-p_I.
\]
\end{lemma}

\begin{proof}
A constant channel gives \(I_R/2\otimes\sigma\), whose overlap
with a maximally entangled qubit state is \(1/4\).
A product pure state has overlap at most \(1/2\); convexity gives
the separable bound.
For Pauli channels the Bell errors are orthogonal, giving the
lower bound \(1-p_I\), while the channel triangle inequality
gives the same upper bound.
\end{proof}

\begin{theorem}[Exact calibrated recovery and memory optima]
\label{thm:recovery}
For \(a=a(K)\), both parities satisfy
\[
\epsIT(3)=\frac34(1-a).
\]
For even \(L\),
\[
\epsop(2,3)=\frac34-\frac a4,\qquad
\epsop(3,3)=\frac34(1-a).
\]
For odd \(L\), \(\epsop(2,3)=3(1-a)/4\).
\end{theorem}

\begin{proof}
Conjugation gives
\[
\begin{array}{c|ccc}
 &P_X&P_Y&P_Z\\ \hline
\text{even}&-Z_1X_2Z_3&-X_1Y_2X_3&-Y_1Z_2Y_3\\
\text{odd}&-X_2Z_3&+Y_1X_2X_3&-Y_1Y_3 .
\end{array}
\]
Hence
\(\mathcal A_L(\rho)=(I+xP_X+yP_Y+zP_Z)/8\).
Every proper even subset is constant.
Applying \(UF^L\) to the full triple and discarding factors
\(1,3\) recovers the message.

The occupied Bell overlap cannot exceed one and the vacuum-branch
overlap is \(1/4\). Lemma~\ref{lem:bell} therefore gives the
unrestricted lower bound \(3(1-a)/4\).
Recover on the occupied branch and prepare \(I/2\) on vacuum
to attain it.

At capacity two, no quantum slot remains from the first packet
at the second atomic arrival. An arbitrary first-packet instrument
therefore leaves only a classical outcome. On the occupied rail,
its effect is
\(E=(\tr E)(I+v_xX+v_yY+v_zZ)/2\), \(|v|\le1\).
The normalized conditional reference--future state is
\[
\frac18(I-v_zX_RA+v_xY_RB-v_yZ_RC),
\]
where \(A=X_2Z_3\), \(B=Y_2X_3\), \(C=Z_2Y_3\), \(AB=-C\).
It equals
\[
\frac14\sum_{\alpha,\beta=\pm1}
\frac{I-\alpha v_zX_R+\beta v_xY_R+
\alpha\beta v_yZ_R}{2}
\otimes
\frac{I+\alpha A}{2}\frac{I+\beta B}{2}.
\]
The reference factors are positive and the joint projectors
are rank one, so the state is separable across \(R\mid23\).
This also covers arbitrary first-packet label mixing: the input
branch blocks are already incoherent and orthogonal.
Later operations preserve separability.
The Bell overlap is at most \(a/2+(1-a)/4\), giving
\(3/4-a/4\).

Measuring \(Z_1,X_2,Z_3\) and preparing the logical \(X\)
eigenstate of their negative parity realizes
\[
a\Delta_X+(1-a)\Tdep,\qquad
\Delta_X=(\id+\Ad_X)/2,\quad
\Tdep(X)=\tr(X)I/2,
\]
which attains the bound.
The explicit decoders below attain unrestricted recovery at the
remaining capacities.
\end{proof}

\subsection{Complete protocols, including off-support inputs}

Set
\[
B_{12}=H_1S_1^\dagger\CX{1}{2}H_2,\quad
R_3=H_3S_3^\dagger,\quad
C_{ts}=X_3^{1-t}Z_3^{1-s}.
\]

\paragraph{Even three-slot protocol.}
Read and consume labels. Retain the first occupied rail through
the second arrival. If both early labels are occupied, apply
\(B_{12}\), read both rails as \(t,s\), and consume them.
If all three labels are occupied, apply \(C_{ts}R_3\) to rail
three and return it after the final arrival.
Otherwise consume all remaining data and prepare \(I/2\).

\paragraph{Odd two-slot protocol.}
The identity
\(B_{12}F=(H_1S_1^\dagger)H_2\)
allows separate early readouts.
Consume each early rail before the next arrival.
On the all-occupied history apply the same final correction;
otherwise prepare \(I/2\) after consuming all packets.

\paragraph{Even two-slot protocol.}
Read \(Z,X,Z\) on the occupied rails, retaining only classical
outcomes. On the all-occupied history prepare the logical \(X\)
eigenstate of negative parity; otherwise prepare \(I/2\).

The identities
\[
B_{12}(Z_1X_2)B_{12}^\dagger=Z_2,\qquad
B_{12}(Y_1Z_2)B_{12}^\dagger=Z_1
\]
verify the successful corrected channel.
Equivalently, substituting the three logical Pauli representatives
into the four early-readout Kraus maps gives the logical Pauli
operators at the corrected output. The early pair is \(I_4/4\),
so all four outcomes have probability \(1/4\).
The complete decoded channels are
\(a\id+(1-a)\Tdep\) and
\(a\Delta_X+(1-a)\Tdep\), respectively.

To extend each protocol to every physical packet input, mixed
vacuum/occupied histories are failures. Invalid binary packet
states are also failures. All such histories are consumed before
fixed-output preparation. Cross-history coherence is removed by
the complete label-readout instrument.

\paragraph{Instruction accounting.}
Single-qubit gates, CNOT, CZ, allocation, destructive computational
readout, classical control, and final return are admitted.
Preparing \(I/2\) uses one recyclable slot: allocate zero, apply
\(H\), destructively read a random bit, retain it classically,
reallocate zero, conditionally apply \(X\), and return.
Preparation of an \(X\) eigenstate uses zero allocation,
conditional \(X\), and \(H\).
These events are included in the ledger; a final direct return is
not recorded as a destructive measurement.

The even reference state is locally Clifford-equivalent to
Smolin's unlockable state \cite{Smolin}. Indeed, for
\(R_0=HS^\dagger\), conjugation by
\(Y_R\otimes R_{0,1}\otimes I_2\otimes R_{0,3}\)
maps it to
\((I+X^{\otimes4}+Y^{\otimes4}+Z^{\otimes4})/16\).
The unlocking mechanism is inherited.

\subsection{What the calibration error controls}

Since \eqref{eq:Nbench} is affine in \(a\),
\[
\ddiam(\mathcal N_{a,L},\mathcal N_{\widetilde a,L})
\le|a-\widetilde a|
\le\dist(\rho_K,\rho_L),\qquad \widetilde a=a(L).
\]
This is a channel bound for a fixed specified calibration interface.
It is not a general conversion of count error into diamond error.
The flagged cutoff adds no error to this particular binary statistic.

%=====================================================================
\section{Analytical controls and numerical acceptance}
\label{sec:acceptance}
%=====================================================================

\subsection{A selected two-packet family}

On \(B=[c-w/2,c+w/2]\subset(0,\infty)\), choose
\[
h_1=w^{-1/2},\qquad
h_2=\sqrt{12}\,w^{-3/2}(\omega-c),
\]
zero outside \(B\). They are orthonormal and
\[
H=\begin{pmatrix}
c&w/\sqrt{12}\\
w/\sqrt{12}&c
\end{pmatrix}.
\]
The covariance \(K\) is evaluated without deleting off-diagonal
entries. Midpoint energy \(cI\) has compressed error
\(w/\sqrt{12}\), bounded by \(w/2\).
These packets are not sharp arrival events.

\begin{example}[Exact phase-sensitive algebraic control]
\label{ex:control}
For the synthetic, non-Schwarzschild covariance
\[
K_{\rm test}=\frac1{20}
\begin{pmatrix}3&\ii\\-\ii&3\end{pmatrix},
\]
the eigenvalues are \(1/10,1/5\),
\[
p_0=\frac{25}{33},\quad a=\frac8{33},\quad
\mu=\frac3{10},\quad
T=\frac1{132}\begin{pmatrix}17&5\ii\\-5\ii&17\end{pmatrix}.
\]
In the explicit order \((\ket{1,0},\ket{0,1})\), the
one-particle density block is
\[
\frac1{4356}
\begin{pmatrix}425&125\ii\\-125\ii&425\end{pmatrix}.
\]
For cutoff \(N=1\), its number-moment matrix is the transpose:
\[
C^{(1)}=\frac1{4356}
\begin{pmatrix}425&-125\ii\\125\ii&425\end{pmatrix}.
\]
These entries distinguish \(K\) from \(K^{\mathsf T}\).

The cutoff dimension including the flag is four, and
\[
\tail(K_{\rm test})=\frac{103}{2178}.
\]
The calibrated recovery errors are
\[
\epsIT=\frac{25}{44},\quad
\epsop^{\rm even}(2,3)=\frac{91}{132},\quad
\epsop^{\rm even}(3,3)=\epsop^{\rm odd}(2,3)=\frac{25}{44}.
\]
These are analytical values, not executed pilot results.
\end{example}

\subsection{Pilot and archive specification}

The first radial pilot uses \(\rh=1\), \(\beta=4\pi\),
\(\ell=0\), \(B=[0.08,0.24]\), the two packets above, and cutoff
\(N=2\). It constructs the full finite state and links it to the
nonvacuum-calibrated benchmark by a parameter identifier.

The appendix separates synthetic tests from the radial pilot.
It records complex amplitudes; flux residuals; separate boundary,
quadrature, and ODE-tolerance comparisons; covariance and energy;
finite Fock matrices and basis dictionaries; complete decoder
matrices; resource histories; and optional SDP variables.

The analytical potential-tail bound is actually evaluated and
archived for each radial boundary choice. Its floating-point
evaluation is labelled as such. It excludes unverified integration
error, and a vacuous bound remains recorded as vacuous.

BlackHawk may provide a version-pinned spectral comparison
\cite{BlackHawk}, while low-frequency scalar results
\cite{Higuchi} provide checks under their own hypotheses.
Neither supplies the complex amplitude error needed here.
No such comparison or numerical run is asserted.

\subsection{SDP acceptance is not a status string}

The SDP formulations are given in Appendix~\ref{app:sdp}.
Every requested solve first archives raw variables, constraint
duals, settings, and solver statistics, before residual checks or
another solve. Failure therefore preserves any obtained decoder.

For complex PSD constraints, the implementation uses realification:
\[
A\succeq0\quad\Longleftrightarrow\quad
\begin{pmatrix}\Re A&-\Im A\\\Im A&\Re A\end{pmatrix}\succeq0
\quad(A=A^\dagger).
\]
It separately checks Hermiticity of every relevant original matrix.
CVXPY constraint residuals and solver statistics are recorded as
diagnostics \cite{CVXPYConstraints,CVXPYAdvanced,CVXPYSolvers}.
Independent original-matrix residuals determine acceptance.

The declared floating-point tests are:
\begin{enumerate}[label=\textup{(\roman*)},leftmargin=*]
\item finite values and acceptable solver status;
\item Hermiticity residual and Frobenius norm of the negative
spectral part at most \(3\times10^{-4}\);
\item affine residual Frobenius norm at most \(3\times10^{-4}\);
\item independent primal--dual objective difference at most
\(5\times10^{-4}\);
\item Choi positivity and trace preservation for every encoded or
decoded channel;
\item agreement with analytical controls at most \(5\times10^{-4}\).
\end{enumerate}
Raw and repaired decoder residuals are both retained.
A numerical decoder repair is not an interval certificate.
Agreement of objectives is insufficient without feasibility.

\subsection{Error budget by mathematical object}

\begin{center}
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}p{0.25\textwidth}p{0.31\textwidth}p{0.34\textwidth}@{}}
\toprule
Error & Controlled object & Valid transfer\\
\midrule
Radial approximation & Complex amplitudes or \(S_\ell\)
& Cutoff channel bound of Theorem~\ref{thm:scattererror}\\
Covariance quadrature & \(K\) in a justified norm
& Gaussian state continuity\\
Packet selection & Named target observables
& Equation~\eqref{eq:subspace}\\
Occupation cutoff & State and discarded moments
& Exact Gaussian error; separate referenced-input bound\\
Energy surrogate & Compressed energy/evolution
& \(N\Delta\) and \(N|t|\Delta\)\\
Calibration & Vacuum/nonvacuum statistic
& Specified affine benchmark only\\
Ancillary approximation & Independent resource state
& Common-interface Theorem~\ref{thm:ancilla}\\
Decoder implementation & Complete decoded channel
& CPTP contraction and triangle inequality\\
\bottomrule
\end{tabular}
\end{center}

%=====================================================================
\section{Analytical conclusion}
%=====================================================================

\begin{theorem}[Field-to-finite interface]
For the specified stationary model and finite orthonormal packet
family, the selected state is \(\rho_K\), its flagged cutoff has
dimension \(\binom{J+N}{N}+1\), and its exact Gaussian state error
is \(\tail(K)\). A justified covariance approximation gives
\eqref{eq:combined}. Energy and coherent scattering have the
separate estimates of Section~\ref{sec:scattering}.
State error controls an encoded channel under the independent
ancillary interface. The specified nonvacuum-calibrated benchmark
has the exact recovery and memory optima of
Theorem~\ref{thm:recovery}.
\end{theorem}

\begin{proof}
Apply Theorems~\ref{thm:gaussian}, \ref{thm:continuity},
\ref{thm:cutoff}, \ref{thm:finitescatter},
\ref{thm:scattererror}, \ref{thm:ancilla}, and
\ref{thm:recovery}, together with
Propositions~\ref{prop:tails}, \ref{prop:generalcut},
and \ref{prop:energy}.
\end{proof}

The principal incorporation is a full finite-state construction,
linked to a nonvacuum-calibrated recovery benchmark.
No logical encoding, core, clock, or microscopic information-release
dynamics is selected by the radiation covariance.
The appendix supplies an unexecuted implementation with operational
acceptance conditions; it supplies no empirical conclusion about
the pilot.

%=====================================================================
\appendix
\section{Radial boundary-error estimate}
\label{app:radial}
%=====================================================================

For real \(V\in L^1(\mathbb R)\), the right Jost solution satisfies
\[
f_V(x,\omega)=e^{\ii\omega x}
+\int_x^\infty\frac{\sin(\omega(y-x))}{\omega}
V(y)f_V(y,\omega)\dd y.
\]
For another real potential \(W\), put
\(v=\norm V_{L^1}\), \(w=\norm W_{L^1}\),
\(d=\norm{V-W}_{L^1}\).

\begin{lemma}[Conservative amplitude bound]
\label{lem:josterror}
For \(\omega\ge\omega_->0\),
\[
\sup_x|f_V-f_W|
\le\frac d{\omega_-}e^{(v+w)/\omega_-}.
\]
For incoming and reflected coefficients \(a,b\),
\[
|a_V-a_W|,\ |b_V-b_W|
\le
A=\frac d{2\omega_-}e^{(v+w)/\omega_-}
\left(1+\frac w{\omega_-}\right).
\]
Consequently
\[
|\tau_V-\tau_W|\le A,\quad
|r_V-r_W|\le2A,\quad
\norm{S_V-S_W}_\infty\le\min\{2,4A\}.
\]
\end{lemma}

\begin{proof}
Volterra iteration gives \(\sup|f_W|\le e^{w/\omega_-}\).
Subtracting equations and applying the Volterra resolvent bound
\(e^{v/\omega_-}\) gives the solution difference.

The coefficient integrals contain
\((2\ii\omega)^{-1}\int e^{\pm\ii\omega y}Vf_V\dd y\).
Write \(Vf_V-Wf_W=(V-W)f_V+W(f_V-f_W)\) to obtain \(A\).
Current conservation gives \(|a|\ge1\), \(\tau=1/a\), and
\(|b/a|\le1\); hence the stated transmission and reflection
bounds. Apply the analogous left Jost construction for opposite
incidence. The four-entry Frobenius error is at most
\(\sqrt{10}A\le4A\); unitarity separately bounds it by two.
\end{proof}

For \eqref{eq:radial},
\[
v=\frac{\ell(\ell+1)}{\rh}+\frac1{2\rh}.
\]
If \(W=V\mathbf1_{[x_a,x_b]}\), then \(w=v-d\), and
\[
\begin{split}
d={}&\ell(\ell+1)\left(\frac1{\rh}-\frac1{r_a}\right)
+\frac1{2\rh}-\frac{\rh}{2r_a^2}\\
&+\frac{\ell(\ell+1)}{r_b}+\frac{\rh}{2r_b^2},
\end{split}
\]
where \(r_a=r(x_a)\), \(r_b=r(x_b)\).
These are exact potential-tail integrals, not ODE solver errors.

The implementation computes the near-horizon potential using
\(z=r-1\), rather than subtracting a rounded value of \(r\)
from one. This avoids prematurely rounding the exponentially small
near-horizon potential to zero at the pilot boundaries.

%=====================================================================
\section{Finite SDPs and feasibility directions}
\label{app:sdp}
%=====================================================================

Use output-first, unnormalized Choi matrices
\[
\Ch(\Phi)=\sum_{i,j}\Phi(\ketbra i j)\otimes\ketbra i j.
\]
For a decoder \(R=\Ch(\mathcal D)\),
\[
R\succeq0,\qquad \Tr_OR=I_B,\qquad
\mathcal D_R(A)=\Tr_B[R(I_O\otimes A^{\mathsf T})].
\]

For a difference \(\Delta\) of CPTP channels, the half-diamond
primal and dual are
\[
\begin{array}{ll}
\text{maximize}&\tr(\Ch(\Delta)W)\\
\text{subject to}&W\succeq0,\quad I_O\otimes\rho-W\succeq0,\\
&\rho\succeq0,\quad\tr\rho=1,
\end{array}
\]
and
\[
\begin{array}{ll}
\text{minimize}&\lambda\\
\text{subject to}&Z\succeq0,\quad Z-\Ch(\Delta)\succeq0,\\
&\lambda I_M-\Tr_OZ\succeq0.
\end{array}
\]
Their common value is \(\norm{\Delta}_\diamond/2\)
\cite{Watrous}.

For noise \(\mathcal N\), unrestricted recovery minimizes
\(\lambda\) over
\[
R\succeq0,\quad\Tr_OR=I_B,\quad
Z\succeq0,\quad
Z-\Ch(\mathcal D_R\mathcal N-\id)\succeq0,\quad
\lambda I_M-\Tr_OZ\succeq0.
\]
All these constraints are tested in the implementation.

For every channel \(\Lambda\), the independent acceptance checks
include \(\Ch(\Lambda)\succeq0\) and
\(\Tr_O\Ch(\Lambda)=I_M\).
A fixed-channel distance primal lower-bounds only that decoder's
error, not the optimal recovery over other decoders.
Here the benchmark's matching recovery lower bound is analytical.

For a raw decoder Choi matrix, the explicit numerical repair is
\[
P=R_++\epsilon I,\quad M=\Tr_OP,\quad
R_{\rm fix}=(I_O\otimes M^{-1/2})P(I_O\otimes M^{-1/2}).
\]
It is positive and trace preserving in exact arithmetic.
The implementation verifies these properties numerically and
archives the repair size. Floating-point residual acceptance is
not formal or interval-certified feasibility.

%=====================================================================
\section{Unexecuted reproducibility supplement}
\label{app:code}
%=====================================================================

Copy this listing to \code{en02_e_v2.py}.
Dependencies are Python, NumPy, and SciPy; optional SDPs require
CVXPY and SCS. Installed versions are recorded when run.

\begin{ShellBlock}
python en02_e_v2.py --mode synthetic
python en02_e_v2.py --mode pilot
python en02_e_v2.py --mode pilot --sdp --tex En02-E.tex --compile
\end{ShellBlock}

The synthetic command requires no radial calculation.
The pilot runs synthetic checks first, then the field layer and
linked operational layer. The source filename is consistently
\code{En02-E.tex}.

Array artifacts have companion basis metadata.
Raw solver artifacts are saved in the solve wrapper's
\code{finally} block, before status or feasibility acceptance.
No passing status is written if a requested check fails.

\begin{CodeBlock}
"""En02-E v2. Unexecuted implementation; no results are prepopulated."""
import argparse
import datetime
import hashlib
import itertools as it
import json
import math
from pathlib import Path
import shutil
import subprocess
import sys
import traceback
import numpy as np
import scipy
from scipy.integrate import solve_ivp
from scipy.special import lambertw

I = np.eye(2,dtype=complex)
X = np.array([[0,1],[1,0]],complex)
Y = np.array([[0,-1j],[1j,0]],complex)
Z = np.diag([1,-1]).astype(complex)
H = np.array([[1,1],[1,-1]],complex)/np.sqrt(2)
SD = np.diag([1,-1j]).astype(complex)
CZ = np.diag([1,1,1,-1]).astype(complex)
CX = np.array([[1,0,0,0],[0,1,0,0],
               [0,0,0,1],[0,0,1,0]],complex)
ROOT = None
TOL, STOL, GAP = 1e-9, 3e-4, 5e-4
DATA = {"checks":{}, "residuals":{}, "solves":[],
        "field":{}, "operational":[], "occupancy":[],
        "certified_numerics":False}

def need(ok,msg):
    if not ok:
        raise AssertionError(msg)

def clean(x):
    if isinstance(x,np.ndarray):
        return clean(x.tolist())
    if isinstance(x,np.generic):
        return clean(x.item())
    if isinstance(x,complex):
        return {"real":clean(x.real),"imag":clean(x.imag)}
    if isinstance(x,float) and not np.isfinite(x):
        return str(x)
    if isinstance(x,dict):
        return {str(k):clean(v) for k,v in x.items()}
    if isinstance(x,(list,tuple)):
        return [clean(v) for v in x]
    if x is None or isinstance(x,(str,int,float,bool)):
        return x
    return repr(x)

def jwrite(name,obj):
    (ROOT/(name+".json")).write_text(
        json.dumps(clean(obj),indent=2,allow_nan=False))

def dump():
    jwrite("records",DATA)

def save(name,**arrays):
    np.savez_compressed(ROOT/(name+".npz"),**arrays)

def herm(A):
    return (A+A.conj().T)/2

def check(name,A,B,tol=TOL):
    need(name not in DATA["checks"],"duplicate check "+name)
    A,B = np.asarray(A),np.asarray(B)
    need(A.shape==B.shape,"shape "+name)
    err = float(np.max(np.abs(A-B)))
    DATA["checks"][name] = err
    need(np.isfinite(err) and err<=tol,name+" residual "+str(err))

def psd_metrics(A):
    A = np.asarray(A)
    need(np.all(np.isfinite(A)),"nonfinite PSD matrix")
    vals = np.linalg.eigvalsh(herm(A))
    return {"hermiticity_op":float(np.linalg.norm(A-A.conj().T,2)),
            "minimum_eigenvalue":float(vals.min()),
            "negative_part_fro":float(np.linalg.norm(np.minimum(vals,0)))}

def accept(name,psds=None,equalities=None,tol=STOL):
    psds,equalities = psds or {},equalities or {}
    record = {"PSD":{k:psd_metrics(v) for k,v in psds.items()},
              "affine_fro":{k:float(np.linalg.norm(np.asarray(v)))
                            for k,v in equalities.items()},
              "tolerance":tol,"certified":False}
    DATA["residuals"][name] = record
    dump()
    for k,m in record["PSD"].items():
        need(m["hermiticity_op"]<=tol and m["negative_part_fro"]<=tol,
             name+" PSD residual "+k)
    for k,v in record["affine_fro"].items():
        need(np.isfinite(v) and v<=tol,name+" affine residual "+k)

def kron(*ops):
    A = np.array([[1]],complex)
    for B in ops:
        A = np.kron(A,B)
    return A

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

def integer(b):
    n = 0
    for z in b:
        n = 2*n+int(z)
    return n

def embed(G,pos,n):
    A = np.zeros((2**n,2**n),complex)
    for col in range(2**n):
        b = list(bits(col,n))
        gc = integer([b[p] for p in pos])
        for row in range(2**len(pos)):
            a = b.copy()
            for p,z in zip(pos,bits(row,len(pos))):
                a[p] = z
            A[integer(a),col] += G[row,gc]
    return A

def units(d=2):
    for i,j in it.product(range(d),repeat=2):
        E = np.zeros((d,d),complex)
        E[i,j] = 1
        yield i,j,E

def dep(A):
    return np.trace(A)*I/2

def ptout(A,o,b):
    return sum(A[a*b:(a+1)*b,a*b:(a+1)*b] for a in range(o))

def ptrace(A,keep,n):
    keep = tuple(keep)
    drop = tuple(i for i in range(n) if i not in keep)
    axes = keep+drop+tuple(n+i for i in keep)+tuple(n+i for i in drop)
    A = A.reshape((2,)*(2*n)).transpose(axes)
    A = A.reshape(2**len(keep),2**len(drop),
                  2**len(keep),2**len(drop))
    return np.einsum("abcb->ac",A)

def choi(N,d=2):
    o = len(N[0,0])
    return sum((np.kron(N[i,j],E) for i,j,E in units(d)),
               np.zeros((o*d,o*d),complex))

def channel_check(N,name,tol=TOL):
    d = int(round(np.sqrt(len(N))))
    o = len(N[0,0])
    J = choi(N,d)
    save(name+"_Choi",J=J)
    jwrite(name+"_Choi_basis",{"ordering":"output then input",
        "output_dimension":o,"input_dimension":d,"normalized":False})
    accept(name,{"Choi":J},{"TP":ptout(J,o,d)-np.eye(d)},tol)
    return J

def entropy(A):
    accept("entropy_"+str(len(DATA["residuals"])),
           {"state":A},{"trace":np.array(np.trace(A)-1)},TOL)
    vals = np.linalg.eigvalsh(herm(A))
    vals = vals[vals>1e-13]
    return float(-np.sum(vals*np.log2(vals)))

def occupation_basis(J,N):
    return [n for n in it.product(range(N+1),repeat=J) if sum(n)<=N]

def permanent(A):
    n = len(A)
    if n==0:
        return 1.+0j
    return sum(np.prod([A[i,p[i]] for i in range(n)])
               for p in it.permutations(range(n)))

def annihilators(basis):
    lookup = {n:i for i,n in enumerate(basis)}
    out = []
    d = len(basis)+1
    for a in range(len(basis[0])):
        B = np.zeros((d,d),complex)
        for col,n in enumerate(basis):
            if n[a]:
                m = list(n)
                m[a] -= 1
                B[lookup[tuple(m)],col] = np.sqrt(n[a])
        out.append(B)
    return out

def gaussian_cutoff(K,N,name):
    J = len(K)
    accept(name+"_covariance",{"K":K},tol=TOL)
    vals,W = np.linalg.eigh(herm(K))
    # No silent eigenvalue clipping in state construction.
    need(vals.min()>=0,"negative covariance eigenvalue")
    z = vals/(1+vals)
    basis = occupation_basis(J,N)
    T = K@np.linalg.inv(np.eye(J)+K)
    p0 = 1/float(np.linalg.det(np.eye(J)+K).real)
    rho = np.zeros((len(basis)+1,len(basis)+1),complex)
    for i,a in enumerate(basis):
        rows = [r for r,n in enumerate(a) for _ in range(n)]
        for j,b in enumerate(basis):
            if sum(a)!=sum(b):
                continue
            cols = [r for r,n in enumerate(b) for _ in range(n)]
            den = np.sqrt(np.prod([math.factorial(n) for n in a+b]))
            rho[i,j] = p0*permanent(T[np.ix_(rows,cols)])/den
    tail = 1-float(np.trace(rho).real)
    rho[-1,-1] = tail
    save(name,rho=rho,K=K,C=K.T,T=T,eigenvalues=vals)
    width = int(math.ceil(math.log2(len(rho))))
    jwrite(name+"_basis",{
        "matrix_axes":["ket occupation or flag","bra occupation or flag"],
        "occupation_order":basis,"flag_index":len(basis),
        "raw_width":width,
        "physical_to_binary":[format(i,"0%db"%width) for i in range(len(rho))],
        "unused_binary_indices":list(range(len(rho),2**width)),
        "unused_prepared_weight":0,
        "reverse_map":"pinch valid/invalid; invalid weight goes to flag",
        "annihilators_on_flag":0})
    accept(name+"_density",{"rho":rho},
           {"trace":np.array(np.trace(rho)-1)},TOL)

    probs = np.zeros(N+1)
    for i,n in enumerate(basis):
        probs[sum(n)] += rho[i,i].real
    independent_probs = np.zeros(N+1)
    means = np.zeros(J)
    for n in basis:
        weight = float(np.prod((1-z)*z**np.array(n)))
        independent_probs[sum(n)] += weight
        means += np.array(n)*weight
    check(name+"_occupation_distribution",probs,independent_probs)
    B = annihilators(basis)
    Ctrunc = np.array([[np.trace(rho@A.conj().T@Bop)
                       for Bop in B] for A in B])
    expectedC = (W@np.diag(means)@W.conj().T).T
    check(name+"_phase_sensitive_moments",Ctrunc,expectedC)
    save(name+"_moments",C_truncated=Ctrunc,C_expected=expectedC,
         occupation_probabilities=probs,normal_mode_retained_means=means)
    return rho,basis,tail,probs,Ctrunc

def synthetic_audit():
    K = np.array([[.15,.05j],[-.05j,.15]],complex)
    rho,basis,tail,p,Cn = gaussian_cutoff(K,1,"synthetic_N1")
    ix = [basis.index((1,0)),basis.index((0,1))]
    expected = np.array([[425,125j],[-125j,425]],complex)/4356
    check("synthetic_one_particle_entries",rho[np.ix_(ix,ix)],expected)
    check("synthetic_moment_orientation",Cn,expected.T)
    need(abs(Cn[0,1]-expected[0,1])>1e-3,
         "phase-sensitive regression is not discriminating")
    check("synthetic_eigenvalues",np.linalg.eigvalsh(K),np.array([.1,.2]))
    check("synthetic_vacuum",np.array(p[0]),np.array(25/33))
    check("synthetic_tail",np.array(tail),np.array(103/2178))
    gaussian_cutoff(K,3,"synthetic_N3")
    DATA["synthetic"] = {"field_dataset":False,"a":8/33,
        "orientation_test":"explicit imaginary entries and truncated moments"}
    dump()
    return 8/33

def zcoord(x):
    # Pilot |x| <= 80; retain z rather than forming r-1 afterwards.
    return float(lambertw(np.exp(x-1)).real)

def potential(x,ell):
    z = zcoord(x)
    r = 1+z
    return (z/r)*(ell*(ell+1)/r**2+1/r**3)

def radial_tail(cut,ell,omega_min):
    za,zb = zcoord(-cut),zcoord(cut)
    L = ell*(ell+1)
    v = L+.5
    left = L*za/(1+za)+.5*za*(2+za)/(1+za)**2
    right = L/(1+zb)+.5/(1+zb)**2
    d = left+right
    w = v-d
    need(d>=0 and w>=0,"potential-tail quantities")
    A = d/(2*omega_min)*np.exp((v+w)/omega_min)*(1+w/omega_min)
    return {"x_a":-cut,"x_b":cut,"r_h":1,
        "omega_min":omega_min,"left_tail":left,"right_tail":right,
        "d":d,"v":v,"w":w,"A":float(A),
        "S_error_bound_formula_value":float(min(2,4*A)),
        "vacuous_for_unitary_difference":bool(4*A>=2),
        "evaluation":"floating-point evaluation of analytical formula",
        "includes_ODE_error":False,"interval_certified":False}

def radial(omega,ell,cut,rtol):
    def rhs(x,y):
        return np.array([y[1],(potential(x,ell)-omega**2)*y[0]],complex)
    y0 = np.array([np.exp(1j*omega*cut),
                   1j*omega*np.exp(1j*omega*cut)],complex)
    sol = solve_ivp(rhs,(cut,-cut),y0,method="DOP853",
                    rtol=rtol,atol=rtol*1e-2)
    need(sol.success,"radial integration")
    f,fp = sol.y[:,-1]
    xa = -cut
    a = .5*np.exp(-1j*omega*xa)*(f+fp/(1j*omega))
    b = .5*np.exp(1j*omega*xa)*(f-fp/(1j*omega))
    tau,rh = 1/a,b/a
    ri = -np.conj(rh)*tau/np.conj(tau)
    S = np.array([[rh,tau],[tau,ri]],complex)
    flux = abs(abs(a)**2-abs(b)**2-1)
    unitary = np.linalg.norm(S.conj().T@S-I,2)
    return tau,rh,S,float(flux),float(unitary),int(sol.nfev)

def simpson_weights(grid):
    need(len(grid)>=3 and len(grid)%2==1,"odd Simpson grid")
    weights = np.ones(len(grid))
    weights[1:-1:2] = 4
    weights[2:-1:2] = 2
    return weights*(grid[-1]-grid[0])/(3*(len(grid)-1))

def field_layer(count,cut,rtol,name):
    lo,hi = .08,.24
    omega = np.linspace(lo,hi,count)
    width,mid = hi-lo,(hi+lo)/2
    h = np.column_stack([np.ones(count)/np.sqrt(width),
                        np.sqrt(12)*(omega-mid)/width**1.5])
    bound = radial_tail(cut,0,lo)
    jwrite(name+"_radial_tail",bound)
    runs = [radial(om,0,cut,rtol) for om in omega]
    tau = np.array([r[0] for r in runs])
    reflection = np.array([r[1] for r in runs])
    S = np.array([r[2] for r in runs])
    flux = np.array([r[3] for r in runs])
    unitary = np.array([r[4] for r in runs])
    weights = simpson_weights(omega)
    q = np.abs(tau)**2/np.expm1(4*np.pi*omega)
    K = h.conj().T@((weights*q)[:,None]*h)
    energy = h.conj().T@((weights*omega)[:,None]*h)
    save(name,omega=omega,tau=tau,reflection=reflection,S=S,
         K=K,C=K.T,H=energy,packets=h,weights=weights,
         flux_residual=flux,unitarity_residual=unitary,
         ODE_function_evaluations=np.array([r[5] for r in runs]))
    jwrite(name+"_basis",{"packet_order":["constant","linear"],
        "frequency_grid_order":"ascending",
        "S_rows":["outgoing horizon","outgoing infinity"],
        "S_columns":["incoming horizon","incoming infinity"],
        "K_indices":"one-particle ket, bra","C":"K transpose",
        "radial_tail_artifact":name+"_radial_tail.json"})
    need(max(flux)<1e-5 and max(unitary)<1e-5,"radial flux residual")
    check(name+"_packet_gram",h.conj().T@(weights[:,None]*h),I,1e-10)
    check(name+"_energy",energy,
          np.array([[mid,width/np.sqrt(12)],[width/np.sqrt(12),mid]]),1e-10)
    return K,energy,{"id":name,"grid":count,"cut":cut,"rtol":rtol,
        "radial_tail":bound,"max_flux_residual":float(max(flux)),
        "max_unitarity_residual":float(max(unitary)),
        "certified_total_amplitude_error":False}

def field_pilot():
    K17,H17,r17 = field_layer(17,80,1e-10,"field_grid17")
    K33,H33,r33 = field_layer(33,80,1e-10,"field_grid33")
    K65,H65,r65 = field_layer(65,80,1e-10,"field_grid65")
    Kb,Hb,rb = field_layer(33,40,1e-10,"field_boundary40")
    Kt,Ht,rt = field_layer(33,80,1e-7,"field_coarse_tolerance")
    rho,basis,tail,p,Cn = gaussian_cutoff(K65,2,"field_finite_state")
    a = 1-1/float(np.linalg.det(I+K65).real)
    mu = float(np.trace(K65).real)
    DATA["field"] = {"dataset_id":"field_grid65",
        "parameters":{"r_h":1,"beta":4*np.pi,"ell":0,
                      "band":[.08,.24],"J":2,"N":2},
        "runs":[r17,r33,r65,rb,rt],
        "diagnostics_not_certificates":{
            "quadrature_17_33":float(np.linalg.norm(K17-K33,2)),
            "quadrature_33_65":float(np.linalg.norm(K33-K65,2)),
            "boundary_40_80":float(np.linalg.norm(Kb-K33,2)),
            "ODE_tolerance":float(np.linalg.norm(Kt-K33,2))},
        "mean_occupation":mu,"selected_energy":float(np.trace(H65@K65).real),
        "normal_mode_means":np.linalg.eigvalsh(K65),
        "Gaussian_tail_estimate":tail,"Markov_tail":min(1,mu/3),
        "discarded_mean":mu-float(np.dot(np.arange(3),p)),
        "offdiagonal_magnitude":float(abs(K65[0,1])),
        "a":a,"benchmark_uses_only":"a, not full K or finite state"}
    dump()
    return a

def encoder(odd):
    U = np.eye(8,dtype=complex)
    sequence = [(CZ,(1,2)),(CZ,(0,1)),(SD,(2,)),(H,(2,)),
                (SD,(0,)),(H,(0,)),(CX,(0,1)),(CX,(2,1)),(Y,(1,))]
    for G,p in sequence:
        U = embed(G,p,3)@U
    J = np.zeros((32,2),complex)
    for m,a,b in it.product(range(2),repeat=3):
        J[integer((a,m,b,a,b)),m] = .5
    V = kron(U.conj().T,np.eye(4))@J
    return embed(CZ,(0,1),5)@V if odd else V

def dilation(V,a,t):
    dk = list(it.product(range(3),repeat=t))
    ek = [(0,b) for b in it.product(range(2),repeat=5)]
    ek += [(1,b) for b in it.product(range(2),repeat=5-t)]
    di,ei = {d:i for i,d in enumerate(dk)},{e:i for i,e in enumerate(ek)}
    A = np.zeros((len(dk),len(ek),2),complex)
    for b in it.product(range(2),repeat=5):
        row = V[integer(b)]
        A[di[(0,)*t],ei[0,b]] += np.sqrt(1-a)*row
        d = tuple(z+1 for z in b[:t])
        A[di[d],ei[1,b[t:]]] += np.sqrt(a)*row
    return A,dk,ek

def channel(A):
    return {(i,j):A[:,:,i]@A[:,:,j].conj().T for i,j,E in units()}

def decoupling(A):
    E = {(i,j):A[:,:,i].T@A[:,:,j].conj() for i,j,U in units()}
    bell = np.block([[E[0,0],E[0,1]],[E[1,0],E[1,1]]])/2
    marginal = (E[0,0]+E[1,1])/2
    return float(np.sum(np.abs(np.linalg.eigvalsh(
        herm(bell-kron(I/2,marginal)))))/2)

def decoder_kraus(dk,odd=False,low=False):
    """Complete decoder on all 27 physical input configurations."""
    occupied = [dk.index(tuple(z+1 for z in b))
                for b in it.product(range(2),repeat=3)]
    E = np.eye(len(dk),dtype=complex)[occupied,:]
    ops = []
    if low:
        for t,s,u in it.product(range(2),repeat=3):
            row = kron(I[:,t].conj()[None,:],
                       H[:,s].conj()[None,:],
                       I[:,u].conj()[None,:])
            sign = -(-1)**(t+s+u)
            out = np.array([[1],[sign]],complex)/np.sqrt(2)
            ops.append(out@row@E)
    else:
        B12 = kron(H,I)@kron(SD,I)@CX@kron(I,H)
        early = B12@(CZ if odd else np.eye(4))
        for t,s in it.product(range(2),repeat=2):
            correction = np.linalg.matrix_power(X,1-t)@np.linalg.matrix_power(Z,1-s)
            ops.append(correction@H@SD@kron(early[2*t+s][None,:],I)@E)
    for j in range(len(dk)):
        if j not in occupied:
            for bit in range(2):
                ops.append(I[:,bit:bit+1]@np.eye(len(dk))[j:j+1,:]/np.sqrt(2))
    return ops

def kraus_archive(ops,name):
    o,d = ops[0].shape
    R = sum(np.outer(A.reshape(-1),A.reshape(-1).conj()) for A in ops)
    completeness = sum(A.conj().T@A for A in ops)
    save(name,Kraus=np.array(ops),Choi=R)
    jwrite(name+"_basis",{"Kraus_axes":["path","output","input"],
        "Choi_axes":"output then input",
        "output_dimension":o,"input_dimension":d})
    accept(name,{"Choi":R},{"Kraus_completeness":completeness-np.eye(d),
        "Choi_TP":ptout(R,o,d)-np.eye(d)},TOL)

def binary_decoder(ops,dk):
    B = np.zeros((64,27),complex)
    for j,d in enumerate(dk):
        codeword = [0 if z==0 else z+1 for z in d]
        idx = 0
        for z in codeword:
            idx = 4*idx+z
        B[idx,j] = 1
    out = [A@B.conj().T for A in ops]
    valid = set(np.where(np.sum(np.abs(B),axis=1)>0)[0])
    for j in range(64):
        if j not in valid:
            for bit in range(2):
                out.append(I[:,bit:bit+1]@np.eye(64)[j:j+1,:]/np.sqrt(2))
    return out,B

def apply_ops(ops,A):
    return sum(K@A@K.conj().T for K in ops)

def ledger(programme,labels,outcomes,coin):
    """All label histories; quantum slots and physically separate events."""
    live,peak,events = 0,0,[]
    failed,held = False,False
    def event(action,change=0,**detail):
        nonlocal live,peak
        live += change
        need(live>=0,"negative ledger occupancy")
        peak = max(peak,live)
        events.append({"action":action,"live":live,**detail})
    def consume(action,**detail):
        event(action,-1,**detail)
    for j,label in enumerate(labels):
        event("atomic_arrival",2,packet=j)
        event("label_readout_and_consumption",-1,packet=j,label=label)
        if label==0:
            failed = True
        if failed:
            if held:
                consume("retained_rail_destructive_discard",outcomes="both")
                held = False
            consume("incoming_rail_or_dummy_destructive_discard",outcomes="both")
            continue
        if programme=="even_full" and j==0:
            held = True
            event("retain_first_rail")
        elif programme=="even_full" and j==1:
            event("early_joint_unitary",gates=["H2","CX1to2","Sdag1","H1"])
            consume("early_rail_destructive_readout",rail=1,outcome=outcomes[0])
            consume("early_rail_destructive_readout",rail=2,outcome=outcomes[1])
            event("classical_outcome_retention",bits=list(outcomes[:2]))
            held = False
        elif j<2 or programme=="even_low":
            gates = [] if programme=="even_low" and j!=1 else \
                ["H"] if programme=="even_low" or j==1 else ["Sdag","H"]
            event("rail_basis_rotation",packet=j,gates=gates)
            consume("early_destructive_rail_readout",
                    packet=j,outcome=outcomes[j])
            event("classical_outcome_retention",bit=outcomes[j])
        else:
            event("final_basis_rotation",gates=["Sdag","H"])
            event("final_classical_Pauli_correction",
                  x=1-outcomes[0],z=1-outcomes[1])
            event("final_direct_return",-1)
    if failed:
        event("allocate_random_bit_slot",1)
        event("random_bit_H")
        consume("random_bit_destructive_readout",outcome=coin)
        event("classical_random_bit_retention",bit=coin)
        event("reallocate_output_zero",1)
        event("conditional_X_for_I_over_2",bit=coin)
        event("failure_state_final_return",-1)
    elif programme=="even_low":
        sign = -(-1)**sum(outcomes)
        event("allocate_output_zero",1)
        event("conditional_X_for_logical_eigenstate",bit=int(sign<0))
        event("output_H")
        event("prepared_logical_eigenstate_final_return",-1)
    bound = 3 if programme=="even_full" else 2
    need(live==0 and peak<=bound,"ledger peak or final occupancy")
    return {"programme":programme,"labels":labels,
        "readout_outcomes":outcomes,"coin":coin,
        "events":events,"peak":peak,"bound":bound}

def ledgers(dataset):
    # Failure discard outcomes with identical occupancy are explicitly quotiented.
    for programme in ("even_low","even_full","odd_full"):
        count = 3 if programme=="even_low" else 2
        for labels in it.product(range(2),repeat=3):
            for outcome in it.product(range(2),repeat=count):
                for coin in ((0,1) if not all(labels) else (0,)):
                    record = ledger(programme,labels,outcome,coin)
                    record["dataset_id"] = dataset
                    DATA["occupancy"].append(record)
    dump()

def operational_pilot(a,dataset):
    record = {"dataset_id":dataset,"a":a,
        "encoding":"declared Clifford encoding",
        "field_information_transferred":"nonvacuum probability only",
        "IT_error":.75*(1-a),"even_two_slot_error":.75-.25*a,
        "prefixes":[]}
    evenN = None
    for odd in (False,True):
        V = encoder(odd)
        check(dataset+"_encoder_"+str(odd),V.conj().T@V,I)
        for t in range(4):
            name = dataset+"_operational_%s_%d"%(odd,t)
            A,dk,ek = dilation(V,a,t)
            save(name,A=A,**{"unit_%d_%d"%k:B for k,B in channel(A).items()})
            jwrite(name+"_basis",{
                "A_axes":["accessible configuration","environment configuration","message"],
                "accessible_order":dk,"environment_order":ek,
                "packet_symbols":{"0":"vacuum","1":"occupied rail 0","2":"occupied rail 1"},
                "environment_branch_0":"all five encoded rails retained",
                "environment_branch_1":"remaining encoded rails t+1 through 5",
                "message_order":[0,1],
                "raw_packet_binary_map":{"0":"00","1":"10","2":"11"},
                "unused_packet_binary":"01, assigned failure"})
            check(name+"_isometry",A.reshape(-1,2).conj().T@A.reshape(-1,2),I)
            N = channel(A)
            channel_check(N,name)
            record["prefixes"].append({"odd":odd,"t":t,
                "prepared_accessible_entropy":entropy(N[0,0]),
                "Bell_complement_distance":decoupling(A)})
            if t==3:
                for low in ([False,True] if not odd else [False]):
                    decname = name+"_decoder_"+str(low)
                    ops = decoder_kraus(dk,odd,low)
                    kraus_archive(ops,decname)
                    binaryops,B = binary_decoder(ops,dk)
                    kraus_archive(binaryops,decname+"_binary")
                    save(decname+"_embedding",physical_to_binary=B)
                    out = {}
                    for i,j,E in units():
                        out[i,j] = apply_ops(ops,N[i,j])
                        expected = a*(E+X@E@X)/2+(1-a)*dep(E) if low \
                            else a*E+(1-a)*dep(E)
                        check(decname+"_unit_%d%d"%(i,j),out[i,j],expected)
                    save(decname+"_decoded",
                         **{"unit_%d_%d"%k:B for k,B in out.items()})
                    channel_check(out,decname+"_decoded")
                if not odd:
                    evenN = N
    DATA["operational"].append(record)
    ledgers(dataset)
    dump()
    return evenN

def cp_psd(A):
    import cvxpy as cp
    B = (A+A.H)/2
    Re,Im = cp.real(B),cp.imag(B)
    return cp.bmat([[Re,-Im],[Im,Re]]) >> 0

def solve_archived(problem,name,expressions):
    """Save raw variables/duals immediately, even if solving raises."""
    need(problem.is_dcp(),"non-DCP problem "+name)
    options = {"solver":"SCS","eps":1e-7,"max_iters":50000,
               "verbose":False,"warm_start":False}
    error = None
    try:
        problem.solve(**options)
    except BaseException:
        error = traceback.format_exc()
        raise
    finally:
        arrays,missing = {},[]
        for key,expression in expressions.items():
            value = expression.value
            if value is None:
                missing.append(key)
            else:
                arrays[key] = np.asarray(value)
        for i,c in enumerate(problem.constraints):
            if c.dual_value is not None:
                arrays["constraint_dual_"+str(i)] = np.asarray(c.dual_value)
        save(name+"_raw",**arrays)
        stats = problem.solver_stats
        info = {"name":name,"status":problem.status,"objective":problem.value,
            "options":options,"missing_values":missing,"exception":error,
            "solver_statistics":None if stats is None else {
                "solver_name":stats.solver_name,"solve_time":stats.solve_time,
                "setup_time":stats.setup_time,"num_iters":stats.num_iters,
                "extra_stats":stats.extra_stats}}
        jwrite(name+"_solve",info)
        DATA["solves"].append(info)
        dump()
    # Raw artifact is already durable before diagnostics or acceptance.
    diagnostics = []
    for i,c in enumerate(problem.constraints):
        try:
            diagnostics.append({"index":i,"violation":c.violation()})
        except Exception as e:
            diagnostics.append({"index":i,"unavailable":repr(e)})
    jwrite(name+"_CVXPY_diagnostics",diagnostics)
    need(problem.status in ("optimal","optimal_inaccurate"),"solver status "+name)
    need(problem.value is not None and np.isfinite(problem.value),"objective "+name)
    for key,e in expressions.items():
        need(e.value is not None and np.all(np.isfinite(e.value)),
             "missing/nonfinite "+name+" "+key)
    return float(problem.value)

def decoder_apply(R,N):
    b = len(N[0,0])
    return {(i,j):np.array([[np.trace(
        R[a*b:(a+1)*b,z*b:(z+1)*b]@N[i,j].T)
        for z in range(2)] for a in range(2)]) for i,j,E in units()}

def independent_distance(N,name):
    import cvxpy as cp
    channel_check(N,name+"_input",STOL)
    J = choi(N)-choi({(i,j):E for i,j,E in units()})
    accept(name+"_Hermitian_difference",equalities={"skew":J-J.conj().T})
    W = cp.Variable((4,4),hermitian=True)
    rho = cp.Variable((2,2),hermitian=True)
    upper = cp.kron(I,rho)-W
    primal = cp.Problem(cp.Maximize(cp.real(cp.trace(J@W))),
        [cp_psd(W),cp_psd(rho),cp.trace(rho)==1,cp_psd(upper)])
    lo = solve_archived(primal,name+"_primal",
                       {"W":W,"rho":rho,"upper_slack":upper})
    accept(name+"_primal_feasibility",
        {"W":W.value,"rho":rho.value,"upper_slack":upper.value},
        {"trace_rho":np.array(np.trace(rho.value)-1)})
    D = cp.Variable((4,4),hermitian=True)
    lam = cp.Variable()
    slack = lam*I-ptout(D,2,2)
    dual = cp.Problem(cp.Minimize(lam),
        [cp_psd(D),cp_psd(D-J),cp_psd(slack)])
    hi = solve_archived(dual,name+"_dual",
                       {"Z":D,"lambda":lam,"upper_slack":slack})
    accept(name+"_dual_feasibility",
        {"Z":D.value,"Z_minus_J":D.value-J,"upper_slack":slack.value})
    need(abs(hi-lo)<=GAP,"distance objective gap "+name)
    save(name+"_difference",J=J)
    result = {"primal_estimate":lo,"dual_estimate":hi,
              "gap":hi-lo,"certified":False}
    jwrite(name+"_distance_result",result)
    return result

def recovery_sdp(N,name,target):
    import cvxpy as cp
    channel_check(N,name+"_noise",STOL)
    b = len(N[0,0])
    R = cp.Variable((2*b,2*b),hermitian=True)
    output = {}
    for i,j,E in units():
        output[i,j] = cp.bmat([[cp.reshape(cp.trace(
            R[a*b:(a+1)*b,z*b:(z+1)*b]@N[i,j].T),(1,1),order="C")
            for z in range(2)] for a in range(2)])
    J = sum(cp.kron(output[i,j],E) for i,j,E in units()) \
        -choi({(i,j):E for i,j,E in units()})
    D = cp.Variable((4,4),hermitian=True)
    lam = cp.Variable()
    upper = lam*I-ptout(D,2,2)
    problem = cp.Problem(cp.Minimize(lam),[
        cp_psd(R),ptout(R,2,b)==np.eye(b),
        cp_psd(D),cp_psd(D-J),cp_psd(upper)])
    value = solve_archived(problem,name+"_recovery",
        {"R":R,"Z":D,"lambda":lam,"difference_Choi":J,"upper_slack":upper})
    raw = np.asarray(R.value).copy()
    rawdecoded = decoder_apply(raw,N)
    Jnum = choi(rawdecoded)-choi({(i,j):E for i,j,E in units()})
    accept(name+"_raw_recovery_feasibility",
        {"R":raw,"Z":D.value,"Z_minus_J":D.value-Jnum,
         "upper_slack":float(lam.value)*I-ptout(D.value,2,2)},
        {"decoder_TP":ptout(raw,2,b)-np.eye(b),
         "affine_Choi":J.value-Jnum})
    channel_check(rawdecoded,name+"_raw_decoded",STOL)

    vals,V = np.linalg.eigh(herm(raw))
    P = (V*np.maximum(vals,0))@V.conj().T+1e-12*np.eye(2*b)
    M = herm(ptout(P,2,b))
    vals,V = np.linalg.eigh(M)
    need(vals.min()>0,"decoder normalization singular")
    G = (V*(1/np.sqrt(vals)))@V.conj().T
    fixed = kron(I,G)@P@kron(I,G)
    save(name+"_repaired_decoder",R=fixed)
    accept(name+"_repaired_decoder_feasibility",{"R":fixed},
           {"TP":ptout(fixed,2,b)-np.eye(b)})
    recovered = decoder_apply(fixed,N)
    save(name+"_repaired_decoded",
         **{"unit_%d_%d"%k:B for k,B in recovered.items()})
    channel_check(recovered,name+"_repaired_decoded",STOL)
    independent = independent_distance(recovered,name+"_independent")
    result = {"recovery_estimate":value,"analytical_target":target,
        "repair_Frobenius_size":float(np.linalg.norm(fixed-raw)),
        "independent_error":independent,"certified":False}
    jwrite(name+"_recovery_result",result)
    need(abs(value-target)<=GAP,"recovery analytical regression")
    need(abs(independent["dual_estimate"]-target)<=GAP,
         "repaired decoder analytical regression")
    return result

def solver_validation(N,a,dataset):
    import cvxpy as cp
    need("SCS" in cp.installed_solvers(),"SCS unavailable")
    tests = [
        ("identity",{(i,j):E for i,j,E in units()},0.),
        ("constant",{(i,j):dep(E) for i,j,E in units()},.75),
        ("dephasing",{(i,j):(E+Z@E@Z)/2 for i,j,E in units()},.5),
        ("calibrated_even",N,.75*(1-a))]
    for name,noise,target in tests:
        recovery_sdp(noise,dataset+"_"+name,target)

def compile_source(tex):
    source = Path(tex).resolve()
    need(source.exists(),"missing TeX")
    shutil.copy2(source,ROOT/source.name)
    for run in (1,2):
        result = subprocess.run(
            ["pdflatex","-interaction=nonstopmode","-halt-on-error",source.name],
            cwd=ROOT,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True)
        (ROOT/("pdflatex_%d.txt"%run)).write_text(result.stdout)
        need(result.returncode==0,"pdfLaTeX failure")
    need((ROOT/(source.stem+".pdf")).exists(),"missing PDF")
    log = ROOT/(source.stem+".log")
    warnings = []
    if log.exists():
        warnings = [line for line in log.read_text(errors="replace").splitlines()
                    if "Warning" in line or "Overfull" in line or "Underfull" in line]
    jwrite("compilation_warnings",{"warnings":warnings,
        "return_code_checks_passed":True,"human_warning_inspection_pending":True})

def main():
    global ROOT
    parser = argparse.ArgumentParser()
    parser.add_argument("--mode",choices=("synthetic","pilot"),default="synthetic")
    parser.add_argument("--sdp",action="store_true")
    parser.add_argument("--tex")
    parser.add_argument("--compile",action="store_true")
    args = parser.parse_args()
    stamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
    ROOT = Path("en02_e_v2_"+stamp)
    ROOT.mkdir()
    source = Path(__file__).resolve()
    shutil.copy2(source,ROOT/source.name)
    manifest = {"status":"RUNNING","mode":args.mode,"python":sys.version,
        "numpy":np.__version__,"scipy":scipy.__version__,
        "source_sha256":hashlib.sha256(source.read_bytes()).hexdigest(),
        "audit_tolerance":TOL,"SDP_feasibility_tolerance":STOL,
        "SDP_gap_tolerance":GAP,"sdp_requested":args.sdp,
        "compilation_requested":args.compile,"numerical_certificate":False}
    path = ROOT/"manifest.json"
    path.write_text(json.dumps(clean(manifest),indent=2))
    try:
        a = synthetic_audit()
        N = operational_pilot(a,"synthetic_control")
        if args.sdp:
            import cvxpy
            import scs
            manifest.update(cvxpy=cvxpy.__version__,scs=scs.__version__,
                            installed_solvers=cvxpy.installed_solvers())
            solver_validation(N,a,"synthetic_control")
        if args.mode=="pilot":
            a = field_pilot()
            N = operational_pilot(a,"field_grid65")
            if args.sdp:
                recovery_sdp(N,"field_calibrated_even",.75*(1-a))
        if args.compile:
            need(args.tex is not None,"--compile requires --tex")
            compile_source(args.tex)
        elif args.tex:
            shutil.copy2(Path(args.tex),ROOT/Path(args.tex).name)
        dump()
        manifest["status"] = "REQUESTED_FLOATING_POINT_CHECKS_PASSED"
        manifest["compilation"] = "RETURN_CODES_PASSED_WARNINGS_NEED_INSPECTION" \
            if args.compile else "NOT_RUN"
        manifest["scope"] = ("requested finite regressions only; radial convergence "
            "diagnostics are not certified total errors; human inspection pending")
    except BaseException:
        dump()
        (ROOT/"failure.txt").write_text(traceback.format_exc())
        manifest["status"] = "FAILED"
        raise
    finally:
        manifest["artifact_sha256"] = {
            f.name:hashlib.sha256(f.read_bytes()).hexdigest()
            for f in ROOT.iterdir() if f.is_file() and f.name!="manifest.json"}
        path.write_text(json.dumps(clean(manifest),indent=2,allow_nan=False))
    print(ROOT)
    print(manifest["status"])

if __name__=="__main__":
    main()
\end{CodeBlock}

\subsection{Interpretation of a future archive}

The raw Fock basis is lexicographic occupation order followed by
the flag; binary indices are explicitly archived.
Operational dilations use ordered accessible configurations,
ordered branch-labelled core configurations, and the declared
message basis. Every tensor axis is documented.

The complete decoder Kraus maps include all physical label histories
and an extension to invalid binary states. This repairs a support-only
decoder implementation that would otherwise fail trace preservation
on unpopulated input configurations.

The resource ledger enumerates all label histories. Destructive
discard outcomes with identical occupancy are quotiented and explicitly
marked as both outcomes; they are not postselected.
Its random-bit preparation path logs destructive measurement,
classical retention, reallocation, and return separately.

A passing archive establishes only the requested floating-point
regressions at recorded tolerances. It does not certify the exact
radial amplitudes, formal SDP feasibility, or a generic recovery
optimum. The universal analytical statements do not depend on that
archive.

%=====================================================================
\section*{Declarations}
%=====================================================================

\paragraph{Competing interests.}
The author declares no competing interests.

\paragraph{Funding.}
No specific grant supported this work.

\paragraph{Author contribution.}
N.C.\ developed the model formulation and manuscript.
Analytical statements, external dependencies, operational choices,
and execution conditions are distinguished explicitly.

\paragraph{Data and code availability.}
Formulas and the unexecuted implementation are included.
No numerical field dataset, executed solver archive, or compilation
record is asserted in this version.

\paragraph{Ethics.}
Not applicable.

%=====================================================================
\begin{thebibliography}{99}

\bibitem{Em03A}
N.~Cheung,
\emph{Em03-A: A Fixed-Background Hawking Emission Theorem},
version 1, 8 October 2026.
Supplied manuscript, \code{Em03-A-v1.tex}.
The stationary boundary model is restated explicitly in this paper.

\bibitem{En02D}
N.~Cheung,
\emph{Energy-Resolved Radiation and Resource-Limited Recovery:
Exact Memory Benchmarks, Loss-Closed Emission, and Explicit
Streaming Protocols},
version 4, 8 October 2026.
Supplied manuscript, \code{En02D-v4.tex}.
The benchmark specialization used here is proved in the text.

\bibitem{Hawking}
S.~W.~Hawking,
\emph{Particle creation by black holes},
Communications in Mathematical Physics \textbf{43},
199--220 (1975).
doi:10.1007/BF02345020.

% Source verification: ([arxiv.org](https://arxiv.org/abs/0907.1034))
\bibitem{DMP}
C.~Dappiaggi, V.~Moretti, and N.~Pinamonti,
\emph{Rigorous construction and Hadamard property of the Unruh state
in Schwarzschild spacetime},
Advances in Theoretical and Mathematical Physics \textbf{15},
355--447 (2011).
arXiv:0907.1034v2, revised 21 February 2012.

% Source verification: ([arxiv.org](https://arxiv.org/abs/1110.3234))
\bibitem{Weedbrook}
C.~Weedbrook, S.~Pirandola, R.~Garc\'ia-Patr\'on, N.~J.~Cerf,
T.~C.~Ralph, J.~H.~Shapiro, and S.~Lloyd,
\emph{Gaussian Quantum Information},
Reviews of Modern Physics \textbf{84}, 621--669 (2012).
arXiv:1110.3234.
doi:10.1103/RevModPhys.84.621.

% Source verification: ([arxiv.org](https://arxiv.org/abs/0804.0511))
\bibitem{Caruso}
F.~Caruso, J.~Eisert, V.~Giovannetti, and A.~S.~Holevo,
\emph{Multi-mode bosonic Gaussian channels},
New Journal of Physics \textbf{10}, 083030 (2008).
arXiv:0804.0511.
doi:10.1088/1367-2630/10/8/083030.

\bibitem{FredenhagenHaag}
K.~Fredenhagen and R.~Haag,
\emph{On the derivation of Hawking radiation associated with the
formation of a black hole},
Communications in Mathematical Physics \textbf{127},
273--284 (1990).
doi:10.1007/BF02096757.

\bibitem{HollandsWald}
S.~Hollands and R.~M.~Wald,
\emph{Quantum fields in curved spacetime},
Physics Reports \textbf{574}, 1--35 (2015).
arXiv:1401.2026.
doi:10.1016/j.physrep.2015.02.001.

\bibitem{Shirokov}
M.~E.~Shirokov,
\emph{Energy-constrained diamond norms and their use in quantum
information theory},
Problems of Information Transmission \textbf{54}, 20--33 (2018).
arXiv:1706.00361.
doi:10.1134/S0032946018010027.

\bibitem{BlackHawk}
A.~Arbey and J.~Auffinger,
\emph{BlackHawk v2.0: A public code for calculating the Hawking
evaporation spectra of any black hole distribution},
arXiv:1905.04268v3, 6 August 2021.
Version-specific manual.
Original article: European Physical Journal C \textbf{79},
693 (2019), doi:10.1140/epjc/s10052-019-7161-1.
No execution or comparison is asserted here.

\bibitem{Higuchi}
A.~Higuchi,
\emph{Low-frequency scalar absorption cross sections for stationary
black holes},
Classical and Quantum Gravity \textbf{18}, L139 (2001);
Addendum, \textbf{19}, 599 (2002).
arXiv:hep-th/0108144v2.
doi:10.1088/0264-9381/18/20/102.

% Source verification: ([arxiv.org](https://arxiv.org/abs/0901.4709))
\bibitem{Watrous}
J.~Watrous,
\emph{Semidefinite programs for completely bounded norms},
Theory of Computing \textbf{5}, 217--238 (2009).
arXiv:0901.4709.
doi:10.4086/toc.2009.v005a011.

\bibitem{Smolin}
J.~A.~Smolin,
\emph{A four-party unlockable bound-entangled state},
Physical Review A \textbf{63}, 032306 (2001).
arXiv:quant-ph/0001001.
doi:10.1103/PhysRevA.63.032306.

\bibitem{Bisio}
A.~Bisio, G.~M.~D'Ariano, P.~Perinotti, and M.~Sedl\'ak,
\emph{Memory cost of quantum protocols},
Physical Review A \textbf{85}, 032333 (2012).
arXiv:1112.3853.
doi:10.1103/PhysRevA.85.032333.

% Source verification: ([cvxpy.org](https://www.cvxpy.org/api_reference/cvxpy.constraints.html))
\bibitem{CVXPYConstraints}
CVXPY authors,
\emph{Constraints: API reference}.
\url{https://www.cvxpy.org/api_reference/cvxpy.constraints.html}
Consulted for constraint-violation diagnostics.
Installed software versions are recorded by execution.

% Source verification: ([cvxpy.org](https://www.cvxpy.org/tutorial/constraints/index.html))
\bibitem{CVXPYAdvanced}
CVXPY authors,
\emph{Advanced Constraints}.
\url{https://www.cvxpy.org/tutorial/constraints/index.html}
Consulted for complex expressions and Hermitian variables.

% Source verification: ([cvxpy.org](https://www.cvxpy.org/tutorial/solvers/index.html))
\bibitem{CVXPYSolvers}
CVXPY authors,
\emph{Solver Features}.
\url{https://www.cvxpy.org/tutorial/solvers/index.html}
Consulted for solver invocation, settings, and statistics.

\end{thebibliography}

\end{document}