All manuscripts

Manuscript XVI-O1-ST@5 · XVI-O1-ST-v5.tex · dd45e0d1

XVI-O1-ST-v5 Finite Enter Certificates with a Permanent Printed-Array Integrity Gate Complete readout, exact counterterm feasibility, an affine gauge propagator, and an audited failed regression

Export XVI-O1-ST-v5.tex

Specifies version 5 of a local Grade S finite Enter certificate for a prescribed-host loop sector, with a permanent printed-array integrity gate. The host is the conical product already fixed by I-B and X-A-ST. The host is not reconstructed and no second cone is derived. prop:geometry retains that presentation. The regular product is not globally hyperbolic. The defect is a worldsheet, not a worldline. Free fields and Green operators live on the declared Minkowski completion, not on the regular product. The signature ledger keeps the host at (-,+,+,+) and the analysis at (+,-,-,-), with iota-star G equal to minus eta. The width stays fixed and positive. No width-removal theorem is claimed. thm:instrument is a complete destructive report instrument for supplied numbers and is not field acquisition. thm:phase records the exact cross-artifact discrepancy a^(0)+f^reg=(8/3)e_6. Python index 5 is displayed structure B_6. Both source values are retained. No physical sign is selected by editing a coefficient. thm:rank is the original-minor and left-kernel certificate. thm:propagator is the exact affine general-xi inverse under the declared Q4S kinetic normalization. The old unchecked affine candidate still has residual (0,0,1)^T. thm:exactness keeps full counterterm-derivative exactness OPEN. rec:q03 keeps Q03 SUPPLIED_CLOSED for the scoped bulk two-point only. That record does not update XVI-O. Full gauge rows stay OPEN. The clean-machine rebuild stays MISSING. The new appendix is PROPOSED and unexecuted. The map does not repair the convolution obstruction. The three-tree plateau identity is retained once. The matter coefficient -2 is counted once on its parent sheet. A later sheet must not count this completion twice. The X-D-ST sharp-width limit is not metric admission and is not this certificate. Smoothing an onset is not a loop regulator. This integrity gate is not an interacting differential and is not a loop anomaly. No field-to-qubit preparation is constructed. A finite instrument is not field acquisition. Enter consumes a finite clock encoding, not the geometric time axis. thm:locality is scheduled ancestry, not a physical causal past. Reference-preserving transport is not gravity-generated entanglement. VII-C does not apply and is not contradicted. The IX-A-ST separator is a domain comparison and does not identify this topology. XI-G is not repaired. The inherited characteristic quantum coefficient is not admitted. That sentence does not deny the scoped Q03 record or the tree coefficients already admitted on earlier sheets. No quantum coefficient is admitted. The quantum certificate remains RG-open. The author field is omitted for anonymous review. XVI-P and XVI-Q are documentary inputs and are not premises. Citation of N. Cheung does not assign authorship of a new priority claim for those parent results. Cited sheets and the OpenAI catalogue are documentary source records and are not a premise. Families 282, 362, and 376 are not this integrity gate. This comparison is not an exhaustive audit. This is not a derivation of a cognitive construct, not holographic identification, not a Page curve, not spacetime emergence, and not Einstein dynamics. Grade E is not constructed. A complete interacting quantum metric is not constructed. A repository registration is not a change of emergence status. It does not discharge XVI-N. XVI-N is not discharged. It does not close O.1. O.1 stays NOT_CLOSED. XV-B is not opened. H2, I3, and J2 stay unresolved. Bulk symmetry is not restored. No compilation is asserted. The source has not been compiled. No machine-checked proof is claimed. Numerical execution is not asserted. Independent execution is not asserted.

Front matter

  • abstractAbstractFront matter · lines 119–168
    Open as its own page

    We develop an audit-hardened finite certificate architecture for a prescribed-host perturbative loop sector, preserving the distinction between mathematical proofs, printed data, supplied scientific records, and execution artifacts. The central v5 finding is a cross-artifact integrity witness: the v4 typeset D01 table has sixth coefficient , whereas its embedded and separately supplied regression has . With the unchanged gauge-table coefficient , the regression relation fails by the exact residual . Python index 5 is displayed structure . Both source values are retained; no physical coefficient is selected by editing a sign.

    The supplied v4 transcript reports eight passing suites and one failed suite. Its phase failure occurs before that suite's variation-count and derivative checks, so those later predicates are not described as executed. Their printed-data proofs remain available. A proposed v5 regression checks the exact known discrepancy as a negative control and keeps data-integrity failure separate from successful regression behavior.

    The retained mathematical results include complete destructive report instruments with untouched references, the sharp complex qubit-report half-diamond distance , its real binary specialization, original-minor and complete-kernel feasibility certificates, quotient descent versus non-feedback, primitive-enlargement criteria, and an exact affine general- inverse under the declared Q4S kinetic normalization. The old unchecked affine candidate still has residual ; finite-field elimination and even/odd vertex-occurrence controls remain permanent audit components.

    The supplied 31-entry second-readout comparison, mutation discrepancies , 13-of-14 D01 variation, and restricted evanescent rank report are preserved with their precise evidence boundaries. The potential impact is a reusable release contract that prevents an expected software failure, a transcription inconsistency, or a missing scientific matrix from becoming a positive physics certificate. No novelty is claimed for elementary channel or rank mathematics. Q03 remains _CLOSED; full gauge rows and counterterm-derivative exactness remain ; the clean-machine rebuild remains . The new appendix is and unexecuted. The cone remains an input, bulk symmetry is not restored, XVI-N remains frozen, and O.1 is _CLOSED outside independently earned scopes.

  • scopeRelease boundary and principal correctionFront matter · lines 170–187
    Open as its own page

    boundary and principal correction{ The permanent discrepancy is not erased by changing the caption or overwriting a coefficient. The typeset vector, the regression vector, and the gauge vector are separately identified below.

    This manuscript contains a self-contained proof of its finite mathematical statements and exact printed-data witnesses. It does not supply the absent loop programs, full gauge-image arrays, enlarged primitive response, or complete 23-row gauge-family matrix.

    A supplied v4 run is an attributed execution record. It is not a v5 run. For the new listing, _status=PROPOSED, _executed=false, and _verified=false.}

Question, Enter background, and evidence

  • sectionEnter and the refusal of identificationQuestion, Enter background, and evidence › Enter and the refusal of identification · lines 196–228
    Open as its own page

    Cheung's Enter calculus treats runtime quantum names as access rights to factors of a global state. Destructive computational-basis readout consumes the measured names from the returned quantum interface and supplies a classical record. Its measurement characterization is restricted to a declared strategy class, not an unrestricted derivation of continuum field measurements CheungEnter,CheungI.

    The introductory essay The Philosophy of Enter distinguishes readout from recovery, a classical record from a quantum-return decoder, a channel from a thermodynamic machine, and an analogy from an identification CheungPhilosophy. These distinctions organize interpretation; they are not additional premises of the mathematical proofs here. Consumption of a name does not assert annihilation of every physical carrier used by an implementation.

    I-B installs finite clocks, registers, calibration, controls, and resources on a prescribed conical spacetime CheungIB. En03-A separately declares geometry, locations, accessible algebras, and control/resource interfaces CheungEn03. We retain this shape but prove the needed finite instrument identities directly. Standard quantum instruments and completely bounded trace norms provide the general setting DaviesLewis,Watrous.

    A numerical loop coefficient is not automatically a probability or a measurable field effect. The finite report channels below are explicitly constructed encodings of supplied numbers, not field-acquisition channels.

  • sectionDesignated artifactsQuestion, Enter background, and evidence › Designated artifacts · lines 229–248
    Open as its own page

    The evidence package supplied for v5 contains:

    1. -O1-ST-v4.tex;

    2. _xvi_o1_st_v4.py;

    3. 4_verification_output.txt;

    4. _SUMMARY_v4.txt;

    5. the earlier supplied consolidated and second-readout manuscripts, together with version-qualified source excerpts.

    The manuscripts and artifacts are cited under their supplied identifiers SuppliedV3,SuppliedBot,SuppliedV4,V4Artifacts.

    The summary is explanatory metadata. It is not an independent execution record or a substitute for examining statement order in the script. No authorship of this anonymous manuscript is inferred from the authorship of cited sources.

  • definitionDefinition: Six evidence categoriesQuestion, Enter background, and evidence › Designated artifacts · XVI-O1-ST@5#def:evidence · lines 249–271
    Open as its own page

    We distinguish:

    1. Specifications: objects, conventions, scopes, and acceptance predicates fixed before a calculation.

    2. Mathematical proofs: written arguments from explicit hypotheses.

    3. Exact synthetic witnesses: specified finite data with exactly established properties. This category includes the printed-array comparison, without identifying it with loop data.

    4. Supplied scientific records: attributed calculations or scientific conclusions in supplied manuscripts.

    5. Execution artifacts: supplied program text, environment descriptions, and transcripts, with provenance qualifications.

    6. Listed implementations: new program text without an executed run.

    These categories are not interchangeable. A supplied transcript is not an independently reproduced run; a displayed exact residual is not merely a software assertion.

  • sectionWhat v5 changesQuestion, Enter background, and evidence › What v5 changes · lines 273–291
    Open as its own page

    The predecessor's successful mathematical results are retained. Two audit corrections are added:

    1. the failed phase predicate is localized to a difference between the typeset table and the regression transcription;

    2. predicates after the failing instruction are distinguished from predicates actually reached in that run.

    The new regression contract records the discrepancy exactly. It does not redefine the false equality to be true.

    No elementary rank theorem, instrument theorem, encryption mechanism, or general propagator technology is claimed as new. The contribution is their joint use in a scope-explicit counterterm and data-integrity release architecture.

The prescribed host and analytical carrier

  • sectionThe prescribed host and analytical carrierThe prescribed host and analytical carrier · XVI-O1-ST@5#eq:host · lines 293–316
    Open as its own page

    Fix , , and . Set

    with prescribed metric

    Increasing is future directed. The completion defect is

    The supported laboratory avoids ; the inherited width remains fixed CheungIB,CheungXAST.

  • propositionProposition: Local development, worldsheet, and non-GH hostThe prescribed host and analytical carrier · XVI-O1-ST@5#prop:geometry · proof attached · lines 317–342
    Open as its own page

    The metric has signature , and is a two-dimensional worldsheet. On an injective angular chart,

    gives . The regular product is not globally hyperbolic.

    Proof. The signature and dimension are immediate, and differentiation gives the local development. For , take in geometrized time

    The points , , belong to by radial causal curves. They have no convergent subsequence in the regular product, since their completion limit has . The diamond is not compact.

  • sectionThe prescribed host and analytical carrierThe prescribed host and analytical carrier · XVI-O1-ST@5#eq:completion · lines 342–358
    Open as its own page

    Declare separately

    on the supported chart. Free fields, Green operators, loop integrals, and local counterterms use this analytical carrier and its prescription, not an assumed global Cauchy theorem on CheungXAST,CheungXGST. A signature reversal does not authorize independent changes of action-Hessian or Green-function signs.

  • propositionProposition: Conservation and trace do not source the hostThe prescribed host and analytical carrier · XVI-O1-ST@5#prop:notsource · proof attached · lines 359–377
    Open as its own page

    A conserved traceless tensor need not satisfy Einstein's equation for the prescribed host.

    Proof. For a nonzero constant , let

    The forms are parallel, so is conserved; its -trace vanishes. The regular host is locally flat and has zero Einstein tensor. Thus fails for nonzero at zero cosmological constant. No distributional source equation at the defect is constructed.

  • sectionThe prescribed host and analytical carrierThe prescribed host and analytical carrier · lines 377–382
    Open as its own page

    The conical product is not globally identified with Minkowski spacetime. The analytical completion is not an inferred geometry.

Scope, the Q03 record, and finite package semantics

  • definitionDefinition: Scope tupleScope, the Q03 record, and finite package semantics · XVI-O1-ST@5#def:scope · lines 387–399
    Open as its own page

    A scope is

    specifying host, action or observable, loop order, power of , external sector, mass, gauge fermion, analytical prescription, counterterm presentation, complete residual space, and separately imposed consistency tests. Equality includes versions, conventions, and identification maps.

  • sectionScope, the Q03 record, and finite package semanticsScope, the Q03 record, and finite package semantics · XVI-O1-ST@5#rec:q03 · lines 399–426
    Open as its own page

    The supplied XVI-Q Q11 record, read with XVI-P p23, attributes closure only to the one-loop, order-, massless bulk two-point retained sector of , with frozen gauge fermion, QdS loop/external conventions, Q4S vertex indices, , and the p22 evanescent contract. All 23 named identity rows are reported cancelled by local counterterms. The consistency statement covers the bulk 11 four-dimensional directions. The used presentation is 11 p14r directions over plus 10 p22 evanescent operators, 21 in total CheungXVIP,CheungXVIQ.

    The v5 status remains _CLOSED. This record does not update XVI-O's different prescription, restore bulk symmetry, discharge XVI-N, or certify higher arity or loop order.

    QdS denotes the quasi-dimensional scheme, not de Sitter spacetime. The symbolic dimension and evanescent algebra must be handled before the prescribed Laurent extraction. Consistent DRED does not license unrestricted use of four-dimensional tensor identities Stockinger.

  • assumptionModel specification: Finite pinned packageScope, the Q03 record, and finite package semantics · XVI-O1-ST@5#spec:package · lines 427–442
    Open as its own page

    A package supplies:

    1. the action, gauge fermion, field/antifield normalizations, Fourier and Grassmann conventions, and subtraction prescription;

    2. the complete inventory and the derivation of every zero;

    3. complete row assembly and all computational dependencies;

    4. counterterm generators, relations, and reconstruction maps;

    5. exact arrays or explicit missing entries;

    6. original minors, complete kernels, residuals, negative controls, error conventions, and budgets;

    7. a manifest binding exact versions and bytes.

    An unfinished task or resource refusal is not zero.

  • sectionScope, the Q03 record, and finite package semanticsScope, the Q03 record, and finite package semantics · lines 442–447
    Open as its own page

    A digest identifies bytes relative to a manifest. It does not prove that the manifest is trustworthy or that the bytes implement the declared physics.

  • sectionFour correctly typed interface structuresScope, the Q03 record, and finite package semantics › Four correctly typed interface structures · lines 448–463
    Open as its own page

    Following the En03-A shape CheungEn03, retain:

    1. external geometry (eq:host) and the separate carrier (eq:completion);

    2. an actual location map for physical laboratory registers;

    3. accessible finite matrix algebras and classical record algebras;

    4. the complete controls, arithmetic, storage, routing, calibration, and failure interface.

    The 12 inventory graphs and 23 named rows are logical tasks, not spacetime ports. The 21-direction analytical presentation is not a quantum observable algebra.

  • sectionCounterterm equationsScope, the Q03 record, and finite package semantics › Counterterm equations · XVI-O1-ST@5#eq:system · lines 464–485
    Open as its own page

    Work over , unless an enlarged exact field is declared. Let

    For each named row choose a complete finite coefficient space , and put . Twenty-three named rows need not mean 23 scalar equations.

    Let , , and let encode only the consistency tests actually claimed. Define

  • propositionProposition: Presentation descent and residual coverageScope, the Q03 record, and finite package semantics › Counterterm equations · XVI-O1-ST@5#prop:descent · proof attached · lines 486–503
    Open as its own page

    The response descends to reconstructed counterterms iff

    A zero tested coefficient residual implies the asserted functional identity when the coefficient/test map is injective on a known subspace containing all possible tested residuals. Without separation, this implication can fail.

    Proof. Equal reconstructions differ by a reconstruction-kernel vector; their responses agree exactly when annihilates it. The coverage assertion is injectivity. A nonzero element in the test map's kernel supplies the counterexample without it.

  • sectionCounterterm equationsScope, the Q03 record, and finite package semantics › Counterterm equations · lines 503–508
    Open as its own page

    No full O.1 rank or original minor is deduced from the numbers 23 and 21.

