All manuscripts

Manuscript En02-A@1 · En02-A-v1.tex · bb1319d5

En02-A Finite-Resource Geometry for the Enter Calculus Cut Monotones, Certificate Costs, and Conditional Born Rigidity

Export En02-A-v1.tex

Records a finite-resource geometry for the Enter calculus of Landmark I: an update grammar derives cut conservation and scalar monotonicity, a latent/active split makes monogamy a typing invariant, the fine-graining register cost is the closed form N0, and a diagonal-faithful rigidity theorem forces Born on every sub-capacity configuration for capacity at least 3. Residual freedom is full-capacity configurations and diagonal-unfaithful update slack. The hierarchy probe does not resolve the residual open problem. The instrument ledger does not instantiate IV's three measurement models. X-Enter's four-live-qubit program class is not this register cost and not the mesh bound 1/6. I's static marginal slack is not this update slack. Cut potentials are not a gravitational Noether current, not an antibracket identity, and not a completion of the frozen insertion. Em02-B and XVI-O package checks are the cited pattern that an artefact pass is not a certificate. En01-A, En01-B, and En01-C are not premises. This is not spacetime emergence, not a gravity-generated entanglement test, and not an ultraviolet completion. H2, I3, and J2 stay unresolved. XV-B is not opened. No quantum coefficient is admitted. No compilation is asserted. No execution record is claimed.

Front matter

  • abstractAbstractFront matter · lines 134–169
    Open as its own page

    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

    This cost is not the unrestricted forcing threshold: the registered three-qubit permutation-symmetric witness already anchors 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 , 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.

Introduction, inheritance, and scope

  • sectionIntroduction, inheritance, and scopeIntroduction, inheritance, and scope · lines 175–203
    Open as its own page

    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 I (labels ass:strategy-class, def:requirements, and thm:main). 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:

    1. a combinatorial update grammar and its cut monotones;

    2. finite-capacity operational constraints on unknown readout strategies;

    3. register accounting and finite computational diagnostics.

    No implication between these subjects is left implicit.

  • sectionStable source locatorsIntroduction, inheritance, and scope › Stable source locators · lines 204–249
    Open as its own page

    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.

    SubjectRegistered manuscript ILegacy draft locator
    Concrete redex diamond:diamondEC Lemmas 4.3–4.4
    Observational confluence:confluenceEC Theorem 4.5
    Uniform correlations:uniformityEC Theorem 9.3
    Decohered fine-graining:fine-anchorEC Theorem 10.3
    Born probabilities:bornEC Theorem 11.1
    Projective residuals:updateEC Corollary 11.2
    Three-qubit symmetry witness:threeAdditional anchoring route
    Budgeted record stability:stabilitySeparate record-stage budget

    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.

  • sectionThree corrections that change the conclusionsIntroduction, inheritance, and scope › Three corrections that change the conclusions · lines 250–273
    Open as its own page

    cost is not unrestricted forcing cost. The fine-graining construction for uses four qubits. Nevertheless, I's permutation-symmetric three-qubit witness anchors the same diagonal law using a different construction I (label prop:three). Consequently, four-qubit optimality within the fine-graining family does not establish a four-qubit unrestricted forcing threshold.

    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.

    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.

  • sectionReadout and physical-model boundariesIntroduction, inheritance, and scope › Readout and physical-model boundaries · lines 274–288
    Open as its own page

    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 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.

