%=====================================================================
% Em03-H-v8.tex
%
% Standalone source for pdfLaTeX.
%
% Build:
%   pdflatex -interaction=nonstopmode -halt-on-error Em03-H-v8.tex
%   pdflatex -interaction=nonstopmode -halt-on-error Em03-H-v8.tex
%
% No external bibliography, figures, numerical arrays, Python execution,
% or shell escape are required to typeset this document.
%
% INPUT AND EVIDENCE BOUNDARY
% Analytical inputs:
%   supplied baseline-input.tex and Em03-H-v7.tex.
% Historical computational inputs:
%   supplied P8-new manifest.json, stdout.txt, stderr.txt,
%   numpy_configuration.txt, coefficients.json, and em03h_tools.py.
% New computational report:
%   supplied Em03-H-v7-results-summary.txt.
%
% The new summary reports candidate computations and a patched defect
% checker invocation. Original candidate arrays, exact certificate
% rationals, patched-source hashes, and complete inspection reports
% were not supplied.
%
% This edition does not assert independent execution, binary-archive
% inspection, compilation, formal checking, or numerical validation.
% Its new v8 programs are unexecuted implementation artifacts.
%
% HISTORICAL SOURCE POLICY
% Preserve historical em03h_tools.py, manifests, and reported v7 outputs
% unchanged. New programs and new invocations require new provenance.
%
% PHYSICAL BOUNDARY
% Controlled extraction is not passive evaporation.
% The continuum candidate is a declared tensor-product reduction.
% No controlled full-gravity reduction or P8 gravitational dictionary
% is supplied.
%=====================================================================

\documentclass[11pt]{article}

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

\hypersetup{
  pdftitle={Em03-H-v8: Exact Fermionic Extraction and
  Stored-Packet Recovery with Reported Computational Results},
  pdfauthor={Ngo Cheung},
  pdfsubject={Complete fermionic channels, quench diagnostics,
  exploratory P8 and continuum results, and rigorous certification}
}

\setcounter{secnumdepth}{3}
\setcounter{tocdepth}{2}
\numberwithin{equation}{section}
\allowdisplaybreaks
\setlength{\emergencystretch}{3em}
\setlength{\parskip}{0.2em}
\setlength{\parindent}{1.2em}
\setlist{leftmargin=*,itemsep=3pt}

\theoremstyle{plain}
\newtheorem{theorem}{Theorem}[section]
\newtheorem{proposition}[theorem]{Proposition}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{corollary}[theorem]{Corollary}
\newtheorem*{externalinput}{Declared external mathematical input}

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

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