Complete destructive report instruments

  • sectionComplete destructive report instrumentsComplete destructive report instruments · XVI-O1-ST@5#eq:instrument · lines 510–529
    Open as its own page

    Fix a finite dictionary within declared representation and resource bounds. Let , , have calibrated orthonormal basis . Let contain all surviving laboratory registers, and install finite words carrying scope, package, evidence, status, and coefficient codes.

    Put

    The record retains even when two words coincide. Unused labels and failures have explicit words.

  • theoremTheorem: Complete destructive reportComplete destructive report instruments · XVI-O1-ST@5#thm:instrument · proof attached · lines 530–558
    Open as its own page

    The map (eq:instrument) is CPTP, and for every finite untouched reference ,

    For a state ,

    The positive-probability conditional state is . No normalized state is assigned to a zero branch. The returned quantum interface excludes .

    Proof. The Kraus maps satisfy

    Writing , the output blocks are , whose sum is . The same calculation with proves the reference identity. Positivity supplies the branch rule.

  • sectionComplete destructive report instrumentsComplete destructive report instruments · lines 558–563
    Open as its own page

    This is an I-B/En09-A supplied-report interface CheungIB,CheungEn09. It does not evaluate unknown loop integrals by measurement or acquire an unknown continuum field.

  • propositionProposition: No universal return and no record-only residualComplete destructive report instruments · XVI-O1-ST@5#prop:noreturn · proof attached · lines 564–578
    Open as its own page

    The report instrument has no universal left inverse. Its classical marginal does not determine its surviving quantum state.

    Proof. The distinct coherent clock states , tensored with the same laboratory state, have identical outputs. Also, and , with , have the same deterministic record and different residuals.

  • propositionProposition: Calibration and finite clock limitationsComplete destructive report instruments · XVI-O1-ST@5#prop:clock · proof attached · lines 580–596
    Open as its own page

    If distinct readings must equal a fixed event time on every positive-probability branch of a normalized input, there is one deterministic matching outcome. A prepared basis clock separately reads its installed word deterministically. Finite matrices cannot satisfy for .

    Proof. At most one distinct reading matches , and probabilities sum to one. Basis readout follows from (eq:instrument). The trace of the proposed commutator would give .

  • sectionComplete destructive report instrumentsComplete destructive report instruments · lines 596–602
    Open as its own page

    A gauge-table comparison at is not this event-time calibration theorem. Repreparing a known basis state is not a universal inverse for an unknown coherent clock.

Numerical reports and sharp complete error

  • sectionNumerical reports and sharp complete errorNumerical reports and sharp complete error · lines 604–633
    Open as its own page

    For real with , define the binary report

    The coefficient is a bounded expectation, not an exact rational value recovered from one shot.

    For complex , , define

    The Bloch bound makes a state. This interface returns a classical task label and a quantum report qubit, not a wholly classical coefficient word. Both maps are channels: they measure the clock and append valid classical or quantum states while retaining the branch block.

  • theoremTheorem: Sharp reference-stable numerical-report errorNumerical reports and sharp complete error · XVI-O1-ST@5#thm:error, XVI-O1-ST@5#eq:complexerror, XVI-O1-ST@5#eq:realerror · proof attached · lines 634–664
    Open as its own page

    With and one common admissible ,

    These equalities include arbitrary finite untouched references.

    Proof. The difference of the two qubit states has eigenvalues , and hence trace norm . For any operator , including a reference extension, the task blocks are orthogonal. Thus the output difference has trace norm

    Clock pinching is an average of unitary conjugations, so . This proves the diamond upper bound. A basis clock input at a maximizing index attains it. For binary reports, the two scalar differences are ; the same calculation applies.

  • remarkRemark: Different report interfaces have different metricsNumerical reports and sharp complete error · lines 666–673
    Open as its own page

    Distinct exact symbolic words are orthogonal outputs and have half-diamond distance one on a distinguishing task. The formulas above do not describe that symbolic metric. Splitting a complex coefficient into separate real and imaginary binary tasks gives the maximum component discrepancy on the expanded dictionary, not automatically the complex modulus.

  • corollaryCorollary: Sparse errors are not dilutedNumerical reports and sharp complete error · XVI-O1-ST@5#cor:sparse · proof attached · lines 675–684
    Open as its own page

    An error confined to one task can attain the full maximum in (eq:complexerror) or (eq:realerror), regardless of its rarity under a chosen sampling law.

    Proof. Prepare the affected basis task.

  • propositionProposition: Complete-channel implementation budgetNumerical reports and sharp complete error · XVI-O1-ST@5#prop:budget · proof attached · lines 686–702
    Open as its own page

    For compatible ideal and implemented complete channels,

    Proof. Telescope the difference, use contractivity under channel composition and the triangle inequality, and use the maximum one for half-diamond channel distance Watrous.

  • sectionNumerical reports and sharp complete errorNumerical reports and sharp complete error · lines 702–709
    Open as its own page

    Records, failures, residual systems, and references remain in the compared interfaces. Oai283-A is a documentary comparison for this resource/error discipline, not a thermodynamic or loop premise CheungOai283.

Exact rank certificates and the repaired affine family

  • sectionExact rank certificates and the repaired affine familyExact rank certificates and the repaired affine family · lines 711–717
    Open as its own page

    The presentation follows II/II-B's original-minor discipline without importing their numerical certificate CheungII,CheungIIB.

  • theoremTheorem: Rank–minor–left-kernel certificateExact rank certificates and the repaired affine family · XVI-O1-ST@5#thm:rank · proof attached · lines 718–746
    Open as its own page

    Let , , and . Suppose original row and column index sets , both of size , and satisfy

    Then

    A solution gives the complete affine family . A nonzero component of gives an outside-span separator.

    Proof. The minor gives . Since and , the opposite inequality holds and . This proves membership and augmented-rank equality. The affine assertion follows by subtracting two solutions. A nonzero row pairing separates the target from the image.

  • sectionExact rank certificates and the repaired affine familyExact rank certificates and the repaired affine family · lines 746–750
    Open as its own page

    The empty minor has determinant one. An annihilating matrix is not necessarily a complete left kernel.

  • propositionProposition: Complete right-kernel certificateExact rank certificates and the repaired affine family · XVI-O1-ST@5#prop:right · proof attached · lines 751–762
    Open as its own page

    If , , and has rank , then . With a verified particular solution, all solutions are .

    Proof. The inclusion and dimensions agree.

  • sectionExact rank certificates and the repaired affine familyExact rank certificates and the repaired affine family · lines 762–769
    Open as its own page

    For (eq:system), this proves exactly the declared cancellation and consistency equations. Functional interpretation additionally requires descent and coverage. Coefficient uniqueness is presentation-relative, not physical or cohomological uniqueness.

  • theoremTheorem: Permanent affine false-positive witnessExact rank certificates and the repaired affine family · XVI-O1-ST@5#thm:affine, XVI-O1-ST@5#eq:oldresidual · proof attached · lines 770–798
    Open as its own page

    Let

    The old fallback has residual

    The complete correct family is

    Proof. Direct multiplication gives the residual and the corrected solution. The original minor on rows , columns , is . The complete left kernel is generated by . The displayed nonzero right-kernel vector spans the one-dimensional kernel. Apply Theorem thm:rank and Proposition prop:right.

  • sectionExact rank certificates and the repaired affine familyExact rank certificates and the repaired affine family · lines 798–804
    Open as its own page

    Adding a kernel vector to the wrong particular solution preserves its nonzero residual. A solver exception does not validate a fallback vector.

Second-readout tables and mutation sensitivity

  • sectionScientific provenanceSecond-readout tables and mutation sensitivity › Scientific provenance · lines 809–835
    Open as its own page

    The second-readout predecessor attributes its rules to XVI-Q's 6q05/gravity.py, derived from the declared action rather than importing XVI-P's vertex tables, and pole extraction to 04/uvpole.py SuppliedBot,CheungXVIQ. Its reported conventions include

    The corresponding ghost and antifield couplings, auxiliary elimination, R09 vertex checks, and fresh same-machine run are supplied scientific records, not newly executed derivations here.

    The record discloses a common author, machine, and extraction route. A second folder is not a clean-machine or heterogeneous rebuild.

  • sectionStructure dictionarySecond-readout tables and mutation sensitivity › Structure dictionary · lines 836–865
    Open as its own page

    Use

    For , the structures are

    \begin{array}{c|l@{\qquad}c|l}
    1&xyQ^2&8&u^2v^2\\
    2&xv^2Q&9&u^2y_tQ\\
    3&xy_tQ^2&10&uvz_tQ\\
    4&z^2Q^2&11&yx_tQ^2\\
    5&zuvQ&12&v^2x_tQ\\
    6&zz_tQ^2&13&x_ty_tQ^2\\
    7&u^2yQ&14&z_t^2Q^2
    \end{array}

    and are denoted . Hats and tildes are scheme contractions, not host geometries.

  • sectionUnchanged typeset comparison dataSecond-readout tables and mutation sensitivity › Unchanged typeset comparison data · lines 866–910
    Open as its own page

    The v4 typeset table uses and . Its mutant values are .

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14

    For D06, use

    with

    These retain all displayed comparison entries.

  • propositionProposition: Retained comparison and mutation arithmeticSecond-readout tables and mutation sensitivity › Unchanged typeset comparison data · XVI-O1-ST@5#prop:mutationdata · proof attached · lines 911–943
    Open as its own page

    For the printed frozen/own arrays, the advertised comparison discrepancy is zero. The component-mutant comparisons give

    At common bound , the complex-report distances are

    The D01 changed-entry count and maximum discrepancy are the same if the regression vector defined below is used instead of .

    Proof. The displayed own/frozen entries coincide. For D01, entry 5 changes by , the maximum. For D03, the maximum is , at entries 5 and 10. For D06, it is , at entry 2. All magnitudes are below 32, so Theorem thm:error applies. Changing only D01 entry 6 from to changes that mutant discrepancy from to ; neither is the maximum, and both are nonzero.

  • sectionUnchanged typeset comparison dataSecond-readout tables and mutation sensitivity › Unchanged typeset comparison data · lines 943–951
    Open as its own page

    This is arithmetic of printed arrays. The original loop provenance is supplied, not re-established. Moreover, the v4 regression does not contain independently constructed own and frozen arrays for all 31 entries; its passing mutation checks are not an independent replay of the 31-entry scientific comparison.

  • sectionGlobal signs and component mutationsSecond-readout tables and mutation sensitivity › Global signs and component mutations · lines 952–958
    Open as its own page

    The recorded ghost mutation changes selected transport terms in , and the graviton mutation changes one Christoffel contribution used in . They are not common reversals of entire vertex rules.

  • theoremTheorem: Even-occurrence blindnessSecond-readout tables and mutation sensitivity › Global signs and component mutations · XVI-O1-ST@5#thm:parity · proof attached · lines 959–976
    Open as its own page

    For amplitudes multilinear in vertex occurrences,

    A bubble is blind to a common cubic-rule reversal. A two-copy ghost loop is similarly blind. For , sign vectors in are invisible to these graphwise comparisons.

    Proof. Multiply one factor for each occurrence. The simultaneous parity condition is .

  • sectionGlobal signs and component mutationsSecond-readout tables and mutation sensitivity › Global signs and component mutations · lines 976–983
    Open as its own page

    Zero amplitudes and cancellations create further blind spots. Odd-occurrence tests, direct differentiated vertices, or independently normalized tree identities supply additional controls. They are not claimed newly executed loop tests.

Permanent printed-array integrity witness

  • sectionThe three arrays, without silent editingPermanent printed-array integrity witness › The three arrays, without silent editing · XVI-O1-ST@5#rec:phase · lines 988–1026
    Open as its own page

    The v4 typeset table and v4 embedded/extracted regression do not encode the same D01 baseline vector SuppliedV4,V4Artifacts.

    Using displayed positions , they are

    The unchanged gauge-table constant vector is

    Python index 5 is displayed row 6, namely .

  • theoremTheorem: Exact phase-integrity residualPermanent printed-array integrity witness › The three arrays, without silent editing · XVI-O1-ST@5#thm:phase, XVI-O1-ST@5#eq:phaseresidual · proof attached · lines 1027–1054
    Open as its own page

    For the arrays in Record rec:phase,

    Thus the v4 regression assertion is false at precisely Python index 5. There is no single scalar with .

    If these arrays are encoded as the corresponding complex reports, the cross-artifact coefficient discrepancy is . At common bound , its half-diamond distance is .

    Proof. All entries cancel except the sixth, where . The first entry forces , which fails at the sixth. Under the convention , compare with ; their difference is . Apply Theorem thm:error.

  • remarkRemark: What is corrected, and what is notPermanent printed-array integrity witness › The three arrays, without silent editing · lines 1056–1070
    Open as its own page

    The predecessor's proposed caption change from to follows algebraically from , since . It remains a documentary normalization observation. It cannot make true.

    The typeset and regression values are both retained. Their physical origin cannot be decided from this comparison: it does not identify which underlying loop artifact, if any, contains the correct coefficient. In particular, it is inaccurate to describe the witness as a failure of every entry in the typeset gauge table. The failure is specifically cross-artifact.

  • propositionProposition: Two different acceptance predicatesPermanent printed-array integrity witness › Known-discrepancy tests are not data acceptance · XVI-O1-ST@5#prop:twopredicates · proof attached · lines 1074–1092
    Open as its own page

    Let

    For the retained arrays, is false and is true. Passing a regression that enforces does not establish .

    Proof. The right sides are different because . Equation (eq:phaseresidual) proves the assertions.

  • sectionKnown-discrepancy tests are not data acceptancePermanent printed-array integrity witness › Known-discrepancy tests are not data acceptance · lines 1092–1102
    Open as its own page

    The integrity gate therefore records _RECORDED and _consistent=false. A later reconciliation requires a new versioned source record, the actual original arrays, a justified convention map, and a fresh exact comparison. Merely treating the old failure as expected does not discharge that obligation.