Finite operational strategies and explicit requirements

  • sectionKinematics and destructive componentsFinite operational strategies and explicit requirements › Kinematics and destructive components · lines 293–325
    Open as its own page

    For a finite set of live qubit names, let

    An ordering of is used only to write coordinates. Global states are unit rays. For and , define

    On a positive Born branch the destructive projective residual is

    The measured factors are removed, not retained.

    For finite laws,

    For unit rays we use

  • assumptionAssumption: Capacity-N structural classFinite operational strategies and explicit requirements › Kinematics and destructive components · En02-A@1#ass:class · lines 326–356
    Open as its own page

    A capacity- strategy supplies, for every and :

    1. a normalized law on ;

    2. a pure unit residual ray whenever .

    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 allocation have their stipulated linear-algebraic meanings. Allocation is allowed only when the resulting live occupancy is at most . 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 , readout has its unique unit outcome and leaves the state unchanged.

  • sectionKinematics and destructive componentsFinite operational strategies and explicit requirements › Kinematics and destructive components · lines 356–360
    Open as its own page

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

  • definitionDefinition: Operational admissibilityFinite operational strategies and explicit requirements › The five capacity-restricted requirements · En02-A@1#def:admissible, En02-A@1#eq:C, En02-A@1#eq:nullity · lines 363–420
    Open as its own page

    A strategy in Assumption ass:class is {operationally admissible at capacity } if it satisfies the following requirements on every specified experiment whose entire execution remains within live qubits. Write .

    {: composability.} For disjoint , joint readout and both sequential orders have the same ordered joint law. Thus

    on positive first branches, with value zero on a zero first branch; the corresponding equation holds in the reverse order.

    {: 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.

    {: nullity.}

    {: continuity.} For each fixed , the map

    is continuous in total variation. No continuity of the unknown update is presumed.

    {: typed records.} Let , and let consume all of , returning classical output and not using the first reported outcome. Compare:

    1. read , then run on the residual , and report the ordered classical outputs;

    2. allocate a fresh register of zero qubits, copy computationally to by bitwise CNOT, run the same on , then read , report the same ordered classical outputs, and return the original .

    Their classical observation laws must agree whenever both complete executions fit the budget.

  • sectionThe five capacity-restricted requirementsFinite operational strategies and explicit requirements › The five capacity-restricted requirements · lines 420–427
    Open as its own page

    The second program retains the original as quantum output. When , a continuation that omits is not a legal record instance. This is the typed interface of I's :record, restated rather than replaced by silent discard I.

  • lemmaLemma: Born inhabitationFinite operational strategies and explicit requirements › The five capacity-restricted requirements · En02-A@1#lem:born-inhabitation · proof attached · lines 428–470
    Open as its own page

    The strategy

    belongs to for every .

    Proof. Normalization follows from . 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: . For bipartite histories the maps factor as . Summing over the remote histories gives

    This proves the specified no-signaling requirement.

    For records write . A continuation history , with path map , has joint weight in the direct program. The copied program has pre-readout vector

    and record readout gives the same weight. Summing histories proves record equality. All compared paths obey the capacity restriction.

  • lemmaLemma: Marginals and remote invarianceFinite operational strategies and explicit requirements › Locality and record marginalization · En02-A@1#lem:remote · proof attached · lines 474–497
    Open as its own page

    For :

    1. composability implies

    2. applying a unitary outside does not change ;

    3. adjoining fresh zero-state spectators outside does not change , provided the enlarged configuration fits.

    Proof. For (i), sum (eq:C) over and use normalization. For (ii), compare the local readout of 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.

  • lemmaLemma: Budgeted purification localityFinite operational strategies and explicit requirements › Locality and record marginalization · En02-A@1#lem:locality · proof attached · lines 499–512
    Open as its own page

    Let two pure configurations have the same reduced state on a register . If padding both environments to a common size fits capacity , their -laws agree.

    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 , map one orthonormal environment family to the other, and extend that isometry to a unitary. Apply Lemma lem:remote.

  • lemmaLemma: Record marginal identityFinite operational strategies and explicit requirements › Locality and record marginalization · En02-A@1#lem:record-marginal, En02-A@1#eq:copy, En02-A@1#eq:record-marginal · proof attached · lines 514–547
    Open as its own page

    Suppose , , and . Define the copied state

    Then

    Proof. Use the legal continuation , retaining all its classical outputs. If is empty, use the unit continuation. The direct joint law has -marginal by composability. In the deferred program, the marginal law of equals its law before the remote readout of , by no-signaling. Record equality identifies these marginals. The density-operator formula follows by tracing the copied vector: the original computational labels in are orthogonal.

  • remarkRemark: What this improves, and what it does notFinite operational strategies and explicit requirements › Locality and record marginalization · En02-A@1#rem:record-budget · lines 549–560
    Open as its own page

    Lemma lem:record-marginal uses fresh record qubits and requires . I's budgeted stability theorem uses whole-register records, including further records of intermediate deferred states; its displayed conditions include and I (label thm:stability). 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.

  • lemmaLemma: Uniform correlations inside the budgetFinite operational strategies and explicit requirements › Uniform correlations without an extra outcome-covariance axiom · En02-A@1#lem:uniformity · proof attached · lines 564–596
    Open as its own page

    Suppose

    fits capacity , where the strings are distinct and the computational strings are distinct. Then is uniform on .

    Proof. A diagonal unitary on removes the phases without changing the -law. Write , , and . Nullity restricts to ; composability gives

    For a permutation of , apply the basis permutation on sending to . The resulting vector can also be obtained by a unitary on sending to . Remote invariance therefore leaves the -law equal to and the -law equal to . Nullity for the new pairing gives

    Thus every permutation preserves , and normalization makes it uniform. No extra qubits are allocated.

  • sectionUniform correlations without an extra outcome-covariance axiomFinite operational strategies and explicit requirements › Uniform correlations without an extra outcome-covariance axiom · lines 596–603
    Open as its own page

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

Cut monotones and decreasing potential reachability

  • sectionCut monotones and decreasing potential reachabilityCut monotones and decreasing potential reachability · lines 769–788
    Open as its own page

    For a cut , with , define

    and

    All counts include identifiers and hence multiplicity.

  • exampleExample: Scalar accounting is insufficientCut monotones and decreasing potential reachability · lines 789–796
    Open as its own page

    Deleting a crossing token and an internal token , then creating edges and , 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 .

  • theoremTheorem: E: cut monotonicity and exact conversionCut monotones and decreasing potential reachability · En02-A@1#thm:E · proof attached · lines 798–841
    Open as its own page

    Under Definition def:moves:

    1. decreases by one under (m1)–(m3) and is preserved by (m4);

    2. for every cut, and are non-increasing;

    3. activation preserves for every cut: one crossing token becomes one crossing identified edge;

    4. along a run, the number of cross-cut activations is at most the initial number of crossing latent links, and therefore at most .

    Proof. Use for the indicator of a condition . For a deleted or activated link with endpoints , let . The changes are:

    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).

  • sectionCut monotones and decreasing potential reachabilityCut monotones and decreasing potential reachability · lines 841–846
    Open as its own page

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

  • definitionDefinition: Potential reachabilityCut monotones and decreasing potential reachability · lines 847–857
    Open as its own page

    including reflexive pairs and forgetting identifiers only when forming reachability.

  • theoremTheorem: F: potential coarsening and one-shot activationCut monotones and decreasing potential reachability · En02-A@1#thm:F · proof attached · lines 859–882
    Open as its own page

    For every legal run,

    at the level of endpoint pairs. Each latent identifier activates at most once. If initially , no crossing active edge or latent link is ever reachable.

    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 thm:E or directly from the absence of crossing generators.

  • propositionProposition: Private observations before communicationCut monotones and decreasing potential reachability › Observation boundaries and no-signaling · En02-A@1#prop:private-ns · proof attached · lines 886–909
    Open as its own page

    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:

    1. the specified Born semantics has program-independent unconditioned remote classical laws;

    2. an operationally admissible unknown strategy has the same independence by ;

    3. the remote private geometric observation is unchanged.

    Proof. Part (i) is the path-map marginalization in Lemma 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.

  • remarkRemark: Activation is not literally invisible in every viewCut monotones and decreasing potential reachability › Observation boundaries and no-signaling · lines 911–920
    Open as its own page

    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.