\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{\code}[1]{\texttt{\detokenize{#1}}}
\newcommand{\HH}{\mathcal H}
\newcommand{\FF}{\mathcal F_{\mathrm f}}
\newcommand{\NN}{\mathcal N}
\newcommand{\CC}{\mathcal C}
\newcommand{\DD}{\mathcal D}
\newcommand{\JJ}{\mathcal J}
\newcommand{\GG}{\mathcal G}
\newcommand{\RR}{\mathcal R}
\newcommand{\id}{\mathrm{id}}
\newcommand{\Ad}{\operatorname{Ad}}
\newcommand{\ii}{\mathrm i}
\newcommand{\dd}{\,\mathrm d}
\newcommand{\dist}{d_{\mathrm{tr}}}
\newcommand{\ddiam}{d_\diamond}
\newcommand{\Parity}{\mathsf P}
\newcommand{\Nsys}{N_{\mathrm B}}
\newcommand{\Nbath}{N_{\mathrm R}}
\newcommand{\Ntot}{N_{\mathrm{tot}}}
\newcommand{\Hsys}{H_{\mathrm B}}
\newcommand{\Hfour}{H_4}
\newcommand{\Ghop}{G_{\mathrm{hop}}}
\newcommand{\TrK}{\operatorname{Tr}_{K}}
\newcommand{\Kext}{\mathscr K_{\mathrm{ext}}}
\newcommand{\Analytical}{\mathsf A}
\newcommand{\Reported}{\mathsf R}
\newcommand{\Inspected}{\mathsf I}
\newcommand{\Validated}{\mathsf V}

\DeclareMathOperator{\Tr}{Tr}
\DeclareMathOperator{\tr}{tr}
\DeclareMathOperator{\Span}{span}
\DeclareMathOperator{\supp}{supp}
\DeclareMathOperator{\rank}{rank}
\DeclareMathOperator{\ran}{ran}
\DeclareMathOperator{\diag}{diag}

\lstset{
  language=Python,
  basicstyle=\ttfamily\scriptsize,
  columns=fullflexible,
  keepspaces=true,
  showstringspaces=false,
  breaklines=true,
  breakatwhitespace=false,
  frame=single,
  numbers=left,
  numberstyle=\tiny,
  tabsize=4
}

\title{\textbf{Em03-H-v8}\\[1mm]
\textbf{Exact Fermionic Extraction, Quench Diagnostics,\\
and Stored-Packet Excitation-Channel Recovery}\\[2mm]
\large Complete-channel proofs, reported computational results,
and reproducible certification}

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

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

\begin{document}
\maketitle

\begin{abstract}
We distinguish a fixed microscopic recovery experiment, a restricted
continuum excitation-code experiment, and a gravitational interpretation
requiring an independent physical identification.

For a quartic Majorana Hamiltonian and an even spectral code, we
construct complete accessible and complementary channels, retaining
arbitrary references and preparation purifications. We prove exact
quench-leakage, best-compression, departure, and interpolation formulas.
A resonant controlled extractor has explicit signed fermionic branches
and a complete decoder. Ideal full transfer is exact. Its minimal
jointly invariant reached space has dimension
\(\sum_{m\ {\rm even}}(m+1)\rank(P_mV)\), at most forty for the
frozen eight-mode instance P8.

The supplied P8-new execution materials report
\(E_{\mathrm{code}}\approx4.318140424446922\),
\(L_N\approx1.4473228981681243\), and departures
\(0.032277775445887835\) and \(0.12385356780895762\)
at times \(1/8\) and \(1/4\).
The new results summary additionally reports agreement between
Volterra and spectral/RK candidate calculations near
\(q\approx-0.77925+0.07681\ii\), with
\(\eta=|q|^2\approx0.61313\).

For the declared continuum reduction, storage changes the occupied
packet while extraction remains coupled to the fixed packet operator.
A unique Volterra solution determines the complete signed
excitation-qubit channel and its information-bearing complement.
The specified complete decoder has exact half-diamond error
\(1-\eta\). The reported candidate values therefore suggest error
about \(0.38687\), above one quarter, for this decoder.
They do not establish a rigorous numerical exclusion.

The supplied summary reports a patched rational defect-checking run
with uniform defect bound about \(0.117\), but its resulting transmission
enclosure is \([0,1]\). Exact certificate rationals, original candidate
arrays, patched-source identifiers, and complete inspection reports
are not supplied. Version 8 incorporates these reported results,
repairs mixed interval/complex dispatch, and introduces journaled
failure recording. The new v8 programs remain unexecuted.
P8 rank certification, a nontrivial continuum amplitude enclosure,
and the validated quarter-error verdict remain open.
No P8 gravitational dictionary is constructed.
\end{abstract}

\tableofcontents

%=====================================================================
\section{Scope, evidence, and the version-8 revision}
\label{sec:scope}
%=====================================================================

The mathematical and physical tasks are separate:
\[
\begin{gathered}
\text{fixed microscopic preparation and controls}
\longrightarrow\text{complete channel}
\longrightarrow\text{referenced recovery},\\
\text{declared continuum reduction}
\longrightarrow\text{excitation-code channel}
\longrightarrow\text{referenced recovery},\\
\text{independent physical identification and dictionary}
\longrightarrow\text{identified gravitational recovery}.
\end{gathered}
\]
The first two chains are constructed below. The third is conditional.

The supplied analytical sources are \code{baseline-input.tex} and
\code{Em03-H-v7.tex}. The supplied P8-new execution materials and the
new \code{Em03-H-v7-results-summary.txt} are documentary numerical
inputs, not mathematical substitutes for error bounds.

\subsection{Evidence classification}

\begin{definition}[Evidence levels]
\begin{description}
\item[\(\Analytical\): analytical.]
A consequence of a stated mathematical specification and proof.
\item[\(\Reported\): reported.]
A numerical result or execution claim attributed to supplied records,
without independent authentication of its underlying binary artifacts.
\item[\(\Inspected\): inspected.]
An artifact reloaded and checked in a separately recorded invocation.
\item[\(\Validated\): validated.]
A numerical conclusion with rigorous arithmetic, selection,
approximation, and applicable model-error allowances.
\end{description}
Physical implementation is a further evidential task.
\end{definition}

A statement in a summary that an inspection succeeded is itself
reported evidence unless its inspection artifact is available.
Likewise, a displayed rational-checker status is not an exact certificate
when only rounded summary values are supplied.

\begin{center}
\small
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}p{0.43\textwidth}p{0.48\textwidth}@{}}
\toprule
Object & Status in v8\\
\midrule
Microscopic extraction and diagnostic identities & \(\Analytical\)\\
P8-new execution and scalar output & \(\Reported\); manifest and logs supplied\\
Prior P8 inspection discrepancy near \(8.5\times10^{-15}\) &
Reported only in the new summary\\
Complete P8 binary archive and inspection report & Not supplied here\\
Exact P8 occupation ranks and reached dimension & Not numerically certified\\
Candidate Volterra and spectral/RK outputs & Newly reported, rounded summaries\\
Patched v7 rational checker invocation & Reported; exact output not supplied\\
Reported transmission enclosure from that invocation & \([0,1]\), inconclusive\\
New v8 software & Printed, statically revised, unexecuted\\
Validated candidate quarter-error verdict & Unresolved\\
P8 gravitational dictionary & Not constructed\\
Compilation and formal proof checking & Not performed here\\
\bottomrule
\end{tabular}
\end{center}

\subsection{What changes and what does not}

Version 8:
\begin{enumerate}[label=\textup{(\arabic*)}]
\item incorporates the newly reported candidate values and coarse
defect-check result;
\item distinguishes exploratory failure of the specified decoder from
a validated exclusion and from optimal-recovery impossibility;
\item corrects the interval/complex multiplication dispatch defect in
the printed v7 checker;
\item replaces repeated fixed-name checkpoint writes with a journal and
unique temporary snapshot files;
\item retains exact JSON/NPZ node-link checks and complete saved
spectral/RK states;
\item states an explicit numerical accuracy target for the next
candidate certificate.
\end{enumerate}

The primary controls, coupling packet, storage interval, microscopic
coefficients, and code-selection rules are unchanged.
No new physical identification is inferred from solver agreement.

The new v8 programs are not the patched v7 source reportedly used.
That patched source and its hash must still be supplied to authenticate
the reported invocation. Historical sources and manifests are not
overwritten.

\subsection{Metrics and standard facts}

The message is \(M\), reference \(Q\), boundary \(B\), and bath \(R\).
Accessible bath modes form \(A\). A non-message factor \(K\) may have
an inaccessible purifying register \(G\).

Unsubscripted norms are operator norms. Subscripts \(1\) and
\(\mathrm F\) denote trace and Frobenius norms. Set
\[
\dist(\rho,\sigma)=\tfrac12\norm{\rho-\sigma}_1,\qquad
\ddiam(\Phi,\Psi)=\tfrac12\norm{\Phi-\Psi}_\diamond.
\]
All channel distances retain arbitrary references.
For an isometry \(S\), \(\Ad_S(X)=SXS^\dagger\), and
\(\RR_\tau(X)=\tr(X)\tau\).
Matrix units are \(E_{\alpha\beta}=\ketbra\alpha\beta\).

For a qubit channel,
\[
\varepsilon_{\mathrm{rec}}(\NN)
=\inf_{\DD\ {\rm CPTP}}\ddiam(\DD\NN,\id_2).
\]
Let \(\ket{\Phi}=(\ket{00}+\ket{11})/\sqrt2\). Define squared
target-overlap fidelities
\[
F_e(\Lambda)=
\bra\Phi(\id\otimes\Lambda)(\ketbra\Phi\Phi)\ket\Phi,
\]
\[
F_{\mathrm{wc}}(\Lambda)=
\inf_{\rho_M}
\bra{\psi_\rho}(\id\otimes\Lambda)
(\ketbra{\psi_\rho}{\psi_\rho})\ket{\psi_\rho}.
\]

\begin{externalinput}[Finite quantum-information facts]
Root fidelity
\(f(\rho,\sigma)=\norm{\sqrt\rho\sqrt\sigma}_1\)
satisfies \(f\ge1-\dist(\rho,\sigma)\).
Its maximal purification overlap equals \(f\), with sufficiently
enlarged purifying spaces.
The diamond norm of a difference of finite channels can be optimized
on referenced density operators.
\end{externalinput}

These conventions and facts are standard
\cite{Watrous,FuchsVandeGraaf}. Recovery and
information--disturbance frameworks are established
\cite{BenyOreshkov,KSW}. A channel error at most \(e\) against the
identity implies both target overlaps are at least \(1-e\), by the
pure-target projector test.

%=====================================================================
\section{Frozen microscopic model and complete preparation}
\label{sec:model}
%=====================================================================

\subsection{Occupation representation}

Use \(\HH_B=\FF(\mathbb C^n)\), \(n\ge2\), with
\[
\ket P=\prod_{j\in P}^{\mathrm{increasing}}
c_j^\dagger\ket\emptyset.
\]
The annihilation rule is
\[
c_j\ket P=
\begin{cases}
(-1)^{\#\{k\in P:k<j\}}\ket{P\setminus\{j\}},&j\in P,\\
0,&j\notin P,
\end{cases}
\]
and creation uses the corresponding preceding-occupation sign.

\begin{lemma}[CAR and number convention]
\label{lem:car}
These operators satisfy
\[
\{c_j,c_k^\dagger\}=\delta_{jk}I,\qquad \{c_j,c_k\}=0.
\]
For
\[
\chi_{2j-1}=\frac{c_j+c_j^\dagger}{\sqrt2},\qquad
\chi_{2j}=\frac{c_j-c_j^\dagger}{\ii\sqrt2},
\]
one has \(\{\chi_a,\chi_b\}=\delta_{ab}I\) and
\[
\boxed{\Nsys=\sum_jc_j^\dagger c_j
=\frac n2I+\ii\sum_j\chi_{2j-1}\chi_{2j}.}
\]
\end{lemma}

\begin{proof}
For equal labels the two orders give complementary occupation
projections. For unequal labels, exchanging actions reverses the
preceding-occupation sign. Expansion gives the Majorana relations.
Finally,
\(\ii\chi_{2j-1}\chi_{2j}=c_j^\dagger c_j-I/2\).
\end{proof}

Fix real coefficients and set
\[
\Hfour=\sum_{a<b<c<d}J_{abcd}\chi_a\chi_b\chi_c\chi_d,\qquad
\Hsys=\Hfour-E_{\min}I,
\]
where \(E_{\min}\) is the minimum over both parity sectors.
Quartic terms are Hermitian because reversal requires six exchanges.
With \(\Parity_B=(-1)^{\Nsys}\),
\[
[\Hsys,\Parity_B]=0,\qquad
\norm{\Hfour}\le h_4=\tfrac14\sum_{a<b<c<d}|J_{abcd}|,
\qquad 0\preceq\Hsys\preceq2h_4I.
\]
Number need not commute with the quartic Hamiltonian.

SYK motivates the quartic setting but does not identify this fixed code
with a black-hole microstate code \cite{MaldacenaStanford}.
No disorder average replaces the fixed coefficient array.

\subsection{Bath and signed access}

Use an independent initially vacuum bath
\(\HH_R=\FF(\mathbb C^n)\), with
\[
H_R=\Omega\Nbath,\qquad
\Nbath=\sum_jb_j^\dagger b_j,\qquad
\Ntot=\Nsys+\Nbath,\qquad \Omega>0,
\]
\[
\Ghop=\sum_j(c_j^\dagger b_j+b_j^\dagger c_j).
\]
The one-particle order is
\(c_1,\ldots,c_n,b_1,\ldots,b_n\).
Odd operators in the two blocks anticommute.
Pair hopping terms commute and \(\norm{\Ghop}\le n\).

The signed regrouping \(\mathscr R_A\) places accessible modes first,
preserving each declared internal order.
For whole-bath access,
\begin{equation}
\mathscr R_R(\ket L_B\ket T_R)
=(-1)^{|L||T|}\ket T_R\ket L_B.
\label{eq:regroup}
\end{equation}

\begin{definition}[Distinct dynamical targets]
Target A stores under \(\Hsys\), replaces it by \(\Omega\Nsys\),
and extracts through resonant hopping.
Target B retains an interacting boundary generator during transfer.
A result for one target does not implement the other.
\end{definition}

The exact microscopic construction solves Target A.
The continuum experiment below is independently declared and retains
its own storage generator.

A general finite path is
\[
H(t)=a(t)\Hsys+\Omega\zeta(t)\Nsys+
\Omega\Nbath+\kappa(t)\Ghop
\]
with bounded piecewise continuous real controls, fixed independently
of the unknown logical input.

\subsection{Code and channels}

Choose \(D=2g\) orthonormal even eigenvectors
\(\beta_{ia}\), \(i=0,1\), \(a=1,\ldots,g\), with fixed spectral,
phase, and degeneracy conventions. Set
\[
V:MK\longrightarrow B,\qquad
V\ket{i,a}=\ket{\beta_{ia}},\qquad P=VV^\dagger.
\]
The full code algebra is \(V\mathcal B(MK)V^\dagger\).
The message algebra is
\(V(\mathcal B(M)\otimes I_K)V^\dagger\).

For a message channel prepare \(\rho_{QM}\otimes\sigma_K\), with
independent \(\sigma_K\). Uniform subsystem recovery instead allows
arbitrary \(\rho_{QMK}\).

\begin{theorem}[Complete finite channel interface]
\label{thm:channels}
The finite path has a unique unitary propagator.
For
\[
W^0x=Vx\otimes\ket\emptyset_R,\qquad
Z_{A,t}=\mathscr R_AU(t)W^0,
\]
the accessible channel and complete complement are the two partial
traces of \(\Ad_{Z_{A,t}}\).

If \(\sigma_K=\sum_ap_a\ketbra{a_\sigma}{a_\sigma}\), define
\[
\ket{\Xi_i}=
\sum_a\sqrt{p_a}\,Z_{A,t}\ket{i,a_\sigma}\otimes\ket a_G.
\]
With \(E=B(R\setminus A)G\),
\[
\NN^\sigma_{A,t}(E_{ij})=\Tr_E\ketbra{\Xi_i}{\Xi_j},\qquad
\CC^\sigma_{A,t}(E_{ij})=\Tr_A\ketbra{\Xi_i}{\Xi_j}.
\]
These formulas determine every referenced input.
\end{theorem}

\begin{proof}
Finite-dimensional integral evolution gives existence and uniqueness;
self-adjointness gives unitarity.
Preparation, evolution, regrouping, and purification form an isometry.
Its partial traces are CPTP. Matrix-unit expansion gives the formulas
and their reference extensions.
\end{proof}

Total-even evolution makes accessible referenced outputs block diagonal
in accessible parity. Total parity factors in access order as accessible
times environmental parity, and the environmental partial trace gives
the assertion. Accessible parity pinching may therefore precede decoding.

%=====================================================================
\section{P8 specification and exact integer assembly}
\label{sec:p8}
%=====================================================================

\begin{specification}[Frozen P8]
Set \(n=8\), \(g=1\). Enumerate the \(1820\) increasing quartets
of \(\{1,\ldots,16\}\) lexicographically and define
\[
a_0=1,\qquad a_r=(75a_{r-1}+74)\bmod65521,\qquad
J_r=\frac{2a_r-65521}{64\cdot65521}.
\]
Order exact even-sector eigenspaces by energy.
Within each exact degenerate eigenspace, project lexicographic
occupation words and apply Gram--Schmidt, discarding zero projections.
Give each vector a first nonzero occupation coefficient that is
positive real. Select the first two vectors.

Retain the global energy shift over both parities, spectral window
\([0,2h_4]\), \(t_0=\Omega=T=1\), bath vacuum, and signed whole-bath access.
\end{specification}

The coefficient generator is deterministic; typicality is not asserted.
The broad spectral window is not a certified gravitational
low-energy window.

Define
\[
b(x)=
\begin{cases}
\exp[-1/((x-1/4)(3/4-x))],&1/4<x<3/4,\\
0,&\text{otherwise},
\end{cases}
\qquad B_0=\int_0^1b(x)\dd x>0,
\]
\begin{equation}
\kappa(u)=\frac{\pi}{2TB_0}b(u/T).
\label{eq:pulse}
\end{equation}
The pulse is smooth, nonnegative, and has area \(\pi/2\).
At \(u/T=0,1/4,1/2,3/4,1\), its cumulative areas are
\(0,0,\pi/4,\pi/2,\pi/2\), by support and reflection symmetry.

With \(\Gamma_a=\sqrt2\chi_a\), the matrices are signed Gaussian-integer
permutations. Hence
\begin{equation}
\Hfour=\frac{Q_{\mathrm R}+\ii Q_{\mathrm I}}{16773376},
\qquad
16773376=256\cdot65521=4\cdot4193344.
\label{eq:integerH}
\end{equation}
The coefficient denominator \(4193344\) is not the Hamiltonian
denominator.

\begin{proposition}[Exact assembly invariants]
\label{prop:assembly}
The exact matrices satisfy
\[
Q_{\mathrm R}^{\mathsf T}=Q_{\mathrm R},\qquad
Q_{\mathrm I}^{\mathsf T}=-Q_{\mathrm I},
\]
zero even--odd blocks, and
\[
\tr(\Hfour)=0,\qquad
\tr(\Hfour^2)=16\sum_rJ_r^2.
\]
Equivalently,
\[
\sum_{ij}(Q_{\mathrm R,ij}^2+Q_{\mathrm I,ij}^2)
=256\sum_r(2a_r-65521)^2.
\]
\end{proposition}

\begin{proof}
Hermiticity and parity give the matrix symmetries and blocks.
Quartic Clifford monomials are trace orthogonal and square to
\(I/16\). The boundary dimension is \(256\).
Substitute the rational denominators to obtain the integer identity.
\end{proof}

The entrywise assembly bound is
\[
|Q_{\mathrm R,ij}|,\ |Q_{\mathrm I,ij}|
\le1820\cdot65521=119248220.
\]
Assembly and trace sums fit signed 64-bit integers.
The complete square sum is evaluated with arbitrary-size Python integers.

The v8 inspector constructs the same Majoranas independently by
\[
\Gamma_{2j-1}=Z^{\otimes(j-1)}\otimes X\otimes I^{\otimes(8-j)},
\qquad
\Gamma_{2j}=Z^{\otimes(j-1)}\otimes Y\otimes I^{\otimes(8-j)}.
\]
Their monomial entries are exactly representable Gaussian units.
This is a distinct construction from the historical occupation-action
assembly, not a second call to its assembly routine.

%=====================================================================
\section{Quench leakage, best compression, and departure}
\label{sec:quench}
%=====================================================================

Storage gives
\(V_{\mathrm{st}}=e^{-\ii t_0\Hsys}V\), with unchanged range.
The actual quench changes the generator by
\[
\Omega\Nsys-\Hsys
=\frac{\Omega n}{2}I+
\ii\Omega\sum_j\chi_{2j-1}\chi_{2j}-\Hsys.
\]
Define
\[
\nu=V^\dagger\Nsys V,\qquad
\mu=V^\dagger\Nsys^2V,\qquad
\Lambda_N=\mu-\nu^2.
\]

\begin{theorem}[Leakage and best compression]
\label{thm:leakage}
\[
\boxed{
\Lambda_N=V^\dagger\Nsys(I-P)\Nsys V\succeq0,\qquad
L_N=\norm{(I-P)\Nsys V}
=\sqrt{\lambda_{\max}(\Lambda_N)}.}
\]
Furthermore,
\[
E_{\mathrm{code}}=\lambda_{\max}(\nu),\qquad
\inf_{A\in\mathcal B(MK)}
\norm{\Omega\Nsys V-VA}=\Omega L_N,
\]
attained at \(A=\Omega\nu\).
\end{theorem}

\begin{proof}
Insert \(P+(I-P)\) between number operators.
The retained term is \(\nu^2\), and the remainder is the Gram matrix
of \((I-P)\Nsys V\). Projection onto \(I-P\) gives the compression
lower bound; choosing \(A=\Omega\nu\) removes the retained component.
Rayleigh optimization gives the scalar quantities.
\end{proof}

Storage conjugates the compressed matrices by a common code unitary,
preserving their spectra.

For \(\Omega=1\), set \(F(u)=V^\dagger e^{-\ii u\Nsys}V\).

\begin{theorem}[Departure and short-time estimates]
\label{thm:departure}
\[
\boxed{
p_{\max}(u)=\norm{(I-P)e^{-\ii u\Nsys}V}^{\,2}
=1-\lambda_{\min}(F(u)^\dagger F(u)).}
\]
For \(u\ge0\),
\[
\max(0,uL_N-u^2n^2/8)^2
\le p_{\max}(u)
\le\min(1,(uL_N+u^2n^2/8)^2),
\]
\[
|p_{\max}(u)-u^2L_N^2|
\le u^3n^2L_N/4+u^4n^4/64.
\]
For general \(\Omega\), replace \(u\) by \(\Omega u\).
\end{theorem}

\begin{proof}
Retained probability is \(\norm{F(u)x}^2\); optimize its complement.
Center at \(A_0=\Nsys-nI/2\), with norm \(n/2\). The scalar phase
does not affect departure, and the integral Taylor remainder gives
\[
\norm{e^{-\ii uA_0}-I+\ii uA_0}\le u^2n^2/8.
\]
The off-code amplitude is
\(-\ii u(I-P)\Nsys V+R_u\), with the displayed remainder bound.
Triangle inequalities give the first bounds; the squared-norm
difference is at most \(2uL_N\norm{R_u}+\norm{R_u}^2\).
\end{proof}

\begin{proposition}[Uniform departure interpolation]
\label{prop:departuregrid}
\[
|p_{\max}(u)-p_{\max}(v)|\le n|u-v|.
\]
A validated grid of covering radius \(\delta\) requires an additional
allowance \(n\delta\) for a uniform-time claim.
\end{proposition}

\begin{proof}
For \(F_0=V^\dagger e^{-\ii uA_0}V\),
\(\norm{F_0}\le1\), \(\norm{\dot F_0}\le n/2\), and
\(\norm{\frac{\mathrm d}{\mathrm du}(F_0^\dagger F_0)}\le n\).
Apply the Rayleigh principle.
\end{proof}

\begin{lemma}[Odd compression and reached transitions]
For every \(j\),
\(V^\dagger c_jV=V^\dagger c_j^\dagger V=0\).
Nevertheless even joint hopping can act nontrivially. Also,
\[
PABP-(PAP)(PBP)=PA(I-P)BP.
\]
A nonzero boundary subspace invariant under all \(c_j,c_j^\dagger\)
is the full Fock space.
\end{lemma}

\begin{proof}
Parity makes odd compression its negative. Joint hopping changes both
parities together. Insert \(P+(I-P)\) for the composite identity.
An occupation projector selects a nonzero word in an invariant vector;
annihilations give vacuum and creations give every word.
\end{proof}

Nonzero \(L_N\) excludes exact number dynamics confined to the initial
code. It does not exclude an enlarged comparison space or approximate
dictionary, and it is not the extraction-loss parameter.

%=====================================================================
\section{Exact signed extraction and its reached space}
\label{sec:extract}
%=====================================================================

Target A extracts under
\[
H_{\mathrm{ext,m}}(u)=\Omega\Ntot+\kappa(u)\Ghop,\qquad
\Theta(u)=\int_0^u\kappa(s)\dd s.
\]
Since \([\Ntot,\Ghop]=0\),
\[
U_{\mathrm{ext,m}}(u)
=e^{-\ii\Omega u\Ntot}e^{-\ii\Theta(u)\Ghop}.
\]
For disjoint \(L,T\), define
\(I(L,T)=\#\{(t,l):t\in T,l\in L,t<l\}\).

\begin{theorem}[Signed branches and complete channels]
\label{thm:branches}
Writing \(c=\cos\Theta(u)\), \(s=\sin\Theta(u)\), boundary-first
evolution is
\[
\begin{aligned}
U_{\mathrm{ext,m}}(u)(\ket P_B\ket\emptyset_R)
={}&e^{-\ii\Omega u|P|}
\sum_{L\subseteq P}(-1)^{I(L,P\setminus L)}
c^{|L|}(-\ii s)^{|P|-|L|}\\
&\hspace{3em}\times\ket L_B\ket{P\setminus L}_R.
\end{aligned}
\]
If \(K_L\) is the bath coefficient, signed bath-first maps are
\[
\overline K_L\ket P=(-1)^{|L|(|P|-|L|)}K_L\ket P.
\]
Consequently,
\[
\mathcal A_u(X)=\sum_L\overline K_LX\overline K_L^\dagger,
\]
\[
\mathcal A_u^c(X)=
\sum_{L,L'}\tr(\overline K_LX\overline K_{L'}^\dagger)
\ketbra L{L'}.
\]
Zero powers are interpreted as one at endpoints.
\end{theorem}

\begin{proof}
The active creator transformation is
\[
Uc_j^\dagger U^\dagger=
e^{-\ii\Omega u}(c\,c_j^\dagger-\ii s\,b_j^\dagger).
\]
Expand the increasing creator product. Transferred creators cross
retained ones, giving the inversion sign.
Equation~\eqref{eq:regroup} supplies the additional access sign.
Partial traces give the channels, and unitarity gives completeness.
\end{proof}

Set
\[
W_{\mathrm{st}}x=V_{\mathrm{st}}x\otimes\ket\emptyset_R,\qquad
Z_u=\mathscr R_RU_{\mathrm{ext,m}}(u)W_{\mathrm{st}}.
\]
The full-code channels used below are
\[
\mathcal E_u(E_{\alpha\beta})
=\Tr_B\ketbra{Z_u\alpha}{Z_u\beta},\qquad
\mathcal E_u^c(E_{\alpha\beta})
=\Tr_R\ketbra{Z_u\alpha}{Z_u\beta}.
\]
For even inputs, an additional branch phase cancels in the accessible
channel. It must not be omitted on general parity-coherent inputs.

\subsection{Minimal jointly invariant space}

Let \(P_m\) project onto boundary occupation \(m\),
\[
\mathscr V_m=\ran(P_mV_{\mathrm{st}}),\qquad r_m=\rank(P_mV).
\]
For \(\phi=\sum_{|P|=m}\phi_P\ket P\), define
\[
B_{m,k}\phi=
\binom mk^{-1/2}\sum_{|P|=m}\phi_P
\sum_{\substack{T\subseteq P\\|T|=k}}
(-1)^{I(P\setminus T,T)}
\ket{P\setminus T}_B\ket T_R.
\]

\begin{lemma}[Collective chain]
Each \(B_{m,k}\) is an isometry. Distinct \((m,k)\) images are
orthogonal, and
\[
\Ntot B_{m,k}=mB_{m,k},
\]
\[
\Ghop B_{m,k}=
\sqrt{(k+1)(m-k)}B_{m,k+1}
+\sqrt{k(m-k+1)}B_{m,k-1}.
\]
Absent endpoint terms are zero.
\end{lemma}

\begin{proof}
Each partition has a unique union; distinct partition words are
orthogonal, and there are \(\binom mk\) terms per word.
Hopping moves one occupied pair. Counting moves and comparing the
binomial normalizations gives the coefficients with the CAR signs
already included in \(B_{m,k}\).
\end{proof}

\begin{theorem}[Exact minimal reached dimension]
\label{thm:dimension}
The smallest subspace containing the prepared stored code and invariant
under \(\Ntot,\Ghop\) is
\[
\Kext=\bigoplus_{m\ {\rm even}}\bigoplus_{k=0}^m
B_{m,k}\mathscr V_m.
\]
Thus
\[
\boxed{
\dim\Kext=\sum_{m\ {\rm even}}(m+1)r_m
\le\sum_{m\ {\rm even}}(m+1)\min(D,\binom nm).}
\]
Restricted propagation is exact on the code.
For P8, \(4\le\dim\Kext\le40\).
\end{theorem}

\begin{proof}
Number-sector projections are polynomials in \(\Ntot\) on this finite
space. Any invariant subspace containing the initial code contains
\(B_{m,0}\mathscr V_m\). The recurrence successively generates every
\(k\), and proves invariance of the displayed sum.
Orthogonality proves the dimension formula.

For P8 the endpoint ranks are at most one and interior ranks at most
two, giving \(1+6+10+14+9=40\).
Also \(2=\rank V\le\sum_mr_m\).
If \(r_0=1\), a further rank has weight at least three.
If \(r_0=0\), the total weight is at least six.
Hence the unconditional lower bound four.
\end{proof}

This reduction uses uniform hopping and common frequency.
It does not construct a forty-dimensional boundary CAR representation
or reduce the physical bath-output interface to forty dimensions.

\begin{proposition}[Joint spectral Gram]
For the joint spectral projection \(\Pi_{m,\lambda}\), where
\(\lambda=-m,-m+2,\ldots,m\),
\[
W_{\mathrm{st}}^\dagger\Pi_{m,\lambda}W_{\mathrm{st}}
=2^{-m}\binom m{(m+\lambda)/2}
V_{\mathrm{st}}^\dagger P_mV_{\mathrm{st}}.
\]
Every projected-code rank is \(r_m\).
\end{proposition}

\begin{proof}
For a fixed occupied-pair set, each exchange has eigenvalues \(\pm1\);
the all-boundary state has overlap squared \(1/2\) with each.
The sum has the binomial law. Different pair sets are orthogonal and
invariant. Every allowed binomial weight is positive.
\end{proof}

\subsection{Complete decoder and uniform recovery}

Let \(J\) identify occupation bases and set
\[
C_T=e^{+\ii(\Omega T+\pi/2)\Nbath},\qquad
W=JV_{\mathrm{st}},\qquad P_W=WW^\dagger,
\]
\[
\DD_0(Y)=\TrK(W^\dagger YW)
+\tr[(I-P_W)Y]I_M/2,\qquad
\DD_{\mathrm{ext}}=\DD_0\circ\Ad_{C_T}.
\]
Retained Kraus operators are
\((I_M\otimes\bra a_K)W^\dagger\).
For an off-code basis \(z_\ell\), add
\(2^{-1/2}\ket i_M\bra{z_\ell}\), \(i=0,1\).
Their effects sum to \(I_R\), so the decoder is CPTP on every bath input.

\begin{theorem}[Uniform microscopic recovery]
\label{thm:microrecovery}
For \(\eta_{\mathrm m}=\sin^2\Theta(T)\) and
\(0\le\Theta(T)\le\pi/2\),
\[
\ddiam(\DD_{\mathrm{ext}}\mathcal E_T,\TrK)
\le\ell(E_{\mathrm{code}},\eta_{\mathrm m}),\qquad
\ell(E,\eta)=\min(1,\sqrt{2E(1-\sqrt\eta)}).
\]
Arbitrary correlated \(QMK\) inputs are allowed.

At full transfer, with
\(L_T=Je^{-\ii(\Omega T+\pi/2)\Nsys}V_{\mathrm{st}}\),
\[
\mathcal E_T(E_{\alpha\beta})=
\ketbra{L_T\alpha}{L_T\beta},\qquad
\mathcal E_T^c(E_{\alpha\beta})=
\delta_{\alpha\beta}\ketbra\emptyset\emptyset_B.
\]
Recovery is exact. For independent gauge preparation, the complete
message complement is replacement by
\(\ketbra\emptyset\emptyset_B\otimes\sigma_G\).
\end{theorem}

\begin{proof}
The corrected no-loss branch is \(J\eta_{\mathrm m}^{\Nsys/2}\).
For a purified encoded input, overlap with ideal transfer and boundary
vacuum is
\(A=\tr(\rho_B\eta_{\mathrm m}^{\Nsys/2})\ge0\).
Since \(1-r^k\le k(1-r)\),
\(1-A\le E_{\mathrm{code}}(1-\sqrt{\eta_{\mathrm m}})\).
Pure-state distance is at most \(\sqrt{2(1-A)}\).
Decode and contract.

At full transfer only the no-loss branch remains, so the isometry
factors as \(L_T\) times boundary vacuum.
The partial traces give the endpoint identities, and the independent
gauge purification gives its fixed complementary factor.
\end{proof}

%=====================================================================
\section{Referenced comparison and complementary recovery bounds}
\label{sec:recovery}
%=====================================================================

For input dimension \(D\), define normalized Choi states
\[
J_\Phi=\frac1D\sum_{\alpha,\beta}
\ketbra\alpha\beta_Q\otimes\Phi(E_{\alpha\beta}).
\]

\begin{lemma}[Choi and matrix-unit conversions]
\label{lem:choi}
For channels with common input dimension \(D\),
\[
\ddiam(\Phi,\Psi)\le\min(1,D\,\dist(J_\Phi,J_\Psi)).
\]
If all matrix-unit trace-norm differences are at most \(r\), then
\(\ddiam(\Phi,\Psi)\le\min(1,Dr/2)\).
\end{lemma}

\begin{proof}
A pure referenced input is
\((A\otimes I)\ket{\Phi_D}\), up to a reference isometry, with
\(\norm{A}^2\le D\). Trace-norm multiplication proves the Choi bound.
Alternatively write its vector as
\(\sum_\alpha v_\alpha\otimes\ket\alpha\), with
\(\sum_\alpha\norm{v_\alpha}^2=1\).
The output difference norm is at most
\(r(\sum_\alpha\norm{v_\alpha})^2\le Dr\).
Divide by two and use convexity.
\end{proof}

\begin{theorem}[Complementary upper and lower certificates]
\label{thm:complementary}
For a finite qubit channel with complete complement \(\CC\), put
\[
\tau_E=\CC(I_2/2),\qquad
\delta_E=\dist(J_\CC,I_Q/2\otimes\tau_E),
\]
\[
L_E=\max_{P=X,Y,Z}
\dist(\CC((I+P)/2),\CC((I-P)/2)).
\]
A polar-isometry decoder satisfies
\[
\ddiam(\DD_{\mathrm{pol}}\NN,\id_2)
\le\min(1,2\sqrt{2\delta_E}),\qquad
F_e\ge(1-\delta_E)^2.
\]
Every deterministic decoder satisfies
\[
F_e,F_{\mathrm{wc}}\le1-L_E^2/4,\qquad
\ddiam(\DD\NN,\id_2)\ge L_E^2/4.
\]
Consequently,
\[
L_E^2/4\le\varepsilon_{\mathrm{rec}}(\NN)
\le\min(3/4,2\sqrt{2\delta_E}).
\]
\end{theorem}

\begin{proof}
The Bell-input dilation purifies \(J_\CC\).
A Bell pair times a purification of \(\tau_E\) purifies the product
center. Enlarging the decoding ancilla, the polar purification
isometry attains root overlap \(f\ge1-\delta_E\).
The decoded Bell distance is at most
\(\sqrt{1-f^2}\le\sqrt{2\delta_E}\).
Lemma~\ref{lem:choi} gives the factor two.
The maximally mixed constant decoder has error \(3/4\), by the
four-Pauli decomposition and the Bell test.

For any decoder, dilate its output and project its pure Bell-input
state onto the target Bell vector. Normalizing the environmental
projection gives a Bell-product purification at distance
\(\sqrt{1-F_e}\), when \(F_e>0\).
After tracing decoder systems,
\(J_\CC\) is within that distance of \(I_Q/2\otimes\tau\).
Since
\[
\Tr_Q[(P^{\mathsf T}\otimes I)
(J_\CC-I_Q/2\otimes\tau)]=\CC(P)/2,
\]
trace duality gives
\(\norm{\CC(P)/2}_1\le2\sqrt{1-F_e}\).
The left side is the complementary pair distance.
The Bell-projector test gives error at least \(1-F_e\);
worst-case overlap cannot exceed Bell overlap.
The case \(F_e=0\) is immediate.
\end{proof}

The complete complement retains all preparation purifications.
A discarded environmental marginal cannot silently replace it.

%=====================================================================
\section{Restricted continuum experiment}
\label{sec:continuum}
%=====================================================================

\subsection{Declaration and physical boundary}

Nearly-\(AdS_2\), Schwarzian dynamics, and probe matter motivate the
model \cite{MSY,EMV,MTV}. The following tensor-product reduction is
declared, not derived with a controlled full-gravity remainder.

The motivating disk parameters are
\[
L=1,\quad8\pi G=1,\quad S_0=0,\quad
C=\phi_{\mathrm r}=100,\quad\beta=2\pi.
\]
A motivating action is
\[
I_{\mathrm{JT}}=
-S_0\chi(M)-\frac1{16\pi G}
\left[\int_M\sqrt g\,\phi(R+2)
+2\int_{\partial M}\sqrt h\,\phi(K-1)\right],
\]
with \(h_{\tau\tau}=\epsilon^{-2}\),
\(\phi|_{\partial M}=\phi_{\mathrm r}/\epsilon\).
Eight complex massless Dirac species have action
\[
I_D=\frac12\sum_{j=1}^8\int_M\sqrt g
\left[\overline\psi_j\gamma^\mu\nabla_\mu\psi_j
-(\nabla_\mu\overline\psi_j)\gamma^\mu\psi_j\right].
\]
A disk-extending spin structure and homogeneous reflecting boundary
condition may be declared using
\[
\mathcal B=\ii\gamma_*\gamma_n,\quad
\mathcal B^2=I,\quad \{\mathcal B,\gamma_n\}=0,\quad
P_\pm=(I\pm\mathcal B)/2,
\]
with \(P_-\psi=\overline\psi P_-=0\), including variations.
The boundary variation vanishes because \(P_+\gamma_nP_+=0\).

The exterior metric
\[
\dd s^2=-(r^2-1)\dd t^2+\frac{\dd r^2}{r^2-1},\qquad r>1,
\]
motivates the reflected positive-frequency one-body model.
The exact analysis begins with the directly declared multiplication
operator
\[
(hf)(\omega)=\omega f(\omega),\qquad
D(h)=\{f\in L^2(\mathbb R_+):\omega f\in L^2(\mathbb R_+)\},
\]
and normal-ordered matter Hamiltonian
\[
H_D=\sum_j\int_0^\infty\omega
[a_j^\dagger(\omega)a_j(\omega)+d_j^\dagger(\omega)d_j(\omega)]
\dd\omega.
\]

Declare
\[
\HH_{\mathrm{Sch}}=
L^2(\mathbb R_+,\rho_C(E)\dd E),\qquad
\rho_C(E)=\sinh(2\pi\sqrt{2CE}),\qquad
H_{\mathrm{Sch}}\phi=E\phi,
\]
\[
\HH_{\mathrm{red}}=\HH_{\mathrm{Sch}}\otimes\FF(\mathfrak h_D),
\qquad
H_{\mathrm{store,red}}=H_{\mathrm{Sch}}\otimes I+I\otimes H_D.
\]
The spectral normalization is part of the declaration.
Backreaction, fluctuating dressing, and loop corrections are neither
included nor bounded. The static Fock vacuum is not assumed to be a
thermal or horizon-regular Hartle--Hawking state.

\subsection{Packet, excitation code, and controls}

Set
\[
f(\omega)=\sqrt2e^{-\omega},\qquad
\mathcal O_j=a_j(f),\qquad
N_{\mathrm g}=\sum_j\mathcal O_j^\dagger\mathcal O_j,
\]
\[
\phi(E)=\mathbf1_{[1,2]}(E)/\sqrt{\rho_C(E)},
\]
\[
\gamma_0=\phi\otimes\ket{\mathrm{vac}},\qquad
\gamma_1=\phi\otimes
a_1^\dagger(f)a_2^\dagger(f)\ket{\mathrm{vac}}.
\]
Creation is linear and annihilation antilinear in its packet.
These are normalized orthogonal even excitation states, not identified
black-hole microstates. Packet operators are bounded CAR operators;
they are not unsmeared coincident fields.

Direct integration gives
\[
\norm{f}=1,\qquad \langle f,hf\rangle=1/2,\qquad
\langle f,h^2f\rangle=1/2.
\]
The code-state storage-energy means are \(3/2,5/2\), with variances
\(1/12,7/12\). They are not energy eigenvectors.

Extraction retains storage and adds
\[
\Nbath+vN_{\mathrm g}+wI+\kappa G_{\mathrm g},\qquad
G_{\mathrm g}=\sum_j(\mathcal O_j^\dagger b_j+
b_j^\dagger\mathcal O_j).
\]
The primary experiment remains
\begin{equation}
\boxed{t_0=T=\Omega=1,\qquad v=1,\qquad w=0,}
\label{eq:primary}
\end{equation}
with pulse \eqref{eq:pulse}. Other six species and bath modes remain
vacuum.

Storage changes the occupied packet to
\(f_{\mathrm{st}}(\omega)=e^{-\ii\omega t_0}f(\omega)\).
Extraction still couples to the fixed \(f\).
The common Schwarzian state evolves to
\(e^{-\ii(t_0+T)E}\phi(E)\).
It remains factorized and independent of the logical input, so it is
a harmless spectator for the reduced channel, while retained as a
pure complementary factor.

\subsection{Exact one-species evolution}

On \(L^2(\mathbb R_+)\oplus\mathbb C\ket b\), set
\[
K(u)=
\begin{pmatrix}
h+v(u)\ketbra ff&\kappa(u)\ket f\\
\kappa(u)\bra f&1
\end{pmatrix},
\qquad
(\psi(0),B(0))=(f_{\mathrm{st}},0).
\]

\begin{proposition}[Well-posed evolution]
For bounded piecewise continuous real \(v,\kappa\), \(K(u)\) has a
unique interaction-picture unitary propagator.
\end{proposition}

\begin{proof}
Relative to \(h\oplus1\), the perturbation is bounded, self-adjoint,
and finite rank. Strong continuity on the finitely many packet vectors
gives norm continuity of the corresponding rank-one
interaction-picture operators on each control segment.
The norm-convergent Dyson series gives existence and uniqueness;
self-adjointness gives unitarity.
\end{proof}

Put \(A(u)=\langle f,\psi(u)\rangle\) and
\(g(t)=2/(2+\ii t)\).

\begin{theorem}[Stored-packet Volterra characterization]
\label{thm:volterra}
The exact evolution is equivalent to the unique continuous solution
\[
\boxed{
\begin{aligned}
A(u)&=g(u+t_0)-\ii\int_0^u
g(u-s)[v(s)A(s)+\kappa(s)B(s)]\dd s,\\
B(u)&=-\ii\int_0^u e^{-\ii(u-s)}\kappa(s)A(s)\dd s.
\end{aligned}}
\]
The matter packet is
\[
\psi(u,\omega)=
f(\omega)e^{-\ii\omega(u+t_0)}
-\ii f(\omega)\int_0^u e^{-\ii\omega(u-s)}
[v(s)A(s)+\kappa(s)B(s)]\dd s.
\]
For the primary experiment, \(A(0)=(4-2\ii)/5\), \(B(0)=0\).
\end{theorem}

\begin{proof}
Variation of constants gives the packet formula.
Contracting with \(f\) uses
\(\langle f,e^{-\ii th}f\rangle=g(t)\).
Variation of constants for \(\ii\dot B=B+\kappa A\) gives the second
equation. Conversely, the packet formula reconstructs the mild
Schr\"odinger solution; uniqueness proves equivalence.
\end{proof}

Let \(q=B(1)\), \(\eta=|q|^2\).
Unitarity gives \(\norm{\psi(1)}^2=1-\eta\).
Zero coupling gives \(B=0\); if \(v=\kappa=0\),
\(A(u)=g(u+1)\).

For the primary Volterra operator, the componentwise maximum-norm
majorant is \(1+|\kappa(u)|\). Thus
\[
M=\int_0^1(1+|\kappa|)\dd u=1+\pi/2.
\]
Ordered integration proves a uniformly convergent Neumann series,
with truncation after \(m\) bounded by
\(e^MM^{m+1}/(m+1)!\).

%=====================================================================
\section{Candidate dilation, decoder, and limitations}
\label{sec:candidate}
%=====================================================================

Write \(r=\sqrt{1-\eta}\). For \(r>0\), let \(e_j\) be the normalized
residual packet \(\psi(1)/r\) in species \(j\).

\begin{theorem}[Complete signed candidate dilation]
\label{thm:dilation}
In bath-first order,
\[
Z\ket0=\ket{00}_R\ket{00}_E,
\]
\[
\boxed{
Z\ket1=
q^2\ket{11}_R\ket{00}_E+
qr\ket{10}_R\ket{01}_E-
qr\ket{01}_R\ket{10}_E+
r^2\ket{00}_R\ket{11}_E.}
\]
Unused modes are vacuum, and the evolved Schwarzian factor is common
and pure.
\end{theorem}

\begin{proof}
Expand
\((re_1^\dagger+qb_1^\dagger)(re_2^\dagger+qb_2^\dagger)\).
CAR and bath-first regrouping give opposite mixed signs.
The occupied column has norm squared
\(\eta^2+2\eta(1-\eta)+(1-\eta)^2=1\) and is orthogonal to
the vacuum column.
\end{proof}

The accessible units are
\[
\begin{aligned}
\NN_{\mathrm g}(E_{00})&=\ketbra{00}{00},\\
\NN_{\mathrm g}(E_{11})&=
\eta^2\ketbra{11}{11}+(1-\eta)^2\ketbra{00}{00}
+\eta(1-\eta)(\ketbra{10}{10}+\ketbra{01}{01}),\\
\NN_{\mathrm g}(E_{01})&=(q^*)^2\ketbra{00}{11},\qquad
\NN_{\mathrm g}(E_{10})=q^2\ketbra{11}{00}.
\end{aligned}
\]
The residual-mode complementary units are
\[
\begin{aligned}
\CC_{\mathrm g}(E_{00})&=\ketbra{00}{00},\\
\CC_{\mathrm g}(E_{11})&=
\eta^2\ketbra{00}{00}+(1-\eta)^2\ketbra{11}{11}
+\eta(1-\eta)(\ketbra{10}{10}+\ketbra{01}{01}),\\
\CC_{\mathrm g}(E_{01})&=(1-\eta)\ketbra{00}{11},\qquad
\CC_{\mathrm g}(E_{10})=(1-\eta)\ketbra{11}{00}.
\end{aligned}
\]
Embedding and tensoring fixed vacuum and spectator factors give the
full channels. The residual modes are not discarded information.

Different experiments require a common environmental identification
before comparing their physical complements. An amplitude enclosure
does not identify residual wavefunctions.

\subsection{Specified complete decoder}

For \(q=\sqrt\eta e^{\ii\alpha}\ne0\), set
\(C_\alpha=e^{-\ii\alpha\Nbath}\); at \(q=0\), fix any phase.
Let \(W_{\mathrm e}\) embed logical \(0,1\) as bath words \(00,11\),
with all unused modes vacuum, and
\(P_{\mathrm e}=W_{\mathrm e}W_{\mathrm e}^\dagger\).
Define
\[
\DD_{\mathrm g}=\DD_{\mathrm e,0}\circ\Ad_{C_\alpha},\qquad
\DD_{\mathrm e,0}(Y)=
W_{\mathrm e}^\dagger YW_{\mathrm e}
+\tr[(I-P_{\mathrm e})Y]I_2/2.
\]
The retained/off-code Kraus construction makes this map CPTP on
every eight-mode bath input.

\begin{theorem}[Exact specified-decoder performance]
\label{thm:specified}
\[
\boxed{
\DD_{\mathrm g}\NN_{\mathrm g}
=\eta\id_2+(1-\eta)\RR_{\ketbra00},\qquad
e_{\mathrm{specified}}
=\ddiam(\DD_{\mathrm g}\NN_{\mathrm g},\id_2)=1-\eta.}
\]
Its Bell fidelity is \((1+3\eta)/4\), and its worst-case target overlap
is \(\eta\). No optimality is asserted.
\end{theorem}

\begin{proof}
Phase correction makes the off-diagonal coefficient \(\eta\).
The odd words are replaced by \(I_2/2\).
The occupied input has decoded \(\ket1\) probability
\(\eta^2+\eta(1-\eta)=\eta\); vacuum is unchanged.
Identity and replacement by \(\ket0\) have half-diamond distance one,
witnessed by \(\ket1\). The replacement Bell overlap is \(1/4\).
Every target overlap is at least \(\eta\), attained by \(\ket1\).
\end{proof}

\begin{proposition}[Complementary diagnostics]
\label{prop:candidatebounds}
\[
L_E=1-\eta^2,\qquad
\delta_E=\frac{1-\eta}{4}
\left(\sqrt{\eta^2+4}+1+2\eta\right),
\]
\[
\frac{(1-\eta^2)^2}{4}
\le\varepsilon_{\mathrm{rec}}(\NN_{\mathrm g})
\le\min(3/4,1-\eta,2\sqrt{2\delta_E}).
\]
\end{proposition}

\begin{proof}
The complementary \(Z\)-pair distance is \(1-\eta^2\), while the
\(X,Y\) distances are \(1-\eta\).
With \(t=1-\eta\), the nontrivial Choi-difference block is
\[
\begin{pmatrix}
t(1+\eta)/4&t/2\\
t/2&t^2/4
\end{pmatrix}.
\]
Its trace norm is \(t\sqrt{\eta^2+4}/2\).
Other diagonal absolute values sum to \(t(1/2+\eta)\).
Divide by two and apply Theorems~\ref{thm:complementary}
and \ref{thm:specified}.
\end{proof}

\begin{theorem}[No exact finite-time transfer]
\label{thm:noexact}
For finite \(T\), \(t_0\ge0\), and bounded piecewise continuous real
controls in the stated one-species model, \(|B(T)|<1\).
\end{theorem}

\begin{proof}
If \(|B(T)|=1\), unitarity gives \(\psi(T)=0\).
Since \(f(\omega)>0\), the packet formula implies
\[
e^{-\ii\omega t_0}
=\ii\int_0^T e^{\ii\omega s}c(s)\dd s,\qquad c=vA+\kappa B,
\]
for almost every positive \(\omega\).
Both sides extend to entire functions, so equality holds everywhere.
At \(\omega=\ii y\), the left side is \(e^{yt_0}\).
For \(t_0>0\) it contradicts boundedness of the right side.
For \(t_0=0\), dominated convergence makes the right side tend to zero
while the left side is one.
\end{proof}

This supplies neither a positive numerical error floor nor a
quarter-error exclusion. It does not apply to finite-mode microscopic
full transfer.

%=====================================================================
\section{Reported P8 and candidate computations}
\label{sec:results}
%=====================================================================

\subsection{Historical P8-new record}

The supplied manifest reports
\[
\code{mode=p8},\quad
\code{status=COMPLETED_NOT_VALIDATED},\quad
\code{validated=false}.
\]
Its invocation is
\begin{verbatim}
em03h_tools.py p8 --out P8-new \
  --baseline /workspace/attachments/Em03-H-v1_6.tex
\end{verbatim}
Reported UTC timestamps are
\code{2026-10-09T07:06:30.089268+00:00} and
\code{2026-10-09T07:06:39.561565+00:00}.
The separately reported monotonic interval is
\(8.495968482999999\) seconds. These timing fields have different
scopes in the printed runner.

The reported environment is Python 3.10.21, NumPy 2.2.6, and
\code{Linux-6.12.8+-x86_64-with-glibc2.36}.
The build configuration reports GCC 10.2.1 and OpenBLAS 0.3.29 with
64-bit integer support; these are build metadata, not independent
runtime verification.

Standard error contains only the supplied warning
\begin{verbatim}
UserWarning: Install `pyyaml` for better output
\end{verbatim}
The warning concerns configuration formatting \cite{NumPyConfig}.
It is not a reported numerical failure.

\begin{center}
\small
\renewcommand{\arraystretch}{1.12}
\begin{longtable}{@{}p{0.43\textwidth}p{0.47\textwidth}@{}}
\toprule
P8 quantity & Reported value, evidence \(\Reported\)\\
\midrule
\endfirsthead
\toprule
P8 quantity & Reported value, evidence \(\Reported\)\\
\midrule
\endhead
\bottomrule
\endfoot
Global unshifted minimum & \(-0.18879744529131348\)\\
Even minimum & \(-0.18879744529131348\)\\
Odd minimum & \(-0.18543532266058962\)\\
Even minus odd minimum & \(-0.003362122630723857\)\\
Selected unshifted even energies &
\(-0.18879744529131348,\ -0.1866030396545205\)\\
Selected shifted energies & \(0,\ 0.00219440563679299\)\\
First-to-second even gap & \(0.00219440563679299\)\\
Second-to-third even gap & \(0.012450995644200352\)\\
\(E_{\mathrm{code}}\) & \(4.318140424446922\)\\
\(L_N\) & \(1.4473228981681243\)\\
\(p_{\max}(1/8)\) & \(0.032277775445887835\)\\
\(p_{\max}(1/4)\) & \(0.12385356780895762\)\\
Exploratory phase-surrogate anchors & \(0,0\)\\
Exact computed dimension & \code{null}\\
\end{longtable}
\end{center}

These numbers agree between supplied stdout and manifest.
That is a textual consistency check, not independent calculation.
The exploratory winner is the even sector; an exact winner requires
validated parity separation.

\begin{center}
\small
\begin{tabular}{@{}c p{0.53\textwidth} c@{}}
\toprule
Occupation & Reported singular values & Exact rank\\
\midrule
0 & \(0.07330013317063244\) & Unresolved\\
2 & \(0.5686438791780172,\ 0.39196357521534353\) & Unresolved\\
4 & \(0.7566902822635679,\ 0.6802142209905506\) & Unresolved\\
6 & \(0.5686438791780176,\ 0.39196357521534364\) & Unresolved\\
8 & \(0.07330013317063266\) & Unresolved\\
\bottomrule
\end{tabular}
\end{center}

The new summary reports a prior inspector discrepancy near
\(8.5\times10^{-15}\). No corresponding complete inspection report
or check-by-check discrepancies are supplied. It is not attributed
to a successful execution of the v7 inspector, which the summary says
encountered transient \code{inspection.json} I/O failures.

The binary files naming full \(\nu,\mu,\Lambda_N\), bases, departures,
units, and Choi objects remain unavailable for independent reloading
here. Their entries are not reconstructed from scalar summaries.

\subsection{New candidate results}

The supplied results summary reports the following rounded values.
Its numerical precision is not promoted to an error guarantee.

\begin{center}
\small
\renewcommand{\arraystretch}{1.12}
\begin{tabular}{@{}p{0.34\textwidth}p{0.56\textwidth}@{}}
\toprule
Candidate quantity & Reported value, evidence \(\Reported\)\\
\midrule
Pulse normalization & \(B_{0,\mathrm{float}}\approx1.194\times10^{-8}\)\\
Volterra mesh \(n=256\) &
\(q\approx-0.779257+0.076788\ii,\quad \eta\approx0.613138\)\\
Volterra mesh \(n=512\) &
\(q\approx-0.779252+0.076806\ii,\quad \eta\approx0.613132\)\\
Reported finest spectral/RK endpoint &
\(q\approx-0.779250+0.076812\ii\)\\
Reported finite spectral-system norm & Approximately one\\
Reported spectral/finest-Volterra difference & Approximately \(6\times10^{-6}\)\\
Specified-decoder exploratory error & \(1-\eta\approx0.38687\)\\
\bottomrule
\end{tabular}
\end{center}

The summary does not identify the actual energy-node and time-step
counts of its ``finest'' spectral calculation. Those parameters are
not inferred from defaults in the source.

The agreement suggests a stable exploratory endpoint.
It does not bound continuum error: both calculations use numerical
pulse normalization, and the spectral method additionally has
quadrature and time-stepping errors.

\subsection{Reported coarse defect-check result}

The summary reports a patched checker invocation with:
\[
\code{bits=48},\quad \code{refine=1},\quad
\code{pulse-cells=512},\quad n=256,
\]
status
\code{BOUND_COMPUTED_INSPECTION_REQUIRED},
uniform defect upper bound about \(0.117\), transmission enclosure
\([0,1]\), and verdict \code{unresolved}.

Only a rounded description of the rational output is supplied.
Consequently, this edition cannot reproduce its exact interval
endpoints or authenticate its patched executable.

For scale only, the analytical amplification is
\[
e^{1+\pi/2}\approx13.1,
\]
so multiplying the rounded reported defect by this factor gives an
amplitude allowance around \(1.53\).
This illustrative calculation explains why the reported enclosure
is uninformative; it is not a substitute for the original certificate.

\subsection{Permitted conclusion}

The reported endpoint suggests that the specified decoder does not
meet one-quarter error.
The validated numerical verdict remains unresolved because the only
reported certified-style transmission interval is \([0,1]\).

Even a future validated exclusion for this decoder would not exclude
all decoders. Theorem~\ref{thm:specified} is a performance identity
for a specified map, not an optimality theorem.

%=====================================================================
\section{Spectral and diagnostic certification}
\label{sec:spectral}
%=====================================================================

\subsection{Exact inputs and routine guarantees}

Use the exact integer matrices and denominator in
\eqref{eq:integerH}, not a decimal reconstruction.

NumPy's \code{eigh} returns ascending approximate eigenvalues and
normalized eigenvector columns, uses a selected triangle, and treats
imaginary diagonal parts as zero \cite{NumPyEigh}.
It does not validate selection or audit full Hermiticity.

The supplied FLINT documentation distinguishes \cite{FLINTMat}:
\begin{enumerate}[label=\textup{(\arabic*)}]
\item approximate QR eigenvalues, with heuristic convergence only;
\item global spectrum coverage, without a one-to-one ball assignment;
\item successful all-simple isolation;
\item successful exhaustive counted clusters;
\item local eigenpair or invariant-subspace enclosures.
\end{enumerate}
A counted cluster does not prove exact degeneracy.
A local ``at least \(k\)'' statement is not an exhaustive selection
certificate. Outputs are not automatically energy-sorted.

The documented eigenvalue routines are experimental and may fail to
converge as precision increases. Archive the actual installed version
or commit, precision, return status, and guarantees used.
No FLINT invocation is reported in the supplied P8-new record.

Approximate routines ignore radii; zero-radius numerical outputs are
not exact-solution certificates. Rigorous routines must establish
certificate premises. The documented infinity-norm bound is a row-sum
bound, whereas
\[
\norm X\le\norm X_{\mathrm F}
\]
or
\(\norm X\le\sqrt{\norm X_1^{\mathrm{ind}}\norm X_\infty^{\mathrm{ind}}}\)
suffices for the operator norm here.

\subsection{Exhaustive indexed eigenvalue intervals}

\begin{theorem}[Full-basis Hermitian certificate]
\label{thm:spectrum}
Let \(H=H^\dagger\),
\(L=\diag(\mu_1,\ldots,\mu_d)\), with sorted real \(\mu_i\),
and \(A\in\mathbb C^{d\times d}\).
Suppose validated bounds establish
\[
\norm{A^\dagger A-I}\le\delta<1,\qquad
\norm{H-ALA^\dagger}\le r_0,\qquad \norm L\le m.
\]
Set
\[
a=1-\sqrt{1-\delta},\qquad
e_{\mathrm{all}}=r_0+(\sqrt{1+\delta}+1)am.
\]
Then, counted with multiplicity,
\[
|\lambda_i(H)-\mu_i|\le e_{\mathrm{all}}
\quad\text{for every }i.
\]
No indexed level is omitted.
\end{theorem}

\begin{proof}
The polar normalization \(Q=A(A^\dagger A)^{-1/2}\) is unitary.
Singular values give \(\norm{A-Q}\le a\),
\(\norm A\le\sqrt{1+\delta}\), hence
\[
\norm{ALA^\dagger-QLQ^\dagger}
\le(\norm A+1)\norm{A-Q}\norm L.
\]
The Hermitian min--max principle compares each ordered eigenvalue
with that of \(QLQ^\dagger\), namely \(\mu_i\).
\end{proof}

The full bases named in P8-new can be inputs to this theorem, but its
numerical premises remain unestablished here.
If centering is used, recompute the centered discrepancy; it is not
unchanged when \(A\) is only approximately unitary.

For parity-minimum intervals \([a_+,b_+]\), \([a_-,b_-]\),
\[
E_{\min}\in[\min(a_+,a_-),\min(b_+,b_-)].
\]
Strict separation establishes the winning parity; overlap does not
establish a tie.

\subsection{Eigenvectors, phases, and ranks}

\begin{lemma}[Isolated residual]
If \(\lambda\) is simple, every other eigenvalue is at least
\(\Delta>0\) from \(\mu\), and normalized \(v\) has residual
\(r=\norm{(H-\mu I)v}<\Delta\), then
\[
\norm{(I-P_\lambda)v}\le r/\Delta,\qquad
\norm{v-\beta'}\le\sqrt2\,r/\Delta
\]
after optimal phase alignment.
\end{lemma}

\begin{proof}
Expand in the eigenbasis.
Off-target squared norm is at most \(r^2/\Delta^2\).
For off-target norm \(s\), aligned distance squared is
\(2(1-\sqrt{1-s^2})\le2s^2\).
\end{proof}

If \(v_0=b>0\) is real and
\(\norm{v-\beta'}\le e<b\), the first exact coefficient is nonzero.
Rotating to the frozen positive-real phase gives
\[
\norm{v-\beta}\le
e+2\sin\!\left(\tfrac12\arcsin(e/b)\right).
\]
The first coefficient lies in the radius-\(e\) disk centered at \(b\).
A later anchor also requires exact zeros for preceding coefficients.

For isometries \(V,\widehat V\), with
\(\norm{V-\widehat V}\le v\),
\[
\norm{\nu-\widehat\nu}\le2nv,\qquad
\norm{\mu-\widehat\mu}\le2n^2v,\qquad
\norm{\Lambda_N-\widehat\Lambda_N}\le6n^2v,
\]
\[
\norm{V^\dagger P_mV-\widehat V^\dagger P_m\widehat V}\le2v.
\]
Insert mixed compressions to prove these estimates.
Arithmetic errors are additional. Normalize eigenvectors rigorously;
FLINT's left normalization \(L=R^{-1}\) is not Euclidean
orthonormality of \(R\).

For a Hermitian \(2\times2\) matrix
\[
X=\begin{pmatrix}a&z\\z^*&d\end{pmatrix},
\qquad
\lambda_\pm(X)=
\frac{a+d\pm\sqrt{(a-d)^2+4|z|^2}}2.
\]
Directed interval evaluation yields diagnostic eigenvalue bounds.
If \(\norm{\widetilde F-F}\le e_F\), then
\[
\norm{\widetilde F^\dagger\widetilde F-F^\dagger F}
\le(2+e_F)e_F.
\]

Interior occupation rank two follows from a positive validated lower
bound for \(\lambda_{\min}(V^\dagger P_mV)\).
Endpoint rank one follows from positive validated trace and structural
rank at most one. If rank intervals remain,
\[
\sum_m(m+1)r_m^-\le\dim\Kext\le\sum_m(m+1)r_m^+.
\]
Positive floating-point singular values alone do not certify ranks
of the exact frozen code.

%=====================================================================
\section{Continuum defect certification and the next accuracy target}
\label{sec:defect}
%=====================================================================

\subsection{Uniform defect conversion}

For continuous approximations define defects against the true pulse:
\[
\begin{aligned}
d_A(u)&=\widetilde A(u)-g(u+1)
+\ii\int_0^u g(u-s)
[\widetilde A(s)+\kappa(s)\widetilde B(s)]\dd s,\\
d_B(u)&=\widetilde B(u)
+\ii\int_0^u e^{-\ii(u-s)}
\kappa(s)\widetilde A(s)\dd s.
\end{aligned}
\]

\begin{theorem}[Defect-to-continuum bound]
\label{thm:defect}
If
\(\sup_u\max(|d_A(u)|,|d_B(u)|)\le\epsilon\), then
\[
\sup_u\max(|A-\widetilde A|,|B-\widetilde B|)
\le\epsilon e^{1+\pi/2}.
\]
In particular, \(|q-\widetilde B(1)|\le\epsilon e^{1+\pi/2}\).
\end{theorem}

\begin{proof}
Subtract the Volterra equations. The maximum component error satisfies
\[
e(u)\le\epsilon+\int_0^u(1+|\kappa(s)|)e(s)\dd s.
\]
Iterate the integral inequality. The exact nonnegative pulse has
area \(\pi/2\).
\end{proof}

Initial-data, arithmetic, pulse, quadrature, and interpolation errors
are included through the true-coefficient defect. Agreement of two
solvers does not replace this premise.

\begin{theorem}[Whole-cell triangular enclosure]
\label{thm:cell}
Partition \([0,1]\) into cells \(I_j=[t_j,t_{j+1}]\).
For \(u\in I_j\), split each defect integral into earlier full cells
and \([t_j,u]\).

On an earlier cell \(I_k\), enclose its integrand using
\[
u-s\in[t_j-t_{k+1},t_{j+1}-t_k],
\]
then multiply by \(|I_k|\).
On the last partial interval use
\(u-s\in[0,|I_j|]\) and multiply the integrand rectangle by
\([0,|I_j|]\).
The resulting defect rectangles cover all \(u\in I_j\).

A rectangle \([a,b]+\ii[c,d]\) has modulus at most
\[
\max(|a|,|b|)+\max(|c|,|d|).
\]
Taking the maximum over cells produces a uniform \(\epsilon\).
\end{theorem}

\begin{proof}
The integral average of a function in a convex rectangle remains in
that rectangle. The partial interval has length in
\([0,|I_j|]\). Interval arithmetic preserves inclusion, and
\(|x+\ii y|\le|x|+|y|\).
\end{proof}

\subsection{Pulse and elementary-function enclosures}

Let \(D(x)=(x-1/4)(3/4-x)\).
Its extrema on a support cell are found at endpoints and, if present,
\(1/2\). Since the bump is increasing in \(D>0\), these extrema
give a pulse rectangle. Boundary-crossing cells include zero.

Summing lengths times pulse intervals encloses \(B_0\). Analytically,
\[
\tfrac14e^{-64/3}\le B_0\le\tfrac12e^{-16}.
\]
The lower bound uses \([3/8,5/8]\), and the upper uses the support
length and maximum.

The checker encloses
\[
\pi=16\arctan(1/5)-4\arctan(1/239)
\]
by alternating series.
For \(e^{-x}\), scale to \(y=x/2^s\le1\), enclose its Taylor
polynomial using
\[
\left|e^{-y}-\sum_{k=0}^p(-y)^k/k!\right|
\le3y^{p+1}/(p+1)!,
\]
and square the interval \(s\) times.
For \(x\ge b\), use \(e^{-x}\le2^{-b}\).
Sine and cosine use alternating bounds and monotonicity on \([0,1]\).

Established ball arithmetic and rigorous integration provide alternative
implementations \cite{JohanssonArb,JohanssonIntegration}; they do not
certify the reported run merely by existing.

\subsection{Amplitude, phase, and verdict}

If a validated certificate gives
\[
|q-\widehat q|\le e_q,\qquad |\widehat q|\in[m_-,m_+],
\]
then
\[
\eta_-=\max(0,m_--e_q)^2,\qquad
\eta_+=\min(1,(m_++e_q)^2),
\]
\[
e_{\mathrm{specified}}\in[1-\eta_+,1-\eta_-].
\]
Thus:
\[
\eta_-\ge3/4
\ \Longrightarrow\ \text{specified decoder meets quarter error},
\]
\[
\eta_+<3/4
\ \Longrightarrow\ \text{specified decoder fails quarter error}.
\]
Otherwise the certificate is inconclusive.

If an estimated phase \(\widehat\alpha\) is used, the decoded channel is
\[
\eta\Ad_{\diag(1,e^{2\ii(\alpha-\widehat\alpha)})}
+(1-\eta)\RR_{\ketbra00}.
\]
Its error is at most
\[
\min(1,1-\eta+\eta|\sin(\alpha-\widehat\alpha)|).
\]
For \(m_->e_q\), use
\(s_{\mathrm{phase}}\le e_q/m_-\); otherwise use one.
A sufficient upper bound is
\(1-\eta_-(1-s_{\mathrm{phase}})\).
Implementation error is separate.

\begin{corollary}[A sufficient exclusion target]
\label{cor:target}
To exclude quarter-error performance of the specified ideal-phase
decoder, it suffices to establish
\[
m_++e_q<\sqrt3/2.
\]
For a defect certificate it suffices that
\[
m_++\epsilon e^{1+\pi/2}<\sqrt3/2.
\]
\end{corollary}

\begin{proof}
The condition gives \(\eta_+<3/4\), then
Theorem~\ref{thm:specified} gives error greater than one quarter.
\end{proof}

Using the rounded exploratory \(\eta\approx0.613132\) only as a
planning estimate gives \(|q|\approx0.7830\).
The estimated amplitude margin to \(\sqrt3/2\) is about \(0.0830\).
The corresponding defect target is roughly \(0.0063\), before any
additional center/modulus allowances. These are refinement targets,
not validated bounds. The reported \(0.117\) defect is too wide
for this purpose.

Refine according to the source of width:
\begin{enumerate}[label=\textup{(\arabic*)}]
\item tighten \(B_0\) when pulse-normalization uncertainty dominates;
\item refine validation cells when kernel/interpolant range wrapping
dominates;
\item refine solver nodes when the approximation defect dominates;
\item increase arithmetic precision only when rounding contributes
materially.
\end{enumerate}
Validation-cell refinement does not improve a fixed interpolant;
it only tightens its enclosure.

\subsection{Normalization cross-check}

For \(c=A+\kappa B\), expansion gives
\[
\begin{aligned}
\norm{\psi(1)}^2={}&1+
2\operatorname{Re}\left[-\ii\int_0^1g(-s-1)c(s)\dd s\right]\\
&+\int_0^1\int_0^1c(s)^*g(s-t)c(t)\dd s\dd t.
\end{aligned}
\]
This follows from the exponential packet measure and Fubini.
With frequency cutoff \(W\),
\[
\int_W^\infty|\psi(1,\omega)|^2\dd\omega
\le e^{-2W}\left(1+\int_0^1|c(s)|\dd s\right)^2.
\]
A finite spectral-system norm near one is not automatically a
continuum normalization certificate.

%=====================================================================
\section{Debugging, provenance, and submission boundary}
\label{sec:debug}
%=====================================================================

\subsection{Mixed arithmetic defect}

The printed v7 real-interval multiplication method attempted to
convert every right operand to a real interval. Expressions such as
\[
\code{kap[j] * bv[j]}
\]
therefore attempted to convert a complex rectangle to a rational
scalar, before reflected multiplication could run.
Reversing operands at individual call sites can avoid the immediate
exception, but does not repair the type interface globally.

The v8 real class returns \code{NotImplemented} for complex operands,
allowing the complex reflected method to handle mixed arithmetic.
This follows Python's documented numeric dispatch convention
\cite{PythonNumeric}. Complex-valued calculations also use explicit
complex promotion. Startup self-tests cover both multiplication orders.

This is a static repair. The exact patched v7 source used for the
reported result remains unidentified.

\subsection{I/O and partial inspection}

The summary reports transient I/O errors but provides no traceback
or filesystem diagnostic. Their cause is not inferred.

Repeated writes to one fixed temporary filename are replaced by:
\begin{enumerate}[label=\textup{(\arabic*)}]
\item an append-only check journal, flushed and synchronized after
each record;
\item unique temporary snapshot files in the destination directory;
\item bounded retries for selected transient I/O errors;
\item independent finalization attempts that do not replace the
original numerical exception;
\item an explicit failure status when persistence does not complete.
\end{enumerate}
The temporary-file and replacement facilities are standard Python
interfaces \cite{PythonIO}.

This is not a guarantee against power loss, process termination, disk
exhaustion, permissions, or an unavailable filesystem.
If persistence fails, inspection is incomplete. Earlier journal
records may survive, but are not promoted to a successful inspection.

\subsection{Conditional gravitational recovery}

\begin{assumption}[Independent physical identification]
An independent construction supplies a gravitational theory, physical
state space, justified code isometry from the same \(MK\), phases,
gauge interpretation, controlled validity remainders, actual controls,
and an accessible channel \(\GG_T\) with fixed CPTP output map
\(\JJ_{\mathrm{out}}\).
The output map uses no inaccessible remnant, reference, interior partner,
or undisclosed purification.
\end{assumption}

If \(F=\JJ_{\mathrm{out}}\GG_T\) satisfies
\(\ddiam(F,\mathcal E_T)\le e_{\mathrm{dict}}\), then
\[
\ddiam(\DD_{\mathrm{ext}}F,\TrK)
\le\min(1,\ell+e_{\mathrm{dict}}),
\]
by postprocessing contraction and Theorem~\ref{thm:microrecovery}.
This implication does not supply its physical premises.

A global comparison isometry requires separate accessible-output
compatibility. Unbounded-generator comparisons require domains and
controlled truncation. Typed implementation, access, decoder, and
dictionary discrepancies are charged once at their respective interfaces.

\subsection{Work and resources}

For stored density \(\rho_{\mathrm{st}}\), put
\(\bar n=\tr(\rho_{\mathrm{st}}\Nsys)\). Ideal extraction gives
\[
\langle\Nbath\rangle_{\mathrm{final}}=\eta_{\mathrm m}\bar n,\qquad
\langle\Nsys\rangle_{\mathrm{final}}=(1-\eta_{\mathrm m})\bar n.
\]
Mode mixing and initial bath vacuum prove these identities.
The instantaneous quench work is
\[
W_{\mathrm{quench}}=
\Omega\bar n-\tr(\rho_{\mathrm{st}}\Hsys).
\]
The hopping switch has zero mean work: \(\Ghop\) is conserved during
extraction and has initial expectation zero.
These are reference-Hamiltonian energies, not free energies or
autonomous black-hole mass loss.

The decoder is a complete mathematical specification, not a physically
implemented local receiver. Preparation, whole-bath delivery, code
inversion, ancillas, and compilation remain separate resources.

\subsection{Release statement}

\begin{theorem}[Version-8 analytical release]
The printed specifications and proofs establish the finite channel
interface, quench diagnostics, exact signed extraction, minimal reached
dimension formula, and uniform microscopic recovery.
They also establish the stored-packet Volterra dynamics, complete
candidate channel, specified-decoder performance, complementary
diagnostics, and no-exact-transfer theorem.

The spectral and defect theorems provide sufficient numerical
certification implications.
The supplied records report exploratory P8 and candidate calculations,
but no independently authenticated nontrivial amplitude certificate or
certified P8 ranks are asserted.
\end{theorem}

\begin{proof}
The finite results follow from
Theorems~\ref{thm:channels}--\ref{thm:microrecovery}.
The continuum results follow from
Theorems~\ref{thm:volterra}--\ref{thm:noexact}.
Theorems~\ref{thm:spectrum}, \ref{thm:defect}, and \ref{thm:cell}
give the numerical implications.
Section~\ref{sec:results} attributes the supplied computation reports
without replacing missing numerical premises.
\end{proof}

The supported submission classification is an analytical
fixed-instance study with attributed exploratory computational evidence
and unexecuted v8 reproducibility software.
It is not yet an independently inspected, numerically validated
fixed-instance release.

No passive evaporation, Page curve, smooth interior, ultraviolet
robustness, evaporation endpoint, or P8 gravitational dictionary is
established. Contextual references to other manuscript programmes do
not discharge their admission or proof obligations.

%=====================================================================
\appendix
\section{Journaled inspection and candidate computation software}
\label{app:tools}
%=====================================================================

Extract this listing as \code{em03h_v8_tools.py}.
It is a new, unexecuted v8 artifact.

\begin{verbatim}
python em03h_v8_tools.py inspect-p8 \
  --archive P8-new --out P8-v8-inspection

python em03h_v8_tools.py candidate \
  --meshes 256 512 --out candidate-v8

python em03h_v8_tools.py inspect-candidate \
  --archive candidate-v8 --out candidate-v8-inspection
\end{verbatim}

The inspector checks archive hashes, frozen metadata, complete units,
both complementary and accessible endpoints, and the exact JSON/NPZ
node correspondence. Its floating-point checks are inspection tests,
not rigorous enclosures.

For candidate runs, final spectral states and quadrature data are
saved. Candidate inspection recomputes the saved solver constructions;
this is replay consistency, not an independent continuum proof.

\begin{lstlisting}
#!/usr/bin/env python3
"""Em03-H-v8 tools. New, statically revised, unexecuted artifact."""
import argparse
import contextlib
import datetime
from fractions import Fraction as F
import hashlib
import itertools
import json
import math
import os
import errno
from pathlib import Path
import platform
import shutil
import sys
import tempfile
import time
import traceback

np = None
TOL = 2e-10
PTOL = 1e-12
DEN = 256*65521
TIMES = (0., .25, .5, .75, 1.)
ANGLES = (0., 0., math.pi/4, math.pi/2, math.pi/2)
CONTRACT = {"t0":1, "T":1, "Omega":1,
            "v":1, "w":0, "packet":"fixed_f"}
TRANSIENT = {errno.EINTR, errno.EAGAIN, errno.EBUSY, errno.EIO}

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

def sha(path):
    return hashlib.sha256(Path(path).read_bytes()).hexdigest()

def atomic_json(path, data):
    path = Path(path)
    payload = json.dumps(data, indent=2, allow_nan=False)
    for attempt in range(3):
        tmp = None
        try:
            fd, name = tempfile.mkstemp(
                prefix="."+path.name+".", suffix=".tmp", dir=path.parent)
            tmp = Path(name)
            with os.fdopen(fd, "w", encoding="utf-8") as stream:
                stream.write(payload)
                stream.flush()
                os.fsync(stream.fileno())
            os.replace(tmp, path)
            return
        except OSError as exc:
            if attempt == 2 or exc.errno not in TRANSIENT:
                raise
            time.sleep(.05*(attempt+1))
        finally:
            if tmp is not None and tmp.exists():
                try:
                    tmp.unlink()
                except OSError:
                    pass

class Recorder:
    def __init__(self, root, metadata):
        self.root = Path(root)
        self.meta = metadata
        self.records = {}
        self.sequence = 0

    def record(self, name, value):
        self.sequence += 1
        self.records[name] = value
        line = {"sequence":self.sequence, "name":name, "value":value}
        # A journal failure is fatal: do not call the inspection complete.
        with (self.root/"checks.jsonl").open("a", encoding="utf-8") as stream:
            stream.write(json.dumps(line, allow_nan=False)+"\n")
            stream.flush()
            os.fsync(stream.fileno())
        if self.sequence % 25 == 0:
            self.snapshot()

    def snapshot(self):
        atomic_json(self.root/"inspection.json",
                    {"records":self.records, "validated":False,
                     "last_sequence":self.sequence})

    def exact(self, name, ok):
        value = {"passed":bool(ok), "exact_predicate":True}
        self.record(name, value)
        need(ok, "Exact check failed: "+name)

    def call(self, name, function):
        value = {"passed":False}
        try:
            result = function()
            value["passed"] = True
            return result
        except BaseException as exc:
            value["failure"] = repr(exc)
            raise
        finally:
            self.record(name, value)

    def check(self, name, actual, expected, tol=TOL):
        value = {"passed":False, "tolerance":float(tol)}
        try:
            a, b = np.asarray(actual), np.asarray(expected)
            value["actual_shape"] = list(a.shape)
            value["expected_shape"] = list(b.shape)
            need(a.shape == b.shape, "Shape: "+name)
            need(np.all(np.isfinite(a)) and np.all(np.isfinite(b)),
                 "Nonfinite: "+name)
            discrepancy = 0. if a.size == 0 else float(np.max(np.abs(a-b)))
            value["observed_max_abs"] = discrepancy
            value["passed"] = discrepancy <= tol
            need(value["passed"], "Tolerance: "+name)
        finally:
            self.record(name, value)

def execute(args, action, source, numerical=True,
            success="COMPLETED_NOT_VALIDATED"):
    global np
    root = Path(args.out)
    root.mkdir(parents=True, exist_ok=False)
    start = time.monotonic()
    meta = {"status":"RUNNING", "mode":getattr(args,"mode","defect"),
            "argv":sys.argv, "validated":False,
            "python":sys.version, "platform":platform.platform(),
            "start_utc":datetime.datetime.now(datetime.timezone.utc).isoformat()}
    r = Recorder(root, meta)
    primary = None
    try:
        atomic_json(root/"manifest.json", meta)
        source = Path(source)
        shutil.copyfile(source, root/source.name)
        meta["source_name"] = source.name
        meta["source_sha256"] = sha(source)
        atomic_json(root/"manifest.json", meta)
        with (root/"stdout.txt").open("w") as out, \
             (root/"stderr.txt").open("w") as err, \
             contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
            if numerical:
                import numpy as numpy
                np = numpy
                meta["numpy"] = np.__version__
                atomic_json(root/"numpy_configuration.json",
                            np.show_config(mode="dicts"))
            result = action(args, root, r)
            if result is not None:
                print(json.dumps(result, indent=2, allow_nan=False))
        meta["status"] = success
    except BaseException as exc:
        primary = exc
        meta["status"] = "FAILED"
        meta["failure"] = repr(exc)
        try:
            (root/"traceback.txt").write_text(traceback.format_exc())
        except OSError as io:
            meta["traceback_write_failure"] = repr(io)
            print(traceback.format_exc(), file=sys.__stderr__)
        raise
    finally:
        meta["elapsed_seconds"] = time.monotonic()-start
        meta["end_utc"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
        errors = []
        try:
            r.snapshot()
        except BaseException as exc:
            errors.append({"inspection_snapshot":repr(exc)})
        hashes = {}
        try:
            for p in sorted(root.iterdir()):
                if p.is_file() and p.name != "manifest.json":
                    hashes[p.name] = sha(p)
        except BaseException as exc:
            errors.append({"artifact_hashing":repr(exc)})
        meta["files_sha256"] = hashes
        if errors:
            meta["status"] = "FAILED"
            meta["finalization_errors"] = errors
        try:
            atomic_json(root/"manifest.json", meta)
        except BaseException as exc:
            errors.append({"manifest_write":repr(exc)})
        if errors:
            print("Incomplete persistence: "+repr(errors), file=sys.__stderr__)
            if primary is None:
                raise OSError("Run finalization incomplete")

def load(path):
    with np.load(path, allow_pickle=False) as data:
        return {key:data[key].copy() for key in data.files}

def archive_hashes(src, r):
    src = Path(src)
    manifest = json.loads((src/"manifest.json").read_text())
    r.record("input_manifest_sha256", sha(src/"manifest.json"))
    table = manifest.get("files_sha256")
    need(isinstance(table,dict) and table, "Missing archive hash table")
    for name, expected in table.items():
        r.exact("safe_name_"+name, name not in (".","..") and
                Path(name).name == name)
        r.exact("hash_format_"+name, isinstance(expected,str) and
                len(expected) == 64 and
                all(x in "0123456789abcdef" for x in expected))
        path = src/name
        r.exact("file_exists_"+name, path.is_file())
        observed = sha(path)
        r.record("hash_values_"+name, {"reported":expected,"observed":observed})
        r.exact("hash_match_"+name, observed == expected)
    r.exact("input_completed",
            manifest.get("status") == "COMPLETED_NOT_VALIDATED")
    return manifest

def coefficients():
    rows, a = [], 1
    for q in itertools.combinations(range(1,17),4):
        a = (75*a+74) % 65521
        rows.append({"quartet":list(q),"numerator":2*a-65521})
    return {"denominator":64*65521,"rows":rows}

def tensor_assembly(data):
    eye = np.eye(2,dtype=complex)
    z = np.diag([1,-1]).astype(complex)
    x = np.array([[0,1],[1,0]],complex)
    y = np.array([[0,-1j],[1j,0]],complex)
    generators = []
    for j in range(8):
        for middle in (x,y):
            matrix = np.array([[1]],complex)
            for k in range(8):
                matrix = np.kron(matrix,z if k < j else
                                 middle if k == j else eye)
            perm = np.argmax(np.abs(matrix),axis=0)
            generators.append((perm,matrix[perm,np.arange(256)]))
    re = np.zeros((256,256),dtype=np.int64)
    im = np.zeros_like(re)
    cols = np.arange(256)
    for row in data["rows"]:
        p, value = cols.copy(), np.ones(256,complex)
        for a in reversed(row["quartet"]):
            perm, sign = generators[a-1]
            value *= sign[p]
            p = perm[p]
        re[p,cols] += row["numerator"]*value.real.astype(np.int64)
        im[p,cols] += row["numerator"]*value.imag.astype(np.int64)
    return re,im

def creator_transfer(v,t,angle):
    c = 0. if angle == math.pi/2 else math.cos(angle)
    s = 0. if angle == 0 else math.sin(angle)
    out = np.zeros((v.shape[1],256,256),complex)
    for p in range(256):
        modes = [j for j in range(8) if p & (1 << (7-j))]
        terms = {0:1.+0j}
        for j in reversed(modes):
            newer = {}
            for word,value in terms.items():
                for index,coefficient in ((j,c),(8+j,-1j*s)):
                    bit = 1 << (15-index)
                    need(not (word & bit),"Double occupation")
                    before = (word >> (16-index)).bit_count()
                    target = word | bit
                    newer[target] = newer.get(target,0j)+ \
                        value*coefficient*((-1)**before)
            terms = newer
        free = np.exp(-1j*t*len(modes))
        for word,value in terms.items():
            boundary,bath = word >> 8, word & 255
            sign = (-1)**(boundary.bit_count()*bath.bit_count())
            out[:,bath,boundary] += free*sign*value*v[p]
    return out

def objects(z):
    d = z.shape[0]
    u = np.array([[z[i]@z[j].conj().T for j in range(d)]
                  for i in range(d)])
    c = np.array([[z[i].T@z[j].conj() for j in range(d)]
                  for i in range(d)])
    ju = np.block([[u[i,j]/d for j in range(d)] for i in range(d)])
    jc = np.block([[c[i,j]/d for j in range(d)] for i in range(d)])
    return u,c,ju,jc

def audit_choi(name,j,r):
    r.check(name+"_Hermitian",j,j.conj().T)
    value = float(np.linalg.eigvalsh((j+j.conj().T)/2)[0])
    r.record(name+"_minimum_eigenvalue",{"value":value,"rigorous":False})
    r.exact(name+"_exploratory_PSD",value >= -TOL)

def matrix_json(a):
    return [[[float(z.real),float(z.imag)] for z in row] for row in a]

def inspect_p8(args,root,r):
    src = Path(args.archive)
    manifest = archive_hashes(src,r)
    r.exact("p8_mode",manifest.get("mode") == "p8")
    results = manifest["results"]
    r.exact("stdout_matches_manifest",
            json.loads((src/"stdout.txt").read_text()) == results)
    data = json.loads((src/"coefficients.json").read_text())
    r.exact("frozen_coefficients",data == coefficients())
    re,im = tensor_assembly(data)
    saved = load(src/"integer_hamiltonian.npz")
    r.exact("Hamiltonian_denominator",int(saved["denominator"]) == DEN)
    r.exact("real_assembly",np.array_equal(re,saved["real"]))
    r.exact("imag_assembly",np.array_equal(im,saved["imag"]))
    r.exact("real_symmetry",np.array_equal(re,re.T))
    r.exact("imag_antisymmetry",np.array_equal(im,-im.T))
    even = np.array([p for p in range(256) if p.bit_count()%2 == 0])
    odd = np.array([p for p in range(256) if p.bit_count()%2 == 1])
    r.exact("even_order",np.array_equal(even,saved["even_words"]))
    r.exact("odd_order",np.array_equal(odd,saved["odd_words"]))
    r.exact("parity_blocks",not np.any(re[np.ix_(even,odd)]) and
            not np.any(im[np.ix_(even,odd)]))
    r.exact("trace",sum(int(x) for x in np.diag(re)) == 0 and
            sum(int(x) for x in np.diag(im)) == 0)
    squares = sum(int(x)**2 for x in re.flat)+sum(int(x)**2 for x in im.flat)
    r.exact("Frobenius_identity",squares ==
            256*sum(row["numerator"]**2 for row in data["rows"]))
    h = (re.astype(float)+1j*im.astype(float))/DEN
    spectra = load(src/"spectra_exploratory.npz")
    ee = np.linalg.eigvalsh(h[np.ix_(even,even)])
    eo = np.linalg.eigvalsh(h[np.ix_(odd,odd)])
    r.check("even_spectrum",spectra["even_unshifted"],ee)
    r.check("odd_spectrum",spectra["odd_unshifted"],eo)
    emin = min(ee[0],eo[0])
    for name,value in (("global_minimum_float",emin),
                       ("even_minimum_float",ee[0]),
                       ("odd_minimum_float",eo[0]),
                       ("parity_minimum_difference_float",ee[0]-eo[0])):
        r.check(name,value,results[name])
    r.check("selected_unshifted",ee[:2],results["selected_even_unshifted"])
    r.check("selected_gaps",[ee[1]-ee[0],ee[2]-ee[1]],
            results["selected_neighbor_gaps"])
    code = load(src/"code_and_quench_exploratory.npz")
    v,energy = code["V"],code["energies"]
    r.exact("code_shape",v.shape == (256,2))
    r.check("orthonormality",v.conj().T@v,np.eye(2))
    r.check("odd_code",v[odd],np.zeros((128,2)))
    r.check("shifted_energies",energy,ee[:2]-emin)
    residual = h@v-v*(energy+emin)[None,:]
    r.check("eigenpair_residual",residual,np.zeros_like(v))
    r.record("residual_norms_float",
             [float(np.linalg.norm(residual[:,i])) for i in range(2)])
    anchors = []
    for i in range(2):
        nz = np.flatnonzero(np.abs(v[:,i]) > PTOL)
        r.exact("anchor_exists_%d"%i,len(nz) > 0)
        p = int(nz[0]); anchors.append(p)
        r.check("anchor_imag_%d"%i,v[p,i].imag,0.)
        r.exact("anchor_positive_%d"%i,v[p,i].real > 0)
    r.exact("phase_summary",anchors == results["phase_surrogate_anchors"])
    pop = np.array([p.bit_count() for p in range(256)],float)
    nu = v.conj().T@(pop[:,None]*v)
    mu = v.conj().T@(pop[:,None]**2*v)
    lam = mu-nu@nu
    leak = pop[:,None]*v-v@nu
    for name,value in (("nu",nu),("mu",mu),("Lambda",lam),
                       ("direct_leakage",leak)):
        r.check("saved_"+name,code[name],value)
    r.check("direct_Gram",leak.conj().T@leak,lam)
    r.check("E_code",np.linalg.eigvalsh((nu+nu.conj().T)/2)[-1],
            results["E_code_float"])
    r.check("L_N",np.linalg.norm(leak,2),results["L_N_float"])
    r.record("compressed_matrices",{"nu":matrix_json(nu),
        "mu":matrix_json(mu),"Lambda":matrix_json(lam)})
    for m in (0,2,4,6,8):
        block = v[pop == m]
        occ = load(src/("occupation_%d.npz"%m))
        r.check("occupation_block_%d"%m,occ["projected_code"],block)
        r.check("occupation_Gram_%d"%m,occ["gram"],block.conj().T@block)
        r.check("occupation_singular_%d"%m,np.linalg.svd(block,compute_uv=False),
                results["occupation_data"][str(m)]["singular_values_float"])
    dep = load(src/"departure_exploratory.npz")
    r.check("departure_grid",dep["times"],np.arange(33)/128,tol=0)
    for k,t in enumerate(dep["times"]):
        f = v.conj().T@(np.exp(-1j*t*pop)[:,None]*v)
        r.check("departure_F_%d"%k,dep["F"][k],f)
        gram = f.conj().T@f
        p = 1-np.linalg.eigvalsh((gram+gram.conj().T)/2)[0]
        r.check("departure_value_%d"%k,dep["departure"][k],p)
    r.check("departure_1_8",dep["departure"][16],results["departure_1_over_8"])
    r.check("departure_1_4",dep["departure"][32],results["departure_1_over_4"])
    bases = load(src/"full_bases_exploratory.npz")
    for name,inds,values in (("even",even,spectra["even_unshifted"]),
                            ("odd",odd,spectra["odd_unshifted"])):
        a = bases[name+"_vectors"]
        r.check(name+"_basis_orthonormal",a.conj().T@a,np.eye(128))
        r.check(name+"_basis_residual",h[np.ix_(inds,inds)]@a-a*values[None,:],
                np.zeros_like(a))
    for i in range(2):
        col = bases["even_vectors"][:,i].copy()
        nz = np.flatnonzero(np.abs(col) > PTOL)
        need(len(nz) > 0,"Basis phase anchor")
        col *= np.exp(-1j*np.angle(col[nz[0]]))
        r.check("selected_basis_link_%d"%i,v[even,i],col)
    stored = v*np.exp(-1j*energy)[None,:]
    for k,(t,angle) in enumerate(zip(TIMES,ANGLES)):
        saved = load(src/("channel_%d.npz"%k))
        r.check("frozen_time_%d"%k,saved["time"],t,tol=0)
        r.check("frozen_area_%d"%k,saved["theta"],angle,tol=0)
        z = saved["Z"]
        r.check("creator_reconstruction_%d"%k,z,creator_transfer(stored,t,angle))
        r.check("isometry_%d"%k,np.einsum("irb,jrb->ij",z.conj(),z),np.eye(2))
        u,c,ju,jc = objects(z)
        for name,value in (("units",u),("complement",c),
                           ("Choi_accessible",ju),("Choi_complement",jc)):
            r.check(name+"_%d"%k,saved[name],value)
        for i in range(2):
            for j in range(2):
                for name,obj in (("R",u),("E",c)):
                    r.check("adjoint_%s_%d_%d_%d"%(name,k,i,j),
                            obj[i,j].conj().T,obj[j,i])
                    r.check("trace_%s_%d_%d_%d"%(name,k,i,j),
                            np.trace(obj[i,j]),float(i == j))
        audit_choi("Choi_R_%d"%k,saved["Choi_accessible"],r)
        audit_choi("Choi_E_%d"%k,saved["Choi_complement"],r)
        if k == 4:
            lt = np.exp(-1j*(1+math.pi/2)*pop)[:,None]*stored
            for i in range(2):
                for j in range(2):
                    r.check("endpoint_R_%d_%d"%(i,j),u[i,j],
                            np.outer(lt[:,i],lt[:,j].conj()))
                    target = np.zeros((256,256),complex)
                    target[0,0] = float(i == j)
                    r.check("endpoint_E_%d_%d"%(i,j),c[i,j],target)
    return {"inspection":"completed", "validated":False,
            "exact_code_selection_certified":False,
            "exact_ranks_certified":False}

def g(t):
    return 2/(2+1j*t)

def bump(t):
    t = np.asarray(t,float)
    out = np.zeros_like(t)
    good = (t > .25) & (t < .75)
    out[good] = np.exp(-1/((t[good]-.25)*(.75-t[good])))
    return out

def pulse_b0(panels):
    x = np.arange(panels+1)/panels
    y = bump(x)
    return float((y[0]/2+y[1:-1].sum()+y[-1]/2)/panels)

def volterra(n,b0,v=1,coupled=True):
    t,h = np.arange(n+1)/n,1/n
    kap = math.pi*bump(t)/(2*b0) if coupled else np.zeros(n+1)
    a,b = np.zeros(n+1,complex),np.zeros(n+1,complex)
    a[0] = g(1)
    for i in range(1,n+1):
        weights = np.ones(i); weights[0] = .5
        ra = g(t[i]+1)-1j*h*np.sum(
            weights*g(t[i]-t[:i])*(v*a[:i]+kap[:i]*b[:i]))
        rb = -1j*h*np.sum(
            weights*np.exp(-1j*(t[i]-t[:i]))*kap[:i]*a[:i])
        matrix = np.array([[1+1j*h*v/2,1j*h*kap[i]/2],
                           [1j*h*kap[i]/2,1]],complex)
        a[i],b[i] = np.linalg.solve(matrix,[ra,rb])
    return t,a,b

def spectral(ne,nt,b0):
    x,weights = np.polynomial.laguerre.laggauss(ne)
    need(np.all(weights > 0) and np.all(np.isfinite(weights)),
         "Laguerre weights")
    f,omega = np.sqrt(weights),x/2
    initial = np.r_[f*np.exp(-1j*omega),0j]
    state,dt = initial.copy(),1/nt
    def rhs(t,y):
        a = np.vdot(f,y[:-1])
        k = float(math.pi*bump(np.array([t]))[0]/(2*b0))
        return -1j*np.r_[omega*y[:-1]+f*a+k*f*y[-1],y[-1]+k*a]
    for j in range(nt):
        t = j*dt
        k1 = rhs(t,state)
        k2 = rhs(t+dt/2,state+dt*k1/2)
        k3 = rhs(t+dt/2,state+dt*k2/2)
        k4 = rhs(t+dt,state+dt*k3)
        state += dt*(k1+2*k2+2*k3+k4)/6
    return x,weights,initial,state

def ratio(value):
    n,d = float(value).as_integer_ratio()
    return [str(n),str(d)]

def encode(array):
    return [[ratio(z.real),ratio(z.imag)] for z in array]

def candidate(args,root,r):
    meshes = args.meshes
    need(meshes == sorted(set(meshes)) and
         all(n >= 8 and n & (n-1) == 0 for n in meshes),
         "Increasing power-of-two meshes")
    panels = max(32768,8*max(meshes))
    b0 = pulse_b0(panels)
    need(math.isfinite(b0) and b0 > 0,"Pulse normalization")
    report = {"contract":CONTRACT,"B0_float":b0,"pulse_panels":panels,
              "volterra":[],"spectral":[],"validated":False}
    previous = None
    for n in meshes:
        t,a,b = volterra(n,b0)
        np.savez_compressed(root/("volterra_%d.npz"%n),times=t,A=a,B=b)
        atomic_json(root/("nodes_%d.json"%n),{
            "contract":CONTRACT,"interpolation":"continuous_piecewise_linear",
            "node_representation":"exact_binary64_dyadic_ratios",
            "A":encode(a),"B":encode(b)})
        q = b[-1]
        row = {"n":n,"q":[float(q.real),float(q.imag)],
               "eta":float(abs(q)**2),
               "successive_difference":None if previous is None else
                                       float(abs(q-previous))}
        report["volterra"].append(row)
        r.record("Volterra_%d"%n,row)
        atomic_json(root/"candidate_report.json",report)
        previous = q
    for ne,nt in ((32,2048),(64,4096),(96,8192)):
        x,weights,initial,state = spectral(ne,nt,b0)
        name = "spectral_%d_%d.npz"%(ne,nt)
        np.savez_compressed(root/name,nodes=x,weights=weights,
            initial=initial,final=state,energy_nodes=ne,time_steps=nt,
            B0=b0,t0=1,T=1,v=1,w_control=0)
        q = state[-1]
        row = {"file":name,"energy_nodes":ne,"time_steps":nt,
               "q":[float(q.real),float(q.imag)],
               "finite_system_norm":float(np.vdot(state,state).real),
               "weight_sum":float(weights.sum()),
               "difference_from_finest_volterra":float(abs(q-previous))}
        report["spectral"].append(row)
        r.record(name,row)
        atomic_json(root/"candidate_report.json",report)
    return report

def node_link(values,array):
    need(array.dtype == np.complex128 and array.ndim == 1,
         "Require one-dimensional complex128 nodes")
    need(len(values) == len(array),"Node lengths")
    for item,z in zip(values,array):
        need(len(item) == 2,"Complex node shape")
        for pair,value in zip(item,(z.real,z.imag)):
            need(len(pair) == 2 and int(pair[1]) > 0,"Rational shape")
            need(F(int(pair[0]),int(pair[1])) ==
                 F(*float(value).as_integer_ratio()),"Exact JSON/NPZ mismatch")
    return True

def inspect_candidate(args,root,r):
    src = Path(args.archive)
    archive_hashes(src,r)
    report = json.loads((src/"candidate_report.json").read_text())
    r.exact("candidate_contract",report["contract"] == CONTRACT)
    b0 = report["B0_float"]
    r.check("pulse_replay",b0,pulse_b0(report["pulse_panels"]))
    t,a,b = volterra(128,b0,coupled=False)
    r.check("zero_coupling_B",b,np.zeros_like(b))
    t,a,b = volterra(128,b0,v=0,coupled=False)
    r.check("free_A",a,g(t+1)); r.check("free_B",b,np.zeros_like(b))
    rows = report["volterra"]
    need(rows,"No Volterra results")
    sizes = [row["n"] for row in rows]
    r.exact("mesh_order",sizes == sorted(set(sizes)))
    finest = None
    for row in rows:
        n = row["n"]
        r.exact("power_two_%d"%n,n >= 8 and n & (n-1) == 0)
        path = src/("volterra_%d.npz"%n)
        saved = load(path)
        t,a,b = saved["times"],saved["A"],saved["B"]
        r.check("grid_%d"%n,t,np.arange(n+1)/n,tol=0)
        r.exact("node_shapes_%d"%n,a.shape == (n+1,) and b.shape == (n+1,))
        nodes_path = src/("nodes_%d.json"%n)
        nodes = json.loads(nodes_path.read_text())
        r.exact("JSON_contract_%d"%n,nodes["contract"] == CONTRACT)
        r.exact("JSON_interpolant_%d"%n,
                nodes["interpolation"] == "continuous_piecewise_linear")
        r.call("A_exact_link_%d"%n,lambda:node_link(nodes["A"],a))
        r.call("B_exact_link_%d"%n,lambda:node_link(nodes["B"],b))
        r.record("file_link_%d"%n,{"npz_sha256":sha(path),
            "json_sha256":sha(nodes_path),"exact_node_equality":True})
        tt,aa,bb = volterra(n,b0)
        r.check("A_solver_replay_%d"%n,a,aa)
        r.check("B_solver_replay_%d"%n,b,bb)
        q = b[-1]; finest = q
        r.check("q_summary_%d"%n,q,complex(*row["q"]))
        r.check("eta_summary_%d"%n,abs(q)**2,row["eta"])
        r.check("initial_A_%d"%n,a[0],(4-2j)/5)
        r.check("initial_B_%d"%n,b[0],0)
    for row in report["spectral"]:
        saved = load(src/row["file"])
        ne,nt = row["energy_nodes"],row["time_steps"]
        for key,value in (("energy_nodes",ne),("time_steps",nt),
                          ("t0",1),("T",1),("v",1),("w_control",0)):
            r.check(key+"_"+row["file"],saved[key],value,tol=0)
        r.check("B0_"+row["file"],saved["B0"],b0,tol=0)
        x,w,initial,final = spectral(ne,nt,b0)
        for key,value in (("nodes",x),("weights",w),
                          ("initial",initial),("final",final)):
            r.check(key+"_"+row["file"],saved[key],value)
        r.check("q_"+row["file"],saved["final"][-1],complex(*row["q"]))
        norm = float(np.vdot(saved["final"],saved["final"]).real)
        r.check("norm_summary_"+row["file"],norm,row["finite_system_norm"])
        r.check("finite_system_norm_"+row["file"],norm,1.,tol=1e-7)
        r.check("difference_"+row["file"],abs(saved["final"][-1]-finest),
                row["difference_from_finest_volterra"])
    return {"inspection":"completed","JSON_NPZ_link_checked":True,
            "solver_replay_checked":True,"continuum_validated":False}

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("mode",
        choices=["inspect-p8","candidate","inspect-candidate"])
    parser.add_argument("--archive")
    parser.add_argument("--out",required=True)
    parser.add_argument("--meshes",nargs="+",type=int,default=[256,512])
    args = parser.parse_args()
    if args.mode != "candidate":
        need(args.archive is not None,"--archive required")
    action = {"inspect-p8":inspect_p8,"candidate":candidate,
              "inspect-candidate":inspect_candidate}[args.mode]
    execute(args,action,__file__)

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

The journal stores partial check results even when the final snapshot
is missing. If any persistence or finalization operation fails, the
run is not classified as a completed inspection.
Hash equality authenticates bytes relative to a manifest; it does not
prove that the manifest itself is an independent trusted record.

%=====================================================================
\section{Repaired exact-rational defect checker}
\label{app:checker}
%=====================================================================

Extract this listing as \code{em03h_v8_defect.py}, in the same directory
as the preceding helper file. Its calculation uses only the Python
standard library. Importing the helper does not import NumPy.

\begin{verbatim}
python em03h_v8_defect.py \
  --nodes candidate-v8/nodes_256.json \
  --out candidate-v8-bound-256 \
  --bits 48 --refine 1 --pulse-cells 512
\end{verbatim}

This invocation reproduces the reported parameter pattern, not the
reported historical output. The v8 source differs from the unidentified
patched v7 source.

The checker records self-tests, pulse intervals, individual cell defects,
and exact rational output. It requires a separate successful node-link
inspection before identifying its JSON approximation with an inspected
solver archive.

\begin{lstlisting}
#!/usr/bin/env python3
"""Em03-H-v8 rational defect checker. New; unexecuted artifact."""
import argparse
from fractions import Fraction as F
import json
import math
from pathlib import Path
import shutil
from em03h_v8_tools import need, sha, atomic_json, execute

BITS = 48
SCALE = 1 << BITS
TERMS = 40

def down(x):
    x = F(x)
    return F((x.numerator*SCALE)//x.denominator,SCALE)

def up(x):
    return -down(-F(x))

class I:
    def __init__(self,lo,hi=None):
        lo,hi = F(lo),F(lo if hi is None else hi)
        need(lo <= hi,"Reversed interval")
        self.lo,self.hi = down(lo),up(hi)

    def __add__(self,y):
        if isinstance(y,C):
            return NotImplemented
        y = ri(y)
        return I(self.lo+y.lo,self.hi+y.hi)

    __radd__ = __add__

    def __neg__(self):
        return I(-self.hi,-self.lo)

    def __sub__(self,y):
        if isinstance(y,C):
            return NotImplemented
        return self+(-ri(y))

    def __rsub__(self,y):
        return ri(y)+(-self)

    def __mul__(self,y):
        # Mixed real/complex arithmetic is handled by C.__rmul__.
        if isinstance(y,C):
            return NotImplemented
        y = ri(y)
        vals = [a*b for a in (self.lo,self.hi) for b in (y.lo,y.hi)]
        return I(min(vals),max(vals))

    __rmul__ = __mul__

    def __truediv__(self,y):
        y = ri(y)
        need(not y.lo <= 0 <= y.hi,"Division through zero")
        return self*I(1/y.hi,1/y.lo)

    def bound(self):
        return max(abs(self.lo),abs(self.hi))

    def width(self):
        return self.hi-self.lo

def ri(x):
    return x if isinstance(x,I) else I(x)

class C:
    def __init__(self,re=0,im=0):
        self.re,self.im = ri(re),ri(im)

    def __add__(self,y):
        y = ci(y)
        return C(self.re+y.re,self.im+y.im)

    __radd__ = __add__

    def __neg__(self):
        return C(-self.re,-self.im)

    def __sub__(self,y):
        return self+(-ci(y))

    def __rsub__(self,y):
        return ci(y)+(-self)

    def __mul__(self,y):
        y = ci(y)
        return C(self.re*y.re-self.im*y.im,
                 self.re*y.im+self.im*y.re)

    __rmul__ = __mul__

    def bound(self):
        return self.re.bound()+self.im.bound()

    def width(self):
        return self.re.width()+self.im.width()

def ci(x):
    return x if isinstance(x,C) else C(x)

def exp_minus(x):
    x = F(x)
    need(x >= 0,"Negative exp-minus argument")
    if x >= BITS:
        return I(0,F(1,SCALE))
    y,s = x,0
    while y > 1:
        y /= 2
        s += 1
    total,term = F(1),F(1)
    for k in range(1,TERMS+1):
        term *= -y/k
        total += term
    error = 3*y**(TERMS+1)/math.factorial(TERMS+1)
    out = I(max(F(0),total-error),min(F(1),total+error))
    for _ in range(s):
        out = out*out
        out = I(max(F(0),out.lo),min(F(1),out.hi))
    return out

def arctan(x):
    x = F(x)
    total = sum((-1)**k*x**(2*k+1)/F(2*k+1) for k in range(TERMS))
    error = x**(2*TERMS+1)/F(2*TERMS+1)
    return I(total-error,total+error)

def pi_ball():
    return 16*arctan(F(1,5))-4*arctan(F(1,239))

def sine(x):
    x = F(x)
    total = sum((-1)**k*x**(2*k+1)/math.factorial(2*k+1)
                for k in range(TERMS))
    error = x**(2*TERMS+1)/math.factorial(2*TERMS+1)
    return I(total-error,total+error)

def cosine(x):
    x = F(x)
    total = sum((-1)**k*x**(2*k)/math.factorial(2*k)
                for k in range(TERMS))
    error = x**(2*TERMS)/math.factorial(2*TERMS)
    return I(total-error,total+error)

def phase(t):
    need(0 <= t.lo <= t.hi <= 1,"Phase domain")
    sa,sb = sine(t.lo),sine(t.hi)
    ca,cb = cosine(t.lo),cosine(t.hi)
    return C(I(cb.lo,ca.hi),I(-sb.hi,-sa.lo))

def kernel(t):
    need(t.lo >= 0,"Kernel domain")
    den = I(4)+t*t
    return C(I(4)/den,(-2*t)/den)

def bump_interval(a,b):
    a,b = max(F(a),F(1,4)),min(F(b),F(3,4))
    if a >= b:
        return I(0)
    def d(x):
        return (x-F(1,4))*(F(3,4)-x)
    dmin = min(d(a),d(b))
    dmax = F(1,16) if a <= F(1,2) <= b else max(d(a),d(b))
    lo = F(0) if dmin == 0 else exp_minus(1/dmin).lo
    hi = exp_minus(1/dmax).hi
    return I(lo,hi)

def rational(pair):
    need(len(pair) == 2 and int(pair[1]) > 0,"Rational representation")
    return F(int(pair[0]),int(pair[1]))

def nodes(values):
    result = []
    for value in values:
        need(len(value) == 2,"Complex node representation")
        result.append((rational(value[0]),rational(value[1])))
    return result

def interpolate(values,t):
    m = len(values)-1
    if t == 1:
        return values[-1]
    x = t*m
    j = x.numerator//x.denominator
    f = x-j
    return tuple((1-f)*values[j][k]+f*values[j+1][k] for k in (0,1))

def enclosure(values,a,b):
    va,vb = interpolate(values,a),interpolate(values,b)
    return C(I(min(va[0],vb[0]),max(va[0],vb[0])),
             I(min(va[1],vb[1]),max(va[1],vb[1])))

def text(x):
    x = F(x)
    return [str(x.numerator),str(x.denominator)]

def interval_text(x):
    return {"lo":text(x.lo),"hi":text(x.hi)}

def complex_text(x):
    return {"real":interval_text(x.re),"imag":interval_text(x.im)}

def sqrt_bounds(x):
    x = F(x)
    need(x >= 0,"Square-root domain")
    k = math.isqrt((x.numerator*SCALE*SCALE)//x.denominator)
    lo = F(k,SCALE)
    return lo,lo if lo*lo == x else F(k+1,SCALE)

def contains(interval,value):
    return interval.lo <= value <= interval.hi

def selftests(r):
    for name,value in (("I_times_C",I(2)*C(3,4)),
                       ("C_times_I",C(3,4)*I(2))):
        r.exact(name,contains(value.re,6) and contains(value.im,8))
    r.exact("mixed_addition",contains((I(2)+C(3,4)).re,5))
    r.exact("mixed_subtraction",contains((I(2)-C(3,4)).im,-4))
    r.exact("exp_zero",contains(exp_minus(0),1))
    r.exact("sin_zero",contains(sine(0),0))
    r.exact("cos_zero",contains(cosine(0),1))
    r.exact("kernel_zero_real",contains(kernel(I(0)).re,1))
    r.exact("kernel_zero_imag",contains(kernel(I(0)).im,0))
    lo,hi = sqrt_bounds(F(9,16))
    r.exact("rational_square_root",lo <= F(3,4) <= hi)

def calculate(args,root,r):
    global BITS,SCALE,TERMS
    need(args.bits >= 32 and args.refine >= 1 and args.pulse_cells >= 8,
         "Parameter ranges")
    need(args.refine & (args.refine-1) == 0,"Power-of-two refinement")
    BITS,SCALE = args.bits,1 << args.bits
    TERMS = max(32,(BITS+32)//2)
    selftests(r)
    path = Path(args.nodes)
    shutil.copyfile(path,root/"nodes-input.json")
    helper = Path(__file__).with_name("em03h_v8_tools.py")
    shutil.copyfile(helper,root/helper.name)
    r.meta["helper_sha256"] = sha(helper)
    r.meta["nodes_sha256"] = sha(path)
    data = json.loads((root/"nodes-input.json").read_text())
    contract = {"t0":1,"T":1,"Omega":1,"v":1,"w":0,"packet":"fixed_f"}
    r.exact("primary_contract",data["contract"] == contract)
    r.exact("piecewise_linear",
            data["interpolation"] == "continuous_piecewise_linear")
    a,b = nodes(data["A"]),nodes(data["B"])
    need(len(a) == len(b) and len(a) >= 9,"Node lengths")
    m = len(a)-1
    need(m & (m-1) == 0,"Original power-of-two grid")
    n = m*args.refine
    need(n <= SCALE,"Grid must be exactly representable at arithmetic bits")
    h = F(1,n)
    t = [F(j,n) for j in range(n+1)]
    pi = pi_ball()
    b0 = I(0)
    for j in range(args.pulse_cells):
        bump = bump_interval(F(j,args.pulse_cells),F(j+1,args.pulse_cells))
        b0 = b0+F(1,args.pulse_cells)*bump
    r.record("pulse_normalization",interval_text(b0))
    need(b0.lo > 0,"Pulse lower bound unresolved")
    kap = [pi*bump_interval(t[j],t[j+1])/(2*b0) for j in range(n)]
    av = [enclosure(a,t[j],t[j+1]) for j in range(n)]
    bv = [enclosure(b,t[j],t[j+1]) for j in range(n)]
    cv = [av[j]+bv[j]*kap[j] for j in range(n)]
    jv = [av[j]*kap[j] for j in range(n)]
    kg = {d:kernel(I(F(d-1,n),F(d+1,n))) for d in range(1,n)}
    kp = {d:phase(I(F(d-1,n),F(d+1,n))) for d in range(1,n)}
    partial_g,partial_p = kernel(I(0,h)),phase(I(0,h))
    epsilon = F(0)
    records = []
    for j in range(n):
        ia,ib = C(),C()
        for k in range(j):
            ia = ia+(kg[j-k]*cv[k])*h
            ib = ib+(kp[j-k]*jv[k])*h
        ia = ia+(partial_g*cv[j])*I(0,h)
        ib = ib+(partial_p*jv[j])*I(0,h)
        da = av[j]-kernel(I(t[j]+1,t[j+1]+1))+C(0,1)*ia
        db = bv[j]+C(0,1)*ib
        local = max(da.bound(),db.bound())
        epsilon = max(epsilon,local)
        record = {"cell":j,"dA":complex_text(da),"dB":complex_text(db),
                  "modulus_upper":text(local),
                  "rectangle_width":text(max(da.width(),db.width()))}
        records.append(record)
        r.record("cell_%d"%j,record)
    atomic_json(root/"cell_defects.json",records)
    denom = exp_minus(1+pi.hi/2).lo
    need(denom > 0,"Amplification enclosure unresolved")
    amplification = 1/denom
    radius = epsilon*amplification
    qr,qi = b[-1]
    modlo,modhi = sqrt_bounds(qr*qr+qi*qi)
    etalo = max(F(0),modlo-radius)**2
    etahi = min(F(1),(modhi+radius)**2)
    need(0 <= etalo <= etahi <= 1,"Inconsistent amplitude enclosure")
    verdict = ("meets_quarter_error" if etalo >= F(3,4) else
               "does_not_meet_quarter_error" if etahi < F(3,4) else
               "unresolved")
    sphase = min(F(1),radius/modlo) if modlo > radius else F(1)
    certificate = {
        "arithmetic":"exact_rational_with_outward_dyadic_rounding",
        "bits":BITS,"Taylor_terms":TERMS,
        "original_cells":m,"validation_cells":n,
        "pulse_cells":args.pulse_cells,
        "rounding_grid":text(F(1,SCALE)),
        "B0":interval_text(b0),
        "B0_relative_width_upper":text(b0.width()/b0.lo),
        "pi":interval_text(pi),
        "uniform_defect_upper":text(epsilon),
        "amplification_upper":text(amplification),
        "q_center":[text(qr),text(qi)],
        "center_modulus":{"lo":text(modlo),"hi":text(modhi)},
        "amplitude_radius":text(radius),
        "eta":{"lo":text(etalo),"hi":text(etahi)},
        "specified_error":{"lo":text(1-etahi),"hi":text(1-etalo)},
        "ideal_phase_verdict":verdict,
        "estimated_phase_error_upper":text(1-etalo*(1-sphase)),
        "JSON_NPZ_link":"requires separate successful inspection",
        "independently_inspected":False,
        "physical_implementation_certified":False}
    atomic_json(root/"certificate.json",certificate)
    return certificate

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--nodes",required=True)
    parser.add_argument("--out",required=True)
    parser.add_argument("--bits",type=int,default=48)
    parser.add_argument("--refine",type=int,default=1)
    parser.add_argument("--pulse-cells",type=int,default=512)
    args = parser.parse_args()
    execute(args,calculate,__file__,numerical=False,
            success="BOUND_COMPUTED_INSPECTION_REQUIRED")

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

\paragraph{Algorithmic justification.}
Every real endpoint is rounded outward using exact integer floor or
ceiling. Mixed complex arithmetic is implemented by rectangular
promotion. Elementary functions use the rational remainder bounds
stated in Section~\ref{sec:defect}. Validation cells refine the original
piecewise-linear grid, so endpoint extrema enclose each interpolant
component on each cell.

Theorems~\ref{thm:cell} and \ref{thm:defect} justify the bound-producing
algorithm. Integer square roots include endpoint-modulus uncertainty.
Startup self-tests address dispatch and selected exact identities,
not completeness of a formal software verification.

No execution of this listing, resulting certificate, or successful
inspection is asserted in this edition.

%=====================================================================
\section{Selected historical identifiers and artifact requirements}
\label{app:provenance}
%=====================================================================

The following SHA-256 identifiers are copied from the supplied P8-new
manifest. Original attachment bytes have not been independently
rehashed here.

\begin{longtable}{@{}p{0.34\textwidth}p{0.59\textwidth}@{}}
\toprule
Historical file & Reported SHA-256\\
\midrule
\endfirsthead
\toprule
Historical file & Reported SHA-256\\
\midrule
\endhead
\bottomrule
\endfoot
\code{em03h_tools.py} &
{\scriptsize\ttfamily
c4d8418aae9c64311196237f6d08136b8332abea0912425ffb58d18958cac9ec}\\
\code{baseline-input.tex} &
{\scriptsize\ttfamily
e8e2bdfca338ca09fbc6e9684fccdf4290aabc2a720de90cff51a242c8a4470d}\\
\code{stdout.txt} &
{\scriptsize\ttfamily
c02b35f1d7116824a9c367e447ef162b7fcdf7842e49916944ac4490b55a9af6}\\
\code{integer_hamiltonian.npz} &
{\scriptsize\ttfamily
03ddb79af822cdcf4e422d26e35eae34f0eadd15bbbf43868065be574d41f457}\\
\code{code_and_quench_exploratory.npz} &
{\scriptsize\ttfamily
473b7c90a6280d246d0873783f491e1ed4ac4783cb46572856988bd3eee9ac1e}\\
\code{departure_exploratory.npz} &
{\scriptsize\ttfamily
210179902ce213732f304549124a811d42a647f4408bdfb1480e895c412257c6}\\
\end{longtable}

New candidate computations require their own manifests, full outputs,
source and helper hashes, environment, controls, pulse normalization,
and failed attempts. Newly generated NPZ files need not have historical
byte hashes even when their mathematical arrays agree.

To authenticate the new summary, obtain:
\begin{enumerate}[label=\textup{(\arabic*)}]
\item its actual candidate archive and invocation manifest;
\item the patched v7 checker source and source hash;
\item the exact rational \code{certificate.json} and cell records;
\item the prior successful P8 inspection report;
\item the failed v7 inspection traceback and surviving partial records.
\end{enumerate}

To upgrade the numerical conclusions, additionally establish:
\begin{enumerate}[label=\textup{(\arabic*)}]
\item exhaustive P8 spectral ordering and selected-code identification;
\item exact normalization and phase conventions;
\item central diagnostic intervals and occupation-rank certificates;
\item exact candidate JSON/NPZ correspondence;
\item a nontrivial true-pulse continuum amplitude enclosure;
\item a decoder verdict including phase and any implementation allowances.
\end{enumerate}

\section*{Declarations}

\paragraph{Availability.}
This single source contains the specifications, proofs, reported
numerical tables, historical identifiers, and new reproducibility
software. No external files are required for typesetting.

\paragraph{Execution and inspection.}
P8-new execution is reported by supplied historical records.
Candidate solver and patched checker invocations are reported by the
new summary. This edition does not assert independently executing
those programs, inspecting their original binary outputs, compiling
the manuscript, or formally checking its proofs.

\paragraph{Numerical conclusion.}
The exploratory candidate estimate suggests specified-decoder error
near \(0.38687\). The reported coarse interval \([0,1]\) does not
validate that estimate or a quarter-error exclusion.
Certified P8 ranks and the exact reached-space dimension remain
unresolved.

\paragraph{Physical interpretation.}
The continuum code is an excitation code in a declared reduction.
No controlled full-gravity remainder, P8 microstate identification,
gravitational dictionary, or physical receiver is supplied.

\paragraph{Attribution.}
Recovery theory, fidelity inequalities, fermionic transfer, SYK and
Schwarzian theory, eigensolvers, and interval arithmetic are established
frameworks. The contributions are the fixed-instance diagnostics,
exact reached-space analysis, stored-packet complete-channel
construction, and the stated certification and evidence interfaces.

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

\bibitem{Baseline}
N.~Cheung,
\emph{Em03-H: Fixed-Instance Diagnostics, Exact Extraction,
and Stored-Packet Excitation-Channel Recovery},
supplied \code{baseline-input.tex}, dated 9 October 2026.

\bibitem{V7}
N.~Cheung,
\emph{Em03-H-v7: Exact Fermionic Extraction, Quench Diagnostics,
and Stored-Packet Excitation-Channel Recovery},
supplied \code{Em03-H-v7.tex}, dated 9 October 2026.

\bibitem{P8Record}
Author-supplied P8-new \code{manifest.json}, \code{stdout.txt},
\code{stderr.txt}, \code{numpy_configuration.txt},
\code{coefficients.json}, and \code{em03h_tools.py}.
Reported status \code{COMPLETED_NOT_VALIDATED}.
These are execution materials, not numerical certificates.

\bibitem{NewSummary}
Author-supplied
\emph{Em03-H v7 Exploratory Results Summary},
\code{Em03-H-v7-results-summary.txt}.
Rounded candidate results, a reported patched defect-check invocation,
and reported inspection issues. Original candidate arrays and exact
certificate rationals are not included in this supplied summary.

\bibitem{Watrous}
J.~Watrous,
\emph{The Theory of Quantum Information},
Cambridge University Press, 2018.
\url{https://jhwatrous.github.io/TQI.pdf}.

\bibitem{FuchsVandeGraaf}
C.~A.~Fuchs and J.~van de Graaf,
\emph{Cryptographic Distinguishability Measures for
Quantum-Mechanical States},
IEEE Transactions on Information Theory \textbf{45} (1999),
1216--1227.
arXiv:quant-ph/9712042.
doi:10.1109/18.761271.

\bibitem{BenyOreshkov}
C.~B\'eny and O.~Oreshkov,
\emph{General conditions for approximate quantum error correction
and near-optimal recovery channels},
Physical Review Letters \textbf{104} (2010), 120501.
arXiv:0907.5391.
doi:10.1103/PhysRevLett.104.120501.

\bibitem{KSW}
D.~Kretschmann, D.~Schlingemann, and R.~F.~Werner,
\emph{The Information-Disturbance Tradeoff and the Continuity
of Stinespring's Representation},
IEEE Transactions on Information Theory \textbf{54} (2008),
1708--1717.
arXiv:quant-ph/0605009.
doi:10.1109/TIT.2008.917696.

\bibitem{MaldacenaStanford}
J.~Maldacena and D.~Stanford,
\emph{Comments on the Sachdev--Ye--Kitaev model},
Physical Review D \textbf{94} (2016), 106002.
arXiv:1604.07818.
doi:10.1103/PhysRevD.94.106002.

\bibitem{MSY}
J.~Maldacena, D.~Stanford, and Z.~Yang,
\emph{Conformal symmetry and its breaking in two dimensional
Nearly Anti-de-Sitter space},
Progress of Theoretical and Experimental Physics \textbf{2016}
(2016), 12C104.
arXiv:1606.01857.
doi:10.1093/ptep/ptw124.

\bibitem{EMV}
J.~Engels\"oy, T.~G.~Mertens, and H.~Verlinde,
\emph{An Investigation of \(AdS_2\) Backreaction and Holography},
Journal of High Energy Physics \textbf{07} (2016), 139.
arXiv:1606.03438.
doi:10.1007/JHEP07(2016)139.

\bibitem{MTV}
T.~G.~Mertens, G.~J.~Turiaci, and H.~L.~Verlinde,
\emph{Solving the Schwarzian via the Conformal Bootstrap},
Journal of High Energy Physics \textbf{08} (2017), 136.
arXiv:1705.08408.
doi:10.1007/JHEP08(2017)136.

\bibitem{NumPyEigh}
NumPy Developers,
\emph{numpy.linalg.eigh}, NumPy v2.2 Manual.
\url{https://numpy.org/doc/2.2/reference/generated/numpy.linalg.eigh.html}.
Interface documentation aligned with the reported NumPy 2.2.6 runtime.

\bibitem{NumPyConfig}
NumPy Developers,
\emph{numpy.show\_config}, NumPy v2.2 Manual.
\url{https://numpy.org/doc/2.2/reference/generated/numpy.show_config.html}.

\bibitem{FLINTMat}
The FLINT Development Team,
\emph{acb\_mat.h -- matrices over the complex numbers},
FLINT 3.7.0-dev documentation, supplied interface text.
\url{https://flintlib.org/doc/acb_mat.html}.
An actual validation archive must pin the installed build or commit
and retain the successful routine's exact guarantees.

\bibitem{JohanssonArb}
F.~Johansson,
\emph{Arb: Efficient Arbitrary-Precision Midpoint-Radius Interval
Arithmetic},
arXiv:1611.02831, 2016.
\url{https://arxiv.org/abs/1611.02831}.

\bibitem{JohanssonIntegration}
F.~Johansson,
\emph{Numerical integration in arbitrary-precision ball arithmetic},
arXiv:1802.07942, 2018.
\url{https://arxiv.org/abs/1802.07942}.

\bibitem{PythonNumeric}
Python Software Foundation,
\emph{The Python Language Reference: Data model,
Emulating numeric types}, Python 3.10 documentation.
\url{https://docs.python.org/3.10/reference/datamodel.html}.

\bibitem{PythonIO}
Python Software Foundation,
\emph{tempfile} and \emph{os}, Python 3.10 library documentation.
\url{https://docs.python.org/3.10/library/tempfile.html}.
\url{https://docs.python.org/3.10/library/os.html}.
Temporary-file creation, replacement, flushing, and synchronization
interfaces; not a guarantee of successful persistence in a failing
environment.

\end{thebibliography}

\end{document}