The supplied v4 run and its execution coverage

  • sectionThe supplied v4 run and its execution coverageThe supplied v4 run and its execution coverage · XVI-O1-ST@5#rec:v4run · lines 1104–1125
    Open as its own page

    The supplied output identifies Python 3.10.21, SymPy 1.14.0, and a Linux platform, and reports eight passing suites and one failure V4Artifacts. The complete short transcript is retained in Appendix app:v4log.

    Its reported source digest is

    9f661c8f3eb1dc75b580eb756174f4ff5711f172230ae369b17dbf5a2fbb106.

    This is a digest printed by the supplied record, not a digest independently recomputed here from authenticated original bytes. No execution date, signed provenance chain, or separately observed process exit code is supplied.

  • propositionProposition: What the failed table suite reachedThe supplied v4 run and its execution coverage · XVI-O1-ST@5#prop:coverage · proof attached · lines 1126–1148
    Open as its own page

    In the supplied v4 script, the mutation-count, maximum-discrepancy, and common-bound checks precede the phase assertion. The 13-varying-structure and derivative checks follow it. Consequently, in the reported failing invocation:

    1. the earlier mutation checks were reached;

    2. the phase assertion rejected the data;

    3. that invocation did not reach the subsequent variation-count and derivative predicates in the same test function.

    The runner continued to the remaining suites.

    Proof. The function executes sequentially and raises at (all(x == -y for x,y in zip(a0,f)), ...). There is no local handler resuming inside that function. The outer runner catches the exception and proceeds to the next listed test.

  • sectionThe supplied v4 run and its execution coverageThe supplied v4 run and its execution coverage · lines 1148–1159
    Open as its own page

    Thus the supplied summary's claim that all other table checks “held” is too broad if read as execution coverage. The 13-of-14 count and derivative formulas are nevertheless proved directly from the printed coefficients in Section sec:gaugetables; they are not lost.

    The reported 1397 evaluated predicates include expected rejections and internal checks. That count does not establish that every advertised predicate was reached.

  • sectionTwo different failures, two different lessonsThe supplied v4 run and its execution coverage › Two different failures, two different lessons · lines 1160–1172
    Open as its own page

    The earlier affine example had a false advertised equation despite attributed PASS. The v4 phase suite instead rejected a false equation and reported aggregate failure. The first is an acceptance-semantics defect; the second is evidence that the relevant fail-closed check worked.

    Neither statement establishes every predicate of the earlier software or the correctness of the loop data.

Direct graded non-feedback and quotient response

  • sectionDirect graded non-feedback and quotient responseDirect graded non-feedback and quotient response · lines 1174–1187
    Open as its own page

    The supplied R07–R09 descriptions report six even cubic classes, four odd classes before a Schouten quotient, and two afterwards SuppliedBot,CheungXVIR. Counts do not provide representatives or response maps.

    Let be local polynomial functionals homogeneous of field/antifield degree , with any permitted relations required to preserve that grading. Let be homogeneous projection and a declared quadratic coefficient map.

  • theoremTheorem: Rank-zero direct graded projectionDirect graded non-feedback and quotient response · XVI-O1-ST@5#thm:graded · proof attached · lines 1188–1210
    Open as its own page

    For ten representatives , the matrix of is

    The original minor is empty with determinant one. The zero map descends through every relation subspace.

    In a nonnegative formal -series, an order- addition cannot change the order- coefficient under operations that do not lower the filtration.

    Proof. Homogeneity gives . The full left kernel and empty minor certify rank zero. A zero map annihilates all relations. For the formal-order assertion, products of nonnegative powers cannot create a term below the order of the addition.

  • sectionDirect graded non-feedback and quotient responseDirect graded non-feedback and quotient response · lines 1210–1224
    Open as its own page

    The reported cubic slots have three field slots; spectator vectors representing an epsilon tensor are not fields. The predecessor attributes a slot-count check on 821 even coordinates and the odd terms to 1_1c.py; that archive is not newly inspected.

    This theorem concerns direct graded re-expansion, not Wick contraction, expansion around a nonzero background, or an unspecified changed identity response. Such operations need their own maps. A formal zero projection does not establish the validity of a strictly four-dimensional Schouten quotient in DRED.

  • theoremTheorem: Quotient descent versus non-feedbackDirect graded non-feedback and quotient response · XVI-O1-ST@5#thm:quotient · proof attached · lines 1225–1249
    Open as its own page

    Let , let be the allowed counterterm response, and let be the complete review response. For a complete left kernel of ,

    where . The descended obstruction vanishes on every supplied class iff

    Proof. Descent requires annihilation of relations after quotienting. Theorem thm:rank gives . Vanishing on all classes requires containment of , not only , in that image.

  • sectionDirect graded non-feedback and quotient responseDirect graded non-feedback and quotient response · lines 1249–1257
    Open as its own page

    Consistency restrictions belong in or in augmented response rows. No projection may discard outside-span components first. Parity mutations test selected software behavior; they do not replace these hypotheses.

The exact affine gauge propagator

  • sectionThe exact affine gauge propagatorThe exact affine gauge propagator · lines 1259–1286
    Open as its own page

    The gauge family is a new scope. Take real , scale the eliminated gauge fixing by , and hold the declared vertices and prescription fixed. An auxiliary/gauge-fermion realization must reproduce this normalization, not merely share its name.

    On symmetric Q4S tensors define

    For momentum , put

    Stars denote algebraic adjoints for the stated pairings, not positive Hilbert-space adjoints. Then

  • lemmaLemma: Projector identitiesThe exact affine gauge propagator · XVI-O1-ST@5#lem:projector · proof attached · lines 1287–1321
    Open as its own page

    For ,

    Also

    where

    Proof. Since , . For a covector ,

    This gives . Furthermore, , which proves the projector identity. Expanding gives the four terms.

  • theoremTheorem: Exact affine inverse under the declared normalizationThe exact affine gauge propagator · XVI-O1-ST@5#thm:propagator, XVI-O1-ST@5#eq:propagator · proof attached · lines 1323–1351
    Open as its own page

    For

    the rational inverse at is

    Proof. Write , , and . Then

    Multiplying by gives

  • sectionThe exact affine gauge propagatorThe exact affine gauge propagator · lines 1351–1363
    Open as its own page

    This is a general algebraic proof in the declared trace-four algebra, not an interpolation from finite momenta. The DRED contraction prescription and overall Feynman factor remain scientific inputs. On , a prescribed boundary value is required; this is not pointwise inversion there. At , the eliminated kinetic expression is undefined. The predecessor's action-Hessian check is attributed to 1_kincheck.py, not newly executed.

Retained gauge-pole data and exact printed consequences

  • sectionRetained gauge-pole data and exact printed consequencesRetained gauge-pole data and exact printed consequences · XVI-O1-ST@5#rec:gauge · lines 1365–1451
    Open as its own page

    Put . With unchanged vertices, a graph with graviton lines has degree at most in under linear pole extraction.

    The predecessor attributes the following to its gauge-family scripts SuppliedBot:

    1. D03 and D11 have no graviton line and are -independent;

    2. D04 has zero UV-pole polynomial in the stated family;

    3. D06 and D13 are affine, and D01 is quadratic;

    4. holds coefficientwise in , in the incoming-antighost convention.

    These remain supplied scientific records. The D01 base-point identification across all v4 artifacts is subject to Section sec:integrity.

    Here

    Momentum orientation and the separately disclosed D13 slot orientation must be transported consistently CheungXVIQ.

    In own-rule normalization , D06 is

    For , set

    On , D13 has coefficients

    The fourth structure first appears at order .

    For D01 write

    All printed coefficients are retained:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
  • propositionProposition: Variation count and derivativeRetained gauge-pole data and exact printed consequences · XVI-O1-ST@5#prop:derivative, XVI-O1-ST@5#eq:hhderivative · proof attached · lines 1452–1468
    Open as its own page

    Exactly 13 of these 14 structures vary with ; is constant. The printed derivative is

    These facts do not require correcting either version of .

    Proof. Only row 14 has both variable coefficients zero. Differentiate the finite polynomial.

  • sectionRetained gauge-pole data and exact printed consequencesRetained gauge-pole data and exact printed consequences · lines 1468–1474
    Open as its own page

    The cross-artifact witness concerns the displayed constant coefficient. It does not alter the formal differentiation of the unchanged arrays. This observation is not a new verification of their loop origin.

  • remarkRemark: Scaleless zeros need their prescriptionRetained gauge-pole data and exact printed consequences · lines 1475–1484
    Open as its own page

    Massless one-point and tadpole zeros are retained under the supplied prescription. Scaleless dimensional integrals can vanish by UV/IR cancellation; the integral with integrand illustrates the logarithmic issue. No assertion that every scaleless tadpole has no logarithmic UV or IR contribution is used. Insertion problems and infrared rearrangements need their own separation SmirnovChetyrkin.

  • sectionRetained gauge-pole data and exact printed consequencesRetained gauge-pole data and exact printed consequences · lines 1484–1491
    Open as its own page

    D04's supplied zero is not a theorem about every gauge-invariant scalar correlation function. Such observables require additional contributions and gauge-dependent cancellations Frob2018.

Free-complex exactness and the missing enlarged image

  • sectionFree-complex exactness and the missing enlarged imageFree-complex exactness and the missing enlarged image · lines 1493–1503
    Open as its own page

    Before differentiating, identify the gauge descriptions and their basis transports. Declare a finite complex

    The primitive space has ghost number ; it is not the 21-direction ghost-number-zero counterterm space.

  • theoremTheorem: Free exactness and exact tangentsFree-complex exactness and the missing enlarged image · XVI-O1-ST@5#thm:exactness · proof attached · lines 1504–1525
    Open as its own page

    For a differentiable solution in the fixed identified presentation,

    At fixed , put . An exact tangent satisfying differentiated cancellation exists iff

    Every such tangent is -closed.

    Proof. Apply Theorem thm:rank to . Differentiate cancellation and substitute . Finally .

  • sectionFree-complex exactness and the missing enlarged imageFree-complex exactness and the missing enlarged image · lines 1525–1538
    Open as its own page

    If the identified differential varies, use and state its transport. Parameter-dependent consistency equations must also be differentiated. A pointwise tangent is not an interval theorem without smooth choices and exceptional-parameter control.

    Free BRST, relative classical BV, free-equation descent, and interacting quantum BRST remain different objects CheungXGST,CheungXHST. No X-G-ST or X-H-ST normalization is substituted for the P/Q action normalization.

  • sectionThe supplied restricted hh obstructionFree-complex exactness and the missing enlarged image › The supplied restricted hh obstruction · XVI-O1-ST@5#rec:restricted · lines 1539–1586
    Open as its own page

    The predecessor reports testing the pole derivative against the image of

    in its 13-generator dimension-two -presentation. For the relaxed map allowing independent in

    it reports on a 15-structure space

    Fixed-normalization failures, including the listed tests, are also reported. The four-dimensional projection is reported to have rank five on six structures and to accept both the derivative and the undifferentiated pole SuppliedBot.

    The full generator list, ambient basis, matrices, original minors, and left-kernel rows are absent from the supplied artifacts. The relaxed rank report is not extended to additional parameters and is not newly re-certified.

    Define the named source-relative obstruction

    If the reported ranks hold for those actual arrays, this class is nonzero at , because adjoining the target raises rank. That excludes only the tested class. The four-dimensional test is nondiscriminating in the reported comparison, not invalid for every purpose.

    A complete rank-seven image certificate on 15 rows needs an original minor and an complete left-kernel matrix, with a nonzero target pairing.

  • theoremTheorem: Projected primitive-enlargement criterionFree-complex exactness and the missing enlarged image › Exact enlargement and separator construction · XVI-O1-ST@5#thm:enlargement, XVI-O1-ST@5#eq:combinedseparator · proof attached · lines 1589–1628
    Open as its own page

    Let have a complete left kernel , let be a specified additional primitive response, and let . Then

    Let be a complete left kernel of , and set

    Then

    If , a row with satisfies

    and is an exact separator for the enlarged class. For several targets , a successful enlargement needs at least independent new image directions.

    Proof. If , then . Conversely, implies . Completeness of gives

    proving (eq:combinedseparator). The row identities follow from and . The multiple-target lower bound follows by dimension.

  • sectionExact enlargement and separator constructionFree-complex exactness and the missing enlarged image › Exact enlargement and separator construction · lines 1628–1633
    Open as its own page

    This gives a precise construction of a separator from supplied arrays; it does not supply numerical rows for an absent physical image.

  • propositionProposition: The rank report alone cannot decide an enlargementFree-complex exactness and the missing enlarged image › Exact enlargement and separator construction · XVI-O1-ST@5#prop:underdetermined · proof attached · lines 1634–1648
    Open as its own page

    Knowing only and does not determine whether an unspecified enlargement removes the obstruction.

    Proof. In , let and . Both rank statements hold. Taking resolves the target; taking does not. For the second choice annihilates both and pairs to one with . These are synthetic examples, not loop images.

  • scopeHonest v5 ending for the requested enlarged primitiveFree-complex exactness and the missing enlarged image › Exact enlargement and separator construction · lines 1650–1659
    Open as its own page

    v5 ending for the requested enlarged primitive{ No concrete enlarged ghost-number-, its response matrix , or numerical physical separator is supplied. A separator annihilating an unspecified enlargement cannot be inferred from the old rank report.

    The missing deliverables are recorded as null artifacts. Theorem thm:enlargement specifies exactly how an eventual separator or primitive solution will be certified. Full counterterm-derivative exactness remains .}

  • sectionExact enlargement and separator constructionFree-complex exactness and the missing enlarged image › Exact enlargement and separator construction · lines 1659–1677
    Open as its own page

    A legitimate enlargement must name its p22-type or dimension-dependent primitives, actual differential, relations, ghost-equation partners, and common normalization. Terms proportional to cannot be inserted or discarded by slogan: their contractions and multiplication by Laurent poles must follow the prescription DuganGrinstein.

    The full identity also requires an actual counterterm family and a joint , auxiliary, and scalar solve where required. Divisibility of one component by is not that joint identity. Oai282-A supplies a documentary local-Ward certificate shape, not the missing gravitational response CheungOai282.