Capacity restriction and its monotonicity

  • lemmaLemma: Restriction in a fixed experimental libraryCapacity restriction and its monotonicity · En02-A@1#lem:restriction · proof attached · lines 927–938
    Open as its own page

    If and , restricting its laws and residuals to inputs and experiments of peak occupancy at most gives a member of .

    Proof. Every capacity- experiment is a capacity- experiment. Its state spaces, fixed gates, and observation interface are unchanged. Every required equation is therefore inherited.

  • sectionCapacity restriction and its monotonicityCapacity restriction and its monotonicity · lines 938–943
    Open as its own page

    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.

  • remarkRemark: No automatic closure for changing access librariesCapacity restriction and its monotonicity · lines 944–952
    Open as its own page

    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 lem:restriction.

  • sectionCapacity restriction and its monotonicityCapacity restriction and its monotonicity · lines 952–961
    Open as its own page

    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 , with the coherent gates of Assumption ass:class.

Exact fine-graining certificate cost and cheaper symmetry

  • definitionDefinition: Reduced rational lawExact fine-graining certificate cost and cheaper symmetry › Primitive multiplicities and the certificate family · En02-A@1#def:primitive · lines 968–984
    Open as its own page

    Let a probability law on qubits have positive support . Write

    Zero weights are omitted. This is the primitive integer representation.

  • definitionDefinition: Decohered fine-graining certificatesExact fine-graining certificate cost and cheaper symmetry › Primitive multiplicities and the certificate family · En02-A@1#def:fg · lines 986–1008
    Open as its own page

    An -certificate for this law uses disjoint registers , with , and a state

    such that:

    1. the labels are pairwise distinct;

    2. the companions are pairwise distinct;

    3. the diagonal marginal on is the target law.

    Its certificate cost is the number of qubits simultaneously hosting . Let be the minimum within this specified family.

  • sectionPrimitive multiplicities and the certificate familyExact fine-graining certificate cost and cheaper symmetry › Primitive multiplicities and the certificate family · lines 1008–1013
    Open as its own page

    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 I (label thm:fine-anchor).

  • theoremTheorem: H: exact certificate costExact fine-graining certificate cost and cheaper symmetry › Primitive multiplicities and the certificate family · En02-A@1#thm:H, En02-A@1#eq:fgcost · proof attached · lines 1014–1048
    Open as its own page

    For primitive multiplicities,

    Proof. For the upper bound, choose and . Partition distinct -bit labels into blocks of sizes . Within block , assign distinct -bit labels. Use the resulting state with .

    For the lower bound, the number of terms in block is

    Thus divides for every . Since the multiplicities have greatest common divisor one, an integer linear combination of them equals one; hence divides , and . Distinct refined labels require . Within block , distinct companions require

    These two bounds are attained by the upper-bound construction.

  • sectionPrimitive multiplicities and the certificate familyExact fine-graining certificate cost and cheaper symmetry › Primitive multiplicities and the certificate family · lines 1048–1053
    Open as its own page

    Without reduction to primitive multiplicities the formula is not representation-invariant: . The revised code reduces multiplicities before computing the cost.

  • propositionProposition: Fine-graining anchoringExact fine-graining certificate cost and cheaper symmetry › Primitive multiplicities and the certificate family · En02-A@1#prop:fg-anchor · proof attached · lines 1054–1072
    Open as its own page

    If , every has the target law on any capacity- purification whose measured reduction is .

    Proof. On the certificate, Lemma lem:uniformity makes the -law uniform on its labels. Nullity restricts joint outcomes to the prescribed pairs . Composability therefore gives weight to each pair and marginal on .

    For another purification, pad the smaller environment to the larger of its size and the certificate size. Both fit . Lemma lem:locality transfers the law.

  • sectionPrimitive multiplicities and the certificate familyExact fine-graining certificate cost and cheaper symmetry › Primitive multiplicities and the certificate family · lines 1072–1080
    Open as its own page

    No record register is included in (eq:fgcost). A separate coherent-to-record comparison on an -qubit input adds 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.

  • propositionProposition: Permutation-symmetric certificatesExact fine-graining certificate cost and cheaper symmetry › Symmetry certificates · En02-A@1#prop:symmetry · proof attached · lines 1083–1113
    Open as its own page

    For the same rational law, capacity suffices to anchor its diagonal reduction, using composability, nullity, and the structural tensor-permutation equivariance, followed by purification locality.

    Proof. Take blocks of qubits. Let contain all sequences with exactly occurrences of label , and set

    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 . Composability gives the first-block marginal

    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.

  • corollaryCorollary: The three-qubit (1/3,2/3) anchorExact fine-graining certificate cost and cheaper symmetry › Symmetry certificates · En02-A@1#cor:third · proof attached · lines 1115–1134
    Open as its own page

    For every , measurement of the first qubit of any two-qubit purification of has law .

    Proof. The state

    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 , and its reduced state is diagonal with those weights. Pad the two-qubit purification by one zero spectator and apply Lemma lem:locality.

  • sectionSymmetry certificatesExact fine-graining certificate cost and cheaper symmetry › Symmetry certificates · lines 1134–1142
    Open as its own page

    This is I's :three, included with its finite proof. In contrast,

    Both statements are true; they optimize different certificate families.

  • definitionDefinition: A fixed witness thresholdExact fine-graining certificate cost and cheaper symmetry › Forcing thresholds · lines 1145–1153
    Open as its own page

    For , put

    Let be the least for which every satisfies , if such an exists.

  • sectionForcing thresholdsExact fine-graining certificate cost and cheaper symmetry › Forcing thresholds · lines 1153–1158
    Open as its own page

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

  • corollaryCorollary: Corrected status of the third-weight thresholdExact fine-graining certificate cost and cheaper symmetry › Forcing thresholds · En02-A@1#cor:L · lines 1159–1167
    Open as its own page

    In particular, a capacity-three strategy deviating at cannot satisfy the retained structural and operational requirements. The exact lower threshold is not determined here.

  • sectionForcing thresholdsExact fine-graining certificate cost and cheaper symmetry › Forcing thresholds · lines 1167–1174
    Open as its own page

    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.

