%=====================================================================
% En02-A
% Finite-Resource Geometry for the Enter Calculus
% Cut Monotones, Certificate Costs, and Conditional Born Rigidity
%
% Self-contained mathematical revision of:
%   085WvIp1v2_DiscQuantSci.tex
%
% Compile:
%   pdflatex En02-A.tex
%   pdflatex En02-A.tex
%
% The Python appendix is a standalone listing, not a compilation
% dependency. No Python execution or local LaTeX compilation is
% asserted by this source file.
%=====================================================================

\documentclass[11pt]{article}

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

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

%---------------------------------------------------------------------
% Environments
%---------------------------------------------------------------------

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

\theoremstyle{definition}
\newtheorem{definition}[theorem]{Definition}
\newtheorem{assumption}[theorem]{Assumption}
\newtheorem{example}[theorem]{Example}
\newtheorem{openproblem}[theorem]{Open Problem}

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

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

\DefineVerbatimEnvironment{ShellBlock}{Verbatim}{
  fontsize=\small,
  breaklines=true,
  breakanywhere=true,
  frame=single,
  framesep=3mm
}

%---------------------------------------------------------------------
% Notation
%---------------------------------------------------------------------

\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{\set}[1]{\left\{#1\right\}}
\newcommand{\ceil}[1]{\left\lceil #1\right\rceil}
\newcommand{\floor}[1]{\left\lfloor #1\right\rfloor}
\newcommand{\code}[1]{\texttt{\detokenize{#1}}}

\DeclareMathOperator{\tr}{tr}
\DeclareMathOperator{\rank}{rank}
\DeclareMathOperator{\diag}{diag}
\DeclareMathOperator{\Choi}{Choi}
\DeclareMathOperator{\Born}{Born}
\DeclareMathOperator{\Reach}{Reach}
\DeclareMathOperator{\Obs}{Obs}

\newcommand{\Q}{\mathsf Q}
\newcommand{\Bit}{\mathsf{Bit}}
\newcommand{\Unit}{\mathbf 1}
\newcommand{\Enter}{\mathsf{Enter}}
\newcommand{\Activate}{\mathsf{Activate}}
\newcommand{\Send}{\mathsf{Send}}
\newcommand{\Recv}{\mathsf{Recv}}
\newcommand{\Strategy}{\mathsf S}
\newcommand{\Prob}{\mathsf P}
\newcommand{\Update}{\mathsf U}
\newcommand{\TV}{d_{\mathrm{TV}}}
\newcommand{\Eact}{E_{\mathrm{act}}}
\newcommand{\Llat}{L_{\mathrm{lat}}}
\newcommand{\FG}{\mathsf{FG}}
\newcommand{\Rfg}{\mathcal R_{\mathrm{fg}}}
\newcommand{\Rcert}{\mathcal R_{\mathrm{cert}}}
\newcommand{\Aclass}{\mathcal A}
\newcommand{\Ray}{\mathbb P}
\newcommand{\DFh}{\mathrm{DF}_{<N}}
\newcommand{\DFall}{\mathrm{DF}_{\le N}}

\title{\textbf{En02-A}\\[2mm]
\textbf{Finite-Resource Geometry for the Enter Calculus}\\[2mm]
\large Cut Monotones, Certificate Costs, and Conditional Born Rigidity}

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

\date{7 October 2026}

\begin{document}

\maketitle

\begin{abstract}
We study destructive computational-basis readout under a finite
live-qubit budget and a separately specified grammar of consumable
geometric resources. The operational assumptions and their capacity
restrictions are stated explicitly; results about the specified Born
semantics are not imported into an unknown measurement strategy.
Identified latent links and active edges give cut-indexed monotones,
a bound on cross-cut activations, and decreasing potential reachability.
A geometric diamond is proved for read--write independent, guard-stable
updates, rather than inferred from quantum-name disjointness alone.
For a precisely delimited decohered fine-graining certificate, reduced
integer multiplicities give the exact register cost
\[
s+\ceil{\log_2 M}+\ceil{\log_2\max_k m_k}.
\]
This cost is not the unrestricted forcing threshold: the registered
three-qubit permutation-symmetric witness already anchors
\((1/3,2/3)\) at capacity three. Fine-graining and symmetry certificates
yield finite rational nets and continuity-controlled approximation
bounds wherever the requisite records fit. The principal new
conditional result is exact Born readout on every sub-capacity input,
at every capacity \(N\ge3\), when positive-branch residuals have the
projective computational diagonal on those inputs. Its proof derives
a cocycle on an explicit open domain and solves the resulting
functional equation. Global diagonal faithfulness additionally removes
the full-capacity boundary freedom in outcome laws. Unrestricted
finite-capacity uniqueness remains open; finite partial slack models
are not admissible counterexamples. A compactness theorem is proved
under an additional uniform regularity assumption on selective
outputs, without claiming an LP formulation or a computable
convergence rate. A separate one-shot instrument ledger distinguishes
coherent environment size from adaptive peak occupancy. A standalone
computational appendix supplies exact arithmetic regressions and
sampled diagnostics, not certificates of universally quantified
statements.
\end{abstract}

\tableofcontents

%=====================================================================
\section{Introduction, inheritance, and scope}
\label{sec:intro}
%=====================================================================

The Enter calculus separates a specified concrete semantics from a
characterization problem for an unknown measurement transition.
In the concrete semantics, destructive readout has Born probabilities
and projective residual rays by definition. In the characterization
problem, those probabilities and residuals are unknown, while the
qubit kinematics, coherent gates, allocation, typing, and observation
interfaces remain fixed.

Manuscript I identifies the Born strategy within its declared
structural class using composability, no-signaling, nullity,
continuity, and a typed record equation
\cite[labels \texttt{ass:strategy-class},
\texttt{def:requirements}, and \texttt{thm:main}]{I}.
That theorem quantifies over unbounded finite resources.
It is not, without a separate resource audit, a theorem about
strategies defined only up to a fixed capacity.

This paper makes that audit explicit. It has three distinct subjects:
\begin{enumerate}[label=\textup{(\roman*)}]
\item a combinatorial update grammar and its cut monotones;
\item finite-capacity operational constraints on unknown readout
strategies;
\item register accounting and finite computational diagnostics.
\end{enumerate}
No implication between these subjects is left implicit.

\subsection{Stable source locators}

The following table records the relationship between the legacy
``EC'' locators used in the earlier draft and the stable labels of
registered manuscript I. The legacy numbers are historical locators,
not a second collection of independent premises.

\begin{center}
\small
\begin{tabular}{@{}p{0.30\linewidth}p{0.35\linewidth}p{0.25\linewidth}@{}}
\toprule
Subject & Registered manuscript I & Legacy draft locator\\
\midrule
Concrete redex diamond
& \code{lem:diamond}
& EC Lemmas 4.3--4.4\\
Observational confluence
& \code{thm:confluence}
& EC Theorem 4.5\\
Uniform correlations
& \code{thm:uniformity}
& EC Theorem 9.3\\
Decohered fine-graining
& \code{thm:fine-anchor}
& EC Theorem 10.3\\
Born probabilities
& \code{thm:born}
& EC Theorem 11.1\\
Projective residuals
& \code{thm:update}
& EC Corollary 11.2\\
Three-qubit symmetry witness
& \code{prop:three}
& Additional anchoring route\\
Budgeted record stability
& \code{thm:stability}
& Separate record-stage budget\\
\bottomrule
\end{tabular}
\end{center}

The local proofs below state the assumptions they use and reproduce the
finite arguments needed here. In particular, no unbounded
characterization theorem is invoked to identify a finite-capacity
strategy.

\subsection{Three corrections that change the conclusions}

\paragraph{Certificate cost is not unrestricted forcing cost.}
The fine-graining construction for \((1/3,2/3)\) uses four qubits.
Nevertheless, I's permutation-symmetric three-qubit witness anchors
the same diagonal law using a different construction
\cite[label \texttt{prop:three}]{I}.
Consequently, four-qubit optimality within the fine-graining family
does not establish a four-qubit unrestricted forcing threshold.

\paragraph{Record equality is not diagonal faithfulness.}
The registered record equation compares classical observations of two
typed programs. Diagonal faithfulness is a condition on an unknown
conditional residual state. They are related in the Born
characterization, but they are not identical definitions. The
conditional rigidity theorem below states diagonal faithfulness
separately.

\paragraph{A finite probe is not a quantified theorem.}
A finite collection of successful tests does not establish
admissibility over every state, gate, continuation, and record
instance. Conversely, one exact failed instance can reject a proposed
strategy. The computational appendix respects this asymmetry.

\subsection{Readout and physical-model boundaries}

The finite four-live-qubit class in X-Enter is an interface restriction
on a specified family of first-order programs, including their input.
It is not the fine-graining cost theorem, a rational-net resolution,
or a field-to-qubit preparation theorem \cite{XEnter}.

The cut quantities defined here are combinatorial resource counters.
They are not a gravitational Noether current, a BV antibracket, a
retarded field coefficient, or a physical causal cone. Likewise,
the instrument ledger below does not instantiate the separately
represented Models 1, 2, or 3 of manuscript IV. No gravitational or
continuous-variable premise is imported.

%=====================================================================
\section{Finite operational strategies and explicit requirements}
\label{sec:strategies}
%=====================================================================

\subsection{Kinematics and destructive components}

For a finite set \(L\) of live qubit names, let
\[
\mathcal H_L=\bigotimes_{q\in L}\mathbb C^2.
\]
An ordering of \(L\) is used only to write coordinates.
Global states are unit rays. For \(S\subseteq L\) and
\(\kappa\in\{0,1\}^S\), define
\[
M^S_\kappa=\bra{\kappa}_S\otimes I_{L\setminus S},
\qquad
b^S_\psi(\kappa)=\norm{M^S_\kappa\psi}^2.
\]
On a positive Born branch the destructive projective residual is
\[
\psi^S_{\mathrm L,\kappa}
=
\frac{M^S_\kappa\psi}{\sqrt{b^S_\psi(\kappa)}}.
\]
The measured factors are removed, not retained.

For finite laws,
\[
\TV(p,q)=\frac12\sum_x\abs{p(x)-q(x)}.
\]
For unit rays we use
\[
d_{\mathrm{ray}}([\psi],[\phi])
=
\min_{\abs z=1}\norm{\psi-z\phi}.
\]

\begin{assumption}[Capacity-\(N\) structural class]
\label{ass:class}
A capacity-\(N\) strategy
\(\Strategy=(\Prob,\Update)\) supplies, for every
\(\abs L\le N\) and \(S\subseteq L\):
\begin{enumerate}[label=\textup{(\roman*)}]
\item a normalized law \(\Prob^S_\psi\) on \(\{0,1\}^S\);
\item a pure unit residual ray
\(\Update^S_\psi(\kappa)\in\Ray(\mathcal H_{L\setminus S})\)
whenever \(\Prob^S_\psi(\kappa)>0\).
\end{enumerate}
These data depend only on the current ray and measured names.
They are equivariant under simultaneous relabeling of names, tensor
factors, and outcome coordinates.

All finite-register unitaries and fresh \(\ket0\) allocation have
their stipulated linear-algebraic meanings. Allocation is allowed only
when the resulting live occupancy is at most \(N\).
No hidden memory, silent quantum deletion, or apparatus-dependent
measurement parameter is included.

A finite experimental program uses allocation, gates, destructive
readout, finite classical control, and return. Every quantum name is
consumed or returned. Local programs exchange neither quantum names
nor classical messages. Single programs use their prescribed
evaluation order; bipartite experiments permit interleavings of their
local orders.

For \(S=\varnothing\), readout has its unique unit outcome and leaves
the state unchanged.
\end{assumption}

This is the finite restriction of the relevant structural interfaces
of manuscript I. It is not obtained from the operational requirements.

\subsection{The five capacity-restricted requirements}

\begin{definition}[Operational admissibility]
\label{def:admissible}
A strategy in Assumption~\ref{ass:class} is
\emph{operationally admissible at capacity \(N\)} if it satisfies the
following requirements on every specified experiment whose entire
execution remains within \(N\) live qubits.
Write \(\Strategy\in\Aclass_N\).

\paragraph{\(\textnormal{(C)}_N\): composability.}
For disjoint \(S,T\subseteq L\), joint readout and both sequential
orders have the same ordered joint law. Thus
\begin{equation}
\Prob^{S\cup T}_\psi(\kappa,\lambda)
=
\Prob^S_\psi(\kappa)\,
\Prob^T_{\Update^S_\psi(\kappa)}(\lambda)
\label{eq:C}
\end{equation}
on positive first branches, with value zero on a zero first branch;
the corresponding equation holds in the reverse order.

\paragraph{\(\textnormal{(NS)}_N\): internal no-signaling.}
For every bipartition, the terminal classical law of one local program
is independent of the other local program and of the interleaving.
Locally allocated qubits and returned quantum spectators are included.
There is no exchange of names or messages.

\paragraph{\(\textnormal{(N)}_N\): nullity.}
\begin{equation}
M^S_\kappa\psi=0
\quad\Longrightarrow\quad
\Prob^S_\psi(\kappa)=0.
\label{eq:nullity}
\end{equation}

\paragraph{\(\textnormal{(K)}_N\): continuity.}
For each fixed \(L,S\), the map
\[
[\psi]\longmapsto\Prob^S_\psi
\]
is continuous in total variation. No continuity of the unknown update
is presumed.

\paragraph{\(\textnormal{(R)}_N\): typed records.}
Let \(L=S\sqcup B\), and let \(u\) consume all of \(B\), returning
classical output and not using the first reported outcome.
Compare:
\begin{enumerate}[label=\textup{(\alph*)}]
\item read \(S\), then run \(u\) on the residual \(B\), and report
the ordered classical outputs;
\item allocate a fresh register \(R\) of \(\abs S\) zero qubits,
copy \(S\) computationally to \(R\) by bitwise CNOT, run the same
\(u\) on \(B\), then read \(R\), report the same ordered classical
outputs, and return the original \(S\).
\end{enumerate}
Their classical observation laws must agree whenever both complete
executions fit the budget.
\end{definition}

The second program retains the original \(S\) as quantum output.
When \(B\ne\varnothing\), a continuation that omits \(B\) is not a
legal record instance. This is the typed interface of I's
\code{def:record}, restated rather than replaced by silent discard
\cite{I}.

\begin{lemma}[Born inhabitation]
\label{lem:born-inhabitation}
The strategy
\[
\Prob^S_\psi(\kappa)=b^S_\psi(\kappa),
\qquad
\Update^S_\psi(\kappa)=[\psi^S_{\mathrm L,\kappa}]
\]
belongs to \(\Aclass_N\) for every \(N\).
\end{lemma}

\begin{proof}
Normalization follows from
\(\sum_\kappa(M^S_\kappa)^\dagger M^S_\kappa=I\).
Disjoint destructive components commute after identifying surviving
factors, proving composability. Nullity and continuity follow directly
from squared norms.

For a finite local program, compose allocation isometries, unitaries,
and destructive measurement bras along each history. Backward
induction on the outcome tree gives a complete family of path maps:
\(\sum_hK_h^\dagger K_h=I\). For bipartite histories the maps factor as
\(K_a\otimes L_b\). Summing over the remote histories gives
\[
\sum_b
\bra\psi K_a^\dagger K_a\otimes L_b^\dagger L_b\ket\psi
=
\bra\psi K_a^\dagger K_a\otimes I\ket\psi.
\]
This proves the specified no-signaling requirement.

For records write
\(\psi=\sum_\kappa\ket\kappa_S\ket{\xi_\kappa}_B\).
A continuation history \(h\), with path map \(K_h\), has joint weight
\(\norm{K_h\xi_\kappa}^2\) in the direct program. The copied program
has pre-readout vector
\[
\sum_\kappa
\ket\kappa_S K_h\ket{\xi_\kappa}_B\ket\kappa_R,
\]
and record readout gives the same weight. Summing histories proves
record equality. All compared paths obey the capacity restriction.
\end{proof}

\subsection{Locality and record marginalization}

\begin{lemma}[Marginals and remote invariance]
\label{lem:remote}
For \(\Strategy\in\Aclass_N\):
\begin{enumerate}[label=\textup{(\roman*)}]
\item composability implies
\[
\Prob^S_\psi
=
\operatorname{marg}_S\Prob^{S\cup T}_\psi;
\]
\item applying a unitary outside \(S\) does not change
\(\Prob^S_\psi\);
\item adjoining fresh zero-state spectators outside \(S\) does not
change \(\Prob^S_\psi\), provided the enlarged configuration fits.
\end{enumerate}
\end{lemma}

\begin{proof}
For (i), sum \eqref{eq:C} over \(\lambda\) and use normalization.
For (ii), compare the local readout of \(S\) against a remote gate
followed by return, and against remote return alone.
For (iii), replace that remote gate experiment by allocation followed
by return. These are capacity-expressible no-signaling comparisons.
\end{proof}

\begin{lemma}[Budgeted purification locality]
\label{lem:locality}
Let two pure configurations have the same reduced state on a register
\(S\). If padding both environments to a common size fits capacity
\(N\), their \(S\)-laws agree.
\end{lemma}

\begin{proof}
Pad the smaller environment by zero spectators. Two purifications of
the same reduced state with equal environment dimension are related
by an environment unitary: choose matching Schmidt vectors on \(S\),
map one orthonormal environment family to the other, and extend that
isometry to a unitary. Apply Lemma~\ref{lem:remote}.
\end{proof}

\begin{lemma}[Record marginal identity]
\label{lem:record-marginal}
Suppose \(n=\abs L\), \(s=\abs S\), and \(n+s\le N\). Define the
copied state
\begin{equation}
\mathcal C_S\psi
=
\sum_\kappa
\ket\kappa_S\ket{\xi_\kappa}_B\ket\kappa_R,
\qquad
\psi=\sum_\kappa\ket\kappa_S\ket{\xi_\kappa}_B.
\label{eq:copy}
\end{equation}
Then
\begin{equation}
\Prob^S_\psi=\Prob^R_{\mathcal C_S\psi},
\qquad
\rho_R
=
\sum_\kappa\norm{\xi_\kappa}^2\ketbra{\kappa}{\kappa}.
\label{eq:record-marginal}
\end{equation}
\end{lemma}

\begin{proof}
Use the legal continuation \(u=\Enter(B)\), retaining all its classical
outputs. If \(B\) is empty, use the unit continuation.
The direct joint law has \(S\)-marginal \(\Prob^S_\psi\) by
composability. In the deferred program, the marginal law of \(R\)
equals its law before the remote readout of \(B\), by no-signaling.
Record equality identifies these marginals. The density-operator
formula follows by tracing the copied vector: the original
computational labels in \(S\) are orthogonal.
\end{proof}

\begin{remark}[What this improves, and what it does not]
\label{rem:record-budget}
Lemma~\ref{lem:record-marginal} uses \(s\) fresh record qubits and
requires \(n+s\le N\).
I's budgeted stability theorem uses whole-register records, including
further records of intermediate deferred states; its displayed
conditions include \(2n\le N\) and \(2(n+s)\le N\)
\cite[label \texttt{thm:stability}]{I}.
The budgets price different comparisons. The present exact marginal
argument does not remove any register from that approximate
continuation theorem, nor does it supply an approximate update estimate.
\end{remark}

\subsection{Uniform correlations without an extra outcome-covariance axiom}

\begin{lemma}[Uniform correlations inside the budget]
\label{lem:uniformity}
Suppose
\[
\psi=
\frac1{\sqrt d}
\sum_{k\in K}e^{i\theta_k}\ket k_S\ket{\eta_k}_B
\]
fits capacity \(N\), where the strings \(k\) are distinct and the
computational strings \(\eta_k\) are distinct.
Then \(\Prob^S_\psi\) is uniform on \(K\).
\end{lemma}

\begin{proof}
A diagonal unitary on \(B\) removes the phases without changing the
\(S\)-law. Write \(p=\Prob^S_\psi\), \(q=\Prob^B_\psi\), and
\(\nu=\Prob^{S\cup B}_\psi\). Nullity restricts \(\nu\) to
\((k,\eta_k)\); composability gives
\[
p(k)=\nu(k,\eta_k)=q(\eta_k).
\]
For a permutation \(\pi\) of \(K\), apply the basis permutation on
\(S\) sending \(k\) to \(\pi(k)\). The resulting vector can also be
obtained by a unitary on \(B\) sending \(\eta_k\) to
\(\eta_{\pi^{-1}(k)}\).
Remote invariance therefore leaves the \(S\)-law equal to \(p\) and
the \(B\)-law equal to \(q\). Nullity for the new pairing gives
\[
p(m)=q(\eta_{\pi^{-1}(m)})=p(\pi^{-1}(m)).
\]
Thus every permutation preserves \(p\), and normalization makes it
uniform. No extra qubits are allocated.
\end{proof}

This is the finite version of I's \code{thm:uniformity}.
It derives the required symmetry; it does not assume covariance of
unknown probabilities under arbitrary computational-basis permutations
\cite{I}.

%=====================================================================
\section{Resource geometry, ownership, and legal updates}
\label{sec:geometry}
%=====================================================================

\subsection{Identified links and capacity}

\begin{definition}[Resource geometry]
\label{def:geometry}
A geometry is
\[
g=(V,\mathrm{cap},\Eact,\Llat),
\]
where:
\begin{enumerate}[label=\textup{(\roman*)}]
\item \(V\) is a fixed finite set of regions;
\item \(\mathrm{cap}:V\to\mathbb N\) is a capacity function;
\item \(\Llat\) is a finite family of identified latent links
\((\ell,\{u,v\})\), with distinct endpoints in \(V\);
\item \(\Eact\) is a finite family of identified directed edges
\((\ell,u,v)\).
\end{enumerate}
Identifiers are unique and no identifier occurs in both components.
The directed graph underlying \(\Eact\) is acyclic.
Distinct identified edges may have the same endpoints.

Set
\[
\mu(g)=\sum_{v\in V}\mathrm{cap}(v)
+\abs{\Llat}+\abs{\Eact}.
\]
\end{definition}

Identified parallel edges are retained because each activation consumes
one identified token and creates one identified edge. If active edges
were instead an unlabelled set of endpoint pairs, activating a second
parallel token would not preserve the scalar count.

A configuration carries:
\[
[g,\psi,t,\lambda],
\]
where \(\lambda:L\to V\) labels live names and
\[
o(v)=\#\set{q\in L:\lambda(q)=v}
\le\mathrm{cap}(v).
\]
Measurement removes names and their tensor factors.
It does not remove the region containing them.
Permanent capacity retirement is a separate update.

\subsection{Ownership of cells, not merely endpoints}

\begin{definition}[Geometric ownership and footprints]
\label{def:footprint}
Mutable geometric cells comprise capacity cells and identified link
cells. Their permissions are linearly owned.
An endpoint region is not, by itself, a permission to modify every
incident link.

A transition has a write footprint \(W\), a read footprint \(D\), and
a guard. Its output on \(W\) depends only on data in \(D\cup W\), and
it fixes all cells outside \(W\).

Two transitions are \emph{independent} if
\[
W_1\cap(D_2\cup W_2)=
W_2\cap(D_1\cup W_1)=\varnothing
\]
and each guard remains true after the other transition.
\end{definition}

An acyclicity check can read nonlocal graph data.
Consequently, disjoint endpoint sets or disjoint quantum names do not
automatically establish geometric independence.

\begin{definition}[Activation authority]
\label{def:authority}
Each latent link has one linear activation authority
\(\Send_\ell@u\), with partner receive capability \(\Recv_\ell@v\).
Only the authority can activate the link, from \(u\) to \(v\).
The orientation and authority are preparation data.
The receive capability is not a second activation authority.

Activation consumes \(\Send_\ell\), replaces the latent link cell by
the active edge with the same identifier, and is legal only if the
resulting active graph is acyclic.
\end{definition}

This avoids a two-party race in which two independently owned
``halves'' both attempt to consume the same global latent object.
A different two-sided activation protocol would require its own
synchronization and progress proof.

\subsection{The update grammar}

\begin{definition}[Legal primitive moves]
\label{def:moves}
The only geometric updates are finite compositions of:
\begin{enumerate}[label=\textnormal{(m\arabic*)}]
\item retire one capacity unit at an owned region, with
\(\mathrm{cap}(v)>o(v)\);
\item delete one owned identified active edge;
\item delete one owned identified latent link;
\item activate one owned latent link as in
Definition~\ref{def:authority}.
\end{enumerate}
No move creates a new identifier, changes endpoints, reverses an
existing edge, or creates an edge without consuming its latent link.
\end{definition}

The strict inequality in (m1) protects occupied slots.
If measurement is followed by permanent retirement, name deletion is
performed first and the resulting free unit is then retired.

\begin{proposition}[Preservation and the geometric diamond]
\label{prop:diamond}
Legal primitive moves preserve geometric well-formedness and the
occupancy bound. Independent geometric transitions commute.
For the specified Born quantum semantics, a pair of name-disjoint
quantum redexes equipped with independent geometric transitions has
the concrete probabilistic diamond.
\end{proposition}

\begin{proof}
Capacity retirement leaves capacity at least occupancy.
Deletion preserves acyclicity. Activation preserves it by its guard
and preserves identifier uniqueness by moving, rather than copying,
the link identifier.

For independent transitions, neither writes data used by the other,
and neither invalidates the other's guard. Each therefore produces
the same update on its own write footprint in either order.
Outside their union both act identically.

The Born quantum diamond follows from the commuting destructive
components, disjoint gates, and fresh-name identification.
Its joint branch weights are the same in both orders.
Combine that equality with the geometric commutation just proved.
\end{proof}

\begin{remark}[Inherited and new parts]
Manuscript I's \code{lem:diamond} concerns quantum-name disjointness
in the specified concrete calculus. The geometric part of
Proposition~\ref{prop:diamond} is new and needs the footprint and guard
conditions above. It is not a theorem about arbitrary unknown updates
merely because their names are disjoint.
\end{remark}

\begin{example}[Local writes need not commute]
\label{ex:read-conflict}
Let \(x,y\in\{0,1\}\) initially both be zero.
One map writes \(x:=1-y\) and leaves \(y\) fixed; the other writes
\(y:=1-x\) and leaves \(x\) fixed.
Their write footprints are disjoint, but both read the other's cell.
The two orders give \((1,0)\) and \((0,1)\).

Similarly, a collection of individually acyclic edge insertions may
form a cycle when combined. A global acyclicity guard is therefore
not automatically stable under disjoint writes.
These are new counterexamples to insufficient geometric hypotheses,
not inherited quantum counterexamples.
\end{example}

%=====================================================================
\section{Cut monotones and decreasing potential reachability}
\label{sec:cuts}
%=====================================================================

For a cut \(X\mid Y\), with \(Y=V\setminus X\), define
\[
\mu_{X\mid Y}(g)
=
\sum_{v\in X}\mathrm{cap}(v)
+\#\set{\text{latent links crossing }X\mid Y}
+\#\set{\text{active edges directed }X\to Y},
\]
and
\[
\sigma_{X\mid Y}(g)
=
\#\set{\text{latent links crossing }X\mid Y}
+\#\set{\text{active edges crossing in either direction}}.
\]
All counts include identifiers and hence multiplicity.

\begin{example}[Scalar accounting is insufficient]
Deleting a crossing token \(\{A,B\}\) and an internal token
\(\{B,B'\}\), then creating edges \(B\to A\) and \(B'\to A\), preserves
the scalar count of links. It increases the number of crossing links
from one to two.
The grammar excludes the second edge because no consumed token had
endpoints \(\{B',A\}\).
\end{example}

\begin{theorem}[E: cut monotonicity and exact conversion]
\label{thm:E}
Under Definition~\ref{def:moves}:
\begin{enumerate}[label=\textup{(\roman*)}]
\item \(\mu\) decreases by one under (m1)--(m3) and is preserved
by (m4);
\item for every cut, \(\mu_{X\mid Y}\) and
\(\sigma_{X\mid Y}\) are non-increasing;
\item activation preserves \(\sigma_{X\mid Y}\) for every cut:
one crossing token becomes one crossing identified edge;
\item along a run, the number of cross-cut activations is at most
the initial number of crossing latent links, and therefore at most
\(\sigma_{X\mid Y}(g_0)\).
\end{enumerate}
\end{theorem}

\begin{proof}
Use \(\mathbf 1_A\) for the indicator of a condition \(A\).
For a deleted or activated link with endpoints \(u,v\), let
\(c=\mathbf 1_{\text{endpoints cross}}\).
The changes are:
\[
\begin{array}{c|c|c|c}
\text{move}&\Delta\mu&\Delta\mu_{X\mid Y}&
\Delta\sigma_{X\mid Y}\\
\hline
\text{retire capacity at }v
&-1&-\mathbf 1_{v\in X}&0\\
\text{delete }u\to v
&-1&-\mathbf 1_{u\in X,v\in Y}&-c\\
\text{delete latent link}
&-1&-c&-c\\
\text{activate }u\to v
&0&-c+\mathbf 1_{u\in X,v\in Y}&0
\end{array}
\]
Every entry in the cut columns is non-positive.
The activation row counts an identified edge, so it remains valid
for parallel endpoint pairs.
Finite composition proves (i)--(iii).

No move adds a latent link. Each crossing latent identifier can be
activated at most once. This proves (iv).
\end{proof}

The word ``conservation'' is appropriate for the latent-to-active
conversion in (iii). The complete quantities are monotones, not
constants along arbitrary runs.

\begin{definition}[Potential reachability]
\[
R(g)=
\Reach\!\left(
\Eact\ \cup\
\set{\text{both orientations of every latent link}}
\right),
\]
including reflexive pairs and forgetting identifiers only when forming
reachability.
\end{definition}

\begin{theorem}[F: potential coarsening and one-shot activation]
\label{thm:F}
For every legal run,
\[
R(g_{t+1})\subseteq R(g_t),
\qquad
\Eact(g_t)\subseteq R(g_0)
\]
at the level of endpoint pairs. Each latent identifier activates at
most once. If initially \(\sigma_{X\mid Y}=0\), no crossing active
edge or latent link is ever reachable.
\end{theorem}

\begin{proof}
Retiring capacity changes no reachability generator.
Deleting structure removes generators.
Activation replaces the two potential orientations of its latent
link by one of those orientations. Thus its generator set only
shrinks, and so does its reachability closure.

An activated identifier never returns to the latent component.
The final assertion follows either from Theorem~\ref{thm:E} or
directly from the absence of crossing generators.
\end{proof}

\subsection{Observation boundaries and no-signaling}

\begin{proposition}[Private observations before communication]
\label{prop:private-ns}
Consider two local quantum programs with disjoint quantum ownership.
Suppose their geometric actions leave the other party's private
readable cells fixed, and neither program inspects shared link status,
uses a cross-party communication primitive, or has its local
enablement changed by the other's geometric actions.
Then:
\begin{enumerate}[label=\textup{(\roman*)}]
\item the specified Born semantics has program-independent
unconditioned remote classical laws;
\item an operationally admissible unknown strategy has the same
independence by \(\textnormal{(NS)}_N\);
\item the remote private geometric observation is unchanged.
\end{enumerate}
\end{proposition}

\begin{proof}
Part (i) is the path-map marginalization in
Lemma~\ref{lem:born-inhabitation}. Part (ii) is the operational
requirement, applied to the stated local experiments.
Part (iii) follows because no transition writes a remotely readable
private cell or changes its local enablement.
\end{proof}

\begin{remark}[Activation is not literally invisible in every view]
An agent's view that includes the actual latent/active status of an
incident link changes when that link activates. Literal equality of
such views is false.
Only an observation interface that cannot inspect or exploit that
shared status before the authorized communication step supports an
invisibility claim. The cut theorem itself does not prove physical
no-signaling, nor does edge counting determine a channel's
information capacity.
\end{remark}

%=====================================================================
\section{Capacity restriction and its monotonicity}
\label{sec:capacity}
%=====================================================================

\begin{lemma}[Restriction in a fixed experimental library]
\label{lem:restriction}
If \(N\le N'\) and \(\Strategy\in\Aclass_{N'}\), restricting its laws
and residuals to inputs and experiments of peak occupancy at most
\(N\) gives a member of \(\Aclass_N\).
\end{lemma}

\begin{proof}
Every capacity-\(N\) experiment is a capacity-\(N'\) experiment.
Its state spaces, fixed gates, and observation interface are
unchanged. Every required equation is therefore inherited.
\end{proof}

For multiple regions one can make the same statement with pointwise
occupancy and effect bounds, provided the experimental library is
fixed independently of the current active graph.

\begin{remark}[No automatic closure for changing access libraries]
Activation can enable a previously unavailable communication or gate
interface. In such a graph-dependent language, pointwise capacity
decrease does not imply that the new set of experiments is a subset
of the old set. Run-invariant admissibility then needs a separate
simulation or library-inclusion theorem.
The present downward-closure claim is only the fixed-library claim
of Lemma~\ref{lem:restriction}.
\end{remark}

A total capacity sum is also not sufficient for local allocation.
A register needed in one region must fit its local capacity, unless
an explicitly permitted distributed placement implements the
construction. All forcing results below concern a single laboratory
of capacity \(N\), with the coherent gates of
Assumption~\ref{ass:class}.

%=====================================================================
\section{Exact fine-graining certificate cost and cheaper symmetry}
\label{sec:forcing}
%=====================================================================

\subsection{Primitive multiplicities and the certificate family}

\begin{definition}[Reduced rational law]
\label{def:primitive}
Let a probability law on \(s\) qubits have positive support
\(K\subseteq\{0,1\}^s\).
Write
\[
p_k=\frac{m_k}{M},
\qquad
m_k\in\mathbb N_{>0},
\quad
M=\sum_{k\in K}m_k,
\quad
\gcd\set{m_k:k\in K}=1.
\]
Zero weights are omitted. This is the primitive integer
representation.
\end{definition}

\begin{definition}[Decohered fine-graining certificates]
\label{def:fg}
An \(\FG\)-certificate for this law uses disjoint registers
\(S,E',E''\), with \(\abs S=s\), and a state
\[
\Phi
=
\frac1{\sqrt{M'}}
\sum_{\alpha=1}^{M'}
\ket{k(\alpha)}_S
\ket{r(\alpha)}_{E'}
\ket{e(\alpha)}_{E''},
\]
such that:
\begin{enumerate}[label=\textup{(\roman*)}]
\item the labels \(r(\alpha)\) are pairwise distinct;
\item the companions \((k(\alpha),e(\alpha))\) are pairwise distinct;
\item the diagonal marginal on \(S\) is the target law.
\end{enumerate}
Its certificate cost is the number of qubits simultaneously hosting
\(S,E',E''\). Let \(C_{\FG}(s,\vec m)\) be the minimum within this
specified family.
\end{definition}

The family is intentionally narrower than all protocols capable of
forcing a law. It is the register pattern of I's decohered
fine-graining proof \cite[label \texttt{thm:fine-anchor}]{I}.

\begin{theorem}[H: exact certificate cost]
\label{thm:H}
For primitive multiplicities,
\begin{equation}
C_{\FG}(s,\vec m)
=
s+\ceil{\log_2 M}
+\ceil{\log_2\max_{k\in K}m_k}.
\label{eq:fgcost}
\end{equation}
\end{theorem}

\begin{proof}
For the upper bound, choose
\(a=\ceil{\log_2 M}\) and
\(b=\ceil{\log_2\max_km_k}\).
Partition \(M\) distinct \(a\)-bit labels into blocks of sizes \(m_k\).
Within block \(k\), assign distinct \(b\)-bit labels.
Use the resulting state with \(M'=M\).

For the lower bound, the number of terms in block \(k\) is
\[
c_k=\frac{m_kM'}M\in\mathbb N.
\]
Thus \(M\) divides \(m_kM'\) for every \(k\).
Since the multiplicities have greatest common divisor one,
an integer linear combination of them equals one; hence \(M\)
divides \(M'\), and \(M'\ge M\).
Distinct refined labels require \(2^{\abs{E'}}\ge M'\ge M\).
Within block \(k\), distinct companions require
\[
2^{\abs{E''}}\ge c_k\ge m_k.
\]
These two bounds are attained by the upper-bound construction.
\end{proof}

Without reduction to primitive multiplicities the formula is not
representation-invariant: \((2,2)/4=(1,1)/2\).
The revised code reduces multiplicities before computing the cost.

\begin{proposition}[Fine-graining anchoring]
\label{prop:fg-anchor}
If \(C_{\FG}(s,\vec m)\le N\), every
\(\Strategy\in\Aclass_N\) has the target law on any
capacity-\(N\) purification whose measured reduction is
\(\diag(\vec m/M)\).
\end{proposition}

\begin{proof}
On the certificate, Lemma~\ref{lem:uniformity} makes the
\(E'\)-law uniform on its \(M\) labels.
Nullity restricts joint \(S,E'\) outcomes to the prescribed pairs
\((k(r),r)\). Composability therefore gives weight \(1/M\) to each
pair and marginal \(m_k/M\) on \(S\).

For another purification, pad the smaller environment to the larger
of its size and the certificate size. Both fit \(N\).
Lemma~\ref{lem:locality} transfers the law.
\end{proof}

No record register is included in \eqref{eq:fgcost}.
A separate coherent-to-record comparison on an \(n\)-qubit input
adds \(\abs S\) live qubits. The two costs are not to be added when
the corresponding witness configurations are used in separate
experiments, but neither may be silently omitted from its own
experiment.

\subsection{Symmetry certificates}

\begin{proposition}[Permutation-symmetric certificates]
\label{prop:symmetry}
For the same rational law, capacity \(sM\) suffices to anchor its
diagonal reduction, using composability, nullity, and the structural
tensor-permutation equivariance, followed by purification locality.
\end{proposition}

\begin{proof}
Take \(M\) blocks of \(s\) qubits. Let \(\mathcal W\) contain all
sequences \((k_1,\ldots,k_M)\) with exactly \(m_k\) occurrences of
label \(k\), and set
\[
\Omega_{\vec m}
=
\frac1{\sqrt{\abs{\mathcal W}}}
\sum_{(k_1,\ldots,k_M)\in\mathcal W}
\ket{k_1}\cdots\ket{k_M}.
\]
Block permutations are tensor-factor permutations. They preserve
the vector and act transitively on its computational support.
Equivariance and nullity make its full outcome law uniform on
\(\mathcal W\). Composability gives the first-block marginal
\[
\frac{\#\set{w\in\mathcal W:w_1=k}}{\abs{\mathcal W}}
=
\frac{m_k}{M}.
\]
The first-block reduction is diagonal: completions corresponding to
different first labels have different remaining multisets and hence
disjoint support. Purification locality gives the stated transfer.
\end{proof}

\begin{corollary}[The three-qubit \((1/3,2/3)\) anchor]
\label{cor:third}
For every \(\Strategy\in\Aclass_3\), measurement of the first qubit
of any two-qubit purification of \(\diag(1/3,2/3)\) has law
\((1/3,2/3)\).
\end{corollary}

\begin{proof}
The state
\[
\Omega=
\frac{\ket{011}+\ket{101}+\ket{110}}{\sqrt3}
\]
is invariant under tensor-factor permutations, which act
transitively on its three support strings. Its full law is uniform
by equivariance and nullity. Its first-qubit marginal is
\((1/3,2/3)\), and its reduced state is diagonal with those weights.
Pad the two-qubit purification by one zero spectator and apply
Lemma~\ref{lem:locality}.
\end{proof}

This is I's \code{prop:three}, included with its finite proof.
In contrast,
\[
C_{\FG}(1,(1,2))=4.
\]
Both statements are true; they optimize different certificate families.

\subsection{Forcing thresholds}

\begin{definition}[A fixed witness threshold]
For \(a\in(0,1)\), put
\[
\chi_a=\sqrt a\,\ket{00}+\sqrt{1-a}\,\ket{11}.
\]
Let \(N_{\mathrm{force}}(a)\) be the least \(N\ge2\) for which
every \(\Strategy\in\Aclass_N\) satisfies
\(\Prob^{\{0\}}_{\chi_a}(0)=a\), if such an \(N\) exists.
\end{definition}

Lemma~\ref{lem:restriction} makes this forcing property upward
monotone. Born inhabitation ensures that the admissible class is
not empty.

\begin{corollary}[Corrected status of the third-weight threshold]
\label{cor:L}
\[
N_{\mathrm{force}}(1/3)\le3.
\]
In particular, a capacity-three strategy deviating at
\(\chi_{1/3}\) cannot satisfy the retained structural and operational
requirements. The exact lower threshold is not determined here.
\end{corollary}

A proof that uses three qubits does not, by itself, exclude forcing
at two. The earlier claimed equivalence between a four-qubit
unrestricted threshold and a capacity-three deviant at this witness
is therefore not retained.

%=====================================================================
\section{Certified rational nets and a budgeted mesh theorem}
\label{sec:mesh}
%=====================================================================

\begin{definition}[Certified nets]
For \(N\ge s\), define
\[
\Rfg(N,s)
=
\set{\vec m/M:C_{\FG}(s,\vec m)\le N},
\]
including zero coordinates at unsupported outcomes.
Also set
\[
\Rcert(N,s)
=
\Rfg(N,s)\cup
\set{\vec m/M:sM\le N}.
\]
The second term uses primitive multiplicities and the symmetry
certificate of Proposition~\ref{prop:symmetry}.
Both nets are finite. They are sufficient anchoring sets, not a
classification of all forceable laws.

For either net \(\mathcal R\), define its covering radius
\[
\delta_{\mathcal R}(N,s)
=
\max_{p\in\Delta_{2^s}}
\min_{q\in\mathcal R(N,s)}\TV(p,q).
\]
\end{definition}

For binary laws the parameter \(p(0)\) identifies the simplex with
\([0,1]\), and total variation is ordinary absolute distance.
Thus the covering radius is half the largest gap between successive
net points.

\begin{proposition}[Binary mesh values]
\label{prop:mesh-values}
The fine-graining covering radii at capacities \(4,5,6\) are
\[
\delta_{\mathrm{fg}}(4,1)=\frac16,\qquad
\delta_{\mathrm{fg}}(5,1)=\frac18,\qquad
\delta_{\mathrm{fg}}(6,1)=\frac1{10}.
\]
Including symmetry certificates gives
\[
\delta_{\mathrm{cert}}(3,1)=\frac16,\quad
\delta_{\mathrm{cert}}(4,1)=\frac18,\quad
\delta_{\mathrm{cert}}(5,1)=\frac1{10},\quad
\delta_{\mathrm{cert}}(6,1)=\frac1{12}.
\]
\end{proposition}

\begin{proof}
The binary fine-graining nets at capacities \(4\) and \(5\) are,
respectively,
\[
\set{0,\tfrac13,\tfrac12,\tfrac23,1},
\qquad
\set{0,\tfrac14,\tfrac13,\tfrac12,\tfrac23,\tfrac34,1}.
\]
At capacity \(6\), the net is
\[
\set{
0,\tfrac15,\tfrac14,\tfrac13,\tfrac25,\tfrac37,
\tfrac12,\tfrac47,\tfrac35,\tfrac23,\tfrac34,\tfrac45,1}.
\]
These lists follow directly from \eqref{eq:fgcost}; their largest
gaps are \(1/3,1/4,1/5\).

For capacities \(3\le N\le6\), symmetry includes every grid point
\(j/N\), so all gaps in the union are at most \(1/N\).
The cost formula shows that fine-graining introduces no positive
point below \(1/N\) in these four cases. The initial gap is therefore
exactly \(1/N\).
\end{proof}

\begin{lemma}[Common probability modulus]
\label{lem:modulus}
For a fixed admissible strategy at capacity \(N\), there is a
nondecreasing function \(\omega_N\), tending to zero at zero, such
that
\[
\TV(\Prob^S_\psi,\Prob^S_\phi)
\le
\omega_N(d_{\mathrm{ray}}([\psi],[\phi]))
\]
for every same-size pair with at most \(N\) qubits.
\end{lemma}

\begin{proof}
Each fixed ray space is compact, so continuity implies uniform
continuity. Up to name relabeling there are finitely many register
sizes and measured subsets at capacity \(N\).
Take the maximum of their uniform moduli.
\end{proof}

\begin{theorem}[C\(^\star\): anchoring and mesh control]
\label{thm:Cstar}
Let \(\Strategy\in\Aclass_N\), let \(n=\abs L\), and let
\(s=\abs S\ge1\).
\begin{enumerate}[label=\textup{(\roman*)}]
\item Every diagonal measured reduction whose weights belong to
\(\Rcert(N,s)\) is exactly Born.
\item If \(n+s\le N\), then
\begin{equation}
\TV(\Prob^S_\psi,\Born^S_\psi)
\le
\omega_N\!\left(\sqrt{2\delta_{\mathrm{cert}}(N,s)}\right)
+\delta_{\mathrm{cert}}(N,s).
\label{eq:meshbound}
\end{equation}
The same bound holds with the fine-graining net and its radius.
\end{enumerate}
\end{theorem}

\begin{proof}
Part (i) is Propositions~\ref{prop:fg-anchor}
and~\ref{prop:symmetry}, including purification locality.

For (ii), use Lemma~\ref{lem:record-marginal}.
Write the copied vector with the record first as
\[
\Psi_p=\sum_\kappa\sqrt{p_\kappa}\ket\kappa_R\ket{v_\kappa}_E,
\]
where the \(v_\kappa\) are orthonormal on positive weights.
The environment has \(n\ge s\) qubits, so extend this family
orthonormally to every record label.
Choose \(q\) in the certified net with
\(\TV(p,q)\le\delta_{\mathrm{cert}}\), and define
\[
\Psi_q=\sum_\kappa\sqrt{q_\kappa}\ket\kappa_R\ket{v_\kappa}_E.
\]
Then
\[
\norm{\Psi_p-\Psi_q}^2
=
\sum_\kappa(\sqrt{p_\kappa}-\sqrt{q_\kappa})^2
\le
\sum_\kappa\abs{p_\kappa-q_\kappa}
=
2\TV(p,q).
\]
The \(R\)-law at \(\Psi_q\) is \(q\) by (i).
Uniform continuity and the triangle inequality give
\[
\TV(\Prob^R_{\Psi_p},p)
\le
\omega_N(\sqrt{2\TV(p,q)})+\TV(p,q).
\]
The record identity transfers this to direct \(S\)-readout.
\end{proof}

\begin{remark}[No boundary cocycle estimate without residual control]
A residual law close to Born on its own state need not be close to
the Born conditional law of the original input: the unknown update
may change that residual state.
Consequently, \eqref{eq:meshbound} alone does not justify replacing
sequential conditionals by L\"uders conditionals at full capacity.
No support-graph classification or state-uniform boundary
\(O(\varepsilon)\) estimate is claimed here.
\end{remark}

For fixed \(s\), the certified radii tend to zero as \(N\) grows.
For example, taking denominator \(2^h\) with
\(h=\floor{(N-s)/2}\) gives a fine-graining grid whose rounding
radius is at most
\[
(2^s-1)2^{-h}.
\]
The argument of \(\omega_N\) is the square root of this probability
radius. There is no strategy-uniform rate without a common modulus
assumption.

%=====================================================================
\section{Diagonal-faithful rigidity}
\label{sec:rigidity}
%=====================================================================

\begin{definition}[Sub-capacity and global diagonal faithfulness]
\label{def:df}
A strategy satisfies \(\DFh\) if, for every input on
\(n\le N-1\) qubits and every positive-probability measurement branch,
\[
\diag\!\left(
\ketbra{\Update^S_\psi(\kappa)}
{\Update^S_\psi(\kappa)}
\right)
=
\diag\!\left(
\ketbra{\psi^S_{\mathrm L,\kappa}}
{\psi^S_{\mathrm L,\kappa}}
\right).
\]
Nullity ensures that the L\"uders residual exists on such a branch.
The diagonals are taken on the surviving full computational basis.

The condition \(\DFall\) imposes the same equality on inputs with
\(n\le N\).
Neither condition identifies residual phases.
\end{definition}

\begin{remark}[Relationship to the registered record condition]
Diagonal faithfulness isolates the projective-diagonal property
needed in the cocycle proof. A continuation record argument that has
already identified Born future-test laws can imply this property by
taking computational diagonals. The registered record equality itself,
however, is an equality of classical observations of typed programs,
not this residual equation. We therefore retain
Definition~\ref{def:df} as an explicit conditional hypothesis.
\end{remark}

\subsection{The scalar functional equation}

\begin{lemma}[Open-domain cocycle rigidity]
\label{lem:functional}
Let \(\varphi:[0,1]\to[0,1]\) be continuous, with
\[
\varphi(0)=0,\qquad
\varphi(1)=1,\qquad
\varphi(1/2)=1/2.
\]
Suppose
\begin{equation}
\varphi(a)\varphi(u)
=
\varphi(m)\varphi(au/m)
\label{eq:cocycle}
\end{equation}
for all
\[
a,u\in(0,1),
\qquad
au<m<au+1-a.
\]
Then \(\varphi(x)=x\) on \([0,1]\).
\end{lemma}

\begin{proof}
We first prove positivity.
Choose \(a=x\) and \(m=2xu\). This is allowed when
\[
0<u<U(x):=\min\left(1,\frac{1-x}{x}\right),
\]
and gives
\begin{equation}
\varphi(x)\varphi(u)=\frac12\varphi(2xu).
\label{eq:doubling}
\end{equation}
If \(\varphi(x_0)=0\) for \(x_0\in(0,1)\), then
\(\varphi\) vanishes on
\[
(0,\lambda_0),
\qquad
\lambda_0=\min(2x_0,2(1-x_0))>0.
\]
If it vanishes on \((0,\lambda)\) with \(\lambda\le1/2\),
then for \(x\in(\lambda/2,\lambda)\) we have \(x<1/2\), hence
\(U(x)=1\); \eqref{eq:doubling} makes it vanish on \((0,2x)\).
Taking the union gives vanishing on \((0,2\lambda)\).
Finite repetition produces an interval containing \(1/2\),
contradicting the anchor. Thus \(\varphi>0\) on \((0,1)\).

Put \(H=\log\varphi\).
For \(x,y\in(0,1)\), set \(p=xy\).
The admissible intervals for the factorizations
\((x,y)\) and \((\sqrt p,\sqrt p)\) are
\[
(p,p+1-x),
\qquad
(p,p+1-\sqrt p).
\]
Their intersection is nonempty. Choosing \(m\) in that intersection
and applying \eqref{eq:cocycle} twice gives
\[
H(x)+H(y)=2H(\sqrt{xy}).
\]
Hence, with \(f(t)=2H(\sqrt t)\),
\[
H(x)+H(y)=f(xy).
\]

Write
\(G(s)=H(e^{-s})\) and \(F(t)=f(e^{-t})\).
Then
\[
G(s)+G(t)=F(s+t),\qquad s,t>0.
\]
For every \(\tau>0\),
\[
G(s+\tau)-G(s)=G(t+\tau)-G(t).
\]
The common increment \(\Delta(\tau)\) is continuous and additive
on positive arguments. Additivity gives
\(\Delta(q)=q\Delta(1)\) for positive rational \(q\);
continuity gives the same formula for every positive real argument.
Thus
\[
G(s)=-cs+d,
\qquad
H(x)=c\log x+d,
\qquad
\varphi(x)=e^dx^c.
\]
Continuity at one and \(\varphi(1)=1\) give \(d=0\).
The half anchor gives \(2^{-c}=1/2\), so \(c=1\).
The endpoint anchors complete the result.
\end{proof}

\subsection{Operational derivation of the cocycle}

\begin{theorem}[I: sub-capacity diagonal-faithful rigidity]
\label{thm:I}
Let \(N\ge3\) and \(\Strategy\in\Aclass_N\).
If \(\Strategy\) satisfies \(\DFh\), then on every input
with \(n\le N-1\) and every measured register \(S\),
\[
\Prob^S_\psi(\kappa)=b^S_\psi(\kappa).
\]
\end{theorem}

\begin{proof}
\paragraph{Step 1: one marginal function.}
Define
\[
\varphi(a)=\Prob^{\{0\}}_{\chi_a}(0),
\qquad
\chi_a=\sqrt a\,\ket{00}+\sqrt{1-a}\,\ket{11}.
\]
For any single-qubit readout on an \(n\le N-1\) input,
let \(a=\bra0\rho_S\ket0\).
One record qubit fits. By
Lemma~\ref{lem:record-marginal}, its law equals the direct law,
and its reduction is \(\diag(a,1-a)\).
Pad \(\chi_a\) with \(n-1\) zero spectators.
The padded reference and copied input are equal-size purifications
of that same record reduction, both on \(n+1\le N\) qubits.
Purification locality and spectator invariance therefore give
\[
\Prob^S_\psi=(\varphi(a),1-\varphi(a)).
\]
Continuity of \(a\mapsto\chi_a\) and \(\textnormal{(K)}_N\)
make \(\varphi\) continuous.

Only the reference and cocycle witnesses below have a fixed
three-qubit maximum. The general marginal comparison uses
\(n+1\le N\), not a universal three-qubit bound.

\paragraph{Step 2: anchors.}
Nullity at \(\chi_0,\chi_1\) gives
\(\varphi(0)=0\), \(\varphi(1)=1\).
Uniform correlations at
\((\ket{00}+\ket{11})/\sqrt2\) give
\(\varphi(1/2)=1/2\).

\paragraph{Step 3: the exact witness domain.}
Fix \(a,u\in(0,1)\) and
\(m\in(au,au+1-a)\). Define
\[
\psi_{a,u,m}
=
\sqrt{au}\,\ket{00}
+\sqrt{a(1-u)}\,\ket{01}
+\sqrt{m-au}\,\ket{10}
+\sqrt{1-a-m+au}\,\ket{11}.
\]
All four squared amplitudes are strictly positive and sum to one.
The computational diagonals of its one-qubit reductions are
\[
\diag(\rho_{q_0})=(a,1-a),
\qquad
\diag(\rho_{q_1})=(m,1-m).
\]
The reductions themselves generally have nonzero off-diagonal
entries; no diagonality claim is needed.

The projective residual after \(q_0=0\) has zero-outcome weight
\(u\); after \(q_1=0\) it has zero-outcome weight \(au/m\).
Both quantities lie in \((0,1)\).
The input occupies two qubits and hence is sub-capacity at
every \(N\ge3\). Its one-qubit residuals are sub-capacity as well.

If the first probability is positive, \(\DFh\) makes the strategy's
residual diagonal equal to the corresponding projective diagonal,
so Step 1 evaluates the second law by \(\varphi\).
If the first probability is zero, the joint probability is zero
and the same product expression remains valid.
Composability in the two orders therefore gives
\[
\varphi(a)\varphi(u)
=
\varphi(m)\varphi(au/m)
\]
on precisely the stated open domain.

\paragraph{Step 4: solve the scalar equation.}
Lemma~\ref{lem:functional} gives \(\varphi=\mathrm{id}\).
Thus every single-qubit readout on a sub-capacity input is Born.

\paragraph{Step 5: arbitrary registers.}
Induct on \(s=\abs S\).
For \(s\ge2\), write \(S=\{i\}\sqcup S'\).
Composability gives
\[
\Prob^S_\psi(\kappa_i,\kappa')
=
\Prob^{\{i\}}_\psi(\kappa_i)
\Prob^{S'}_{\Update^{\{i\}}_\psi(\kappa_i)}(\kappa').
\]
A positive first branch has its projective residual diagonal by
\(\DFh\). The residual occupies \(n-1\le N-2\) qubits.
The induction hypothesis makes its \(S'\)-law Born, and that Born
law depends only on the residual computational diagonal.
The Born chain rule then gives the joint Born law.
Zero first branches contribute zero to both sides.
The empty register has its unique outcome.
\end{proof}

\begin{corollary}[K: a precise update-slack separation]
\label{cor:K}
If an admissible capacity-\(N\) strategy, \(N\ge3\), deviates from
Born on a sub-capacity input, it violates \(\DFh\).
Equivalently, under \(\DFh\), any outcome-law deviation must be at
full capacity.
\end{corollary}

This is a statement about the strategy's update conditions, not a
claim that the observed deviating branch itself must be the branch
on which diagonal faithfulness fails.

\subsection{Global diagonal faithfulness removes the boundary}

\begin{theorem}[Full-capacity outcome rigidity under global faithfulness]
\label{thm:boundary}
Let \(N\ge3\), \(\Strategy\in\Aclass_N\), and assume \(\DFall\).
Then every outcome law on every input with \(n\le N\) is Born.
\end{theorem}

\begin{proof}
Theorem~\ref{thm:I} handles \(n<N\).
Take \(n=N\) and first suppose every computational amplitude of
\(\psi\) is nonzero. Partition its names into nonempty \(A,B\).
Every first-readout residual has fewer than \(N\) qubits and therefore
has Born laws by Theorem~\ref{thm:I}.
Global diagonal faithfulness identifies its computational diagonal
with the original input's projective conditional diagonal.
Consequently,
\[
\Prob^L_\psi(\kappa,\lambda)
=
\Prob^A_\psi(\kappa)
\frac{b^L_\psi(\kappa,\lambda)}{b^A_\psi(\kappa)}
=
\Prob^B_\psi(\lambda)
\frac{b^L_\psi(\kappa,\lambda)}{b^B_\psi(\lambda)}.
\]
The formula remains true when a strategy first weight is zero.
All Born weights in the display are positive, so
\[
\frac{\Prob^A_\psi(\kappa)}{b^A_\psi(\kappa)}
=
\frac{\Prob^B_\psi(\lambda)}{b^B_\psi(\lambda)}
\]
for every pair. These ratios have one common value.
Normalization makes it one, and hence the full law is Born.
Composability gives every measured marginal.

Full-support rays are dense: perturb a vector in a direction with
all coordinates nonzero, avoid the finitely many perturbation values
that cancel a coordinate, and normalize.
Continuity of the strategy laws and Born laws extends the conclusion
to every ray.
\end{proof}

\begin{remark}[Boundary freedom is not sharp under the original global hypothesis]
The distinction between \(\DFh\) and \(\DFall\) matters.
The weaker condition supports Corollary~\ref{cor:K}'s boundary
alternative. Under the stronger, globally diagonal-faithful condition,
Theorem~\ref{thm:boundary} removes that alternative for outcome laws.
No exceptional GHZ support classification is needed.
\end{remark}

\begin{corollary}[Projective residuals when the continuation record fits]
\label{cor:update}
Under the hypotheses of Theorem~\ref{thm:boundary}, a readout of
\(S\) on an \(n\)-qubit input has its destructive projective residual
on every positive branch whenever
\(n+\abs S\le N\).
If no qubits survive, the residual ray is unique without this budget
condition.
\end{corollary}

\begin{proof}
Write
\(\psi=\sum_\kappa\ket\kappa_S\ket{\xi_\kappa}_B\).
For a fixed unitary \(V\) on all of \(B\), compare the direct
continuation \(\Enter(V(B))\) with its typed deferral.
The copied input fits by hypothesis.
All outcome laws involved are Born by
Theorem~\ref{thm:boundary}.
Record equality gives, for \(b_\kappa=\norm{\xi_\kappa}^2>0\),
\[
b_\kappa
\abs{\bra\lambda V\Update^S_\psi(\kappa)\rangle}^2
=
\abs{\bra\lambda V\xi_\kappa\rangle}^2.
\]
Choose \(V\) sending
\(\xi_\kappa/\sqrt{b_\kappa}\) to a fixed basis vector.
The equality makes the strategy residual have unit overlap with
that ray. Thus the rays agree.
The chosen continuation is fixed within each experiment and does
not depend on the first reported outcome.
\end{proof}

%=====================================================================
\section{The remaining finite-capacity question and partial slack}
\label{sec:slack}
%=====================================================================

\begin{openproblem}[G: unrestricted finite-capacity uniqueness]
\label{op:G}
For a fixed \(N\ge3\), do the requirements defining
\(\Aclass_N\), without diagonal faithfulness, force every
capacity-\(N\) outcome law and every positive residual ray to be Born
and destructive projective, respectively?

A witness-specific version asks whether an admissible strategy can
deviate at a specified input not already anchored by a certificate.
For capacity three, one possible diagnostic is
\[
D_3(\Strategy)
=
\abs{\Prob^{\{0\}}_{\chi_{1/5}}(0)-1/5}.
\]
No claim is made that this diagnostic captures every possible
deviation.
\end{openproblem}

The diagnostic at \(\chi_{1/3}\) is identically zero on
\(\Aclass_3\) by Corollary~\ref{cor:third}.
It is therefore unsuitable as an open capacity-three witness.

\begin{remark}[Static slack is a different problem]
I's static appendix assigns marginal probabilities without the full
operational record equation and without a finite-capacity protocol
model. It is not a capacity-three admissible strategy.
The operational question here additionally constrains conditional
residuals, sequential experiments, null branches, and records.
Neither a static deformation nor a finite partial assignment settles
Open Problem~\ref{op:G}.
\end{remark}

\subsection{An exact finite partial compensation}

The following example replaces an unsupported claim of a globally
admissible compensated strategy by an explicitly partial construction.

\begin{example}[A non-Born scalar candidate and a compensated table]
\label{ex:partial}
For \(0<\eta\le1/2\), set
\[
\varphi_\eta(x)
=
x+\eta x(1-x)(1-2x)(x-1/3)(x-2/3).
\]
It has anchors at \(0,1/3,1/2,2/3,1\) and obeys
\(\varphi_\eta(1-x)=1-\varphi_\eta(x)\).
The derivative of the added polynomial has absolute value at most
one on \([0,1]\): the product rule bounds its terms by
\(4/9\), \(2/9\), and \(1/3\).
Thus \(\varphi_\eta'\ge1-\eta>0\), and it maps \([0,1]\)
increasingly onto itself.

At \(\eta=1/2\),
\[
\varphi_\eta(1/5)-1/5=\frac{28}{9375}>0.
\]
However, the cocycle instance
\[
a=\frac13,\qquad u=\frac12,\qquad m=\frac14,
\qquad \frac{au}{m}=\frac23
\]
has defect
\begin{equation}
\varphi_\eta(a)\varphi_\eta(u)
-
\varphi_\eta(m)\varphi_\eta(au/m)
=
-\frac5{4608}
\quad(\eta=1/2).
\label{eq:partial-defect}
\end{equation}
The associated Born table is
\[
B=
\begin{pmatrix}
1/6&1/6\\
1/12&7/12
\end{pmatrix}.
\]

One can nevertheless satisfy both sequential orders on this one
strictly supported input by setting the proposed joint table to
\[
J_{ij}=r_i c_j,
\quad
r=(\varphi_\eta(a),1-\varphi_\eta(a)),
\quad
c=(\varphi_\eta(m),1-\varphi_\eta(m)).
\]
After the first-qubit readout, assign a one-qubit residual with
computational zero-weight \(m\); after the second-qubit readout,
assign one with zero-weight \(a\).
If one-qubit readout uses \(\varphi_\eta\), both sequential products
equal \(J_{ij}\).

The first assigned residual has weight \(m=1/4\), whereas the
projective residual after first outcome zero has weight \(u=1/2\).
The compensation is therefore diagonally unfaithful.

This is an exact partial assignment at the displayed state and
continuations. It is not a strategy on all rays. It does not prove
continuity across support boundaries, all record equations, or
no-signaling for arbitrary local programs.
\end{example}

A record-law equality can be assigned on a finite copied family as
well, but extending all these assignments simultaneously is precisely
an additional feasibility obligation. A passing selected record test
is not that extension.

%=====================================================================
\section{Conditional compactness without an LP claim}
\label{sec:compactness}
%=====================================================================

Continuity of outcome laws alone does not compactify unknown update
maps. A correct compactness statement must control selective outputs.

\begin{definition}[Selective pure outputs]
\label{def:selective}
Represent a strategy branch by
\[
\tau^S_\kappa([\psi])
=
\Prob^S_\psi(\kappa)
\ketbra{\Update^S_\psi(\kappa)}
{\Update^S_\psi(\kappa)}.
\]
At zero probability set \(\tau^S_\kappa=0\).
Then \(\tau\) is positive semidefinite, has rank at most one, and
\[
\tr\tau^S_\kappa=\Prob^S_\psi(\kappa).
\]
\end{definition}

\begin{assumption}[Additional selective-output regularity]
\label{ass:selective-modulus}
Fix a nondecreasing modulus \(\nu\) with \(\nu(t)\to0\) as
\(t\downarrow0\). For every branch at capacity \(N\), require
\[
\norm{
\tau^S_\kappa([\psi])-\tau^S_\kappa([\phi])
}_1
\le
\nu(d_{\mathrm{ray}}([\psi],[\phi])).
\]
This is additional to \(\textnormal{(K)}_N\).
\end{assumption}

Let \(\mathcal K_{N,\nu}\) be the family of all finite tuples of
continuous branch maps satisfying this modulus, positivity,
rank at most one, normalization of their traces, the empty-readout
convention, and relabeling equivariance.

\begin{lemma}[Compactness of the selective-output family]
\label{lem:compact}
The space \(\mathcal K_{N,\nu}\), with the uniform trace-norm
topology on all branch maps, is compact.
\end{lemma}

\begin{proof}
There are finitely many canonical register sizes, subsets, and
outcomes at capacity \(N\). Each ray space is compact, and each
finite-dimensional output set is closed and bounded.
The common modulus gives equicontinuity.

For completeness, choose a countable dense subset of each input
ray space. Repeated subsequence extraction makes a sequence converge
on every selected point. The common modulus then makes that
subsequence uniformly Cauchy: cover each input space by finitely
many sufficiently small balls centered at selected points.
The resulting uniform limits satisfy the same modulus.
Positivity, rank at most one, trace normalization, and equivariance
are closed under uniform limits. Thus every sequence has a convergent
subsequence in \(\mathcal K_{N,\nu}\).
\end{proof}

\begin{lemma}[Closed finite-experiment constraints]
\label{lem:closed}
The law of any fixed finite experiment is a continuous functional
of \(\tau\in\mathcal K_{N,\nu}\).
Consequently, each fixed instance of composability, nullity,
no-signaling, and record equality is closed.
\end{lemma}

\begin{proof}
At a positive branch of weight \(p\), the rank-one operator
\(\tau/p\) determines the residual ray continuously.
A gate or allocation is a continuous map on that ray.
Evaluation of a subsequent branch map is continuous by the common
modulus.

At a branch whose weight tends to zero, every downstream terminal
contribution is bounded by that first weight. Such a contribution
therefore tends to zero independently of the normalized residual.
Induction on the finite history tree proves continuity of every
reported law. Equality of continuous laws and exact zero conditions
are closed.
\end{proof}

\begin{theorem}[J: compact constraint exhaustion]
\label{thm:J}
Choose a countable collection of experiment constraints dense in the
parameter spaces of all required instances, including dense samples
within each nullity subspace.
Let \(K_k\subseteq\mathcal K_{N,\nu}\) impose the first \(k\)
constraints, with \(K_{k+1}\subseteq K_k\).
Assume
\[
K_\infty=\bigcap_{k=1}^\infty K_k
\]
is nonempty and equals the admissible family with the additional
modulus assumption.

For a continuous witness functional \(D\), define
\[
\varepsilon_k=\max_{\tau\in K_k}D(\tau),
\qquad
\varepsilon_\infty=\max_{\tau\in K_\infty}D(\tau).
\]
Then
\[
\varepsilon_{k+1}\le\varepsilon_k,
\qquad
\lim_{k\to\infty}\varepsilon_k=\varepsilon_\infty,
\]
and the limiting maximum is attained.
\end{theorem}

\begin{proof}
The sets \(K_k\) are nonempty compact sets by
Lemmas~\ref{lem:compact} and~\ref{lem:closed}.
The maximum exists, and nesting gives monotonicity.
Choose maximizers \(\tau_k\).
A convergent subsequence has limit \(\tau_\infty\).
For each fixed \(j\), its tail lies in \(K_j\), so the limit lies in
every \(K_j\) and hence in \(K_\infty\).
Continuity gives
\[
D(\tau_\infty)=\lim_k\varepsilon_k.
\]
The reverse inequality follows because
\(K_\infty\subseteq K_k\) for every \(k\).
\end{proof}

\begin{remark}[Exactly what J does not establish]
\label{rem:not-lp}
Theorem~\ref{thm:J} is a compactness theorem with finitely many
constraints at each stage. Its unknowns are still functions on ray
spaces. It is not a finite-dimensional LP.

Sequential probabilities contain products and evaluation at unknown
residual states. A grid discretization must prove an interpolation or
extension theorem, error bounds, and preservation of all required
constraints before its optimum can be identified with
\(\varepsilon_k\).
Neither effective computability nor a convergence rate follows from
compactness alone.

If \(\varepsilon_\infty=0\), every positive target is eventually
excluded by a sufficiently small upper bound. This supports rigidity;
it does not ``refute rigidity.''
Finite tests of one candidate do not optimize over \(K_k\).
Without Assumption~\ref{ass:selective-modulus}, this theorem does not
settle Open Problem~\ref{op:G}.
\end{remark}

%=====================================================================
\section{A one-shot instrument ledger and the adaptive separation}
\label{sec:instruments}
%=====================================================================

This section concerns the specified Born execution interface.
An unknown admissible finite-capacity strategy is not assumed to
produce linear completely positive maps.

Let \(\Phi=\{\Phi_x\}_{x\in X}\) be a finite instrument from \(s\)
input qubits to \(s'\) output qubits: each \(\Phi_x\) is completely
positive and \(\sum_x\Phi_x\) is trace preserving.
Discard zero outcome maps and write \(X_+\) for the remaining labels.
For a Kraus family,
\[
\Choi(\Phi_x)
=
\sum_j
\operatorname{vec}(K_{xj})
\operatorname{vec}(K_{xj})^\dagger.
\]
Set
\[
r_x=\rank\Choi(\Phi_x),
\qquad
R=\sum_{x\in X_+}r_x.
\]
The finite-dimensional Choi, Kraus, and Stinespring conventions are
those of \cite[Chapter 2]{Watrous}.

\begin{definition}[One-shot realization model]
\label{def:oneshot}
A one-shot realization consists of:
\begin{enumerate}[label=\textup{(\roman*)}]
\item a pure initialized environment;
\item an isometry from the input into output tensored with
environment;
\item a projective environment readout whose orthogonal blocks are
labelled by \(x\);
\item optional classical coarse-graining of a fully read fine index.
\end{enumerate}
Arbitrary coherent unitaries are available.
A classical outcome register, if explicitly retained quantumly,
is counted separately; it is not a free output qubit.
\end{definition}

\begin{theorem}[D\('\): exact one-shot environment ledger]
\label{thm:Dprime}
In Definition~\ref{def:oneshot}:
\begin{enumerate}[label=\textup{(\roman*)}]
\item the minimum environment dimension is \(R\);
\item full computational readout followed by classical
coarse-graining needs
\[
e=\ceil{\log_2 R}
\]
environment qubits;
\item within a rectangular outcome/index register split, the exact
register cost is
\[
e_{\mathrm{split}}
=
\ceil{\log_2\abs{X_+}}
+\ceil{\log_2\max_xr_x};
\]
\item the full-readout one-shot peak is \(s'+e\).
For an input already occupying \(s\) slots in a region with
\(o_{\mathrm{other}}\) unrelated occupied slots, realization is
possible precisely when
\[
o_{\mathrm{other}}+s'+e\le\mathrm{cap}(v).
\]
Equivalently, the additional free slots must cover
\(s'+e-s\).
\end{enumerate}
\end{theorem}

\begin{proof}
A positive Choi matrix of rank \(r_x\) has a spectral decomposition
with exactly \(r_x\) nonzero vectors. Unvectorizing them gives a
Kraus family of size \(r_x\).
Conversely, a family of \(d_x\) Kraus operators gives a Choi sum of
\(d_x\) rank-one matrices, so \(r_x\le d_x\).

If an environment block for outcome \(x\) has dimension \(d_x\),
expanding the dilation in a basis of that block gives at most
\(d_x\) Kraus operators for \(\Phi_x\). Thus
\[
\dim E=\sum_xd_x\ge\sum_xr_x=R.
\]
For the upper bound, choose minimum Kraus families and define
\[
V\ket\psi
=
\sum_{x,j}K_{xj}\ket\psi\otimes\ket{x,j}.
\]
Completeness gives \(V^\dagger V=I\).
The environment has \(R\) basis states, and its block readout realizes
the instrument.

Encode those states in \(e\) qubits and measure the full fine index.
On reporting only \(x\), the conditional output density operator is
\[
\frac{\sum_jK_{xj}\rho K_{xj}^\dagger}
{\tr\Phi_x(\rho)}.
\]
This is a classical mixture of fine pure branches, not a single
pure primitive residual. No unmeasured quantum environment needs an
affine discard operation; classical forgetting is explicit.

For a prescribed product split, the outcome register must encode
\(\abs{X_+}\) labels and the common index register must encode at
least \(\max_xr_x\) indices. The displayed cost is both necessary
within that model and sufficient.

The isometry embeds a \(2^s\)-dimensional space in a
\(2^{s'}R\)-dimensional one, so \(s'+e\ge s\).
Allocate \(s'+e-s\) zero ancillas, embed the isometry in the
\(s'+e\)-qubit space, and extend it to a unitary.
The peak and local-capacity condition follow.
\end{proof}

The classically correlated channel
\[
\rho\longmapsto\sum_x\ketbra{x}{x}\otimes\Phi_x(\rho)
\]
has Choi rank \(R\). Its explicit classical output is not to be
counted twice as both a retained quantum register and a destructively
read environment.

\begin{example}[Adaptive peak need not obey a prefix Choi bound]
\label{ex:adaptive}
A qubit depolarizing channel is the uniform mixture of the four
Pauli conjugations. Its four Pauli Kraus vectors are orthogonal, so
its Choi rank is four. Its one-shot environment ledger requires two
environment qubits and peak three including the input.

An adaptive implementation needs only one coin qubit at a time.
Prepare and destructively read a Hadamard coin, apply \(X\) or \(I\)
to the input according to that bit, reuse the freed slot for a second
coin, and apply \(Z\) or \(I\).
Classically forgetting the two bits gives the depolarizing channel.
The peak is two live qubits.

Thus the Choi rank of the accumulated channel bounds a coherent
environment that retains its whole dilation, not the instantaneous
quantum memory of every adaptive implementation.
\end{example}

\begin{remark}[Capacity retirement is not a physical decoherence rate]
Allocation occupancy, recyclable ancillas, permanent capacity
retirement, and classical forgetting are distinct operations.
One may define a bookkeeping flux as the number of permanently
retired capacity units per step. No theorem here identifies that
quantity with a physical decoherence rate, entropy production rate,
or coupling constant.
\end{remark}

%=====================================================================
\section{Status, evidence, and retained open boundaries}
\label{sec:status}
%=====================================================================

\begin{center}
\fbox{\begin{minipage}{0.92\linewidth}
\textbf{Inherited layer: registered Enter characterization.}

Manuscript I characterizes Born probabilities and destructive
projective residual rays in its stated unbounded finite structural
class under its five starred requirements. Its concrete metatheory
belongs first to the specified Born semantics.
\end{minipage}}

\medskip

\fbox{\begin{minipage}{0.92\linewidth}
\textbf{New layer: explicitly resource-relative statements.}

Identified-link grammar gives all-cut monotones and decreasing
potential reachability. Restricted certificate families have exact
register costs. Budget-expressible records give certified-net
bounds. Sub-capacity diagonal faithfulness gives exact Born laws;
global diagonal faithfulness also fixes boundary outcome laws.
\end{minipage}}

\medskip

\setlength{\unitlength}{1pt}
\begin{picture}(400,66)
\dashbox{4}(400,66){
\parbox{370pt}{
\textbf{Open frontier, not completed.}

Unrestricted finite-capacity uniqueness, including capacity three,
remains undecided here. The \((1/3,2/3)\) diagonal witness is already
closed by the three-qubit symmetry certificate. Partial slack
assignments and sampled checks do not provide an admissible
counterexample.
}}
\end{picture}
\end{center}

\begin{remark}[Package evidence boundary]
\label{rem:package}
A passing script, regression, or manifest is package evidence, not a
proof of a universally quantified theorem.
This is the same evidential separation emphasized in the package
remarks of Em02-B and XVI-O \cite{Em02B,XVIO}.
Those remarks supply a scope convention, not a mathematical premise
for the present results.

Theorem~\ref{thm:E} quantifies over every cut and legal run.
The appendix can enumerate all cuts only for its finite examples.
Theorem~\ref{thm:I} quantifies over every admissible input and the full
open cocycle domain. The numerical diagnostic samples finitely many
points.
Theorem~\ref{thm:J} is conditional compactness, not a solved
optimization hierarchy.
No formal proof-checker certificate, compilation certificate, field
preparation, or physical admission is claimed.
\end{remark}

\begin{center}
\small
\begin{tabular}{@{}p{0.26\linewidth}p{0.34\linewidth}p{0.30\linewidth}@{}}
\toprule
Result & Mathematical status & Appendix evidence\\
\midrule
E and F
& Proved for the identified-link grammar
& Finite all-cut and reachability checks\\
Geometric diamond
& Proved for independent, guard-stable transitions
& Illegal-cycle and frame regressions\\
H
& Exact within \(\FG\), primitive multiplicities
& Exact integer cost arithmetic\\
Three-qubit anchor
& Proved under retained tensor equivariance
& Explicit symmetric support\\
C\(^\star\)
& Proved where records fit
& Exact binary net radii\\
I and boundary extension
& Conditional on the stated diagonal faithfulness
& Sampled Born identities, not proof execution\\
Partial compensation
& Exact only on the specified finite assignments
& Rational defects and joint-table identities\\
J
& Conditional compactness, not an LP theorem
& No optimizer supplied\\
D\('\)
& Exact in the stated one-shot model
& Ledger arithmetic with supplied ranks\\
\bottomrule
\end{tabular}
\end{center}

%=====================================================================
\appendix
\section{Standalone computational specification}
\label{app:code}
%=====================================================================

The following single-file Python listing uses only the standard
library. It has no dependency on an unavailable
\code{enter-calculus} package.
Copy it to \code{en02_a_checks.py} and run:
\begin{ShellBlock}
python en02_a_checks.py
\end{ShellBlock}

The exact arithmetic portions use integers and
\code{fractions.Fraction}. Floating-point portions are explicitly
sampled diagnostics.

This listing has been statically revised to separate rejected legal
guards from invariant failures, retain parallel link identifiers,
reject cycles, reduce multiplicities, bound denominator enumeration
from capacity, and check every cut of each finite test geometry.
It is supplied without an execution log; no particular machine
epsilon or generated session is asserted.

\begin{CodeBlock}
"""En02-A: finite regressions and sampled diagnostics.

This file is package evidence, not a proof certificate.
No finite test establishes global operational admissibility.
"""

from __future__ import annotations

from dataclasses import dataclass, replace
from fractions import Fraction as F
from itertools import combinations, product
from math import gcd, sqrt
from functools import reduce
from random import Random


class GuardFailure(Exception):
    """Expected refusal of an illegal operation."""


class InvariantError(Exception):
    """A bug or malformed geometry; never silently swallowed."""


def require(condition, message):
    if not condition:
        raise InvariantError(message)


@dataclass(frozen=True)
class Geometry:
    # cap: ((region, nonnegative integer), ...)
    # active: ((identifier, source, target), ...)
    # latent: ((identifier, frozenset({u, v})), ...)
    cap: tuple
    active: tuple = ()
    latent: tuple = ()

    def __post_init__(self):
        regions = [v for v, _ in self.cap]
        require(len(regions) == len(set(regions)),
                "duplicate capacity region")
        require(all(isinstance(c, int) and c >= 0
                    for _, c in self.cap),
                "invalid capacity")
        V = set(regions)
        ids_a = [tid for tid, _, _ in self.active]
        ids_l = [tid for tid, _ in self.latent]
        require(len(ids_a) == len(set(ids_a)),
                "duplicate active identifier")
        require(len(ids_l) == len(set(ids_l)),
                "duplicate latent identifier")
        require(not (set(ids_a) & set(ids_l)),
                "identifier is both active and latent")
        require(all(u in V and v in V and u != v
                    for _, u, v in self.active),
                "invalid active endpoint")
        require(all(len(ends) == 2 and set(ends) <= V
                    for _, ends in self.latent),
                "invalid latent endpoint")
        require(self.acyclic(), "active graph contains a cycle")

    def regions(self):
        return frozenset(v for v, _ in self.cap)

    def capacity(self):
        return dict(self.cap)

    def adjacency(self, include_latent=False):
        adj = {v: set() for v in self.regions()}
        for _, u, v in self.active:
            adj[u].add(v)
        if include_latent:
            for _, ends in self.latent:
                u, v = tuple(ends)
                adj[u].add(v)
                adj[v].add(u)
        return adj

    def acyclic(self):
        adj = self.adjacency()
        colour = {v: 0 for v in adj}

        def visit(v):
            if colour[v] == 1:
                return False
            if colour[v] == 2:
                return True
            colour[v] = 1
            for w in adj[v]:
                if not visit(w):
                    return False
            colour[v] = 2
            return True

        return all(visit(v) for v in adj)

    def has_path(self, source, target):
        seen = set()
        todo = [source]
        adj = self.adjacency()
        while todo:
            v = todo.pop()
            if v == target:
                return True
            if v not in seen:
                seen.add(v)
                todo.extend(adj[v] - seen)
        return False

    def potential_relation(self):
        adj = self.adjacency(include_latent=True)
        out = set()
        for source in adj:
            seen = set()
            todo = [source]
            while todo:
                v = todo.pop()
                if v not in seen:
                    seen.add(v)
                    out.add((source, v))
                    todo.extend(adj[v] - seen)
        return frozenset(out)

    def mu(self):
        return (sum(c for _, c in self.cap)
                + len(self.active) + len(self.latent))

    def cut_mu(self, X):
        X = frozenset(X)
        require(X <= self.regions(), "cut contains unknown region")
        Y = self.regions() - X
        cap_x = sum(c for v, c in self.cap if v in X)
        latent_x = sum(len(ends & X) == 1
                       for _, ends in self.latent)
        active_xy = sum(u in X and v in Y
                        for _, u, v in self.active)
        return cap_x + latent_x + active_xy

    def sigma(self, X):
        X = frozenset(X)
        require(X <= self.regions(), "cut contains unknown region")
        return (
            sum(len(ends & X) == 1 for _, ends in self.latent)
            + sum((u in X) != (v in X)
                  for _, u, v in self.active)
        )


def all_cuts(g):
    V = sorted(g.regions())
    for k in range(len(V) + 1):
        for members in combinations(V, k):
            yield frozenset(members)


def owned(cell, frame):
    if cell not in set(frame):
        raise GuardFailure("missing ownership permission")


def finish(g, g2, expected_mu_delta):
    require(g2.mu() - g.mu() == expected_mu_delta,
            "incorrect scalar ledger")
    for X in all_cuts(g):
        require(g2.cut_mu(X) <= g.cut_mu(X),
                "cut_mu increased")
        require(g2.sigma(X) <= g.sigma(X),
                "sigma increased")
    require(g2.potential_relation() <= g.potential_relation(),
            "potential reachability increased")
    return g2


def retire_capacity(g, region, frame, occupancy=None):
    owned(("cap", region), frame)
    occ = dict(occupancy or {})
    caps = g.capacity()
    if region not in caps or caps[region] <= occ.get(region, 0):
        raise GuardFailure("no unoccupied capacity unit")
    caps[region] -= 1
    g2 = replace(g, cap=tuple(sorted(caps.items())))
    return finish(g, g2, -1)


def delete_active(g, tid, frame):
    owned(("link", tid), frame)
    found = [edge for edge in g.active if edge[0] == tid]
    if not found:
        raise GuardFailure("active identifier absent")
    g2 = replace(g, active=tuple(edge for edge in g.active
                                if edge[0] != tid))
    return finish(g, g2, -1)


def delete_latent(g, tid, frame):
    owned(("link", tid), frame)
    found = [link for link in g.latent if link[0] == tid]
    if not found:
        raise GuardFailure("latent identifier absent")
    g2 = replace(g, latent=tuple(link for link in g.latent
                                if link[0] != tid))
    return finish(g, g2, -1)


def activate(g, tid, source, frame):
    # The frame represents the single activation authority.
    # Production term typing must issue that authority linearly.
    owned(("link", tid), frame)
    found = [link for link in g.latent if link[0] == tid]
    if not found:
        raise GuardFailure("latent identifier absent or spent")
    _, ends = found[0]
    if source not in ends:
        raise GuardFailure("source is not an endpoint")
    target = next(iter(ends - {source}))
    if g.has_path(target, source):
        raise GuardFailure("activation would create a cycle")
    g2 = replace(
        g,
        latent=tuple(link for link in g.latent if link[0] != tid),
        active=g.active + ((tid, source, target),),
    )
    return finish(g, g2, 0)


def expect_guard_failure(fn):
    try:
        fn()
    except GuardFailure:
        return
    raise InvariantError("expected guard refusal did not occur")


def ceil_log2(n):
    require(isinstance(n, int) and n >= 1,
            "ceil_log2 requires a positive integer")
    return (n - 1).bit_length()


def primitive_multiplicities(m):
    m = tuple(m)
    require(bool(m), "empty multiplicity list")
    require(all(isinstance(x, int) and x >= 0 for x in m),
            "multiplicities must be nonnegative integers")
    positive = [x for x in m if x]
    require(bool(positive), "all multiplicities vanish")
    d = reduce(gcd, positive)
    return tuple(x // d for x in m)


def finegrain_cost(m, s=1):
    require(isinstance(s, int) and s >= 0, "invalid register size")
    m = primitive_multiplicities(m)
    require(len(m) <= 2 ** s, "too many outcome labels")
    M = sum(m)
    return s + ceil_log2(M) + ceil_log2(max(m))


def finegrain_words(m, s=1):
    """Return certificate basis labels; amplitudes are 1/sqrt(M)."""
    m = primitive_multiplicities(m)
    require(len(m) <= 2 ** s, "too many outcome labels")
    words = []
    refined = 0
    for label, count in enumerate(m):
        for tie in range(count):
            words.append((label, refined, tie))
            refined += 1
    require(len({r for _, r, _ in words}) == len(words),
            "refined labels repeat")
    require(len({(k, e) for k, _, e in words}) == len(words),
            "companions repeat")
    return tuple(words)


def binary_finegrain_net(N):
    require(isinstance(N, int) and N >= 1, "invalid capacity")
    out = {F(0), F(1)}
    # Every certificate has ceil(log2(M)) <= N - 1.
    # This is a complete capacity-derived bound, not a fixed cutoff.
    max_M = 1 << (N - 1)
    for M in range(2, max_M + 1):
        for m0 in range(1, M):
            if finegrain_cost((m0, M - m0), 1) <= N:
                out.add(F(m0, M))
    return tuple(sorted(out))


def binary_certified_net(N):
    out = set(binary_finegrain_net(N))
    for M in range(2, N + 1):
        for m0 in range(1, M):
            out.add(F(m0, M))
    return tuple(sorted(out))


def binary_mesh(points):
    points = tuple(sorted(points))
    require(points[0] == 0 and points[-1] == 1,
            "net must include endpoints")
    return max((b - a) / 2
               for a, b in zip(points, points[1:]))


def phi_candidate(x, eta=F(1, 2)):
    return (x + eta * x * (1 - x) * (1 - 2 * x)
            * (x - F(1, 3)) * (x - F(2, 3)))


def exact_partial_compensation():
    a, u, m = F(1, 3), F(1, 2), F(1, 4)
    pa, pm = phi_candidate(a), phi_candidate(m)
    row = (pa, 1 - pa)
    col = (pm, 1 - pm)
    J = {(i, j): row[i] * col[j]
         for i in (0, 1) for j in (0, 1)}
    for i in (0, 1):
        require(sum(J[i, j] for j in (0, 1)) == row[i],
                "wrong joint row")
    for j in (0, 1):
        require(sum(J[i, j] for i in (0, 1)) == col[j],
                "wrong joint column")
    # Assigned residual zero-weights are m and a respectively.
    for i in (0, 1):
        for j in (0, 1):
            require(J[i, j] == row[i] * col[j],
                    "forward sequential mismatch")
            require(J[i, j] == col[j] * row[i],
                    "reverse sequential mismatch")
    defect = (phi_candidate(a) * phi_candidate(u)
              - phi_candidate(m) * phi_candidate(a * u / m))
    deviation = phi_candidate(F(1, 5)) - F(1, 5)
    require(defect == -F(5, 4608), "unexpected cocycle defect")
    require(deviation == F(28, 9375),
            "unexpected witness deviation")
    require(m != u, "compensation accidentally faithful")
    return {
        "partial_joint": J,
        "cocycle_defect": defect,
        "candidate_deviation_at_1/5": deviation,
        "assigned_minus_projective_residual_weight": m - u,
        "status": "finite partial assignment, not admissibility",
    }


def chi(a):
    require(0.0 <= a <= 1.0, "a outside [0,1]")
    return (sqrt(a), 0j, 0j, sqrt(1.0 - a))


def witness(a, u, m):
    if not (0.0 < a < 1.0 and 0.0 < u < 1.0):
        raise ValueError("a and u must be in (0,1)")
    if not (a * u < m < a * u + 1.0 - a):
        raise ValueError("m outside exact open cocycle domain")
    w = (a * u, a * (1 - u), m - a * u,
         1 - a - m + a * u)
    require(min(w) > 0.0, "nonpositive witness amplitude weight")
    require(abs(sum(w) - 1.0) < 1e-12,
            "witness is not normalized")
    return tuple(complex(sqrt(x)) for x in w)


def qubit_count(psi):
    length = len(psi)
    require(length >= 1 and length & (length - 1) == 0,
            "state length is not a power of two")
    return length.bit_length() - 1


def project_delete(psi, S, outcome):
    n = qubit_count(psi)
    S = tuple(S)
    require(len(S) == len(set(S)), "duplicate measured coordinate")
    require(all(0 <= i < n for i in S), "invalid measured coordinate")
    require(len(outcome) == len(S), "wrong outcome arity")
    survivors = tuple(i for i in range(n) if i not in S)
    out = [0j] * (1 << len(survivors))
    for index, amp in enumerate(psi):
        bits = tuple((index >> (n - 1 - i)) & 1
                     for i in range(n))
        if tuple(bits[i] for i in S) == tuple(outcome):
            target = 0
            for i in survivors:
                target = 2 * target + bits[i]
            out[target] = complex(amp)
    p = sum(abs(z) ** 2 for z in out)
    if p == 0.0:
        return p, None
    return p, tuple(z / sqrt(p) for z in out)


def born_law(psi, S):
    return {
        outcome: project_delete(psi, S, outcome)[0]
        for outcome in product((0, 1), repeat=len(S))
    }


class BornStrategy:
    def P(self, psi, S):
        return born_law(psi, S)

    def U(self, psi, S, outcome):
        p, residual = project_delete(psi, S, outcome)
        if p == 0.0:
            raise ValueError("zero branch has no residual")
        return residual


def diagonal_residual_defect(strategy, psi, S, outcome):
    p = strategy.P(psi, S)[tuple(outcome)]
    if p <= 0.0:
        return 0.0
    b, projective = project_delete(psi, S, outcome)
    require(b > 0.0, "positive strategy branch violates nullity")
    residual = strategy.U(psi, S, outcome)
    require(len(residual) == len(projective),
            "residual has wrong dimension")
    return max(abs(abs(x) ** 2 - abs(y) ** 2)
               for x, y in zip(residual, projective))


def sample_rigidity_identities(strategy, samples=200, seed=0):
    """Sample necessary identities; this is not proof execution."""
    rng = Random(seed)

    def phi(x):
        return strategy.P(chi(x), (0,))[(0,)]

    worst_df = 0.0
    worst_cocycle = 0.0
    worst_product = 0.0
    worst_identity = 0.0

    for x in (0.0, 0.5, 1.0):
        require(abs(phi(x) - x) < 1e-9, "anchor diagnostic failed")

    for _ in range(samples):
        a = rng.uniform(0.05, 0.95)
        u = rng.uniform(0.05, 0.95)
        lo, hi = a * u, a * u + 1.0 - a
        # Fractional positioning avoids a fixed endpoint margin.
        m = lo + rng.uniform(0.1, 0.9) * (hi - lo)
        psi = witness(a, u, m)
        for S in ((0,), (1,)):
            worst_df = max(
                worst_df,
                diagonal_residual_defect(strategy, psi, S, (0,))
            )
        worst_cocycle = max(
            worst_cocycle,
            abs(phi(a) * phi(u) - phi(m) * phi(a * u / m))
        )
        x = rng.uniform(0.05, 0.95)
        y = rng.uniform(0.05, 0.95)
        worst_product = max(
            worst_product,
            abs(phi(x) * phi(y) - phi(sqrt(x * y)) ** 2)
        )
        worst_identity = max(worst_identity, abs(phi(x) - x))

    return {
        "sampled_diagonal_defect": worst_df,
        "sampled_cocycle_defect": worst_cocycle,
        "sampled_product_defect": worst_product,
        "sampled_phi_identity_defect": worst_identity,
        "status": "sampled diagnostics only",
    }


def one_shot_ledger_from_ranks(ranks, s, s_out):
    ranks = tuple(ranks)
    require(bool(ranks) and all(isinstance(r, int) and r > 0
                               for r in ranks),
            "supply positive Choi ranks after removing zero maps")
    R = sum(ranks)
    e = ceil_log2(R)
    e_split = ceil_log2(len(ranks)) + ceil_log2(max(ranks))
    require(s_out + e >= s,
            "ranks/dimensions cannot support the required isometry")
    return {
        "environment_dimension": R,
        "environment_qubits": e,
        "aligned_environment_qubits": e_split,
        "one_shot_peak": s_out + e,
        "additional_slots_beyond_input": s_out + e - s,
        "status": "arithmetic with supplied ranks",
    }


def run_exact_regressions():
    g = Geometry(
        cap=(("A", 2), ("B", 2), ("C", 1)),
        latent=(
            ("ab1", frozenset(("A", "B"))),
            ("ab2", frozenset(("A", "B"))),
            ("bc", frozenset(("B", "C"))),
            ("ca", frozenset(("C", "A"))),
        ),
    )
    g1 = activate(g, "ab1", "A", {("link", "ab1")})
    g2 = activate(g1, "ab2", "A", {("link", "ab2")})
    require(len(g2.active) == 2, "parallel identifiers collapsed")
    require(g2.mu() == g.mu(), "activation did not conserve mu")
    expect_guard_failure(
        lambda: activate(g2, "ab1", "A", {("link", "ab1")})
    )
    g3 = activate(g2, "bc", "B", {("link", "bc")})
    expect_guard_failure(
        lambda: activate(g3, "ca", "C", {("link", "ca")})
    )
    expect_guard_failure(
        lambda: retire_capacity(
            g3, "A", {("cap", "A")}, occupancy={"A": 2}
        )
    )
    g4 = retire_capacity(g3, "A", {("cap", "A")},
                         occupancy={"A": 1})
    g5 = delete_active(g4, "ab2", {("link", "ab2")})
    g6 = delete_latent(g5, "ca", {("link", "ca")})
    require(g6.mu() == g3.mu() - 3, "retirement ledger wrong")

    require(finegrain_cost((1, 2)) == 4, "wrong FG cost")
    require(finegrain_cost((1, 1)) == 2, "wrong uniform cost")
    require(finegrain_cost((2, 2)) == 2,
            "multiplicities were not reduced")
    require(finegrain_cost((3, 5)) == 7, "wrong FG cost")
    require(len(finegrain_words((1, 2))) == 3,
            "wrong certificate support")

    expected_fg = {4: F(1, 6), 5: F(1, 8), 6: F(1, 10)}
    for N, value in expected_fg.items():
        require(binary_mesh(binary_finegrain_net(N)) == value,
                "wrong fine-graining mesh")
    for N in range(3, 7):
        require(binary_mesh(binary_certified_net(N)) == F(1, 2 * N),
                "wrong combined certificate mesh")

    exact_partial_compensation()

    # Supplied symbolic ranks: projective instrument and depolarization.
    require(one_shot_ledger_from_ranks((1, 1), 1, 1)
            ["one_shot_peak"] == 2,
            "wrong projective-instrument ledger")
    require(one_shot_ledger_from_ranks((4,), 1, 1)
            ["one_shot_peak"] == 3,
            "wrong depolarizing one-shot ledger")


def main():
    run_exact_regressions()
    print("Exact finite regressions: PASS")
    print("This pass is package evidence, not a quantified certificate.")
    for N in range(3, 7):
        print("capacity", N,
              "FG radius", binary_mesh(binary_finegrain_net(N)),
              "combined radius",
              binary_mesh(binary_certified_net(N)))
    print(exact_partial_compensation())
    print(sample_rigidity_identities(BornStrategy()))


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

\section{Revision and proof-obligation ledger}
\label{app:repairs}

The changes from the preceding draft are substantive.

\begin{enumerate}[leftmargin=*,label=\textup{(\arabic*)}]
\item \textbf{Stable inheritance.}
Registered I labels replace drifting internal numbers as the primary
source locators. The characterization remains restricted to its
declared strategy class.

\item \textbf{Three-qubit symmetry retained.}
The four-qubit fine-graining optimum is no longer identified with
unrestricted forcing of \((1/3,2/3)\). The registered three-qubit
certificate is included and proved.

\item \textbf{Primitive rational representation.}
The register formula and code reduce multiplicities by their greatest
common divisor. Zero outcomes are handled separately.

\item \textbf{Correct reduced-state calculation.}
The cocycle witness has specified reduced-state diagonals, not
generally diagonal reduced states.

\item \textbf{Correct capacity bookkeeping.}
General one-qubit record comparisons use \(n+1\le N\).
Only the scalar witnesses have the fixed three-qubit bound.

\item \textbf{Faithfulness scope separated.}
Sub-capacity faithfulness gives the headroom theorem.
Global faithfulness additionally gives full-capacity outcome
rigidity. Neither condition is silently equated with the full record
requirement.

\item \textbf{Geometric identity counts.}
Active edges retain identifiers, including parallel edges.
Activation then really preserves the scalar and crossing-link counts.

\item \textbf{Ownership and read dependencies.}
Quantum-name disjointness no longer implies disjoint geometric frames.
Read footprints and guard stability are explicit.

\item \textbf{Acyclicity enforced.}
An activation that creates a directed cycle is refused before
constructing the new geometry.

\item \textbf{Occupied slots protected.}
Permanent capacity retirement requires a free unit.
Measurement removes names, not their regions.

\item \textbf{No-signaling observations delimited.}
Incident link status is not declared literally invisible.
Private observations, shared status, enablement, and communication
are distinguished.

\item \textbf{Fixed-library restriction.}
Downward closure is proved for a fixed experimental library.
No unproved closure under newly enabled graph-dependent operations is
claimed.

\item \textbf{Boundary approximation withdrawn.}
The mesh bound is not used to identify an unknown residual with the
original state's L\"uders conditional. Unsupported support-graph
classification and state-uniform boundary constants are removed.

\item \textbf{Compactness repaired.}
Selective-output regularity is added explicitly to the compactness
theorem. Finite constraints are not called a finite LP, and
compactness is not called effective computability.

\item \textbf{Partial slack honestly labelled.}
An exact partial compensation replaces the asserted all-state
level-one witness. Its extension to all required experiments remains
an open obligation.

\item \textbf{One-shot and adaptive instruments separated.}
The one-shot environment lower bound is proved in its own model.
An adaptive counterexample excludes the former prefix Choi-rank
claim about instantaneous quantum memory.

\item \textbf{Physical flux identification removed.}
Permanent capacity retirement is a bookkeeping operation, not a
derived physical decoherence rate.

\item \textbf{Artefact scope corrected.}
Invariant failures are not caught as ordinary guard refusals.
The denominator bound follows from capacity.
Numerical fitting and sampling are not described as execution of a
universal mathematical proof.
\end{enumerate}

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

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

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

\paragraph{Author contribution.}
N.C.\ developed the mathematical framework and prepared the
manuscript and computational specification.

\paragraph{Data and code availability.}
The exact finite constructions and standalone computational source
are included in this manuscript. No external package execution log
or formal verification certificate is supplied.

\paragraph{Ethics and clinical studies.}
Not applicable.

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

\bibitem{I}
N.~Cheung,
\emph{Born--L\"uders as the unique measurement strategy of a strictly
linear quantum \(\lambda\)-calculus: The Enter Calculus}.
Registered manuscript I, version 1, \code{I.tex}.
Stable locators used here include
\code{ass:strategy-class},
\code{def:requirements},
\code{def:record},
\code{lem:diamond},
\code{thm:confluence},
\code{thm:uniformity},
\code{prop:three},
\code{thm:fine-anchor},
\code{thm:born},
\code{thm:update},
\code{thm:stability}, and
\code{thm:main}.
Source interface:
\url{https://enter.grok.me/browse/I}.

\bibitem{XEnter}
N.~Cheung,
\emph{X-Enter}.
Registered manuscript, version 1, \code{X-Enter.tex}.
Finite readout interface and complete selective-record formulas,
including \code{eq:instrument} and \code{eq:recordchannel}.
Source interface:
\url{https://enter.grok.me}.

\bibitem{Watrous}
J.~Watrous,
\emph{The Theory of Quantum Information}.
Cambridge University Press, 2018.
Chapter 2: completely positive maps, Kraus representations,
Stinespring representations, and instruments.
Author's reference interface:
\url{https://cs.uwaterloo.ca/~watrous/TQI/}.

\bibitem{Em02B}
N.~Cheung,
\emph{Em02-B}.
Manuscript, version 1.
Package-boundary remark \code{conv:package}.
Cited only for the distinction between package evidence and proof.

\bibitem{XVIO}
N.~Cheung,
\emph{XVI-O}.
Manuscript, version \code{o70-sync}.
Package-boundary remark \code{conv:package}.
Cited only for the distinction between an archive or pass flag and
a mathematical certificate.

\end{thebibliography}

\end{document}