Finite reduction of the full gauge-family row problem

  • sectionFinite reduction of the full gauge-family row problemFinite reduction of the full gauge-family row problem · lines 1679–1684
    Open as its own page

    The affine propagator does not imply an affine counterterm solution or a constant response matrix.

  • theoremTheorem: Constant-response polynomial liftFinite reduction of the full gauge-family row problem · XVI-O1-ST@5#thm:constantlift · proof attached · lines 1685–1708
    Open as its own page

    Let be a constant finite matrix and , over . For a complete left kernel , the following are equivalent:

    1. for every ;

    2. a polynomial solution exists;

    3. the target belongs to at every point of an infinite parameter set in the field.

    The same original minor and left kernel certify each coefficient solve. With complete right kernel , all polynomial solutions differ by .

    Proof. The first condition solves each . A polynomial solution gives pointwise membership. Conversely, vanishes on infinitely many points, so every entry is the zero polynomial. The kernel assertion is coefficientwise.

  • sectionFinite reduction of the full gauge-family row problemFinite reduction of the full gauge-family row problem · lines 1708–1715
    Open as its own page

    If constancy of the complete response is established and the complete target is quadratic, a certified base coefficient leaves two additional membership tests. Theorem thm:phase prevents claiming that every supplied D01 artifact already provides a consistent base coefficient.

  • theoremTheorem: Varying-response block systemFinite reduction of the full gauge-family row problem · XVI-O1-ST@5#thm:blocklift · proof attached · lines 1716–1736
    Open as its own page

    Let

    For a declared degree bound , existence of is equivalent to

    where absent target coefficients are zero.

    Proof. Expand the product and equate every coefficient, including coefficients above the target degree.

  • sectionFinite reduction of the full gauge-family row problemFinite reduction of the full gauge-family row problem · lines 1736–1749
    Open as its own page

    Theorem thm:rank certifies this finite block system. Rational families may be treated over or after clearing declared denominators on a specified domain. Exceptional ranks and denominator zeros require separate checks: is generically solvable and fails at zero.

    The complete , original minor, and complete kernels for the changed-gauge 23-row problem remain absent. Full gauge-family row closure stays . D04 and the ghost equation are cross-checks, not replacement rows.

Genuine modular rank and permanent verification rules

  • propositionProposition: Modular original minorsGenuine modular rank and permanent verification rules · XVI-O1-ST@5#prop:modular · proof attached · lines 1754–1768
    Open as its own page

    For rational , with all denominators invertible modulo a prime , a nonzero reduced original minor proves . Finite-field rank alone does not upper-bound rational rank. Taking is not computing .

    Proof. A zero rational determinant reduces to zero wherever reduction is defined. The matrix has rational rank one and finite-field rank zero, while .

  • sectionGenuine modular rank and permanent verification rulesGenuine modular rank and permanent verification rules · lines 1768–1800
    Open as its own page

    For

    the separate rational original minor is . Modulo five,

    and the corresponding determinant is one. Both ranks are two. Composite moduli and noninvertible denominators are rejected.

    For Gaussian-rational coefficients,

    Restriction of scalars proves the identity. Alternatively, a compatible finite-field representation can be declared. Field labels are not interchanged.

    Finite-field reconstruction and IBP reduction are discovery methods ManteuffelSchabinger,Peraro. A candidate becomes an exact certificate only after checking the original arrays, characteristic-zero identities, original minor, complete kernels, and target residual. Finite kinematic samples need coverage or certified degree/denominator bounds for a broader identity claim.

  • propositionProposition: An acceptance string cannot override an equationGenuine modular rank and permanent verification rules · XVI-O1-ST@5#prop:pass · proof attached · lines 1801–1813
    Open as its own page

    An aggregate acceptance does not certify an advertised conjunction if one advertised equation is false. A known-discrepancy regression must not label data consistency true merely because it successfully rejects that equation.

    Proof. The first statement follows from the logic of conjunction, with (eq:oldresidual) as an explicit witness. The second is Proposition prop:twopredicates.

  • sectionGenuine modular rank and permanent verification rulesGenuine modular rank and permanent verification rules · lines 1813–1820
    Open as its own page

    The proposed implementation uses required predicates rather than optimizable , residual verification after solving, genuine modular elimination, and rejection controls with exact expected reasons PythonAssert,SymPyMatrices.

Retained exact synthetic examples

  • sectionRank two and complete affine ambiguityRetained exact synthetic examples › Rank two and complete affine ambiguity · lines 1827–1858
    Open as its own page

    Let

    The original minor on rows , columns , is . Columns of form ; the last two rows of form . Direct multiplication gives

    Hence and every solution is .

    For

    the rank is one and .

  • sectionDescent without non-feedbackRetained exact synthetic examples › Descent without non-feedback · lines 1859–1884
    Open as its own page

    Take

    The upper-left minor is one and is complete. For

    Thus 's obstruction descends but does not vanish. For , one has , so descent fails.

  • sectionFree exactness, tangent failure, and closed nonexact vectorsRetained exact synthetic examples › Free exactness, tangent failure, and closed nonexact vectors · lines 1885–1915
    Open as its own page

    Let

    Then , , and

    satisfy cancellation and . The vector is not exact.

    With

    the left kernel is . Target is feasible; is not. Also

    give but .

  • sectionBounded report attainmentRetained exact synthetic examples › Bounded report attainment · lines 1916–1926
    Open as its own page

    For

    the maximum discrepancy is ; the half-diamond distance at scale one is , attained at task 2 or 3. Using at scale two gives the same value.

  • sectionCorrelated reference branchesRetained exact synthetic examples › Correlated reference branches · lines 1927–1948
    Open as its own page

    Let the clock basis be the columns of

    and let . For

    the nonzero blocks are and . Their sum is . The unconditional reference is , while positive conditional references are . Zero blocks are not normalized.

  • sectionGaussian-rational rankRetained exact synthetic examples › Gaussian-rational rank · lines 1949–1964
    Open as its own page

    For

    the original minor is one, , , and . The realification has rational rank two. The left-kernel multiplication is algebraic, not an unannounced conjugate-transpose convention.

Scheduled locality, transport, and rebuild resources

  • sectionScheduled locality, transport, and rebuild resourcesScheduled locality, transport, and rebuild resources · lines 1966–1979
    Open as its own page

    Let each complete tick channel factor over a prescribed partition , including all controllers, records, manifests, shared solvers, selectors, and resource wires. Define

  • theoremTheorem: Complete scheduled ancestryScheduled locality, transport, and rebuild resources · XVI-O1-ST@5#thm:locality · proof attached · lines 1980–2001
    Open as its own page

    Equal joint reductions on the ancestor region and an untouched reference give equal corresponding outputs. A local CPTP intervention outside the full backward region cannot change those outputs, with schedule and interfaces fixed. If each dependency edge has a certified regular future-causal host route, scheduled ancestry is contained in the prescribed metric causal relation.

    Proof. An excluded block acts on an identity factor, preserved by its unital adjoint. A meeting block enlarges support only within itself. Backward induction proves support containment. Joint observables prove the reference and intervention claims. Concatenation proves metric containment.

  • sectionScheduled locality, transport, and rebuild resourcesScheduled locality, transport, and rebuild resources · lines 2001–2009
    Open as its own page

    This is the finite mechanism compared in I-B, En03-A, and X-Enter-ST CheungIB,CheungEn03,CheungXEnterST. Scheduled ancestry bounds influence, not always equals it. Cancellation can make an ancestor unobservable. A shared solve can introduce dependencies absent from a row's direct Feynman sum.

  • propositionProposition: Regular reference-preserving transportScheduled locality, transport, and rebuild resources · XVI-O1-ST@5#prop:route · proof attached · lines 2010–2025
    Open as its own page

    Let . Place equal payload registers on a straight developed segment of length in a convex regular reserve. Initialize all but the source in independent blanks. Successive SWAPs realize the identity payload channel, including every reference. Hop duration gives arrival time in geometrized units.

    Proof. Each SWAP moves the entire payload and reference correlations to the next register and leaves the old site blank. Induction gives the channel identity; spacing and declared duration give the regular null routes.

  • sectionScheduled locality, transport, and rebuild resourcesScheduled locality, transport, and rebuild resources · lines 2025–2050
    Open as its own page

    SWAP permissions and speed are inputs, not a derived gravitational Hamiltonian. Transporting a counterterm code does not define its analytical insertion.

    For dictionary entries and a -qubit payload, a conservative reserve is

    Classical dictionaries, manifests, bit lengths, records, source storage, and any quantum realization of them are charged separately. References are identified, not treated as workspace.

    Step 1b stays . A clean-machine or heterogeneous rebuild must specify changes in hardware/software, hash the pinned tree, rebuild intermediates, enforce the same residual checks, retain failures and refusals, and disclose common conceptual inputs. Q11's author rebuild is not reclassified as that rebuild.

The integrity-aware finite release gate

  • sectionThe integrity-aware finite release gateThe integrity-aware finite release gate · lines 2052–2086
    Open as its own page

    A report names its full scope, evidence, provenance, and status. A regression status is not a scientific release status.

    VERIFY(P, scope, budget): resolve scope and bind exact inputs, versions, and manifest check cross-artifact consistency required by the claim if a required equality fails: retain exact residual and report DISCREPANCY_RECORDED do not return CERTIFIED_SCOPED reject undeclared prescription or domain changes require all ancestors of the requested report verify inventory, zero provenance, descent, and coverage verify original minor and complete left kernel verify candidate residual and all declared consistency rows verify any complete right-kernel / affine-family claim enforce declared independence and mutation obligations retain resource, error, and provenance ledgers return CERTIFIED_SCOPED for exactly the resolved scope

    missing input / unfinished computation -> MISSING unresolved scientific residual -> OPEN failed advertised exact check -> FAILED resource limit -> MISSING with RESOURCE_REFUSAL

    An irrelevant discrepancy need not block an unrelated theorem. The D01 artifact mismatch blocks claims requiring that cross-artifact equality; it does not refute the abstract channel theorems, the synthetic affine repair, or the documentary Q03 record.

  • theoremTheorem: Conditional exact-scope soundnessThe integrity-aware finite release gate · XVI-O1-ST@5#thm:gate · proof attached · lines 2087–2102
    Open as its own page

    Assume the maps implement the declared analytical problem, required artifact identifications hold, descent and coverage hold, and every required exact check succeeds. Then _SCOPED proves cancellation and the listed consistency identities on exactly that scope.

    Proof. Theorem thm:rank gives . Its blocks are (eq:system). The semantic, integrity, descent, and coverage hypotheses identify them with the declared equations. No premise identifies changed scopes with those equations.

  • sectionThe integrity-aware finite release gateThe integrity-aware finite release gate · lines 2102–2108
    Open as its own page

    The gate is a finite specification with possible refusals, not a general algorithm deciding arbitrary analytical coverage. A verifier does not formally certify itself by printing PASS.