Certified rational nets and a budgeted mesh theorem

  • definitionDefinition: Certified netsCertified rational nets and a budgeted mesh theorem · lines 1179–1206
    Open as its own page

    For , define

    including zero coordinates at unsupported outcomes. Also set

    The second term uses primitive multiplicities and the symmetry certificate of Proposition prop:symmetry. Both nets are finite. They are sufficient anchoring sets, not a classification of all forceable laws.

    For either net , define its covering radius

  • sectionCertified rational nets and a budgeted mesh theoremCertified rational nets and a budgeted mesh theorem · lines 1206–1212
    Open as its own page

    For binary laws the parameter identifies the simplex with , and total variation is ordinary absolute distance. Thus the covering radius is half the largest gap between successive net points.

  • propositionProposition: Binary mesh valuesCertified rational nets and a budgeted mesh theorem · En02-A@1#prop:mesh-values · proof attached · lines 1213–1252
    Open as its own page

    The fine-graining covering radii at capacities are

    Including symmetry certificates gives

    Proof. The binary fine-graining nets at capacities and are, respectively,

    At capacity , the net is

    These lists follow directly from (eq:fgcost); their largest gaps are .

    For capacities , symmetry includes every grid point , so all gaps in the union are at most . The cost formula shows that fine-graining introduces no positive point below in these four cases. The initial gap is therefore exactly .

  • lemmaLemma: Common probability modulusCertified rational nets and a budgeted mesh theorem · En02-A@1#lem:modulus · proof attached · lines 1254–1272
    Open as its own page

    For a fixed admissible strategy at capacity , there is a nondecreasing function , tending to zero at zero, such that

    for every same-size pair with at most qubits.

    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 . Take the maximum of their uniform moduli.

  • theoremTheorem: C : anchoring and mesh controlCertified rational nets and a budgeted mesh theorem · En02-A@1#thm:Cstar, En02-A@1#eq:meshbound · proof attached · lines 1274–1328
    Open as its own page

    Let , let , and let .

    1. Every diagonal measured reduction whose weights belong to is exactly Born.

    2. If , then

      The same bound holds with the fine-graining net and its radius.

    Proof. Part (i) is Propositions prop:fg-anchor and prop:symmetry, including purification locality.

    For (ii), use Lemma lem:record-marginal. Write the copied vector with the record first as

    where the are orthonormal on positive weights. The environment has qubits, so extend this family orthonormally to every record label. Choose in the certified net with , and define

    Then

    The -law at is by (i). Uniform continuity and the triangle inequality give

    The record identity transfers this to direct -readout.

  • remarkRemark: No boundary cocycle estimate without residual controlCertified rational nets and a budgeted mesh theorem · lines 1330–1338
    Open as its own page

    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, (eq:meshbound) alone does not justify replacing sequential conditionals by Lüders conditionals at full capacity. No support-graph classification or state-uniform boundary estimate is claimed here.

  • sectionCertified rational nets and a budgeted mesh theoremCertified rational nets and a budgeted mesh theorem · lines 1338–1351
    Open as its own page

    For fixed , the certified radii tend to zero as grows. For example, taking denominator with gives a fine-graining grid whose rounding radius is at most

    The argument of is the square root of this probability radius. There is no strategy-uniform rate without a common modulus assumption.

Diagonal-faithful rigidity

  • definitionDefinition: Sub-capacity and global diagonal faithfulnessDiagonal-faithful rigidity · En02-A@1#def:df · lines 1356–1377
    Open as its own page

    A strategy satisfies if, for every input on qubits and every positive-probability measurement branch,

    Nullity ensures that the Lüders residual exists on such a branch. The diagonals are taken on the surviving full computational basis.

    The condition imposes the same equality on inputs with . Neither condition identifies residual phases.

  • remarkRemark: Relationship to the registered record conditionDiagonal-faithful rigidity · lines 1379–1387
    Open as its own page

    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 def:df as an explicit conditional hypothesis.

  • lemmaLemma: Open-domain cocycle rigidityDiagonal-faithful rigidity › The scalar functional equation · En02-A@1#lem:functional, En02-A@1#eq:cocycle, En02-A@1#eq:doubling · proof attached · lines 1391–1484
    Open as its own page

    Let be continuous, with

    Suppose

    for all

    Then on .

    Proof. We first prove positivity. Choose and . This is allowed when

    and gives

    If for , then vanishes on

    If it vanishes on with , then for we have , hence ; (eq:doubling) makes it vanish on . Taking the union gives vanishing on . Finite repetition produces an interval containing , contradicting the anchor. Thus on .

    Put . For , set . The admissible intervals for the factorizations and are

    Their intersection is nonempty. Choosing in that intersection and applying (eq:cocycle) twice gives

    Hence, with ,

    Write and . Then

    For every ,

    The common increment is continuous and additive on positive arguments. Additivity gives for positive rational ; continuity gives the same formula for every positive real argument. Thus

    Continuity at one and give . The half anchor gives , so . The endpoint anchors complete the result.

  • theoremTheorem: I: sub-capacity diagonal-faithful rigidityDiagonal-faithful rigidity › Operational derivation of the cocycle · En02-A@1#thm:I · proof attached · lines 1488–1593
    Open as its own page

    Let and . If satisfies , then on every input with and every measured register ,

    Proof. 1: one marginal function. Define

    For any single-qubit readout on an input, let . One record qubit fits. By Lemma lem:record-marginal, its law equals the direct law, and its reduction is . Pad with zero spectators. The padded reference and copied input are equal-size purifications of that same record reduction, both on qubits. Purification locality and spectator invariance therefore give

    Continuity of and make continuous.

    Only the reference and cocycle witnesses below have a fixed three-qubit maximum. The general marginal comparison uses , not a universal three-qubit bound.

    2: anchors. Nullity at gives , . Uniform correlations at give .

    3: the exact witness domain. Fix and . Define

    All four squared amplitudes are strictly positive and sum to one. The computational diagonals of its one-qubit reductions are

    The reductions themselves generally have nonzero off-diagonal entries; no diagonality claim is needed.

    The projective residual after has zero-outcome weight ; after it has zero-outcome weight . Both quantities lie in . The input occupies two qubits and hence is sub-capacity at every . Its one-qubit residuals are sub-capacity as well.

    If the first probability is positive, makes the strategy's residual diagonal equal to the corresponding projective diagonal, so Step 1 evaluates the second law by . 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

    on precisely the stated open domain.

    4: solve the scalar equation. Lemma lem:functional gives . Thus every single-qubit readout on a sub-capacity input is Born.

    5: arbitrary registers. Induct on . For , write . Composability gives

    A positive first branch has its projective residual diagonal by . The residual occupies qubits. The induction hypothesis makes its -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.

  • corollaryCorollary: K: a precise update-slack separationDiagonal-faithful rigidity › Operational derivation of the cocycle · En02-A@1#cor:K · lines 1595–1601
    Open as its own page

    If an admissible capacity- strategy, , deviates from Born on a sub-capacity input, it violates . Equivalently, under , any outcome-law deviation must be at full capacity.

  • sectionOperational derivation of the cocycleDiagonal-faithful rigidity › Operational derivation of the cocycle · lines 1601–1606
    Open as its own page

    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.

  • theoremTheorem: Full-capacity outcome rigidity under global faithfulnessDiagonal-faithful rigidity › Global diagonal faithfulness removes the boundary · En02-A@1#thm:boundary · proof attached · lines 1609–1649
    Open as its own page

    Let , , and assume . Then every outcome law on every input with is Born.

    Proof. Theorem thm:I handles . Take and first suppose every computational amplitude of is nonzero. Partition its names into nonempty . Every first-readout residual has fewer than qubits and therefore has Born laws by Theorem thm:I. Global diagonal faithfulness identifies its computational diagonal with the original input's projective conditional diagonal. Consequently,

    The formula remains true when a strategy first weight is zero. All Born weights in the display are positive, so

    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.

  • remarkRemark: Boundary freedom is not sharp under the original global hypothesisDiagonal-faithful rigidity › Global diagonal faithfulness removes the boundary · lines 1651–1657
    Open as its own page

    The distinction between and matters. The weaker condition supports Corollary cor:K's boundary alternative. Under the stronger, globally diagonal-faithful condition, Theorem thm:boundary removes that alternative for outcome laws. No exceptional GHZ support classification is needed.

  • corollaryCorollary: Projective residuals when the continuation record fitsDiagonal-faithful rigidity › Global diagonal faithfulness removes the boundary · En02-A@1#cor:update · proof attached · lines 1659–1690
    Open as its own page

    Under the hypotheses of Theorem thm:boundary, a readout of on an -qubit input has its destructive projective residual on every positive branch whenever . If no qubits survive, the residual ray is unique without this budget condition.

    Proof. Write . For a fixed unitary on all of , compare the direct continuation with its typed deferral. The copied input fits by hypothesis. All outcome laws involved are Born by Theorem thm:boundary. Record equality gives, for ,

    Choose sending 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.