Machine-readable scope and evidence ledger

  • sectionMachine-readable scope and evidence ledgerMachine-readable scope and evidence ledger · lines 2110–2118
    Open as its own page

    The ledger retains the prior scientific status strings. Historical v4 production flags and the supplied later v4 execution record are distinct fields. The current appendix flags refer only to the new v5 listing. Null means no supplied artifact, never a zero coefficient.

  • listingListing: ListingMachine-readable scope and evidence ledger · lines 2119–2330
    Open as its own page
    {
      "schema": "XVI-O1-ST.scope-ledger.v5",
      "scope_key_order": [
        "H", "A", "loop", "kappa_power", "external",
        "mass", "Psi", "prescription", "V", "R", "J"
      ],
      "scopes": {
        "s_Q03": {
          "H": "prescribed_cone_and_supported_lab",
          "A": "S_inv_PQ_normalization",
          "loop": 1,
          "kappa_power": 2,
          "external": "retained_bulk_two_point_QdS",
          "mass": 0,
          "Psi": "frozen_base_gauge_xi_1",
          "prescription": "XVI-P_p23_DRED_QdS_Q4S_MSbar_p22",
          "V": "11_p14r_over_Qi_plus_10_p22",
          "R": "23_named_rows_with_complete_scalar_expansions",
          "J": "Q03_bulk_11_4D_consistency_only"
        },
        "s_readout": {
          "base": "s_Q03",
          "patch": {
            "R": "D01_D03_D06_typeset_31_coefficients",
            "J": "component_mutations_and_attributed_ghost_equation"
          }
        },
        "s_phase": {
          "base": "s_readout",
          "patch": {
            "A": "cross_artifact_D01_array_comparison",
            "R": "14_exact_printed_coordinates",
            "J": "distinguish_f_tex_f_reg_and_a0"
          }
        },
        "s_grade": {
          "base": "s_Q03",
          "patch": {
            "A": "direct_cubic_to_quadratic_projection",
            "R": "21_direct_quadratic_coordinates",
            "J": "homogeneous_cubic_inputs_no_lowering_operation"
          }
        },
        "s_xi": {
          "base": "s_Q03",
          "patch": {
            "Psi": "declared_xi_family_xi_real_nonzero",
            "R": "complete_parameter_dependent_23_row_expansion",
            "J": "identified_gauge_family_consistency_maps"
          }
        },
        "s_kinetic": {
          "base": "s_xi",
          "patch": {
            "A": "declared_Q4S_kinetic_form",
            "loop": 0,
            "kappa_power": 0,
            "V": "symmetric_Q4S_tensors",
            "R": "rational_operator_inverse",
            "J": "trace_4_k_squared_nonzero_xi_nonzero"
          }
        },
        "s_xi_hh_restricted": {
          "base": "s_xi",
          "patch": {
            "A": "derivative_of_reported_hh_pole_block",
            "V": "source_restricted_Ktilde_X_h_primitive_image",
            "R": "source_declared_15_hh_structures",
            "J": "relaxed_rank_report_at_xi_1_and_2"
          }
        }
      },
      "results": [
        {
          "id": "Q03",
          "scope": "s_Q03",
          "status": "SUPPLIED_CLOSED",
          "evidence": "supplied_scientific_record",
          "new_replay": false,
          "original_matrix_artifact": null
        },
        {
          "id": "1a_tables",
          "scope": "s_readout",
          "status": "PROVED_FOR_PRINTED_DATA",
          "source_status": "Earned",
          "new_loop_execution": false,
          "independent_31_entry_engine_replay": false,
          "cross_artifact_dependency": "2a_phase_integrity"
        },
        {
          "id": "1b",
          "scope": "s_Q03",
          "status": "MISSING",
          "clean_machine_rebuild": false,
          "heterogeneous_rebuild": false
        },
        {
          "id": "1c",
          "scope": "s_grade",
          "status": "PROVED_GRADED",
          "matrix_shape": [21, 10],
          "rank": 0,
          "minor_rows": [],
          "minor_columns": [],
          "minor_determinant": "1",
          "left_kernel": "I_21",
          "universal_response_nonfeedback": false
        },
        {
          "id": "2a_propagator",
          "scope": "s_kinetic",
          "status": "PROVED_FOR_DECLARED_KINETIC_FORM",
          "action_hessian_reexecution": false
        },
        {
          "id": "2a_poles",
          "scope": "s_xi",
          "status": "SUPPLIED_RECORD",
          "printed_polynomial_arithmetic": "PROVED",
          "arithmetic_scope": [
            "degree", "13_of_14_variation", "formal_derivative"
          ],
          "D01_varying_structure_count": 13,
          "cross_artifact_phase_consistency": false,
          "new_loop_execution": false
        },
        {
          "id": "2a_phase_integrity",
          "scope": "s_phase",
          "status": "DISCREPANCY_RECORDED",
          "evidence": "exact_synthetic_witness",
          "python_index": 5,
          "displayed_structure": "B_6",
          "f_tex": "-4/3",
          "f_reg": "4/3",
          "a0": "4/3",
          "residual": "(8/3)*e_6",
          "original_matrix_artifact": null,
          "phase_consistent": false,
          "physical_sign_selected": false
        },
        {
          "id": "2a_restricted_hh",
          "scope": "s_xi_hh_restricted",
          "status": "SUPPLIED_RESTRICTED_OBSTRUCTION",
          "reported_rank": 7,
          "reported_augmented_rank": 8,
          "original_minor_artifact": null,
          "complete_left_kernel_artifact": null,
          "v4_recertified": false,
          "v5_recertified": false
        },
        {
          "id": "2a_full_exactness",
          "scope": "s_xi",
          "status": "OPEN",
          "enlarged_primitive_artifact": null,
          "enlargement_response_artifact": null,
          "physical_separator_artifact": null,
          "separator_construction": "Q_E*L_when_arrays_are_supplied"
        },
        {
          "id": "2a_full_rows",
          "scope": "s_xi",
          "status": "OPEN",
          "full_matrix_artifact": null
        },
        {"id": "2b_mass", "status": "PROGRAMME"},
        {"id": "2c_externals", "status": "PROGRAMME"},
        {"id": "3_three_point", "status": "OUTSIDE_Q03_SCOPE"},
        {"id": "4_four_point",
         "status": "PROGRAMME_RESOURCE_LIMIT_REPORTED"},
        {"id": "5_two_loop", "status": "PROGRAMME"}
      ],
      "historical_v4_source_flags": {
        "appendix_status": "PROPOSED",
        "appendix_executed": false,
        "appendix_verified": false
      },
      "supplied_v4_run": {
        "status": "SUPPLIED_FAILED_EXECUTION_RECORD",
        "reported_python": "3.10.21",
        "reported_sympy": "1.14.0",
        "reported_passed_suites": 8,
        "reported_failed_suites": 1,
        "reported_predicate_count": 1397,
        "failed_predicate": "corrected D01 phase",
        "post_phase_variation_checks_reached": false,
        "new_replay_in_v5": false,
        "digest_independently_authenticated": false
      },
      "production": {
        "appendix_status": "PROPOSED",
        "appendix_executed": false,
        "appendix_verified": false,
        "compilation_executed": false,
        "formal_proof_check": false,
        "new_loop_execution": false
      },
      "standing_boundaries": {
        "O1_outside_earned_scopes": "NOT_CLOSED",
        "bulk_symmetry_restored": false,
        "XVI_N_insertion": "FROZEN",
        "Route_B_discharged": false,
        "XV_B_admission_exit_opened": false,
        "inherited_characteristic_quantum_coefficient_admitted": false,
        "host_reconstructed": false
      }
    }
  • sectionMachine-readable scope and evidence ledgerMachine-readable scope and evidence ledger · lines 2330–2336
    Open as its own page

    Base/patch scope resolution must finish before comparison. A future executable release must bind these semantic identifiers to complete byte manifests.

Successor calculations and documentary boundaries

  • sectionMass and external dataSuccessor calculations and documentary boundaries › Mass and external data · lines 2341–2360
    Open as its own page

    At nonzero mass, recompute every relevant graph, including D04, D05a, and D12 where mass enters the actual rules. Not every massless zero must become nonzero. List mass monomials and changed consistency maps before testing the old domain.

    General off-shell momentum is distinct from general external index/polarization conventions. Construct the full ambient divergence before testing membership in the old 21-direction image. The exact old-domain criterion is

    A failed membership test has a separator; adding columns is a disclosed domain revision.

  • sectionThree-point chronologySuccessor calculations and documentary boundaries › Three-point chronology · lines 2361–2383
    Open as its own page

    The pinned Q06–Q11 ledger supersedes the old Q05 task list: and the G01/G02 pole results were supplied; the assembly includes its corrected auxiliary/gauge channel CheungXVIQ. Later R07–R09 hat-aware reduced-system records remain separately attributed SuppliedBot,CheungXVIR.

    Q11's conditional

    and the reduced even/odd counts have different presentations and qualifications. They are not collapsed into one unconditional cohomology theorem. No unresolved direction is certified physical.

    The scientific successor still needs complete pole/zero audit, all channels, cubic p22 completion, evanescent operator and invariant-basis checks, and a complete affine certificate. Pole exactness is not a finite-amplitude theorem or an interacting quantum master equation.

  • sectionFour points and modular methodsSuccessor calculations and documentary boundaries › Four points and modular methods · lines 2384–2397
    Open as its own page

    The predecessor reports resource failures on a 15\,GB machine, multi-gigabyte ghost-box expressions, stopped symbolic or numerical-point paths, absent higher vertices, and ansatz widths for and for SuppliedBot,CheungXVIR. These are implementation-specific records, not mathematical impossibility.

    A future certificate needs the actual original matrix, exact field, rank, original minor, complete left kernel, and target membership. Choosing reconstruction or IBP is not evaluating it.

  • sectionTwo-loop subgraphs and analytical insertionSuccessor calculations and documentary boundaries › Two-loop subgraphs and analytical insertion · lines 2398–2437
    Open as its own page

    A validated coefficient code requires an insertion map

    with derivative, tensor, antifield, Grassmann, symmetry, evanescent, and subtraction conventions.

    For the declared pole extraction,

    The sum uses allowed disjoint proper UV subgraphs; nested subtractions are recursive Zimmermann,SmirnovChetyrkin. Every required proper subgraph needs its counterterm and insertion.

    For ordinary gravitational vertex weights,

    A one-loop cubic counterterm can therefore contribute to the two-loop two-point inventory. Required Laurent depth and evanescent contributions are retained before multiplication by subdivergent poles DuganGrinstein. Separate success on gauge, mass, and external axes does not prove their simultaneous combination.

Source-label audit and non-transfer

  • sectionSource-label audit and non-transferSource-label audit and non-transfer · lines 2439–2542
    Open as its own page

    The source audit distinguishes supplied passages, accessible rendered pages, and unsuccessful fetches. A rendered page is not a byte-authenticated archive or proof verification. A failed fetch is not proof of HTTP 404, nonregistration, or mathematical nonexistence.

    For this revision, the public essay, I-B, En03-A, X-H-ST, Oai283-A, publisher record, and official software references were consulted. Attempts for X-A-ST, X-G-ST, XVI-Q, and Oai282-A did not provide fresh accessible text. Their supplied version-qualified material remains usable as documentary attribution, not as an invented fresh source audit.

    {}1.12 {@{}p{0.21}p{0.71}@{}} Source & Component retained and non-transfer boundary
    Source & Component retained and non-transfer boundary
    I-B & The accessible version-1 page displays :instrument and the complete clock/readout distinction. The host, calibration, and metric cone remain inputs.
    En03-A & The four-part interface and :locality are visible. Coefficient spaces are not accessible quantum algebras; logical task names are not ports.
    X-H-ST & The accessible page displays :BV, :nondescent, :instrument, and :noacquisition. Relative classical BV and its residual reports do not construct interacting quantum BRST. Its reciprocity comparison is not a loop anomaly.
    X-G-ST & The supplied :freeBRST and :obstruction descriptions are retained. No fresh full-source retrieval or normalization transfer is claimed.
    II; II-B & Original-minor, complete-kernel, coverage, and affine-family discipline only. Their numerical certificate is not imported.
    Oai283-A & The accessible :assembly compares conditional complete-channel and resource certificates. Its oracle-synthesis setting is not a loop or thermodynamic result here.
    Oai282-A & The supplied :ward certificate shape is documentary. It does not supply an enlarged gravitational primitive or counterterm map.
    X-Enter-ST & The supplied route, locality, and attachment descriptions motivate transport accounting. They do not define analytical insertion or continuum acquisition.
    X-A-ST & The supplied host, non-GH, completion, and signature records are retained. No fresh retrieval success is asserted in v5. The host locators are not silently replaced by an :host label from another sheet.
    X-I-ST; X-J-ST & Optional deformation/coefficient/selective-amplitude descriptions in the plan are not needed here. No newly verified locator, registration update, second charged coefficient, or radiative vacuum-stability theorem is imported.
    XVI-P/Q/R & Pinned prescription and scientific records remain distinct from their missing original artifacts and a new replay. R07–R09 are supplied review-package descriptions.
    OpenAI 282/362/376 & Supplied catalogue comparisons only, not premises or verified proofs. Their attribution is not merged with Cheung's sources.

  • sectionSource-label audit and non-transferSource-label audit and non-transfer · lines 2542–2550
    Open as its own page

    rule

    The publisher record consulted identifies Cheung's Enter article as accepted on 28 September 2026 and describes the final formatted version as forthcoming. No final publication date is invented CheungEnter.

  • sectionPermanent non-claimsSource-label audit and non-transfer › Permanent non-claims · lines 2551–2592
    Open as its own page
    1. O.1 remains _CLOSED outside earned scopes; . XVI-O's prescription and verdict are not rewritten CheungXVIO,CheungXVIQ.

    2. XVI-N remains frozen; Route B and the universal insertion completion are not discharged CheungXVIN.

    3. Free exactness, relative classical BV, free-equation descent, variational reciprocity, and loop anomaly are not identified CheungXGST,CheungXHST.

    4. Three inherited equation-level trees are counted once. Convolution remains unrepaired; the X-D-ST sharp limit is not metric admission or a loop regulator CheungXComparisons.

    5. The historical XIV-H H2 stop is retained without erasing XIV-I's I2 internal-amplitude advance. The complete characteristic map remains unresolved at I3/J2 in the supplied releases CheungXIVH,CheungXIVI,CheungXIVJ.

    6. Technical XV-B lifting and normal-jet interfaces do not open its inherited downstream quantum-admission exit CheungXVB.

    7. Finite matrix certificates do not construct the missing joint map, joint section and remainder, transverse estimates, contact compatibility, output wavefront theorem, or admission. No differential is applied to an absent quantum coefficient.

    8. No Einstein equation from records, derived cone, metric reconstruction, Page curve, entanglement wedge, gravity-generated entanglement, external-clock-free quantum evolution, ultraviolet completion, or spacetime emergence is constructed.

    For comparison, the supplied XIV-J null identity illustrates why presentation degree alone need not descend through reconstruction CheungXIVJ. It is not used to replace the finite matrix problem by a distributional product theorem.

    These are release boundaries, not universal impossibility theorems.

Consolidated v5 release

  • theoremTheorem: Integrity-aware finite releaseConsolidated v5 release · XVI-O1-ST@5#thm:release · proof attached · lines 2597–2656
    Open as its own page

    For the declared host and finite interfaces:

    1. the complete destructive instrument and its conditional reference blocks are established;

    2. real binary and complex qubit reports have the sharp complete error formulas;

    3. feasibility, inconsistency, and full affine ambiguity have original-minor and complete-kernel certificates;

    4. the printed mutation arrays retain their counts and discrepancies, while the phase inconsistency has the exact cross-artifact witness (eq:phaseresidual);

    5. direct graded non-feedback has the stated rank-zero certificate, with the separate quotient-response criterion;

    6. the declared Q4S kinetic form has the exact affine inverse;

    7. the unchanged printed gauge polynomial has 13 varying structures and derivative (eq:hhderivative);

    8. free exactness, primitive enlargement, separator construction, and polynomial family solving have the stated finite criteria;

    9. the old affine fallback, modular-rank confusion, and v4 execution-coverage overstatement are explicitly audited;

    10. complete scheduled ancestry, transport, and conditional release soundness retain their precise scopes.

    The phase-data consistency predicate remains false for the retained regression array. A successful known-discrepancy test would not change that predicate.

    Q03 remains _CLOSED. The restricted rank increase remains supplied, not newly re-certified. Full counterterm-derivative exactness and full gauge-family rows remain ; step 1b remains . No physical enlarged primitive or numerical physical separator is invented.

    The supplied v4 failed transcript is retained. No v5 regression run, loop evaluation, compiler execution, formal proof check, or independent rebuild is asserted.

    Proof. Items 1–3 follow from Theorems thm:instrument, thm:error, thm:rank, and Proposition prop:right. Item 4 is Proposition prop:mutationdata and Theorem thm:phase. Item 5 is Theorems thm:graded and thm:quotient. Items 6–8 are Theorem thm:propagator, Proposition prop:derivative, and Theorems thm:exactness–thm:blocklift. Item 9 is Theorem thm:affine, Propositions prop:modular, prop:pass, and prop:coverage. Item 10 follows from Theorem thm:locality, Proposition prop:route, and Theorem thm:gate. The missing scientific artifacts are not premises of any claimed new closure.

  • sectionConclusionConsolidated v5 release › Conclusion · lines 2658–2669
    Open as its own page

    Version 5 retains the discrepancy rather than manufacturing agreement. It also retains the distinction between a test that correctly rejects data and data that satisfy the scientific claim.

    The finite architecture remains useful precisely because its positive outputs have limited, inspectable meanings. Neither an expected failure nor an absent response matrix is hidden by a successful regression contract.

  • scopeFinal v5 verdictConsolidated v5 release › Conclusion · lines 2670–2684
    Open as its own page

    v5 verdict{

    The cone remains an input.}

Declarations

  • sectionDeclarationsDeclarations · lines 2687–2727
    Open as its own page

    . Cited Cheung manuscripts retain their supplied N. Cheung attribution. This anonymous revision does not assign its audit wording or authorship to that author. Authorized authorship and affiliation metadata are needed for a signed submission.

    and scientific scope. The mathematical release consists of the printed statements and proofs. Missing scientific constructions remain missing. The evidence package does not permit selecting the physical sign of the disputed D01 coefficient or supplying the absent enlarged primitive/row response.

    provenance. The v4 code and transcript are supplied artifacts, not a new invocation performed here. Their reported environment and digest are attributed, not independently authenticated. The new v5 appendix is unexecuted.

    and submission. This source uses standard pdfLaTeX packages, one internal bibliography, and no external inputs. No successful compiler run, pagination inspection, proof-assistant check, referee decision, submission, or journal acceptance is asserted. Actual two-pass compilation and log inspection remain pre-submission tasks.

    sources and availability. No frozen XVI-P/Q/R or earlier ST source is edited. A replayable scientific release must archive the original arrays, complete scripts, manifests, and logs. The new program below does not depend on those unavailable scientific files.

Supplied v4 transcript

  • sectionSupplied v4 transcriptSupplied v4 transcript · lines 2729–2735
    Open as its own page

    The following is the supplied short output, reproduced as an execution artifact rather than as a new run V4Artifacts.

  • listingListing: ListingSupplied v4 transcript · lines 2736–2754
    Open as its own page
    XVI-O1-ST-v4: SYNTHETIC/PRINTED-DATA REGRESSION ONLY
    Python: 3.10.21 (main, Sep 19 2026, 01:08:03) [GCC 12.2.0]
    Platform: Linux-6.12.8+-x86_64-with-glibc2.36
    SymPy: 1.14.0
    Source SHA256: e9f661c8f3eb1dc75b580eb756174f4ff5711f172230ae369b17dbf5a2fbb106
    No inherited loop engine, matrix, or archive is evaluated.
    PASS_SYNTHETIC: rank / affine repair
    PASS_SYNTHETIC: fields / genuine modular rank
    PASS_SYNTHETIC: quotient / primitive enlargement
    PASS_SYNTHETIC: free complex / polynomial family
    FAIL_SYNTHETIC: printed coefficient tables CheckFailure corrected D01 phase
    PASS_SYNTHETIC: bounded report witnesses
    PASS_SYNTHETIC: complete instrument / reference
    PASS_SYNTHETIC: direct grading / sign parity
    PASS_SYNTHETIC: finite propagator regression
    Evaluated predicates, including expected rejections: 1397
    SYNTHETIC SUITE FAILED: 1 case(s)
  • sectionSupplied v4 transcriptSupplied v4 transcript · lines 2754–2761
    Open as its own page

    This record supersedes any unqualified present-tense statement that no v4 execution record has been supplied. It does not establish successful v4 completion, formal verification, or a v5 execution.