The remaining finite-capacity question and partial slack

  • sectionThe remaining finite-capacity question and partial slackThe remaining finite-capacity question and partial slack · En02-A@1#op:G · lines 1694–1719
    Open as its own page

    For a fixed , do the requirements defining , without diagonal faithfulness, force every capacity- 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

    No claim is made that this diagnostic captures every possible deviation.

    The diagnostic at is identically zero on by Corollary cor:third. It is therefore unsuitable as an open capacity-three witness.

  • remarkRemark: Static slack is a different problemThe remaining finite-capacity question and partial slack · lines 1720–1728
    Open as its own page

    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 op:G.

  • sectionAn exact finite partial compensationThe remaining finite-capacity question and partial slack › An exact finite partial compensation · lines 1730–1734
    Open as its own page

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

  • exampleExample: A non-Born scalar candidate and a compensated tableThe remaining finite-capacity question and partial slack › An exact finite partial compensation · En02-A@1#ex:partial, En02-A@1#eq:partial-defect · lines 1735–1802
    Open as its own page

    For , set

    It has anchors at and obeys . The derivative of the added polynomial has absolute value at most one on : the product rule bounds its terms by , , and . Thus , and it maps increasingly onto itself.

    At ,

    However, the cocycle instance

    has defect

    The associated Born table is

    One can nevertheless satisfy both sequential orders on this one strictly supported input by setting the proposed joint table to

    After the first-qubit readout, assign a one-qubit residual with computational zero-weight ; after the second-qubit readout, assign one with zero-weight . If one-qubit readout uses , both sequential products equal .

    The first assigned residual has weight , whereas the projective residual after first outcome zero has weight . 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.

  • sectionAn exact finite partial compensationThe remaining finite-capacity question and partial slack › An exact finite partial compensation · lines 1802–1809
    Open as its own page

    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.

Conditional compactness without an LP claim

  • sectionConditional compactness without an LP claimConditional compactness without an LP claim · lines 1811–1816
    Open as its own page

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

  • definitionDefinition: Selective pure outputsConditional compactness without an LP claim · En02-A@1#def:selective · lines 1817–1832
    Open as its own page

    Represent a strategy branch by

    At zero probability set . Then is positive semidefinite, has rank at most one, and

  • assumptionAssumption: Additional selective-output regularityConditional compactness without an LP claim · En02-A@1#ass:selective-modulus · lines 1834–1846
    Open as its own page

    Fix a nondecreasing modulus with as . For every branch at capacity , require

    This is additional to .

  • sectionConditional compactness without an LP claimConditional compactness without an LP claim · lines 1846–1852
    Open as its own page

    Let 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.

  • lemmaLemma: Compactness of the selective-output familyConditional compactness without an LP claim · En02-A@1#lem:compact · proof attached · lines 1853–1874
    Open as its own page

    The space , with the uniform trace-norm topology on all branch maps, is compact.

    Proof. There are finitely many canonical register sizes, subsets, and outcomes at capacity . 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 .

  • lemmaLemma: Closed finite-experiment constraintsConditional compactness without an LP claim · En02-A@1#lem:closed · proof attached · lines 1876–1897
    Open as its own page

    The law of any fixed finite experiment is a continuous functional of . Consequently, each fixed instance of composability, nullity, no-signaling, and record equality is closed.

    Proof. At a positive branch of weight , the rank-one operator 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.

  • theoremTheorem: J: compact constraint exhaustionConditional compactness without an LP claim · En02-A@1#thm:J · proof attached · lines 1899–1942
    Open as its own page

    Choose a countable collection of experiment constraints dense in the parameter spaces of all required instances, including dense samples within each nullity subspace. Let impose the first constraints, with . Assume

    is nonempty and equals the admissible family with the additional modulus assumption.

    For a continuous witness functional , define

    Then

    and the limiting maximum is attained.

    Proof. The sets are nonempty compact sets by Lemmas lem:compact and lem:closed. The maximum exists, and nesting gives monotonicity. Choose maximizers . A convergent subsequence has limit . For each fixed , its tail lies in , so the limit lies in every and hence in . Continuity gives

    The reverse inequality follows because for every .

  • remarkRemark: Exactly what J does not establishConditional compactness without an LP claim · En02-A@1#rem:not-lp · lines 1944–1964
    Open as its own page

    Theorem 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 . Neither effective computability nor a convergence rate follows from compactness alone.

    If , 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 . Without Assumption ass:selective-modulus, this theorem does not settle Open Problem op:G.