Proposed v5 exact regression with retained discrepancy

  • sectionProposed v5 exact regression with retained discrepancyProposed v5 exact regression with retained discrepancy · lines 2763–2794
    Open as its own page

    Copy this listing to _xvi_o1_st_v5.py. It is not executed or extracted by LaTeX.

    The two D01 baseline vectors are independent retained literals. The script never overwrites the v4 regression value. It verifies the exact nonzero witness, then verifies that the old phase equality is rejected for the intended reason. Unexpected discrepancies remain fatal.

    The exit contract is:

    • exit 1: an unexpected regression or checker failure;

    • exit 2: the listed regression contracts completed, with the known data-integrity discrepancy still present;

    • exit 0: reserved for a clean contract with no recorded discrepancy; it is not the expected outcome for the retained data.

    Thus a future run cannot be read as an all-data-consistent success merely because the negative control behaved correctly. There is no newly observed exit result in this manuscript.

    The list retains all v4 test categories and separates the phase witness into its own suite so that other table predicates are not hidden behind its expected rejection. The finite-component propagator regression is not the general Q4S or loop proof. Official solving and language behavior are documented in SymPyMatrices,PythonAssert.

  • listingListing: ListingProposed v5 exact regression with retained discrepancy · lines 2795–3413
    Open as its own page
    #!/usr/bin/env python3
    """
    XVI-O1-ST-v5: exact finite regression with a retained discrepancy.
    
    No loop engine, original scientific matrix, or R archive is read.
    Exit 2 means regression contracts satisfied WITH known inconsistent
    data. It is not release acceptance or phase reconciliation.
    """
    
    import hashlib
    import json
    import platform
    import sys
    from pathlib import Path
    
    import sympy as sp
    from sympy import Matrix, Rational as Q, eye, zeros, I
    
    CHECKS = 0
    DISCREPANCIES = {}
    
    
    class CheckFailure(RuntimeError):
        pass
    
    
    def require(condition, message):
        global CHECKS
        CHECKS += 1
        if condition is not True and condition is not sp.S.true:
            raise CheckFailure(message)
    
    
    def same(X, Y, message):
        require(X.shape == Y.shape, message + ": shape")
        require(all(sp.simplify(z) == 0 for z in X-Y),
                message + ": nonzero difference")
    
    
    def reject(name, action, expected):
        try:
            action()
        except CheckFailure as exc:
            require(str(exc) == expected,
                    name + ": unexpected rejection reason")
            return
        raise CheckFailure("invalid control accepted: " + name)
    
    
    def gaussian_entries(X):
        for z in X:
            re, im = sp.expand_complex(z).as_real_imag()
            require(re.is_Rational is True
                    and im.is_Rational is True,
                    "entry is not an exact Gaussian rational")
    
    
    def verify_rank(M, r, rows, cols, L):
        gaussian_entries(M)
        gaussian_entries(L)
        n, p = M.shape
        rows, cols = list(rows), list(cols)
        require(type(r) is int and 0 <= r <= min(n,p),
                "invalid rank parameter")
        require(len(rows) == r and len(cols) == r, "minor size")
        require(all(type(j) is int for j in rows+cols),
                "minor index type")
        require(len(set(rows)) == r and len(set(cols)) == r,
                "duplicate minor index")
        require(all(0 <= j < n for j in rows), "minor row range")
        require(all(0 <= j < p for j in cols), "minor column range")
        require(L.shape == (n-r,n), "left-kernel shape")
        delta = sp.Integer(1) if r == 0 else \
            sp.simplify(M.extract(rows,cols).det())
        require(delta != 0, "original minor is zero")
        same(L*M, zeros(n-r,p), "left-kernel identity")
        require(L.rank() == n-r, "left kernel is incomplete")
        return delta
    
    
    def verify_solution(M, y, c):
        for X in (M,y,c):
            gaussian_entries(X)
        require(y.shape == (M.rows,1), "target shape")
        require(c.shape == (M.cols,1), "candidate shape")
        same(M*c,y,"candidate solution")
    
    
    def verify_right(M, r, Z):
        # Precondition: rank(M)=r has a separate certificate.
        gaussian_entries(M)
        gaussian_entries(Z)
        require(type(r) is int and 0 <= r <= min(M.shape),
                "invalid right-kernel rank parameter")
        require(Z.shape == (M.cols,M.cols-r), "right-kernel shape")
        same(M*Z,zeros(M.rows,Z.cols),"right-kernel identity")
        require(Z.rank() == M.cols-r, "right kernel is incomplete")
    
    
    def reduce_rational(x, p):
        x = sp.sympify(x)
        require(x.is_Rational is True,
                "modular input is not rational")
        num, den = map(int,x.as_numer_denom())
        require(den % p != 0, "denominator is not invertible")
        return (num % p)*pow(den % p,-1,p) % p
    
    
    def rank_mod(M, p):
        require(type(p) is int and bool(sp.isprime(p)),
                "modulus is not prime")
        A = [[reduce_rational(M[i,j],p)
              for j in range(M.cols)] for i in range(M.rows)]
        r = 0
        for col in range(M.cols):
            pivot = next((j for j in range(r,M.rows)
                          if A[j][col] != 0),None)
            if pivot is None:
                continue
            A[r],A[pivot] = A[pivot],A[r]
            inv = pow(A[r][col],-1,p)
            A[r] = [(x*inv) % p for x in A[r]]
            for j in range(M.rows):
                if j != r:
                    f = A[j][col]
                    A[j] = [(A[j][k]-f*A[r][k]) % p
                            for k in range(M.cols)]
            r += 1
            if r == M.rows:
                break
        return r
    
    
    def unit(d,j):
        v = zeros(d,1)
        v[j,0] = 1
        return v
    
    
    def channel(Ks,X):
        require(len(Ks) > 0,"empty Kraus list")
        out = zeros(Ks[0].rows,Ks[0].rows)
        for K in Ks:
            out += K*X*K.H
        return out.applyfunc(sp.simplify)
    
    
    def trace_first(X,d,rest):
        require(X.shape == (d*rest,d*rest),"partial-trace shape")
        out = zeros(rest,rest)
        for j in range(d):
            out += X[j*rest:(j+1)*rest,j*rest:(j+1)*rest]
        return out.applyfunc(sp.simplify)
    
    
    def rats(text):
        return [Q(s) for s in text.split()]
    
    
    def printed_data():
        # Both original literals are retained; neither is overwritten.
        f_tex = rats(
            "-27/80 19/60 -11/48 -71/120 11/10 -4/3 "
            "19/60 -13/15 1/6 4/3 -11/48 1/6 -1/8 -3/4")
        f_reg = rats(
            "-27/80 19/60 -11/48 -71/120 11/10 4/3 "
            "19/60 -13/15 1/6 4/3 -11/48 1/6 -1/8 -3/4")
        fm = rats(
            "-871/120 911/120 -229/48 56/15 -829/30 17/3 "
            "911/120 -99/10 91/12 -65/3 -229/48 91/12 -21/8 5/4")
        g = rats(
            "7/48 -1/8 5/48 1/12 -1/12 1/3 -1/8 "
            "1/6 -1/24 -1/3 5/48 -1/24 1/16 1/4")
        gm = rats(
            "-1/48 -7/24 1/48 5/12 7/12 2/3 -7/24 "
            "1/6 -5/24 1/3 1/48 -5/24 1/16 1/4")
        h = rats("-3/8 1/4 -1/2")
        hm = rats("-19/24 -7/12 -1/2")
        a0 = rats(
            "27/80 -19/60 11/48 71/120 -11/10 4/3 "
            "-19/60 13/15 -1/6 -4/3 11/48 -1/6 1/8 3/4")
        a1 = rats(
            "1/2 -2/3 1 1/2 -1 1/2 -2/3 4/3 "
            "-5/4 -1/2 1 -5/4 3/2 0")
        a2 = rats(
            "1/2 -1/2 5/6 1/6 -1/3 0 -1/2 2/3 "
            "-5/6 0 5/6 -5/6 5/4 0")
        return f_tex,f_reg,fm,g,gm,h,hm,a0,a1,a2
    
    
    def test_rank_affine():
        M = Matrix([[1,2,3,4],[2,4,6,8],[1,1,1,1],
                    [3,5,7,9],[0,0,0,0]])
        L = Matrix([[-2,1,0,0,0],[-2,0,-1,1,0],[0,0,0,0,1]])
        Z = Matrix([[1,2],[-2,-3],[1,0],[0,1]])
        y,c = Matrix([1,2,1,3,0]),Matrix([1,0,0,0])
        require(verify_rank(M,2,[0,2],[0,1],L) == -1,
                "rank-two original minor")
        verify_solution(M,y,c)
        verify_right(M,2,Z)
        same(L*y,zeros(3,1),"target membership")
        alpha,beta = sp.symbols("alpha beta")
        same(M*(c+Z*Matrix([alpha,beta])),y,"affine family")
        reject("incomplete left kernel",
               lambda: verify_rank(M,2,[0,2],[0,1],zeros(3,5)),
               "left kernel is incomplete")
        reject("zero chosen minor",
               lambda: verify_rank(M,2,[0,1],[0,1],L),
               "original minor is zero")
        verify_rank(zeros(2,3),0,[],[],eye(2))
        verify_right(zeros(2,3),0,eye(3))
        verify_rank(eye(3),3,[0,1,2],[0,1,2],zeros(0,3))
        verify_right(eye(3),3,zeros(3,0))
    
        Ma = Matrix([[1,2,1],[2,4,2],[1,1,0]])
        ya,ca = Matrix([3,6,1]),Matrix([1,0,2])
        La,Za = Matrix([[-2,1,0]]),Matrix([1,-1,1])
        verify_rank(Ma,2,[0,2],[0,1],La)
        verify_solution(Ma,ya,ca)
        verify_right(Ma,2,Za)
        old = Matrix([1,1,0])
        same(Ma*old-ya,Matrix([0,0,1]),"old residual")
        reject("old unchecked fallback",
               lambda: verify_solution(Ma,ya,old),
               "candidate solution: nonzero difference")
        sol,params = Ma.gauss_jordan_solve(ya)
        same(Ma*sol,ya,"parametric solver residual")
        require(len(params) == 1,"free parameter count")
        verify_solution(Ma,ya,sol.subs({t:0 for t in params}))
    
        Mu = Matrix([[1,2],[2,4],[0,0]])
        Lu = Matrix([[-2,1,0],[0,0,1]])
        yu = Matrix([1,1,1])
        verify_rank(Mu,1,[0],[0],Lu)
        same(Lu*yu,Matrix([-1,1]),"inconsistency separator")
        require(Matrix.hstack(Mu,yu).rank() == 2,
                "inconsistent augmented rank")
    
    
    def test_fields_modular():
        M = Matrix([[Q(1,2),Q(1,3)],[Q(2,3),Q(1,2)],[1,1]])
        red = M.applyfunc(lambda z: reduce_rational(z,5))
        same(red,Matrix([[3,2],[4,3],[1,1]]),"rational reduction")
        require(M.extract([0,1],[0,1]).det() == Q(1,36),
                "separate rational minor")
        require(int(red.extract([0,1],[0,1]).det()) % 5 == 1,
                "finite-field minor")
        require(rank_mod(M,5) == 2 and M.rank() == 2,
                "rational and modular rank")
        require(Matrix([[5]]).rank() == 1,"rank over Q")
        require(rank_mod(Matrix([[5]]),5) == 0,"rank over F5")
        reject("bad denominator",
               lambda: rank_mod(Matrix([[Q(1,5)]]),5),
               "denominator is not invertible")
        reject("composite modulus",
               lambda: rank_mod(eye(2),6),"modulus is not prime")
        reject("floating certificate",
               lambda: gaussian_entries(Matrix([[sp.Float("0.5")]])),
               "entry is not an exact Gaussian rational")
    
        G = Matrix([[1,I],[I,-1],[0,0]])
        L = Matrix([[-I,1,0],[0,0,1]])
        Z = Matrix([-I,1])
        verify_rank(G,1,[0],[0],L)
        verify_right(G,1,Z)
        verify_solution(G,Matrix([1,I,0]),Matrix([1,0]))
        GR,GI = G.applyfunc(sp.re),G.applyfunc(sp.im)
        realified = Matrix.vstack(Matrix.hstack(GR,-GI),
                                   Matrix.hstack(GI,GR))
        require(realified.rank() == 2,"realification rank")
    
    
    def test_quotient_enlargement():
        T = Matrix([[1,0,2],[0,1,1],[1,1,3],[0,0,0]])
        L = Matrix([[-1,-1,1,0],[0,0,0,1]])
        F = Matrix([[1,2],[0,1],[1,3],[0,0]])
        R = Matrix([2,-1])
        verify_rank(T,2,[0,1],[0,1],L)
        same(L*F,zeros(2,2),"nonfeedback")
        same(F*R,Matrix([0,-1,-1,0]),"relation response")
        same(L*F*R,zeros(2,1),"quotient descent")
        Fd = Matrix([[1,2],[0,1],[1,3],[1,2]])
        same(L*Fd,Matrix([[0,0],[1,2]]),"descended obstruction")
        same(L*Fd*R,zeros(2,1),"descent without vanishing")
        require(Matrix.hstack(T,Fd).rank() == 3,"outside-span rank")
        reject("descent is not nonfeedback",
               lambda: same(L*Fd,zeros(2,2),"nonfeedback"),
               "nonfeedback: nonzero difference")
        Fb = Matrix([[1,0],[0,1],[1,1],[1,0]])
        reject("bad descent",
               lambda: same(L*Fb*R,zeros(2,1),"descent"),
               "descent: nonzero difference")
    
        H = Matrix([1,0,0])
        LH = Matrix([[0,1,0],[0,0,1]])
        E,b = Matrix([0,1,0]),Matrix([1,2,0])
        verify_rank(H,1,[0],[0],LH)
        same(LH*b,LH*E*Matrix([2]),"projected enlargement")
        same(H*Matrix([1])+E*Matrix([2]),b,"enlarged solution")
        QE = Matrix([[0,1]])
        D = QE*LH
        same(D*H,zeros(1,1),"separator old image")
        same(D*E,zeros(1,1),"separator new image")
        require((D*Matrix([1,2,1]))[0] == 1,
                "enlarged obstruction")
    
        # Same old ranks, opposite enlargement outcomes.
        H15 = eye(15)[:,:7]
        b15 = unit(15,7)
        require(H15.rank() == 7,"old rank seven")
        require(Matrix.hstack(H15,b15).rank() == 8,
                "augmented rank eight")
        require(Matrix.hstack(H15,unit(15,7),b15).rank() == 8,
                "resolving enlargement")
        require(Matrix.hstack(H15,unit(15,8),b15).rank() == 9,
                "nonresolving enlargement")
    
    
    def test_free_complex_family():
        S = Matrix([[1,0],[0,1],[1,1]])
        B0 = Matrix([[-1,-1,1]])
        A = Matrix([[1,0,0],[0,1,0]])
        verify_rank(S,2,[0,1],[0,1],B0)
        same(B0*S,zeros(1,2),"free complex")
        xi = sp.symbols("xi",real=True)
        c,d = xi*Matrix([1,-1,0]),Matrix([-xi,xi])
        same(A*c+d,zeros(2,1),"gauge cancellation")
        same(c.diff(xi),S*Matrix([1,-1]),"primitive")
        same(A*S,eye(2),"surjective tangent")
        reject("nonexact vector",
               lambda: same(B0*Matrix([0,0,1]),zeros(1,1),"exactness"),
               "exactness: nonzero difference")
        Ast = Matrix([[1,0,0],[0,0,1],[1,0,1]])
        HH,LH = Ast*S,Matrix([[-1,-1,1]])
        verify_rank(HH,2,[0,1],[0,1],LH)
        same(LH*Ast*c.diff(xi),zeros(1,1),"feasible tangent")
        reject("infeasible tangent",
               lambda: same(LH*Matrix([1,0,0]),zeros(1,1),"tangent"),
               "tangent: nonzero difference")
        S0,B1,z = Matrix([1,0,0]),Matrix([[0,0,1]]),Matrix([0,1,0])
        same(B1*S0,zeros(1,1),"second complex")
        same(B1*z,zeros(1,1),"closed vector")
        require(Matrix.hstack(S0,z).rank() == 2,"closed nonexact")
    
        M,L = S,B0
        zeta = sp.symbols("zeta")
        coeffs = [Matrix([1,0]),Matrix([0,2]),Matrix([3,-1])]
        cp,yp = zeros(2,1),zeros(3,1)
        for j,a in enumerate(coeffs):
            b = M*a
            same(L*b,zeros(1,1),"coefficient membership")
            cp += zeta**j*a
            yp += zeta**j*b
        same(M*cp,yp,"constant-response polynomial lift")
        same(yp.subs(zeta,0),M*coeffs[0],"base point")
    
    
    def test_table_arithmetic():
        ft,fr,fm,g,gm,h,hm,a0,a1,a2 = printed_data()
        for name,arr in [("ft",ft),("fr",fr),("fm",fm),("g",g),
                         ("gm",gm),("a0",a0),("a1",a1),("a2",a2)]:
            require(len(arr) == 14,"table length "+name)
            gaussian_entries(Matrix(arr))
        for a,b,count,delta in [
            (ft,fm,14,Q(431,30)),(fr,fm,14,Q(431,30)),
            (g,gm,11,Q(1,3)),(h,hm,2,Q(5,12))
        ]:
            require(len(a) == len(b),"mutation array lengths")
            require(sum(x != y for x,y in zip(a,b)) == count,
                    "mutation count")
            require(max(abs(x-y) for x,y in zip(a,b))/2 == delta,
                    "mutation discrepancy")
            require(max(abs(x) for x in a+b) <= 32,
                    "common report bound")
    
        # Independent from the known phase-failure suite.
        require(sum(x != 0 or y != 0 for x,y in zip(a1,a2)) == 13,
                "D01 varying structure count")
        require(a1[13] == 0 and a2[13] == 0,
                "constant D01 structure")
        zeta = sp.symbols("zeta")
        for j in range(14):
            p = a0[j]+zeta*a1[j]+zeta**2*a2[j]
            require(sp.diff(p,zeta) == a1[j]+2*zeta*a2[j],
                    "printed derivative")
    
    
    def test_phase_integrity():
        ft,fr,fm,g,gm,h,hm,a0,a1,a2 = printed_data()
        FT,FR,A0 = Matrix(ft),Matrix(fr),Matrix(a0)
        expected = Q(8,3)*unit(14,5)
        same(A0+FT,zeros(14,1),"typeset phase relation")
        same(FR-FT,expected,"cross-artifact transcription witness")
        same(A0+FR,expected,"retained phase residual")
        require([j for j,z in enumerate(A0+FR) if z != 0] == [5],
                "unique phase mismatch index")
        require(ft[5] == -Q(4,3) and fr[5] == Q(4,3)
                and a0[5] == Q(4,3),"retained coefficient literals")
        reject("legacy phase equality",
               lambda: same(A0+FR,zeros(14,1),"legacy D01 phase"),
               "legacy D01 phase: nonzero difference")
        require("2a_phase_integrity" not in DISCREPANCIES,
                "duplicate discrepancy record")
        DISCREPANCIES["2a_phase_integrity"] = {
            "status":"DISCREPANCY_RECORDED",
            "python_index":5,
            "displayed_structure":"B_6",
            "residual":[str(z) for z in A0+FR],
            "phase_consistent":False,
            "physical_sign_selected":False
        }
        require(max(abs(z) for z in A0+FR)/2 == Q(4,3),
                "integrity coefficient discrepancy")
        require(max(abs(z) for z in A0+FR)/64 == Q(1,24),
                "integrity report distance at B32")
    
    
    def bounded_probabilities(v):
        v = [sp.sympify(x) for x in v]
        require(len(v) > 0,"empty report")
        require(all(x.is_Rational is True for x in v),
                "report not exact rational")
        require(all(-1 <= x <= 1 for x in v),
                "report outside [-1,1]")
        return [[(1+b*x)/2 for b in (-1,1)] for x in v]
    
    
    def test_report():
        v = rats("3/10 -1/2 4/5 1/10")
        vt = rats("3/10 -2/5 7/10 1/10")
        P,PT = bounded_probabilities(v),bounded_probabilities(vt)
        distances = []
        for j in range(4):
            require(sum(P[j]) == 1 and sum(PT[j]) == 1,
                    "report normalization")
            tv = sum(abs(P[j][b]-PT[j][b]) for b in range(2))/2
            require(tv == abs(v[j]-vt[j])/2,"basis TV distance")
            distances.append(tv)
        require(max(distances) == Q(1,20),"attaining task")
        reject("bad report range",
               lambda: bounded_probabilities([2]),
               "report outside [-1,1]")
        XP,YP = Matrix([[0,1],[1,0]]),Matrix([[0,-I],[I,0]])
        B = Q(2)
        z,w = Q(3,5)+I*Q(4,5),-Q(1,5)+I*Q(2,5)
        def tau(a):
            return (eye(2)+sp.re(a)*XP/B+sp.im(a)*YP/B)/2
        D = tau(z)-tau(w)
        m2 = sp.expand_complex((z-w)*sp.conjugate(z-w))
        same(D*D,m2*eye(2)/(4*B**2),"qubit difference square")
        require(sp.trace(D) == 0,"qubit difference trace")
    
    
    def test_instrument():
        D,a,e = 4,2,2
        U = Q(1,2)*Matrix([[1,1,1,1],[1,-1,1,-1],
                           [1,1,-1,-1],[1,-1,-1,1]])
        same(U.H*U,eye(D),"clock calibration")
        Ds = [sp.kronecker_product(U[:,j].H,eye(a)) for j in range(D)]
        Ks = [sp.kronecker_product(unit(D,j),Ds[j]) for j in range(D)]
        total = zeros(D*a,D*a)
        for K in Ks:
            total += K.H*K
        same(total,eye(D*a),"Kraus completeness")
        psi = (sp.kronecker_product(U[:,0],unit(a,0),unit(e,0))
               + sp.kronecker_product(U[:,1],unit(a,1),unit(e,1))) \
              / sp.sqrt(2)
        rho = psi*psi.H
        out = channel([sp.kronecker_product(K,eye(e)) for K in Ks],rho)
        expected = sp.diag(Q(1,2),0,0,Q(1,2))
        same(trace_first(out,D,a*e),expected,"discard record")
        same(trace_first(rho,D,a*e),expected,"discard clock")
        same(trace_first(expected,a,e),eye(e)/2,"reference marginal")
        for j in range(D):
            Dj = sp.kronecker_product(Ds[j],eye(e))
            sigma = (Dj*rho*Dj.H).applyfunc(sp.simplify)
            target = zeros(a*e,a*e)
            if j in (0,1):
                v = unit(a*e,0 if j == 0 else 3)
                target = v*v.H/2
                same(sigma/(Q(1,2)),v*v.H,"positive conditional state")
            same(sigma,target,"actual reference branch")
            if sp.trace(sigma) == 0:
                same(sigma,zeros(a*e,a*e),"zero branch")
        ap = unit(a,0)
        vp = sp.kronecker_product((U[:,0]+U[:,1])/sp.sqrt(2),ap)
        vm = sp.kronecker_product((U[:,0]-U[:,1])/sp.sqrt(2),ap)
        same(channel(Ks,vp*vp.H),channel(Ks,vm*vm.H),
             "clock coherence loss")
    
    
    def test_grading_parity():
        verify_rank(zeros(21,10),0,[],[],eye(21))
        h,c,K,cb,cs = sp.symbols("h c K cb cs")
        for monomial in (K*c*h,cb*c*h,cs*c*c,h*h*h):
            require(sp.Poly(monomial,h,c,K,cb,cs).total_degree() == 3,
                    "formal cubic slot count")
        even,odd = Matrix([[2,0],[0,2]]),eye(2)
        require(rank_mod(even,2) == 0,"even blindness")
        require(rank_mod(odd,2) == 2,"odd occurrence rank")
        for x in (0,1):
            for y in (0,1):
                s = Matrix([x,y])
                require(all(int(z)%2 == 0 for z in even*s),
                        "bubble sign blindness")
                if x or y:
                    require(any(int(z)%2 for z in odd*s),
                            "odd control missed sign")
    
    
    def test_propagator():
        # Finite-component regression, not a loop/DRED implementation.
        pairs = [(a,b) for a in range(4) for b in range(a,4)]
        eta = sp.diag(1,-1,-1,-1)
        k = Matrix([3,1,1,1])
        kc = eta*k
        k2 = (k.T*eta*k)[0]
        require(k2 == 6,"test momentum")
        basis = []
        for a,b in pairs:
            E = zeros(4,4)
            E[a,b] = 1
            E[b,a] = 1
            basis.append(E)
        def coords(E):
            return Matrix([E[a,b] for a,b in pairs])
        A,F = zeros(10,10),zeros(4,10)
        for j,E in enumerate(basis):
            tr = sp.trace(eta*E)
            A[:,j] = coords(E-eta*tr/2)
            F[:,j] = E*k-kc*tr/2
        R = zeros(10,4)
        for j in range(4):
            v = unit(4,j)
            R[:,j] = coords((kc*v.T+v*kc.T)/2)
        same(A*A,eye(10),"trace reversal")
        same(F*R,k2*eye(4)/2,"F R identity")
        G,S4 = 2*A*R*F,R*F*A
        xi = sp.symbols("xi",nonzero=True)
        Kxi = k2*A+(1/xi-1)*G
        Pxi = A/k2+2*(xi-1)*S4/k2**2
        same(Kxi*Pxi,eye(10),"propagator left inverse")
        same(Pxi*Kxi,eye(10),"propagator right inverse")
        wrong = A/k2+(xi-1)*S4/k2**2
        reject("wrong longitudinal coefficient",
               lambda: same(Kxi*wrong,eye(10),"propagator"),
               "propagator: nonzero difference")
    
    
    def main():
        print("XVI-O1-ST-v5: FINITE REGRESSION, NOT A LOOP GATE")
        print("Python:",sys.version.replace("\n"," "))
        print("Platform:",platform.platform())
        print("SymPy:",sp.__version__)
        print("Source SHA256:",
              hashlib.sha256(Path(__file__).read_bytes()).hexdigest())
        print("The v4 D01 regression coefficient is retained unchanged.")
    
        reject("checker false",
               lambda: require(False,"deliberate rejection"),
               "deliberate rejection")
        reject("truthy integer",
               lambda: require(1,"non-boolean predicate"),
               "non-boolean predicate")
        reject("undecided predicate",
               lambda: require(sp.Symbol("unknown"),"undecided predicate"),
               "undecided predicate")
    
        tests = [
            ("rank / affine repair",test_rank_affine),
            ("fields / genuine modular rank",test_fields_modular),
            ("quotient / primitive enlargement",test_quotient_enlargement),
            ("free complex / polynomial family",test_free_complex_family),
            ("printed table arithmetic",test_table_arithmetic),
            ("permanent phase-integrity witness",test_phase_integrity),
            ("bounded report witnesses",test_report),
            ("complete instrument / reference",test_instrument),
            ("direct grading / sign parity",test_grading_parity),
            ("finite propagator regression",test_propagator),
        ]
        failures = []
        for name,test in tests:
            before = CHECKS
            try:
                test()
                require(CHECKS > before,"vacuous test")
            except Exception as exc:
                failures.append((name,type(exc).__name__,str(exc)))
                print("FAIL_REGRESSION:",name,type(exc).__name__,str(exc))
            else:
                print("PASS_REGRESSION_CONTRACT:",name)
    
        report = {
            "evaluated_predicates":CHECKS,
            "unexpected_failures":failures,
            "known_discrepancies":DISCREPANCIES,
            "phase_consistent":False,
            "scientific_release_accepted":False,
            "loop_evaluated":False,
            "formal_verification":False
        }
        print(json.dumps(report,indent=2,allow_nan=False))
        if failures:
            print("REGRESSION FAILED")
            return 1
        if DISCREPANCIES:
            print("REGRESSION CONTRACTS SATISFIED WITH KNOWN DISCREPANCY")
            print("DATA INTEGRITY NOT CLEARED; EXIT 2; NO LOOP RELEASE")
            return 2
        print("REGRESSION CONTRACTS SATISFIED WITHOUT KNOWN DISCREPANCY")
        print("Still not a loop release or formal verification.")
        return 0
    
    
    if __name__ == "__main__":
        sys.exit(main())
  • bibliographyReferencesProposed v5 exact regression with retained discrepancy · lines 3416–3760
    Open as its own page

    CheungEnter

    N. Cheung, “The Enter Calculus: A Linear Quantum Lambda Calculus with an Operational Characterization of Measurement,” Frontiers in Physics 14 (2026). DOI: 10.3389/fphy.2026.1954943. Publisher accepted-article record, accepted 28 September 2026; the consulted page describes the final formatted version as forthcoming. https://www.frontiersin.org/journals/physics/articles/10.3389/fphy.2026.1954943/abstract.

    CheungI

    N. Cheung, Manuscript I, version 2, .tex. Enter Calculus Companion; supplied version-qualified record. Finite measurement characterization within its stated class. https://enter.grok.me/browse/I.

    CheungPhilosophy

    N. Cheung, The Philosophy of Enter: Destructive Readout, Quantum Recovery, and the Refusal of Identification, -v2.tex, version 2. Introductory essay, not a theorem premise. https://enter.grok.me/enter.

    CheungIB

    N. Cheung, I-B: A Finite Enter Spacetime—Calibrated Destructive Time Readout on a Prescribed Conical Product, -B-v1.tex, version 1. Enter Calculus Companion. Complete clock instrument, calibration, reference-preserving transport, and prescribed-geometry boundaries. https://enter.grok.me/browse/I-B.

    CheungEn03

    N. Cheung, Observation Boundaries for Destructive Quantum Readout and External Geometry, 03-A.tex, version 1. Enter Calculus Companion. Four-part interface and :locality. https://enter.grok.me/browse/En03-A.

    CheungEn09

    N. Cheung, Realization of Relational Time by Destructive Enter on a Clock Register, 09-A.tex, version 1. Enter Calculus Companion; supplied record. https://enter.grok.me/browse/En09-A.

    DaviesLewis

    E. B. Davies and J. T. Lewis, “An operational approach to quantum probability,” Communications in Mathematical Physics 17 (1970), 239–260. DOI: 10.1007/BF01647093.

    Watrous

    J. Watrous, The Theory of Quantum Information, Cambridge University Press, 2018. DOI: 10.1017/9781316848142. https://cs.uwaterloo.ca/ watrous/TQI/.

    SuppliedV3

    XVI-O1-ST-v3.tex. User-supplied consolidated predecessor. Finite proofs, synthetic witnesses, and audit of the earlier affine and modular-rank verification claims. No authorship or execution is inferred from its filename.

    SuppliedBot

    XVI-O1-ST(bot).tex. User-supplied second-readout and gauge-lift predecessor. Source for the attributed loop calculations and printed coefficient tables. Its underlying loop scripts and complete logs are not supplied as inspected artifacts here.

    SuppliedV4

    XVI-O1-ST-v4.tex. User-supplied audit-hardened predecessor, including its tables, ledger, and embedded regression. The typeset D01 table and embedded regression are distinguished in the present integrity audit.

    V4Artifacts

    verify_xvi_o1_st_v4.py, v4_verification_output.txt, and DETAILED_SUMMARY_v4.txt. User-supplied v4 program, failed execution transcript, and explanatory summary. Reported environment: Python 3.10.21 and SymPy 1.14.0. The transcript is attributed, not independently replayed; the summary is not an independent execution record.

    CheungXAST

    N. Cheung, X-A-ST: Supported Classical Covariance of a Fixed-Ramp Relational Scalar, -A-ST.tex, version 1. Enter Calculus Companion; supplied host, completion, non-GH, and signature records. https://enter.grok.me/browse/X-A-ST.

    CheungXGST

    N. Cheung, X-G-ST: Free Causal BRST Compatibility and a Variational Upgrade Obstruction, -G-ST.tex, version 1. Enter Calculus Companion; supplied source descriptions, including :freeBRST and :obstruction. No successful fresh full-source retrieval is asserted. https://enter.grok.me/browse/X-G-ST.

    CheungXHST

    N. Cheung, X-H-ST: Relative Classical BV Structure and Complete Instruments for Supplied Residual Reports, -H-ST.tex, version 1. Enter Calculus Companion. Relevant locators: :BV, :nondescent, :instrument, :noacquisition. https://enter.grok.me/browse/X-H-ST.

    CheungXEnterST

    N. Cheung, X-Enter-ST: Readout Closure of an Obstructed Convolution Coefficient on a Prescribed Conical Host, -Enter-ST.tex, version 1. Enter Calculus Companion; supplied locality, route, and attachment descriptions. https://enter.grok.me/browse/X-Enter-ST.

    CheungXVIP

    N. Cheung, Manuscript XVI-P, -P.tex, release p23. Enter Calculus Companion; supplied record. DRED/ prescription, p14r/p22 domains, inventory, pole records, and Grassmann-orientation errata. https://enter.grok.me/browse/XVI-P.

    CheungXVIQ

    N. Cheung, Manuscript XVI-Q, -Q.tex, release Q11. Enter Calculus Companion; supplied excerpts and reading map. Q03 scope, Q05 rules, Q06–Q11 chronology, and conditional evanescent classification remain version-qualified. https://enter.grok.me/browse/XVI-Q.

    CheungXVIR

    N. Cheung, as attributed in the supplied predecessor, XVI-R review package, R07–R09. Supplied review-package descriptions, not independently inspected registered manuscripts. Reduced-system classification and resource reports retain their own presentations and evidence status.

    CheungII

    N. Cheung, Finite Contact-Span Certificates for a Two-Species Spin-Two Tree, Manuscript II, version 2. Enter Calculus Companion; supplied record. Original-minor, affine-family, and coverage discipline. https://enter.grok.me/browse/II.

    CheungIIB

    N. Cheung, II-B: Finite Contact-Span Certificates on a Declared Conical Enter Spacetime—A Grade S Operational Adaptation, version 1. Enter Calculus Companion; supplied record. Presentation template only; its numerical certificate is not imported. https://enter.grok.me/browse/II-B.

    CheungOai282

    N. Cheung, Oai282-A: Finite Local-Ward Certificates and Scale–Conformal Separation, version 1. Enter Calculus Companion; supplied excerpts, including :ward and the finite-release description. Not a gravitational response map or verification of an external catalogue family. https://enter.grok.me/browse/Oai282-A.

    CheungOai283

    Oai283-A: Conditional Operational Certification of Constant-Error Oracle Unitary Synthesis, version 1. Enter Calculus Companion, under its supplied N. Cheung manuscript attribution; the rendered record notes a conflicting authorship declaration, not resolved here. Resource/error and conditional-assembly comparison only. https://enter.grok.me/browse/Oai283-A.

    Stockinger

    D. Stöckinger, “Regularization by dimensional reduction: consistency, quantum action principle, and supersymmetry,” Journal of High Energy Physics 03 (2005), 076. DOI: 10.1088/1126-6708/2005/03/076. https://arxiv.org/abs/hep-ph/0503129.

    Frob2018

    M. B. Fröb, “Gauge-invariant quantum gravitational corrections to correlation functions,” Classical and Quantum Gravity 35 (2018), 055006. DOI: 10.1088/1361-6382/aaa74c. https://arxiv.org/abs/1710.00839.

    ManteuffelSchabinger

    A. von Manteuffel and R. M. Schabinger, “A novel approach to integration by parts reduction,” Physics Letters B 744 (2015), 101–104. DOI: 10.1016/j.physletb.2015.03.029. https://arxiv.org/abs/1406.4513.

    Peraro

    T. Peraro, “Scattering amplitudes over finite fields and multivariate functional reconstruction,” Journal of High Energy Physics 12 (2016), 030. DOI: 10.1007/JHEP12(2016)030. https://arxiv.org/abs/1608.01902.

    Zimmermann

    W. Zimmermann, “Convergence of Bogoliubov's method of renormalization in momentum space,” Communications in Mathematical Physics 15 (1969), 208–234. DOI: 10.1007/BF01645676.

    SmirnovChetyrkin

    V. A. Smirnov and K. G. Chetyrkin, “ operation in the minimal subtraction scheme,” Theoretical and Mathematical Physics 63 (1985), 462–469. DOI: 10.1007/BF01017902.

    DuganGrinstein

    M. J. Dugan and B. Grinstein, “On the vanishing of evanescent operators,” Physics Letters B 256 (1991), 239–244. DOI: 10.1016/0370-2693(91)90680-O.

    CheungXVIN

    N. Cheung, Manuscript XVI-N, -N.tex, revision r12. Enter Calculus Companion; supplied excerpts. Conditional massless special-family obstruction, unresolved universal completion, and retained Route B boundary. https://enter.grok.me/browse/XVI-N.

    CheungXVIO

    N. Cheung, Manuscript XVI-O, -O.tex, revision 70-sync. Enter Calculus Companion; supplied excerpts. Distinct kernel prescription, insertion freeze, and standing O.1 boundary. https://enter.grok.me/browse/XVI-O.

    CheungXComparisons

    N. Cheung, X-A-conv-ST, X-D-ST, and X-F-ST, supplied version-qualified records. Fixed-convolution obstruction, sharp-limit versus metric-admission distinction, and three equation-level trees counted once. Grouped documentary comparison only. https://enter.grok.me/browse.

    CheungXIVH

    N. Cheung, Landmark XIV-H: Internal Kernel Relations on the Operator Route, -H.tex, version 1. Supplied excerpts, including :H2. Historical amplitude stop, not a finite-matrix premise. https://enter.grok.me/browse/XIV-H.

    CheungXIVI

    N. Cheung, Landmark XIV-I, -I.tex, version 1. Supplied excerpts, including :I2, :I3, and :release. Internal amplitude construction does not supply the full joint characteristic map. https://enter.grok.me/browse/XIV-I.

    CheungXIVJ

    N. Cheung, Landmark XIV-J, -J.tex, version 1. Supplied excerpts, including :descent, :null, :reference, :J2, and :noadmission. Supported reference and reconstruction descent are not complete characteristic composition or quantum admission. https://enter.grok.me/browse/XIV-J.

    CheungXVB

    N. Cheung, Manuscript XV-B, -B.tex, version 2. Supplied technical-interface descriptions. Relative lifting and normal-jet interfaces do not open the inherited downstream quantum-admission exit. https://enter.grok.me/browse/XV-B.

    SymPyMatrices

    SymPy Development Team, Matrices: linear algebra, official SymPy documentation. Matrix extraction, rank, nullspaces, and parametric _jordan_solve. https://docs.sympy.org/latest/modules/matrices/matrices.html. Documentation consultation is not execution of the v5 listing.

    PythonAssert

    Python Software Foundation, The Python Language Reference: Simple statements, section “The assert statement.” https://docs.python.org/3/reference/simple_stmts.html. Documents assertion behavior under optimized execution.