A one-shot instrument ledger and the adaptive separation

  • sectionA one-shot instrument ledger and the adaptive separationA one-shot instrument ledger and the adaptive separation · lines 1968–1995
    Open as its own page

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

    Let be a finite instrument from input qubits to output qubits: each is completely positive and is trace preserving. Discard zero outcome maps and write for the remaining labels. For a Kraus family,

    Set

    The finite-dimensional Choi, Kraus, and Stinespring conventions are those of Watrous (Chapter 2).

  • definitionDefinition: One-shot realization modelA one-shot instrument ledger and the adaptive separation · En02-A@1#def:oneshot · lines 1996–2010
    Open as its own page

    A one-shot realization consists of:

    1. a pure initialized environment;

    2. an isometry from the input into output tensored with environment;

    3. a projective environment readout whose orthogonal blocks are labelled by ;

    4. optional classical coarse-graining of a fully read fine index.

    Arbitrary coherent unitaries are available. A classical outcome register, if explicitly retained quantumly, is counted separately; it is not a free output qubit.

  • theoremTheorem: D': exact one-shot environment ledgerA one-shot instrument ledger and the adaptive separation · En02-A@1#thm:Dprime · proof attached · lines 2012–2086
    Open as its own page

    In Definition def:oneshot:

    1. the minimum environment dimension is ;

    2. full computational readout followed by classical coarse-graining needs

      environment qubits;

    3. within a rectangular outcome/index register split, the exact register cost is

    4. the full-readout one-shot peak is . For an input already occupying slots in a region with unrelated occupied slots, realization is possible precisely when

      Equivalently, the additional free slots must cover .

    Proof. A positive Choi matrix of rank has a spectral decomposition with exactly nonzero vectors. Unvectorizing them gives a Kraus family of size . Conversely, a family of Kraus operators gives a Choi sum of rank-one matrices, so .

    If an environment block for outcome has dimension , expanding the dilation in a basis of that block gives at most Kraus operators for . Thus

    For the upper bound, choose minimum Kraus families and define

    Completeness gives . The environment has basis states, and its block readout realizes the instrument.

    Encode those states in qubits and measure the full fine index. On reporting only , the conditional output density operator is

    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 labels and the common index register must encode at least indices. The displayed cost is both necessary within that model and sufficient.

    The isometry embeds a -dimensional space in a -dimensional one, so . Allocate zero ancillas, embed the isometry in the -qubit space, and extend it to a unitary. The peak and local-capacity condition follow.

  • sectionA one-shot instrument ledger and the adaptive separationA one-shot instrument ledger and the adaptive separation · lines 2086–2095
    Open as its own page

    The classically correlated channel

    has Choi rank . Its explicit classical output is not to be counted twice as both a retained quantum register and a destructively read environment.

  • exampleExample: Adaptive peak need not obey a prefix Choi boundA one-shot instrument ledger and the adaptive separation · En02-A@1#ex:adaptive · lines 2096–2113
    Open as its own page

    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 or to the input according to that bit, reuse the freed slot for a second coin, and apply or . 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.

  • remarkRemark: Capacity retirement is not a physical decoherence rateA one-shot instrument ledger and the adaptive separation · lines 2115–2122
    Open as its own page

    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.

Status, evidence, and retained open boundaries

  • sectionStatus, evidence, and retained open boundariesStatus, evidence, and retained open boundaries · lines 2126–2167
    Open as its own page

    {{0.92} 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. }

    {{0.92} 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. }

    (400,66) 4(400,66){ 370pt{ Open frontier, not completed.

    Unrestricted finite-capacity uniqueness, including capacity three, remains undecided here. The diagonal witness is already closed by the three-qubit symmetry certificate. Partial slack assignments and sampled checks do not provide an admissible counterexample. }}

  • remarkRemark: Package evidence boundaryStatus, evidence, and retained open boundaries · En02-A@1#rem:package · lines 2168–2186
    Open as its own page

    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 Em02B,XVIO. Those remarks supply a scope convention, not a mathematical premise for the present results.

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

  • sectionStatus, evidence, and retained open boundariesStatus, evidence, and retained open boundaries · lines 2186–2226
    Open as its own page
    ResultMathematical statusAppendix evidence
    E and FProved for the identified-link grammarFinite all-cut and reachability checks
    Geometric diamondProved for independent, guard-stable transitionsIllegal-cycle and frame regressions
    HExact within , primitive multiplicitiesExact integer cost arithmetic
    Three-qubit anchorProved under retained tensor equivarianceExplicit symmetric support
    CProved where records fitExact binary net radii
    I and boundary extensionConditional on the stated diagonal faithfulnessSampled Born identities, not proof execution
    Partial compensationExact only on the specified finite assignmentsRational defects and joint-table identities
    JConditional compactness, not an LP theoremNo optimizer supplied
    DExact in the stated one-shot modelLedger arithmetic with supplied ranks

Standalone computational specification

  • sectionStandalone computational specificationStandalone computational specification · lines 2228–2317
    Open as its own page

    The following single-file Python listing uses only the standard library. It has no dependency on an unavailable -calculus package. Copy it to 02_a_checks.py and run:

    python en02_a_checks.py

    The exact arithmetic portions use integers and .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.

    """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)

  • sectionStandalone computational specificationStandalone computational specification · lines 2317–2422
    Open as its own page

    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

  • sectionStandalone computational specificationStandalone computational specification · lines 2423–2507
    Open as its own page

    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))

  • sectionStandalone computational specificationStandalone computational specification · lines 2508–2599
    Open as its own page

    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))

  • sectionStandalone computational specificationStandalone computational specification · lines 2600–2688
    Open as its own page

    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")

  • sectionStandalone computational specificationStandalone computational specification · lines 2688–2773
    Open as its own page

    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")

  • sectionStandalone computational specificationStandalone computational specification · lines 2773–2818
    Open as its own page

    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()

Revision and proof-obligation ledger

  • sectionRevision and proof-obligation ledgerRevision and proof-obligation ledger · lines 2820–2897
    Open as its own page

    The changes from the preceding draft are substantive.

    • Stable inheritance. Registered I labels replace drifting internal numbers as the primary source locators. The characterization remains restricted to its declared strategy class.

    • Three-qubit symmetry retained. The four-qubit fine-graining optimum is no longer identified with unrestricted forcing of . The registered three-qubit certificate is included and proved.

    • Primitive rational representation. The register formula and code reduce multiplicities by their greatest common divisor. Zero outcomes are handled separately.

    • Correct reduced-state calculation. The cocycle witness has specified reduced-state diagonals, not generally diagonal reduced states.

    • Correct capacity bookkeeping. General one-qubit record comparisons use . Only the scalar witnesses have the fixed three-qubit bound.

    • 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.

    • Geometric identity counts. Active edges retain identifiers, including parallel edges. Activation then really preserves the scalar and crossing-link counts.

    • Ownership and read dependencies. Quantum-name disjointness no longer implies disjoint geometric frames. Read footprints and guard stability are explicit.

    • Acyclicity enforced. An activation that creates a directed cycle is refused before constructing the new geometry.

    • Occupied slots protected. Permanent capacity retirement requires a free unit. Measurement removes names, not their regions.

    • No-signaling observations delimited. Incident link status is not declared literally invisible. Private observations, shared status, enablement, and communication are distinguished.

    • Fixed-library restriction. Downward closure is proved for a fixed experimental library. No unproved closure under newly enabled graph-dependent operations is claimed.

    • Boundary approximation withdrawn. The mesh bound is not used to identify an unknown residual with the original state's Lüders conditional. Unsupported support-graph classification and state-uniform boundary constants are removed.

    • 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.

    • 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.

    • 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.

  • sectionRevision and proof-obligation ledgerRevision and proof-obligation ledger · lines 2897–2910
    Open as its own page

    • Physical flux identification removed. Permanent capacity retirement is a bookkeeping operation, not a derived physical decoherence rate.

    • 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.

Declarations

  • sectionDeclarationsDeclarations · lines 2911–2932
    Open as its own page

    interests. The author declares no competing interests.

    . No specific grant supported this work.

    contribution. N.C.\ developed the mathematical framework and prepared the manuscript and computational specification.

    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.

    and clinical studies. Not applicable.

  • bibliographyReferencesDeclarations · lines 2933–2989
    Open as its own page

    I

    N. Cheung, {Born–Lüders as the unique measurement strategy of a strictly linear quantum -calculus: The Enter Calculus}. Registered manuscript I, version 1, .tex. Stable locators used here include :strategy-class, :requirements, :record, :diamond, :confluence, :uniformity, :three, :fine-anchor, :born, :update, :stability, and :main. Source interface: https://enter.grok.me/browse/I.

    XEnter

    N. Cheung, X-Enter. Registered manuscript, version 1, -Enter.tex. Finite readout interface and complete selective-record formulas, including :instrument and :recordchannel. Source interface: https://enter.grok.me.

    Watrous

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

    Em02B

    N. Cheung, Em02-B. Manuscript, version 1. Package-boundary remark :package. Cited only for the distinction between package evidence and proof.

    XVIO

    N. Cheung, XVI-O. Manuscript, version 70-sync. Package-boundary remark :package. Cited only for the distinction between an archive or pass flag and a mathematical certificate.