All manuscripts

Manuscript Em03-H@8 · Em03-H-v8.tex · 91e9e3bd

Em03-H-v8 Exact Fermionic Extraction, Quench Diagnostics, and Stored-Packet Excitation-Channel Recovery Complete-channel proofs, reported computational results, and reproducible certification

Export Em03-H-v8.tex

Specifies version 8 of one fixed quartic Majorana Hamiltonian coupled to a declared nongravitating fermionic bath, together with a declared continuum excitation-code reduction. The coefficient array, parity-even spectral code, preparation, control path, and accessible bath are fixed before decoding. No disorder average is substituted for the channel of that Hamiltonian. Target A stores under the quartic Hamiltonian, replaces it by the number operator, and transfers by resonant hopping. Target B retains the boundary interaction during transfer. A result for Target B does not discharge Target A. The finite channel interface, signed extraction, and uniform microscopic recovery are proved. Ideal full transfer is exact. The minimal jointly invariant reached space has dimension at most forty for the frozen eight-mode instance P8. Odd boundary operators vanish on the initial even code, and a nonzero boundary subspace invariant under the full CAR family is the full Fock space. The continuum reduction is declared, not derived with a controlled full-gravity remainder. Its specified complete decoder has exact half-diamond error one minus eta. Supplied P8-new records report a code energy, a leakage, and two departures. A later summary reports candidate agreement and a suggested specified-decoder error near 0.38687, above one quarter. Those reports are not validated. Independent execution is not asserted. The new v8 programs are unexecuted. The reported transmission enclosure is the unit interval and is not a rigorous numerical exclusion. P8 rank certification and the validated quarter-error verdict remain open. No P8 gravitational dictionary is constructed. Matrix-unit and Choi comparisons are not a constructed gravitational dictionary. Entropy is not a decoder certificate and not a Page curve. Quench work is not black-hole mass loss. The controlled extractor is not passive Hawking evaporation. This is not a pointlike detector, not a coherent local receiver, not interior information escape, not an island, not a smooth interior, not an evaporation endpoint, and not quantum-gravitational evaporation. Em03-G's two-pulse scalar source does not supply this fermionic bath. Em03-F's measure-and-prepare channel does not supply the extractor. H2, I3, and J2 remain unresolved. It does not close O.1, discharge the XVI-N insertion, or admit the XIV-XV characteristic coefficient. XVI-P is registered and is not a premise. XV-B is not opened. No quantum coefficient is admitted. No compilation is asserted.

Front matter

  • abstractAbstractFront matter · lines 160–204
    Open as its own page

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

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

    The supplied P8-new execution materials report , , and departures and at times and . The new results summary additionally reports agreement between Volterra and spectral/RK candidate calculations near , with .

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

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

Scope, evidence, and the version-8 revision

  • sectionScope, evidence, and the version-8 revisionScope, evidence, and the version-8 revision · lines 210–232
    Open as its own page

    The mathematical and physical tasks are separate:

    The first two chains are constructed below. The third is conditional.

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

  • definitionDefinition: Evidence levelsScope, evidence, and the version-8 revision › Evidence classification · lines 235–249
    Open as its own page
    : analytical.

    A consequence of a stated mathematical specification and proof.

    : reported.

    A numerical result or execution claim attributed to supplied records, without independent authentication of its underlying binary artifacts.

    : inspected.

    An artifact reloaded and checked in a separately recorded invocation.

    : validated.

    A numerical conclusion with rigorous arithmetic, selection, approximation, and applicable model-error allowances.

    Physical implementation is a further evidential task.

  • sectionEvidence classificationScope, evidence, and the version-8 revision › Evidence classification · lines 249–279
    Open as its own page

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

    {}1.12

    ObjectStatus in v8
    Microscopic extraction and diagnostic identities
    P8-new execution and scalar output; manifest and logs supplied
    Prior P8 inspection discrepancy near Reported only in the new summary
    Complete P8 binary archive and inspection reportNot supplied here
    Exact P8 occupation ranks and reached dimensionNot numerically certified
    Candidate Volterra and spectral/RK outputsNewly reported, rounded summaries
    Patched v7 rational checker invocationReported; exact output not supplied
    Reported transmission enclosure from that invocation, inconclusive
    New v8 softwarePrinted, statically revised, unexecuted
    Validated candidate quarter-error verdictUnresolved
    P8 gravitational dictionaryNot constructed
    Compilation and formal proof checkingNot performed here
  • sectionWhat changes and what does notScope, evidence, and the version-8 revision › What changes and what does not · lines 280–306
    Open as its own page

    Version 8:

    1. incorporates the newly reported candidate values and coarse defect-check result;

    2. distinguishes exploratory failure of the specified decoder from a validated exclusion and from optimal-recovery impossibility;

    3. corrects the interval/complex multiplication dispatch defect in the printed v7 checker;

    4. replaces repeated fixed-name checkpoint writes with a journal and unique temporary snapshot files;

    5. retains exact JSON/NPZ node-link checks and complete saved spectral/RK states;

    6. states an explicit numerical accuracy target for the next candidate certificate.

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

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

  • sectionMetrics and standard factsScope, evidence, and the version-8 revision › Metrics and standard facts · lines 307–359
    Open as its own page

    The message is , reference , boundary , and bath . Accessible bath modes form . A non-message factor may have an inaccessible purifying register .

    Unsubscripted norms are operator norms. Subscripts and denote trace and Frobenius norms. Set

    All channel distances retain arbitrary references. For an isometry , , and . Matrix units are .

    For a qubit channel,

    Let . Define squared target-overlap fidelities

    Root fidelity satisfies . Its maximal purification overlap equals , with sufficiently enlarged purifying spaces. The diamond norm of a difference of finite channels can be optimized on referenced density operators.

    These conventions and facts are standard Watrous,FuchsVandeGraaf. Recovery and information–disturbance frameworks are established BenyOreshkov,KSW. A channel error at most against the identity implies both target overlaps are at least , by the pure-target projector test.

Frozen microscopic model and complete preparation

  • sectionOccupation representationFrozen microscopic model and complete preparation › Occupation representation · lines 364–380
    Open as its own page

    Use , , with

    The annihilation rule is

    and creation uses the corresponding preceding-occupation sign.

  • lemmaLemma: CAR and number conventionFrozen microscopic model and complete preparation › Occupation representation · Em03-H@8#lem:car · proof attached · lines 381–405
    Open as its own page

    These operators satisfy

    For

    one has and

    Proof. For equal labels the two orders give complementary occupation projections. For unequal labels, exchanging actions reverses the preceding-occupation sign. Expansion gives the Majorana relations. Finally, .

  • sectionOccupation representationFrozen microscopic model and complete preparation › Occupation representation · lines 405–425
    Open as its own page

    Fix real coefficients and set

    where is the minimum over both parity sectors. Quartic terms are Hermitian because reversal requires six exchanges. With ,

    Number need not commute with the quartic Hamiltonian.

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

  • sectionBath and signed accessFrozen microscopic model and complete preparation › Bath and signed access · Em03-H@8#eq:regroup · lines 426–451
    Open as its own page

    Use an independent initially vacuum bath , with

    The one-particle order is . Odd operators in the two blocks anticommute. Pair hopping terms commute and .

    The signed regrouping places accessible modes first, preserving each declared internal order. For whole-bath access,

  • definitionDefinition: Distinct dynamical targetsFrozen microscopic model and complete preparation › Bath and signed access · lines 452–457
    Open as its own page

    Target A stores under , replaces it by , and extracts through resonant hopping. Target B retains an interacting boundary generator during transfer. A result for one target does not implement the other.

  • sectionBath and signed accessFrozen microscopic model and complete preparation › Bath and signed access · lines 457–470
    Open as its own page

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

    A general finite path is

    with bounded piecewise continuous real controls, fixed independently of the unknown logical input.

  • sectionCode and channelsFrozen microscopic model and complete preparation › Code and channels · lines 471–487
    Open as its own page

    Choose orthonormal even eigenvectors , , , with fixed spectral, phase, and degeneracy conventions. Set

    The full code algebra is . The message algebra is .

    For a message channel prepare , with independent . Uniform subsystem recovery instead allows arbitrary .

  • theoremTheorem: Complete finite channel interfaceFrozen microscopic model and complete preparation › Code and channels · Em03-H@8#thm:channels · proof attached · lines 488–518
    Open as its own page

    The finite path has a unique unitary propagator. For

    the accessible channel and complete complement are the two partial traces of .

    If , define

    With ,

    These formulas determine every referenced input.

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

  • sectionCode and channelsFrozen microscopic model and complete preparation › Code and channels · lines 518–525
    Open as its own page

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

P8 specification and exact integer assembly

  • assumptionModel specification: Frozen P8P8 specification and exact integer assembly · lines 530–545
    Open as its own page

    Set , . Enumerate the increasing quartets of lexicographically and define

    Order exact even-sector eigenspaces by energy. Within each exact degenerate eigenspace, project lexicographic occupation words and apply Gram–Schmidt, discarding zero projections. Give each vector a first nonzero occupation coefficient that is positive real. Select the first two vectors.

    Retain the global energy shift over both parities, spectral window , , bath vacuum, and signed whole-bath access.

  • sectionP8 specification and exact integer assemblyP8 specification and exact integer assembly · Em03-H@8#eq:pulse, Em03-H@8#eq:integerH · lines 545–578
    Open as its own page

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

    Define

    The pulse is smooth, nonnegative, and has area . At , its cumulative areas are , by support and reflection symmetry.

    With , the matrices are signed Gaussian-integer permutations. Hence

    The coefficient denominator is not the Hamiltonian denominator.

  • propositionProposition: Exact assembly invariantsP8 specification and exact integer assembly · Em03-H@8#prop:assembly · proof attached · lines 579–603
    Open as its own page

    The exact matrices satisfy

    zero even–odd blocks, and

    Equivalently,

    Proof. Hermiticity and parity give the matrix symmetries and blocks. Quartic Clifford monomials are trace orthogonal and square to . The boundary dimension is . Substitute the rational denominators to obtain the integer identity.

  • sectionP8 specification and exact integer assemblyP8 specification and exact integer assembly · lines 603–623
    Open as its own page

    The entrywise assembly bound is

    Assembly and trace sums fit signed 64-bit integers. The complete square sum is evaluated with arbitrary-size Python integers.

    The v8 inspector constructs the same Majoranas independently by

    Their monomial entries are exactly representable Gaussian units. This is a distinct construction from the historical occupation-action assembly, not a second call to its assembly routine.

Quench leakage, best compression, and departure

  • sectionQuench leakage, best compression, and departureQuench leakage, best compression, and departure · lines 625–642
    Open as its own page

    Storage gives , with unchanged range. The actual quench changes the generator by

    Define

  • theoremTheorem: Leakage and best compressionQuench leakage, best compression, and departure · Em03-H@8#thm:leakage · proof attached · lines 643–666
    Open as its own page

    Furthermore,

    attained at .

    Proof. Insert between number operators. The retained term is , and the remainder is the Gram matrix of . Projection onto gives the compression lower bound; choosing removes the retained component. Rayleigh optimization gives the scalar quantities.

  • sectionQuench leakage, best compression, and departureQuench leakage, best compression, and departure · lines 666–672
    Open as its own page

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

    For , set .

  • theoremTheorem: Departure and short-time estimatesQuench leakage, best compression, and departure · Em03-H@8#thm:departure · proof attached · lines 673–704
    Open as its own page

    For ,

    For general , replace by .

    Proof. Retained probability is ; optimize its complement. Center at , with norm . The scalar phase does not affect departure, and the integral Taylor remainder gives

    The off-code amplitude is , with the displayed remainder bound. Triangle inequalities give the first bounds; the squared-norm difference is at most .

  • propositionProposition: Uniform departure interpolationQuench leakage, best compression, and departure · Em03-H@8#prop:departuregrid · proof attached · lines 706–720
    Open as its own page

    A validated grid of covering radius requires an additional allowance for a uniform-time claim.

    Proof. For , , , and . Apply the Rayleigh principle.

  • lemmaLemma: Odd compression and reached transitionsQuench leakage, best compression, and departure · proof attached · lines 722–738
    Open as its own page

    For every , . Nevertheless even joint hopping can act nontrivially. Also,

    A nonzero boundary subspace invariant under all is the full Fock space.

    Proof. Parity makes odd compression its negative. Joint hopping changes both parities together. Insert for the composite identity. An occupation projector selects a nonzero word in an invariant vector; annihilations give vacuum and creations give every word.

  • sectionQuench leakage, best compression, and departureQuench leakage, best compression, and departure · lines 738–744
    Open as its own page

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

Exact signed extraction and its reached space

  • sectionExact signed extraction and its reached spaceExact signed extraction and its reached space · lines 746–761
    Open as its own page

    Target A extracts under

    Since ,

    For disjoint , define .

  • theoremTheorem: Signed branches and complete channelsExact signed extraction and its reached space · Em03-H@8#thm:branches · proof attached · lines 762–801
    Open as its own page

    Writing , , boundary-first evolution is

    If is the bath coefficient, signed bath-first maps are

    Consequently,

    Zero powers are interpreted as one at endpoints.

    Proof. The active creator transformation is

    Expand the increasing creator product. Transferred creators cross retained ones, giving the inversion sign. Equation (eq:regroup) supplies the additional access sign. Partial traces give the channels, and unitarity gives completeness.

  • sectionExact signed extraction and its reached spaceExact signed extraction and its reached space · lines 801–817
    Open as its own page

    Set

    The full-code channels used below are

    For even inputs, an additional branch phase cancels in the accessible channel. It must not be omitted on general parity-coherent inputs.

  • sectionMinimal jointly invariant spaceExact signed extraction and its reached space › Minimal jointly invariant space · lines 818–832
    Open as its own page

    Let project onto boundary occupation ,

    For , define

  • lemmaLemma: Collective chainExact signed extraction and its reached space › Minimal jointly invariant space · proof attached · lines 833–853
    Open as its own page

    Each is an isometry. Distinct images are orthogonal, and

    Absent endpoint terms are zero.

    Proof. Each partition has a unique union; distinct partition words are orthogonal, and there are terms per word. Hopping moves one occupied pair. Counting moves and comparing the binomial normalizations gives the coefficients with the CAR signs already included in .

  • theoremTheorem: Exact minimal reached dimensionExact signed extraction and its reached space › Minimal jointly invariant space · Em03-H@8#thm:dimension · proof attached · lines 855–886
    Open as its own page

    The smallest subspace containing the prepared stored code and invariant under is

    Thus

    Restricted propagation is exact on the code. For P8, .

    Proof. Number-sector projections are polynomials in on this finite space. Any invariant subspace containing the initial code contains . The recurrence successively generates every , and proves invariance of the displayed sum. Orthogonality proves the dimension formula.

    For P8 the endpoint ranks are at most one and interior ranks at most two, giving . Also . If , a further rank has weight at least three. If , the total weight is at least six. Hence the unconditional lower bound four.

  • sectionMinimal jointly invariant spaceExact signed extraction and its reached space › Minimal jointly invariant space · lines 886–891
    Open as its own page

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

  • propositionProposition: Joint spectral GramExact signed extraction and its reached space › Minimal jointly invariant space · proof attached · lines 892–908
    Open as its own page

    For the joint spectral projection , where ,

    Every projected-code rank is .

    Proof. For a fixed occupied-pair set, each exchange has eigenvalues ; the all-boundary state has overlap squared with each. The sum has the binomial law. Different pair sets are orthogonal and invariant. Every allowed binomial weight is positive.

  • sectionComplete decoder and uniform recoveryExact signed extraction and its reached space › Complete decoder and uniform recovery · lines 910–927
    Open as its own page

    Let identify occupation bases and set

    Retained Kraus operators are . For an off-code basis , add , . Their effects sum to , so the decoder is CPTP on every bath input.

  • theoremTheorem: Uniform microscopic recoveryExact signed extraction and its reached space › Complete decoder and uniform recovery · Em03-H@8#thm:microrecovery · proof attached · lines 928–966
    Open as its own page

    For and ,

    Arbitrary correlated inputs are allowed.

    At full transfer, with ,

    Recovery is exact. For independent gauge preparation, the complete message complement is replacement by .

    Proof. The corrected no-loss branch is . For a purified encoded input, overlap with ideal transfer and boundary vacuum is . Since , . Pure-state distance is at most . Decode and contract.

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

Referenced comparison and complementary recovery bounds

  • sectionReferenced comparison and complementary recovery boundsReferenced comparison and complementary recovery bounds · lines 970–978
    Open as its own page

    For input dimension , define normalized Choi states

  • lemmaLemma: Choi and matrix-unit conversionsReferenced comparison and complementary recovery bounds · Em03-H@8#lem:choi · proof attached · lines 979–999
    Open as its own page

    For channels with common input dimension ,

    If all matrix-unit trace-norm differences are at most , then .

    Proof. A pure referenced input is , up to a reference isometry, with . Trace-norm multiplication proves the Choi bound. Alternatively write its vector as , with . The output difference norm is at most . Divide by two and use convexity.

  • theoremTheorem: Complementary upper and lower certificatesReferenced comparison and complementary recovery bounds · Em03-H@8#thm:complementary · proof attached · lines 1001–1058
    Open as its own page

    For a finite qubit channel with complete complement , put

    A polar-isometry decoder satisfies

    Every deterministic decoder satisfies

    Consequently,

    Proof. The Bell-input dilation purifies . A Bell pair times a purification of purifies the product center. Enlarging the decoding ancilla, the polar purification isometry attains root overlap . The decoded Bell distance is at most . Lemma lem:choi gives the factor two. The maximally mixed constant decoder has error , by the four-Pauli decomposition and the Bell test.

    For any decoder, dilate its output and project its pure Bell-input state onto the target Bell vector. Normalizing the environmental projection gives a Bell-product purification at distance , when . After tracing decoder systems, is within that distance of . Since

    trace duality gives . The left side is the complementary pair distance. The Bell-projector test gives error at least ; worst-case overlap cannot exceed Bell overlap. The case is immediate.

  • sectionReferenced comparison and complementary recovery boundsReferenced comparison and complementary recovery bounds · lines 1058–1063
    Open as its own page

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

Restricted continuum experiment

  • sectionDeclaration and physical boundaryRestricted continuum experiment › Declaration and physical boundary · lines 1068–1138
    Open as its own page

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

    The motivating disk parameters are

    A motivating action is

    with , . Eight complex massless Dirac species have action

    A disk-extending spin structure and homogeneous reflecting boundary condition may be declared using

    with , including variations. The boundary variation vanishes because .

    The exterior metric

    motivates the reflected positive-frequency one-body model. The exact analysis begins with the directly declared multiplication operator

    and normal-ordered matter Hamiltonian

    Declare

    The spectral normalization is part of the declaration. Backreaction, fluctuating dressing, and loop corrections are neither included nor bounded. The static Fock vacuum is not assumed to be a thermal or horizon-regular Hartle–Hawking state.

  • sectionPacket, excitation code, and controlsRestricted continuum experiment › Packet, excitation code, and controls · Em03-H@8#eq:primary · lines 1139–1190
    Open as its own page

    Set

    Creation is linear and annihilation antilinear in its packet. These are normalized orthogonal even excitation states, not identified black-hole microstates. Packet operators are bounded CAR operators; they are not unsmeared coincident fields.

    Direct integration gives

    The code-state storage-energy means are , with variances . They are not energy eigenvectors.

    Extraction retains storage and adds

    The primary experiment remains

    with pulse (eq:pulse). Other six species and bath modes remain vacuum.

    Storage changes the occupied packet to . Extraction still couples to the fixed . The common Schwarzian state evolves to . It remains factorized and independent of the logical input, so it is a harmless spectator for the reduced channel, while retained as a pure complementary factor.

  • sectionExact one-species evolutionRestricted continuum experiment › Exact one-species evolution · lines 1191–1203
    Open as its own page

    On , set

  • propositionProposition: Well-posed evolutionRestricted continuum experiment › Exact one-species evolution · proof attached · lines 1204–1216
    Open as its own page

    For bounded piecewise continuous real , has a unique interaction-picture unitary propagator.

    Proof. Relative to , the perturbation is bounded, self-adjoint, and finite rank. Strong continuity on the finitely many packet vectors gives norm continuity of the corresponding rank-one interaction-picture operators on each control segment. The norm-convergent Dyson series gives existence and uniqueness; self-adjointness gives unitarity.

  • theoremTheorem: Stored-packet Volterra characterizationRestricted continuum experiment › Exact one-species evolution · Em03-H@8#thm:volterra · proof attached · lines 1221–1249
    Open as its own page

    The exact evolution is equivalent to the unique continuous solution

    The matter packet is

    For the primary experiment, , .

    Proof. Variation of constants gives the packet formula. Contracting with uses . Variation of constants for gives the second equation. Conversely, the packet formula reconstructs the mild Schrödinger solution; uniqueness proves equivalence.

  • sectionExact one-species evolutionRestricted continuum experiment › Exact one-species evolution · lines 1249–1265
    Open as its own page

    Let , . Unitarity gives . Zero coupling gives ; if , .

    For the primary Volterra operator, the componentwise maximum-norm majorant is . Thus

    Ordered integration proves a uniformly convergent Neumann series, with truncation after bounded by .

Candidate dilation, decoder, and limitations

  • sectionCandidate dilation, decoder, and limitationsCandidate dilation, decoder, and limitations · lines 1267–1272
    Open as its own page

    Write . For , let be the normalized residual packet in species .

  • theoremTheorem: Complete signed candidate dilationCandidate dilation, decoder, and limitations · Em03-H@8#thm:dilation · proof attached · lines 1273–1298
    Open as its own page

    In bath-first order,

    Unused modes are vacuum, and the evolved Schwarzian factor is common and pure.

    Proof. Expand . CAR and bath-first regrouping give opposite mixed signs. The occupied column has norm squared and is orthogonal to the vacuum column.

  • sectionCandidate dilation, decoder, and limitationsCandidate dilation, decoder, and limitations · lines 1298–1328
    Open as its own page

    The accessible units are

    The residual-mode complementary units are

    Embedding and tensoring fixed vacuum and spectator factors give the full channels. The residual modes are not discarded information.

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

  • sectionSpecified complete decoderCandidate dilation, decoder, and limitations › Specified complete decoder · lines 1329–1345
    Open as its own page

    For , set ; at , fix any phase. Let embed logical as bath words , with all unused modes vacuum, and . Define

    The retained/off-code Kraus construction makes this map CPTP on every eight-mode bath input.

  • theoremTheorem: Exact specified-decoder performanceCandidate dilation, decoder, and limitations › Specified complete decoder · Em03-H@8#thm:specified · proof attached · lines 1346–1367
    Open as its own page

    Its Bell fidelity is , and its worst-case target overlap is . No optimality is asserted.

    Proof. Phase correction makes the off-diagonal coefficient . The odd words are replaced by . The occupied input has decoded probability ; vacuum is unchanged. Identity and replacement by have half-diamond distance one, witnessed by . The replacement Bell overlap is . Every target overlap is at least , attained by .

  • propositionProposition: Complementary diagnosticsCandidate dilation, decoder, and limitations › Specified complete decoder · Em03-H@8#prop:candidatebounds · proof attached · lines 1369–1397
    Open as its own page

    Proof. The complementary -pair distance is , while the distances are . With , the nontrivial Choi-difference block is

    Its trace norm is . Other diagonal absolute values sum to . Divide by two and apply Theorems thm:complementary and thm:specified.

  • theoremTheorem: No exact finite-time transferCandidate dilation, decoder, and limitations › Specified complete decoder · Em03-H@8#thm:noexact · proof attached · lines 1399–1418
    Open as its own page

    For finite , , and bounded piecewise continuous real controls in the stated one-species model, .

    Proof. If , unitarity gives . Since , the packet formula implies

    for almost every positive . Both sides extend to entire functions, so equality holds everywhere. At , the left side is . For it contradicts boundedness of the right side. For , dominated convergence makes the right side tend to zero while the left side is one.

  • sectionSpecified complete decoderCandidate dilation, decoder, and limitations › Specified complete decoder · lines 1418–1424
    Open as its own page

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

Reported P8 and candidate computations

  • sectionHistorical P8-new recordReported P8 and candidate computations › Historical P8-new record · lines 1429–1523
    Open as its own page

    The supplied manifest reports

    \texttt{\detokenize{mode=p8}},\quad
    \texttt{\detokenize{status=COMPLETED_NOT_VALIDATED}},\quad
    \texttt{\detokenize{validated=false}}.

    Its invocation is

    em03h_tools.py p8 –out P8-new \ –baseline /workspace/attachments/Em03-H-v1_6.tex

    Reported UTC timestamps are 2026-10-09T07:06:30.089268+00:00 and 2026-10-09T07:06:39.561565+00:00. The separately reported monotonic interval is seconds. These timing fields have different scopes in the printed runner.

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

    Standard error contains only the supplied warning

    UserWarning: Install `pyyaml` for better output

    The warning concerns configuration formatting NumPyConfig. It is not a reported numerical failure.

    {}1.12

    P8 quantityReported value, evidence
    P8 quantityReported value, evidence
    Global unshifted minimum
    Even minimum
    Odd minimum
    Even minus odd minimum
    Selected unshifted even energies
    Selected shifted energies
    First-to-second even gap
    Second-to-third even gap
    Exploratory phase-surrogate anchors
    Exact computed dimension

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

    OccupationReported singular valuesExact rank
    0Unresolved
    2Unresolved
    4Unresolved
    6Unresolved
    8Unresolved

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

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

  • sectionNew candidate resultsReported P8 and candidate computations › New candidate results · lines 1524–1558
    Open as its own page

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

    {}1.12

    Candidate quantityReported value, evidence
    Pulse normalization
    Volterra mesh
    Volterra mesh
    Reported finest spectral/RK endpoint
    Reported finite spectral-system normApproximately one
    Reported spectral/finest-Volterra differenceApproximately
    Specified-decoder exploratory error

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

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

  • sectionReported coarse defect-check resultReported P8 and candidate computations › Reported coarse defect-check result · lines 1559–1583
    Open as its own page

    The summary reports a patched checker invocation with:

    status _COMPUTED_INSPECTION_REQUIRED, uniform defect upper bound about , transmission enclosure , and verdict .

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

    For scale only, the analytical amplification is

    so multiplying the rounded reported defect by this factor gives an amplitude allowance around . This illustrative calculation explains why the reported enclosure is uninformative; it is not a substitute for the original certificate.

  • sectionPermitted conclusionReported P8 and candidate computations › Permitted conclusion · lines 1584–1595
    Open as its own page

    The reported endpoint suggests that the specified decoder does not meet one-quarter error. The validated numerical verdict remains unresolved because the only reported certified-style transmission interval is .

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

Spectral and diagnostic certification

  • sectionExact inputs and routine guaranteesSpectral and diagnostic certification › Exact inputs and routine guarantees · lines 1600–1637
    Open as its own page

    Use the exact integer matrices and denominator in (eq:integerH), not a decimal reconstruction.

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

    The supplied FLINT documentation distinguishes FLINTMat:

    1. approximate QR eigenvalues, with heuristic convergence only;

    2. global spectrum coverage, without a one-to-one ball assignment;

    3. successful all-simple isolation;

    4. successful exhaustive counted clusters;

    5. local eigenpair or invariant-subspace enclosures.

    A counted cluster does not prove exact degeneracy. A local “at least ” statement is not an exhaustive selection certificate. Outputs are not automatically energy-sorted.

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

    Approximate routines ignore radii; zero-radius numerical outputs are not exact-solution certificates. Rigorous routines must establish certificate premises. The documented infinity-norm bound is a row-sum bound, whereas

    or suffices for the operator norm here.

  • theoremTheorem: Full-basis Hermitian certificateSpectral and diagnostic certification › Exhaustive indexed eigenvalue intervals · Em03-H@8#thm:spectrum · proof attached · lines 1640–1673
    Open as its own page

    Let , , with sorted real , and . Suppose validated bounds establish

    Set

    Then, counted with multiplicity,

    No indexed level is omitted.

    Proof. The polar normalization is unitary. Singular values give , , hence

    The Hermitian min–max principle compares each ordered eigenvalue with that of , namely .

  • sectionExhaustive indexed eigenvalue intervalsSpectral and diagnostic certification › Exhaustive indexed eigenvalue intervals · lines 1673–1686
    Open as its own page

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

    For parity-minimum intervals , ,

    Strict separation establishes the winning parity; overlap does not establish a tie.

  • lemmaLemma: Isolated residualSpectral and diagnostic certification › Eigenvectors, phases, and ranks · proof attached · lines 1689–1705
    Open as its own page

    If is simple, every other eigenvalue is at least from , and normalized has residual , then

    after optimal phase alignment.

    Proof. Expand in the eigenbasis. Off-target squared norm is at most . For off-target norm , aligned distance squared is .

  • sectionEigenvectors, phases, and ranksSpectral and diagnostic certification › Eigenvectors, phases, and ranks · lines 1705–1756
    Open as its own page

    If is real and , the first exact coefficient is nonzero. Rotating to the frozen positive-real phase gives

    The first coefficient lies in the radius- disk centered at . A later anchor also requires exact zeros for preceding coefficients.

    For isometries , with ,

    Insert mixed compressions to prove these estimates. Arithmetic errors are additional. Normalize eigenvectors rigorously; FLINT's left normalization is not Euclidean orthonormality of .

    For a Hermitian matrix

    Directed interval evaluation yields diagnostic eigenvalue bounds. If , then

    Interior occupation rank two follows from a positive validated lower bound for . Endpoint rank one follows from positive validated trace and structural rank at most one. If rank intervals remain,

    Positive floating-point singular values alone do not certify ranks of the exact frozen code.

Continuum defect certification and the next accuracy target

  • sectionUniform defect conversionContinuum defect certification and the next accuracy target › Uniform defect conversion · lines 1761–1774
    Open as its own page

    For continuous approximations define defects against the true pulse:

  • theoremTheorem: Defect-to-continuum boundContinuum defect certification and the next accuracy target › Uniform defect conversion · Em03-H@8#thm:defect · proof attached · lines 1775–1793
    Open as its own page

    If , then

    In particular, .

    Proof. Subtract the Volterra equations. The maximum component error satisfies

    Iterate the integral inequality. The exact nonnegative pulse has area .

  • sectionUniform defect conversionContinuum defect certification and the next accuracy target › Uniform defect conversion · lines 1793–1798
    Open as its own page

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

  • theoremTheorem: Whole-cell triangular enclosureContinuum defect certification and the next accuracy target › Uniform defect conversion · Em03-H@8#thm:cell · proof attached · lines 1799–1827
    Open as its own page

    Partition into cells . For , split each defect integral into earlier full cells and .

    On an earlier cell , enclose its integrand using

    then multiply by . On the last partial interval use and multiply the integrand rectangle by . The resulting defect rectangles cover all .

    A rectangle has modulus at most

    Taking the maximum over cells produces a uniform .

    Proof. The integral average of a function in a convex rectangle remains in that rectangle. The partial interval has length in . Interval arithmetic preserves inclusion, and .

  • sectionPulse and elementary-function enclosuresContinuum defect certification and the next accuracy target › Pulse and elementary-function enclosures · lines 1829–1861
    Open as its own page

    Let . Its extrema on a support cell are found at endpoints and, if present, . Since the bump is increasing in , these extrema give a pulse rectangle. Boundary-crossing cells include zero.

    Summing lengths times pulse intervals encloses . Analytically,

    The lower bound uses , and the upper uses the support length and maximum.

    The checker encloses

    by alternating series. For , scale to , enclose its Taylor polynomial using

    and square the interval times. For , use . Sine and cosine use alternating bounds and monotonicity on .

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

  • sectionAmplitude, phase, and verdictContinuum defect certification and the next accuracy target › Amplitude, phase, and verdict · lines 1862–1901
    Open as its own page

    If a validated certificate gives

    then

    Thus:

    Otherwise the certificate is inconclusive.

    If an estimated phase is used, the decoded channel is

    Its error is at most

    For , use ; otherwise use one. A sufficient upper bound is . Implementation error is separate.

  • corollaryCorollary: A sufficient exclusion targetContinuum defect certification and the next accuracy target › Amplitude, phase, and verdict · Em03-H@8#cor:target · proof attached · lines 1902–1918
    Open as its own page

    To exclude quarter-error performance of the specified ideal-phase decoder, it suffices to establish

    For a defect certificate it suffices that

    Proof. The condition gives , then Theorem thm:specified gives error greater than one quarter.

  • sectionAmplitude, phase, and verdictContinuum defect certification and the next accuracy target › Amplitude, phase, and verdict · lines 1918–1939
    Open as its own page

    Using the rounded exploratory only as a planning estimate gives . The estimated amplitude margin to is about . The corresponding defect target is roughly , before any additional center/modulus allowances. These are refinement targets, not validated bounds. The reported defect is too wide for this purpose.

    Refine according to the source of width:

    1. tighten when pulse-normalization uncertainty dominates;

    2. refine validation cells when kernel/interpolant range wrapping dominates;

    3. refine solver nodes when the approximation defect dominates;

    4. increase arithmetic precision only when rounding contributes materially.

    Validation-cell refinement does not improve a fixed interpolant; it only tightens its enclosure.

  • sectionNormalization cross-checkContinuum defect certification and the next accuracy target › Normalization cross-check · lines 1940–1959
    Open as its own page

    For , expansion gives

    This follows from the exponential packet measure and Fubini. With frequency cutoff ,

    A finite spectral-system norm near one is not automatically a continuum normalization certificate.

Debugging, provenance, and submission boundary

  • sectionMixed arithmetic defectDebugging, provenance, and submission boundary › Mixed arithmetic defect · lines 1964–1984
    Open as its own page

    The printed v7 real-interval multiplication method attempted to convert every right operand to a real interval. Expressions such as

    therefore attempted to convert a complex rectangle to a rational scalar, before reflected multiplication could run. Reversing operands at individual call sites can avoid the immediate exception, but does not repair the type interface globally.

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

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

  • sectionI/O and partial inspectionDebugging, provenance, and submission boundary › I/O and partial inspection · lines 1985–2007
    Open as its own page

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

    Repeated writes to one fixed temporary filename are replaced by:

    1. an append-only check journal, flushed and synchronized after each record;

    2. unique temporary snapshot files in the destination directory;

    3. bounded retries for selected transient I/O errors;

    4. independent finalization attempts that do not replace the original numerical exception;

    5. an explicit failure status when persistence does not complete.

    The temporary-file and replacement facilities are standard Python interfaces PythonIO.

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

  • assumptionAssumption: Independent physical identificationDebugging, provenance, and submission boundary › Conditional gravitational recovery · lines 2010–2018
    Open as its own page

    An independent construction supplies a gravitational theory, physical state space, justified code isometry from the same , phases, gauge interpretation, controlled validity remainders, actual controls, and an accessible channel with fixed CPTP output map . The output map uses no inaccessible remnant, reference, interior partner, or undisclosed purification.

  • sectionConditional gravitational recoveryDebugging, provenance, and submission boundary › Conditional gravitational recovery · lines 2018–2033
    Open as its own page

    If satisfies , then

    by postprocessing contraction and Theorem thm:microrecovery. This implication does not supply its physical premises.

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

  • sectionWork and resourcesDebugging, provenance, and submission boundary › Work and resources · lines 2034–2056
    Open as its own page

    For stored density , put . Ideal extraction gives

    Mode mixing and initial bath vacuum prove these identities. The instantaneous quench work is

    The hopping switch has zero mean work: is conserved during extraction and has initial expectation zero. These are reference-Hamiltonian energies, not free energies or autonomous black-hole mass loss.

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

  • theoremTheorem: Version-8 analytical releaseDebugging, provenance, and submission boundary › Release statement · proof attached · lines 2059–2083
    Open as its own page

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

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

    Proof. The finite results follow from Theorems thm:channels–thm:microrecovery. The continuum results follow from Theorems thm:volterra–thm:noexact. Theorems thm:spectrum, thm:defect, and thm:cell give the numerical implications. Section sec:results attributes the supplied computation reports without replacing missing numerical premises.

  • sectionRelease statementDebugging, provenance, and submission boundary › Release statement · lines 2083–2097
    Open as its own page

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

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

Journaled inspection and candidate computation software

  • sectionJournaled inspection and candidate computation softwareJournaled inspection and candidate computation software · lines 2099–2124
    Open as its own page

    Extract this listing as 03h_v8_tools.py. It is a new, unexecuted v8 artifact.

    python em03h_v8_tools.py inspect-p8 \ –archive P8-new –out P8-v8-inspection

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

    python em03h_v8_tools.py inspect-candidate \ –archive candidate-v8 –out candidate-v8-inspection

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

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

  • listingListing: ListingJournaled inspection and candidate computation software · lines 2125–2748
    Open as its own page
    #!/usr/bin/env python3
    """Em03-H-v8 tools. New, statically revised, unexecuted artifact."""
    import argparse
    import contextlib
    import datetime
    from fractions import Fraction as F
    import hashlib
    import itertools
    import json
    import math
    import os
    import errno
    from pathlib import Path
    import platform
    import shutil
    import sys
    import tempfile
    import time
    import traceback
    
    np = None
    TOL = 2e-10
    PTOL = 1e-12
    DEN = 256*65521
    TIMES = (0., .25, .5, .75, 1.)
    ANGLES = (0., 0., math.pi/4, math.pi/2, math.pi/2)
    CONTRACT = {"t0":1, "T":1, "Omega":1,
                "v":1, "w":0, "packet":"fixed_f"}
    TRANSIENT = {errno.EINTR, errno.EAGAIN, errno.EBUSY, errno.EIO}
    
    def need(ok, message):
        if not ok:
            raise AssertionError(message)
    
    def sha(path):
        return hashlib.sha256(Path(path).read_bytes()).hexdigest()
    
    def atomic_json(path, data):
        path = Path(path)
        payload = json.dumps(data, indent=2, allow_nan=False)
        for attempt in range(3):
            tmp = None
            try:
                fd, name = tempfile.mkstemp(
                    prefix="."+path.name+".", suffix=".tmp", dir=path.parent)
                tmp = Path(name)
                with os.fdopen(fd, "w", encoding="utf-8") as stream:
                    stream.write(payload)
                    stream.flush()
                    os.fsync(stream.fileno())
                os.replace(tmp, path)
                return
            except OSError as exc:
                if attempt == 2 or exc.errno not in TRANSIENT:
                    raise
                time.sleep(.05*(attempt+1))
            finally:
                if tmp is not None and tmp.exists():
                    try:
                        tmp.unlink()
                    except OSError:
                        pass
    
    class Recorder:
        def __init__(self, root, metadata):
            self.root = Path(root)
            self.meta = metadata
            self.records = {}
            self.sequence = 0
    
        def record(self, name, value):
            self.sequence += 1
            self.records[name] = value
            line = {"sequence":self.sequence, "name":name, "value":value}
            # A journal failure is fatal: do not call the inspection complete.
            with (self.root/"checks.jsonl").open("a", encoding="utf-8") as stream:
                stream.write(json.dumps(line, allow_nan=False)+"\n")
                stream.flush()
                os.fsync(stream.fileno())
            if self.sequence % 25 == 0:
                self.snapshot()
    
        def snapshot(self):
            atomic_json(self.root/"inspection.json",
                        {"records":self.records, "validated":False,
                         "last_sequence":self.sequence})
    
        def exact(self, name, ok):
            value = {"passed":bool(ok), "exact_predicate":True}
            self.record(name, value)
            need(ok, "Exact check failed: "+name)
    
        def call(self, name, function):
            value = {"passed":False}
            try:
                result = function()
                value["passed"] = True
                return result
            except BaseException as exc:
                value["failure"] = repr(exc)
                raise
            finally:
                self.record(name, value)
    
        def check(self, name, actual, expected, tol=TOL):
            value = {"passed":False, "tolerance":float(tol)}
            try:
                a, b = np.asarray(actual), np.asarray(expected)
                value["actual_shape"] = list(a.shape)
                value["expected_shape"] = list(b.shape)
                need(a.shape == b.shape, "Shape: "+name)
                need(np.all(np.isfinite(a)) and np.all(np.isfinite(b)),
                     "Nonfinite: "+name)
                discrepancy = 0. if a.size == 0 else float(np.max(np.abs(a-b)))
                value["observed_max_abs"] = discrepancy
                value["passed"] = discrepancy <= tol
                need(value["passed"], "Tolerance: "+name)
            finally:
                self.record(name, value)
    
    def execute(args, action, source, numerical=True,
                success="COMPLETED_NOT_VALIDATED"):
        global np
        root = Path(args.out)
        root.mkdir(parents=True, exist_ok=False)
        start = time.monotonic()
        meta = {"status":"RUNNING", "mode":getattr(args,"mode","defect"),
                "argv":sys.argv, "validated":False,
                "python":sys.version, "platform":platform.platform(),
                "start_utc":datetime.datetime.now(datetime.timezone.utc).isoformat()}
        r = Recorder(root, meta)
        primary = None
        try:
            atomic_json(root/"manifest.json", meta)
            source = Path(source)
            shutil.copyfile(source, root/source.name)
            meta["source_name"] = source.name
            meta["source_sha256"] = sha(source)
            atomic_json(root/"manifest.json", meta)
            with (root/"stdout.txt").open("w") as out, \
                 (root/"stderr.txt").open("w") as err, \
                 contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
                if numerical:
                    import numpy as numpy
                    np = numpy
                    meta["numpy"] = np.__version__
                    atomic_json(root/"numpy_configuration.json",
                                np.show_config(mode="dicts"))
                result = action(args, root, r)
                if result is not None:
                    print(json.dumps(result, indent=2, allow_nan=False))
            meta["status"] = success
        except BaseException as exc:
            primary = exc
            meta["status"] = "FAILED"
            meta["failure"] = repr(exc)
            try:
                (root/"traceback.txt").write_text(traceback.format_exc())
            except OSError as io:
                meta["traceback_write_failure"] = repr(io)
                print(traceback.format_exc(), file=sys.__stderr__)
            raise
        finally:
            meta["elapsed_seconds"] = time.monotonic()-start
            meta["end_utc"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
            errors = []
            try:
                r.snapshot()
            except BaseException as exc:
                errors.append({"inspection_snapshot":repr(exc)})
            hashes = {}
            try:
                for p in sorted(root.iterdir()):
                    if p.is_file() and p.name != "manifest.json":
                        hashes[p.name] = sha(p)
            except BaseException as exc:
                errors.append({"artifact_hashing":repr(exc)})
            meta["files_sha256"] = hashes
            if errors:
                meta["status"] = "FAILED"
                meta["finalization_errors"] = errors
            try:
                atomic_json(root/"manifest.json", meta)
            except BaseException as exc:
                errors.append({"manifest_write":repr(exc)})
            if errors:
                print("Incomplete persistence: "+repr(errors), file=sys.__stderr__)
                if primary is None:
                    raise OSError("Run finalization incomplete")
    
    def load(path):
        with np.load(path, allow_pickle=False) as data:
            return {key:data[key].copy() for key in data.files}
    
    def archive_hashes(src, r):
        src = Path(src)
        manifest = json.loads((src/"manifest.json").read_text())
        r.record("input_manifest_sha256", sha(src/"manifest.json"))
        table = manifest.get("files_sha256")
        need(isinstance(table,dict) and table, "Missing archive hash table")
        for name, expected in table.items():
            r.exact("safe_name_"+name, name not in (".","..") and
                    Path(name).name == name)
            r.exact("hash_format_"+name, isinstance(expected,str) and
                    len(expected) == 64 and
                    all(x in "0123456789abcdef" for x in expected))
            path = src/name
            r.exact("file_exists_"+name, path.is_file())
            observed = sha(path)
            r.record("hash_values_"+name, {"reported":expected,"observed":observed})
            r.exact("hash_match_"+name, observed == expected)
        r.exact("input_completed",
                manifest.get("status") == "COMPLETED_NOT_VALIDATED")
        return manifest
    
    def coefficients():
        rows, a = [], 1
        for q in itertools.combinations(range(1,17),4):
            a = (75*a+74) % 65521
            rows.append({"quartet":list(q),"numerator":2*a-65521})
        return {"denominator":64*65521,"rows":rows}
    
    def tensor_assembly(data):
        eye = np.eye(2,dtype=complex)
        z = np.diag([1,-1]).astype(complex)
        x = np.array([[0,1],[1,0]],complex)
        y = np.array([[0,-1j],[1j,0]],complex)
        generators = []
        for j in range(8):
            for middle in (x,y):
                matrix = np.array([[1]],complex)
                for k in range(8):
                    matrix = np.kron(matrix,z if k < j else
                                     middle if k == j else eye)
                perm = np.argmax(np.abs(matrix),axis=0)
                generators.append((perm,matrix[perm,np.arange(256)]))
        re = np.zeros((256,256),dtype=np.int64)
        im = np.zeros_like(re)
        cols = np.arange(256)
        for row in data["rows"]:
            p, value = cols.copy(), np.ones(256,complex)
            for a in reversed(row["quartet"]):
                perm, sign = generators[a-1]
                value *= sign[p]
                p = perm[p]
            re[p,cols] += row["numerator"]*value.real.astype(np.int64)
            im[p,cols] += row["numerator"]*value.imag.astype(np.int64)
        return re,im
    
    def creator_transfer(v,t,angle):
        c = 0. if angle == math.pi/2 else math.cos(angle)
        s = 0. if angle == 0 else math.sin(angle)
        out = np.zeros((v.shape[1],256,256),complex)
        for p in range(256):
            modes = [j for j in range(8) if p & (1 << (7-j))]
            terms = {0:1.+0j}
            for j in reversed(modes):
                newer = {}
                for word,value in terms.items():
                    for index,coefficient in ((j,c),(8+j,-1j*s)):
                        bit = 1 << (15-index)
                        need(not (word & bit),"Double occupation")
                        before = (word >> (16-index)).bit_count()
                        target = word | bit
                        newer[target] = newer.get(target,0j)+ \
                            value*coefficient*((-1)**before)
                terms = newer
            free = np.exp(-1j*t*len(modes))
            for word,value in terms.items():
                boundary,bath = word >> 8, word & 255
                sign = (-1)**(boundary.bit_count()*bath.bit_count())
                out[:,bath,boundary] += free*sign*value*v[p]
        return out
    
    def objects(z):
        d = z.shape[0]
        u = np.array([[z[i]@z[j].conj().T for j in range(d)]
                      for i in range(d)])
        c = np.array([[z[i].T@z[j].conj() for j in range(d)]
                      for i in range(d)])
        ju = np.block([[u[i,j]/d for j in range(d)] for i in range(d)])
        jc = np.block([[c[i,j]/d for j in range(d)] for i in range(d)])
        return u,c,ju,jc
    
    def audit_choi(name,j,r):
        r.check(name+"_Hermitian",j,j.conj().T)
        value = float(np.linalg.eigvalsh((j+j.conj().T)/2)[0])
        r.record(name+"_minimum_eigenvalue",{"value":value,"rigorous":False})
        r.exact(name+"_exploratory_PSD",value >= -TOL)
    
    def matrix_json(a):
        return [[[float(z.real),float(z.imag)] for z in row] for row in a]
    
    def inspect_p8(args,root,r):
        src = Path(args.archive)
        manifest = archive_hashes(src,r)
        r.exact("p8_mode",manifest.get("mode") == "p8")
        results = manifest["results"]
        r.exact("stdout_matches_manifest",
                json.loads((src/"stdout.txt").read_text()) == results)
        data = json.loads((src/"coefficients.json").read_text())
        r.exact("frozen_coefficients",data == coefficients())
        re,im = tensor_assembly(data)
        saved = load(src/"integer_hamiltonian.npz")
        r.exact("Hamiltonian_denominator",int(saved["denominator"]) == DEN)
        r.exact("real_assembly",np.array_equal(re,saved["real"]))
        r.exact("imag_assembly",np.array_equal(im,saved["imag"]))
        r.exact("real_symmetry",np.array_equal(re,re.T))
        r.exact("imag_antisymmetry",np.array_equal(im,-im.T))
        even = np.array([p for p in range(256) if p.bit_count()%2 == 0])
        odd = np.array([p for p in range(256) if p.bit_count()%2 == 1])
        r.exact("even_order",np.array_equal(even,saved["even_words"]))
        r.exact("odd_order",np.array_equal(odd,saved["odd_words"]))
        r.exact("parity_blocks",not np.any(re[np.ix_(even,odd)]) and
                not np.any(im[np.ix_(even,odd)]))
        r.exact("trace",sum(int(x) for x in np.diag(re)) == 0 and
                sum(int(x) for x in np.diag(im)) == 0)
        squares = sum(int(x)**2 for x in re.flat)+sum(int(x)**2 for x in im.flat)
        r.exact("Frobenius_identity",squares ==
                256*sum(row["numerator"]**2 for row in data["rows"]))
        h = (re.astype(float)+1j*im.astype(float))/DEN
        spectra = load(src/"spectra_exploratory.npz")
        ee = np.linalg.eigvalsh(h[np.ix_(even,even)])
        eo = np.linalg.eigvalsh(h[np.ix_(odd,odd)])
        r.check("even_spectrum",spectra["even_unshifted"],ee)
        r.check("odd_spectrum",spectra["odd_unshifted"],eo)
        emin = min(ee[0],eo[0])
        for name,value in (("global_minimum_float",emin),
                           ("even_minimum_float",ee[0]),
                           ("odd_minimum_float",eo[0]),
                           ("parity_minimum_difference_float",ee[0]-eo[0])):
            r.check(name,value,results[name])
        r.check("selected_unshifted",ee[:2],results["selected_even_unshifted"])
        r.check("selected_gaps",[ee[1]-ee[0],ee[2]-ee[1]],
                results["selected_neighbor_gaps"])
        code = load(src/"code_and_quench_exploratory.npz")
        v,energy = code["V"],code["energies"]
        r.exact("code_shape",v.shape == (256,2))
        r.check("orthonormality",v.conj().T@v,np.eye(2))
        r.check("odd_code",v[odd],np.zeros((128,2)))
        r.check("shifted_energies",energy,ee[:2]-emin)
        residual = h@v-v*(energy+emin)[None,:]
        r.check("eigenpair_residual",residual,np.zeros_like(v))
        r.record("residual_norms_float",
                 [float(np.linalg.norm(residual[:,i])) for i in range(2)])
        anchors = []
        for i in range(2):
            nz = np.flatnonzero(np.abs(v[:,i]) > PTOL)
            r.exact("anchor_exists_%d"%i,len(nz) > 0)
            p = int(nz[0]); anchors.append(p)
            r.check("anchor_imag_%d"%i,v[p,i].imag,0.)
            r.exact("anchor_positive_%d"%i,v[p,i].real > 0)
        r.exact("phase_summary",anchors == results["phase_surrogate_anchors"])
        pop = np.array([p.bit_count() for p in range(256)],float)
        nu = v.conj().T@(pop[:,None]*v)
        mu = v.conj().T@(pop[:,None]**2*v)
        lam = mu-nu@nu
        leak = pop[:,None]*v-v@nu
        for name,value in (("nu",nu),("mu",mu),("Lambda",lam),
                           ("direct_leakage",leak)):
            r.check("saved_"+name,code[name],value)
        r.check("direct_Gram",leak.conj().T@leak,lam)
        r.check("E_code",np.linalg.eigvalsh((nu+nu.conj().T)/2)[-1],
                results["E_code_float"])
        r.check("L_N",np.linalg.norm(leak,2),results["L_N_float"])
        r.record("compressed_matrices",{"nu":matrix_json(nu),
            "mu":matrix_json(mu),"Lambda":matrix_json(lam)})
        for m in (0,2,4,6,8):
            block = v[pop == m]
            occ = load(src/("occupation_%d.npz"%m))
            r.check("occupation_block_%d"%m,occ["projected_code"],block)
            r.check("occupation_Gram_%d"%m,occ["gram"],block.conj().T@block)
            r.check("occupation_singular_%d"%m,np.linalg.svd(block,compute_uv=False),
                    results["occupation_data"][str(m)]["singular_values_float"])
        dep = load(src/"departure_exploratory.npz")
        r.check("departure_grid",dep["times"],np.arange(33)/128,tol=0)
        for k,t in enumerate(dep["times"]):
            f = v.conj().T@(np.exp(-1j*t*pop)[:,None]*v)
            r.check("departure_F_%d"%k,dep["F"][k],f)
            gram = f.conj().T@f
            p = 1-np.linalg.eigvalsh((gram+gram.conj().T)/2)[0]
            r.check("departure_value_%d"%k,dep["departure"][k],p)
        r.check("departure_1_8",dep["departure"][16],results["departure_1_over_8"])
        r.check("departure_1_4",dep["departure"][32],results["departure_1_over_4"])
        bases = load(src/"full_bases_exploratory.npz")
        for name,inds,values in (("even",even,spectra["even_unshifted"]),
                                ("odd",odd,spectra["odd_unshifted"])):
            a = bases[name+"_vectors"]
            r.check(name+"_basis_orthonormal",a.conj().T@a,np.eye(128))
            r.check(name+"_basis_residual",h[np.ix_(inds,inds)]@a-a*values[None,:],
                    np.zeros_like(a))
        for i in range(2):
            col = bases["even_vectors"][:,i].copy()
            nz = np.flatnonzero(np.abs(col) > PTOL)
            need(len(nz) > 0,"Basis phase anchor")
            col *= np.exp(-1j*np.angle(col[nz[0]]))
            r.check("selected_basis_link_%d"%i,v[even,i],col)
        stored = v*np.exp(-1j*energy)[None,:]
        for k,(t,angle) in enumerate(zip(TIMES,ANGLES)):
            saved = load(src/("channel_%d.npz"%k))
            r.check("frozen_time_%d"%k,saved["time"],t,tol=0)
            r.check("frozen_area_%d"%k,saved["theta"],angle,tol=0)
            z = saved["Z"]
            r.check("creator_reconstruction_%d"%k,z,creator_transfer(stored,t,angle))
            r.check("isometry_%d"%k,np.einsum("irb,jrb->ij",z.conj(),z),np.eye(2))
            u,c,ju,jc = objects(z)
            for name,value in (("units",u),("complement",c),
                               ("Choi_accessible",ju),("Choi_complement",jc)):
                r.check(name+"_%d"%k,saved[name],value)
            for i in range(2):
                for j in range(2):
                    for name,obj in (("R",u),("E",c)):
                        r.check("adjoint_%s_%d_%d_%d"%(name,k,i,j),
                                obj[i,j].conj().T,obj[j,i])
                        r.check("trace_%s_%d_%d_%d"%(name,k,i,j),
                                np.trace(obj[i,j]),float(i == j))
            audit_choi("Choi_R_%d"%k,saved["Choi_accessible"],r)
            audit_choi("Choi_E_%d"%k,saved["Choi_complement"],r)
            if k == 4:
                lt = np.exp(-1j*(1+math.pi/2)*pop)[:,None]*stored
                for i in range(2):
                    for j in range(2):
                        r.check("endpoint_R_%d_%d"%(i,j),u[i,j],
                                np.outer(lt[:,i],lt[:,j].conj()))
                        target = np.zeros((256,256),complex)
                        target[0,0] = float(i == j)
                        r.check("endpoint_E_%d_%d"%(i,j),c[i,j],target)
        return {"inspection":"completed", "validated":False,
                "exact_code_selection_certified":False,
                "exact_ranks_certified":False}
    
    def g(t):
        return 2/(2+1j*t)
    
    def bump(t):
        t = np.asarray(t,float)
        out = np.zeros_like(t)
        good = (t > .25) & (t < .75)
        out[good] = np.exp(-1/((t[good]-.25)*(.75-t[good])))
        return out
    
    def pulse_b0(panels):
        x = np.arange(panels+1)/panels
        y = bump(x)
        return float((y[0]/2+y[1:-1].sum()+y[-1]/2)/panels)
    
    def volterra(n,b0,v=1,coupled=True):
        t,h = np.arange(n+1)/n,1/n
        kap = math.pi*bump(t)/(2*b0) if coupled else np.zeros(n+1)
        a,b = np.zeros(n+1,complex),np.zeros(n+1,complex)
        a[0] = g(1)
        for i in range(1,n+1):
            weights = np.ones(i); weights[0] = .5
            ra = g(t[i]+1)-1j*h*np.sum(
                weights*g(t[i]-t[:i])*(v*a[:i]+kap[:i]*b[:i]))
            rb = -1j*h*np.sum(
                weights*np.exp(-1j*(t[i]-t[:i]))*kap[:i]*a[:i])
            matrix = np.array([[1+1j*h*v/2,1j*h*kap[i]/2],
                               [1j*h*kap[i]/2,1]],complex)
            a[i],b[i] = np.linalg.solve(matrix,[ra,rb])
        return t,a,b
    
    def spectral(ne,nt,b0):
        x,weights = np.polynomial.laguerre.laggauss(ne)
        need(np.all(weights > 0) and np.all(np.isfinite(weights)),
             "Laguerre weights")
        f,omega = np.sqrt(weights),x/2
        initial = np.r_[f*np.exp(-1j*omega),0j]
        state,dt = initial.copy(),1/nt
        def rhs(t,y):
            a = np.vdot(f,y[:-1])
            k = float(math.pi*bump(np.array([t]))[0]/(2*b0))
            return -1j*np.r_[omega*y[:-1]+f*a+k*f*y[-1],y[-1]+k*a]
        for j in range(nt):
            t = j*dt
            k1 = rhs(t,state)
            k2 = rhs(t+dt/2,state+dt*k1/2)
            k3 = rhs(t+dt/2,state+dt*k2/2)
            k4 = rhs(t+dt,state+dt*k3)
            state += dt*(k1+2*k2+2*k3+k4)/6
        return x,weights,initial,state
    
    def ratio(value):
        n,d = float(value).as_integer_ratio()
        return [str(n),str(d)]
    
    def encode(array):
        return [[ratio(z.real),ratio(z.imag)] for z in array]
    
    def candidate(args,root,r):
        meshes = args.meshes
        need(meshes == sorted(set(meshes)) and
             all(n >= 8 and n & (n-1) == 0 for n in meshes),
             "Increasing power-of-two meshes")
        panels = max(32768,8*max(meshes))
        b0 = pulse_b0(panels)
        need(math.isfinite(b0) and b0 > 0,"Pulse normalization")
        report = {"contract":CONTRACT,"B0_float":b0,"pulse_panels":panels,
                  "volterra":[],"spectral":[],"validated":False}
        previous = None
        for n in meshes:
            t,a,b = volterra(n,b0)
            np.savez_compressed(root/("volterra_%d.npz"%n),times=t,A=a,B=b)
            atomic_json(root/("nodes_%d.json"%n),{
                "contract":CONTRACT,"interpolation":"continuous_piecewise_linear",
                "node_representation":"exact_binary64_dyadic_ratios",
                "A":encode(a),"B":encode(b)})
            q = b[-1]
            row = {"n":n,"q":[float(q.real),float(q.imag)],
                   "eta":float(abs(q)**2),
                   "successive_difference":None if previous is None else
                                           float(abs(q-previous))}
            report["volterra"].append(row)
            r.record("Volterra_%d"%n,row)
            atomic_json(root/"candidate_report.json",report)
            previous = q
        for ne,nt in ((32,2048),(64,4096),(96,8192)):
            x,weights,initial,state = spectral(ne,nt,b0)
            name = "spectral_%d_%d.npz"%(ne,nt)
            np.savez_compressed(root/name,nodes=x,weights=weights,
                initial=initial,final=state,energy_nodes=ne,time_steps=nt,
                B0=b0,t0=1,T=1,v=1,w_control=0)
            q = state[-1]
            row = {"file":name,"energy_nodes":ne,"time_steps":nt,
                   "q":[float(q.real),float(q.imag)],
                   "finite_system_norm":float(np.vdot(state,state).real),
                   "weight_sum":float(weights.sum()),
                   "difference_from_finest_volterra":float(abs(q-previous))}
            report["spectral"].append(row)
            r.record(name,row)
            atomic_json(root/"candidate_report.json",report)
        return report
    
    def node_link(values,array):
        need(array.dtype == np.complex128 and array.ndim == 1,
             "Require one-dimensional complex128 nodes")
        need(len(values) == len(array),"Node lengths")
        for item,z in zip(values,array):
            need(len(item) == 2,"Complex node shape")
            for pair,value in zip(item,(z.real,z.imag)):
                need(len(pair) == 2 and int(pair[1]) > 0,"Rational shape")
                need(F(int(pair[0]),int(pair[1])) ==
                     F(*float(value).as_integer_ratio()),"Exact JSON/NPZ mismatch")
        return True
    
    def inspect_candidate(args,root,r):
        src = Path(args.archive)
        archive_hashes(src,r)
        report = json.loads((src/"candidate_report.json").read_text())
        r.exact("candidate_contract",report["contract"] == CONTRACT)
        b0 = report["B0_float"]
        r.check("pulse_replay",b0,pulse_b0(report["pulse_panels"]))
        t,a,b = volterra(128,b0,coupled=False)
        r.check("zero_coupling_B",b,np.zeros_like(b))
        t,a,b = volterra(128,b0,v=0,coupled=False)
        r.check("free_A",a,g(t+1)); r.check("free_B",b,np.zeros_like(b))
        rows = report["volterra"]
        need(rows,"No Volterra results")
        sizes = [row["n"] for row in rows]
        r.exact("mesh_order",sizes == sorted(set(sizes)))
        finest = None
        for row in rows:
            n = row["n"]
            r.exact("power_two_%d"%n,n >= 8 and n & (n-1) == 0)
            path = src/("volterra_%d.npz"%n)
            saved = load(path)
            t,a,b = saved["times"],saved["A"],saved["B"]
            r.check("grid_%d"%n,t,np.arange(n+1)/n,tol=0)
            r.exact("node_shapes_%d"%n,a.shape == (n+1,) and b.shape == (n+1,))
            nodes_path = src/("nodes_%d.json"%n)
            nodes = json.loads(nodes_path.read_text())
            r.exact("JSON_contract_%d"%n,nodes["contract"] == CONTRACT)
            r.exact("JSON_interpolant_%d"%n,
                    nodes["interpolation"] == "continuous_piecewise_linear")
            r.call("A_exact_link_%d"%n,lambda:node_link(nodes["A"],a))
            r.call("B_exact_link_%d"%n,lambda:node_link(nodes["B"],b))
            r.record("file_link_%d"%n,{"npz_sha256":sha(path),
                "json_sha256":sha(nodes_path),"exact_node_equality":True})
            tt,aa,bb = volterra(n,b0)
            r.check("A_solver_replay_%d"%n,a,aa)
            r.check("B_solver_replay_%d"%n,b,bb)
            q = b[-1]; finest = q
            r.check("q_summary_%d"%n,q,complex(*row["q"]))
            r.check("eta_summary_%d"%n,abs(q)**2,row["eta"])
            r.check("initial_A_%d"%n,a[0],(4-2j)/5)
            r.check("initial_B_%d"%n,b[0],0)
        for row in report["spectral"]:
            saved = load(src/row["file"])
            ne,nt = row["energy_nodes"],row["time_steps"]
            for key,value in (("energy_nodes",ne),("time_steps",nt),
                              ("t0",1),("T",1),("v",1),("w_control",0)):
                r.check(key+"_"+row["file"],saved[key],value,tol=0)
            r.check("B0_"+row["file"],saved["B0"],b0,tol=0)
            x,w,initial,final = spectral(ne,nt,b0)
            for key,value in (("nodes",x),("weights",w),
                              ("initial",initial),("final",final)):
                r.check(key+"_"+row["file"],saved[key],value)
            r.check("q_"+row["file"],saved["final"][-1],complex(*row["q"]))
            norm = float(np.vdot(saved["final"],saved["final"]).real)
            r.check("norm_summary_"+row["file"],norm,row["finite_system_norm"])
            r.check("finite_system_norm_"+row["file"],norm,1.,tol=1e-7)
            r.check("difference_"+row["file"],abs(saved["final"][-1]-finest),
                    row["difference_from_finest_volterra"])
        return {"inspection":"completed","JSON_NPZ_link_checked":True,
                "solver_replay_checked":True,"continuum_validated":False}
    
    def main():
        parser = argparse.ArgumentParser()
        parser.add_argument("mode",
            choices=["inspect-p8","candidate","inspect-candidate"])
        parser.add_argument("--archive")
        parser.add_argument("--out",required=True)
        parser.add_argument("--meshes",nargs="+",type=int,default=[256,512])
        args = parser.parse_args()
        if args.mode != "candidate":
            need(args.archive is not None,"--archive required")
        action = {"inspect-p8":inspect_p8,"candidate":candidate,
                  "inspect-candidate":inspect_candidate}[args.mode]
        execute(args,action,__file__)
    
    if __name__ == "__main__":
        main()
  • sectionJournaled inspection and candidate computation softwareJournaled inspection and candidate computation software · lines 2748–2756
    Open as its own page

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

Repaired exact-rational defect checker

  • sectionRepaired exact-rational defect checkerRepaired exact-rational defect checker · lines 2758–2780
    Open as its own page

    Extract this listing as 03h_v8_defect.py, in the same directory as the preceding helper file. Its calculation uses only the Python standard library. Importing the helper does not import NumPy.

    python em03h_v8_defect.py \ –nodes candidate-v8/nodes_256.json \ –out candidate-v8-bound-256 \ –bits 48 –refine 1 –pulse-cells 512

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

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

  • listingListing: ListingRepaired exact-rational defect checker · lines 2781–3123
    Open as its own page
    #!/usr/bin/env python3
    """Em03-H-v8 rational defect checker. New; unexecuted artifact."""
    import argparse
    from fractions import Fraction as F
    import json
    import math
    from pathlib import Path
    import shutil
    from em03h_v8_tools import need, sha, atomic_json, execute
    
    BITS = 48
    SCALE = 1 << BITS
    TERMS = 40
    
    def down(x):
        x = F(x)
        return F((x.numerator*SCALE)//x.denominator,SCALE)
    
    def up(x):
        return -down(-F(x))
    
    class I:
        def __init__(self,lo,hi=None):
            lo,hi = F(lo),F(lo if hi is None else hi)
            need(lo <= hi,"Reversed interval")
            self.lo,self.hi = down(lo),up(hi)
    
        def __add__(self,y):
            if isinstance(y,C):
                return NotImplemented
            y = ri(y)
            return I(self.lo+y.lo,self.hi+y.hi)
    
        __radd__ = __add__
    
        def __neg__(self):
            return I(-self.hi,-self.lo)
    
        def __sub__(self,y):
            if isinstance(y,C):
                return NotImplemented
            return self+(-ri(y))
    
        def __rsub__(self,y):
            return ri(y)+(-self)
    
        def __mul__(self,y):
            # Mixed real/complex arithmetic is handled by C.__rmul__.
            if isinstance(y,C):
                return NotImplemented
            y = ri(y)
            vals = [a*b for a in (self.lo,self.hi) for b in (y.lo,y.hi)]
            return I(min(vals),max(vals))
    
        __rmul__ = __mul__
    
        def __truediv__(self,y):
            y = ri(y)
            need(not y.lo <= 0 <= y.hi,"Division through zero")
            return self*I(1/y.hi,1/y.lo)
    
        def bound(self):
            return max(abs(self.lo),abs(self.hi))
    
        def width(self):
            return self.hi-self.lo
    
    def ri(x):
        return x if isinstance(x,I) else I(x)
    
    class C:
        def __init__(self,re=0,im=0):
            self.re,self.im = ri(re),ri(im)
    
        def __add__(self,y):
            y = ci(y)
            return C(self.re+y.re,self.im+y.im)
    
        __radd__ = __add__
    
        def __neg__(self):
            return C(-self.re,-self.im)
    
        def __sub__(self,y):
            return self+(-ci(y))
    
        def __rsub__(self,y):
            return ci(y)+(-self)
    
        def __mul__(self,y):
            y = ci(y)
            return C(self.re*y.re-self.im*y.im,
                     self.re*y.im+self.im*y.re)
    
        __rmul__ = __mul__
    
        def bound(self):
            return self.re.bound()+self.im.bound()
    
        def width(self):
            return self.re.width()+self.im.width()
    
    def ci(x):
        return x if isinstance(x,C) else C(x)
    
    def exp_minus(x):
        x = F(x)
        need(x >= 0,"Negative exp-minus argument")
        if x >= BITS:
            return I(0,F(1,SCALE))
        y,s = x,0
        while y > 1:
            y /= 2
            s += 1
        total,term = F(1),F(1)
        for k in range(1,TERMS+1):
            term *= -y/k
            total += term
        error = 3*y**(TERMS+1)/math.factorial(TERMS+1)
        out = I(max(F(0),total-error),min(F(1),total+error))
        for _ in range(s):
            out = out*out
            out = I(max(F(0),out.lo),min(F(1),out.hi))
        return out
    
    def arctan(x):
        x = F(x)
        total = sum((-1)**k*x**(2*k+1)/F(2*k+1) for k in range(TERMS))
        error = x**(2*TERMS+1)/F(2*TERMS+1)
        return I(total-error,total+error)
    
    def pi_ball():
        return 16*arctan(F(1,5))-4*arctan(F(1,239))
    
    def sine(x):
        x = F(x)
        total = sum((-1)**k*x**(2*k+1)/math.factorial(2*k+1)
                    for k in range(TERMS))
        error = x**(2*TERMS+1)/math.factorial(2*TERMS+1)
        return I(total-error,total+error)
    
    def cosine(x):
        x = F(x)
        total = sum((-1)**k*x**(2*k)/math.factorial(2*k)
                    for k in range(TERMS))
        error = x**(2*TERMS)/math.factorial(2*TERMS)
        return I(total-error,total+error)
    
    def phase(t):
        need(0 <= t.lo <= t.hi <= 1,"Phase domain")
        sa,sb = sine(t.lo),sine(t.hi)
        ca,cb = cosine(t.lo),cosine(t.hi)
        return C(I(cb.lo,ca.hi),I(-sb.hi,-sa.lo))
    
    def kernel(t):
        need(t.lo >= 0,"Kernel domain")
        den = I(4)+t*t
        return C(I(4)/den,(-2*t)/den)
    
    def bump_interval(a,b):
        a,b = max(F(a),F(1,4)),min(F(b),F(3,4))
        if a >= b:
            return I(0)
        def d(x):
            return (x-F(1,4))*(F(3,4)-x)
        dmin = min(d(a),d(b))
        dmax = F(1,16) if a <= F(1,2) <= b else max(d(a),d(b))
        lo = F(0) if dmin == 0 else exp_minus(1/dmin).lo
        hi = exp_minus(1/dmax).hi
        return I(lo,hi)
    
    def rational(pair):
        need(len(pair) == 2 and int(pair[1]) > 0,"Rational representation")
        return F(int(pair[0]),int(pair[1]))
    
    def nodes(values):
        result = []
        for value in values:
            need(len(value) == 2,"Complex node representation")
            result.append((rational(value[0]),rational(value[1])))
        return result
    
    def interpolate(values,t):
        m = len(values)-1
        if t == 1:
            return values[-1]
        x = t*m
        j = x.numerator//x.denominator
        f = x-j
        return tuple((1-f)*values[j][k]+f*values[j+1][k] for k in (0,1))
    
    def enclosure(values,a,b):
        va,vb = interpolate(values,a),interpolate(values,b)
        return C(I(min(va[0],vb[0]),max(va[0],vb[0])),
                 I(min(va[1],vb[1]),max(va[1],vb[1])))
    
    def text(x):
        x = F(x)
        return [str(x.numerator),str(x.denominator)]
    
    def interval_text(x):
        return {"lo":text(x.lo),"hi":text(x.hi)}
    
    def complex_text(x):
        return {"real":interval_text(x.re),"imag":interval_text(x.im)}
    
    def sqrt_bounds(x):
        x = F(x)
        need(x >= 0,"Square-root domain")
        k = math.isqrt((x.numerator*SCALE*SCALE)//x.denominator)
        lo = F(k,SCALE)
        return lo,lo if lo*lo == x else F(k+1,SCALE)
    
    def contains(interval,value):
        return interval.lo <= value <= interval.hi
    
    def selftests(r):
        for name,value in (("I_times_C",I(2)*C(3,4)),
                           ("C_times_I",C(3,4)*I(2))):
            r.exact(name,contains(value.re,6) and contains(value.im,8))
        r.exact("mixed_addition",contains((I(2)+C(3,4)).re,5))
        r.exact("mixed_subtraction",contains((I(2)-C(3,4)).im,-4))
        r.exact("exp_zero",contains(exp_minus(0),1))
        r.exact("sin_zero",contains(sine(0),0))
        r.exact("cos_zero",contains(cosine(0),1))
        r.exact("kernel_zero_real",contains(kernel(I(0)).re,1))
        r.exact("kernel_zero_imag",contains(kernel(I(0)).im,0))
        lo,hi = sqrt_bounds(F(9,16))
        r.exact("rational_square_root",lo <= F(3,4) <= hi)
    
    def calculate(args,root,r):
        global BITS,SCALE,TERMS
        need(args.bits >= 32 and args.refine >= 1 and args.pulse_cells >= 8,
             "Parameter ranges")
        need(args.refine & (args.refine-1) == 0,"Power-of-two refinement")
        BITS,SCALE = args.bits,1 << args.bits
        TERMS = max(32,(BITS+32)//2)
        selftests(r)
        path = Path(args.nodes)
        shutil.copyfile(path,root/"nodes-input.json")
        helper = Path(__file__).with_name("em03h_v8_tools.py")
        shutil.copyfile(helper,root/helper.name)
        r.meta["helper_sha256"] = sha(helper)
        r.meta["nodes_sha256"] = sha(path)
        data = json.loads((root/"nodes-input.json").read_text())
        contract = {"t0":1,"T":1,"Omega":1,"v":1,"w":0,"packet":"fixed_f"}
        r.exact("primary_contract",data["contract"] == contract)
        r.exact("piecewise_linear",
                data["interpolation"] == "continuous_piecewise_linear")
        a,b = nodes(data["A"]),nodes(data["B"])
        need(len(a) == len(b) and len(a) >= 9,"Node lengths")
        m = len(a)-1
        need(m & (m-1) == 0,"Original power-of-two grid")
        n = m*args.refine
        need(n <= SCALE,"Grid must be exactly representable at arithmetic bits")
        h = F(1,n)
        t = [F(j,n) for j in range(n+1)]
        pi = pi_ball()
        b0 = I(0)
        for j in range(args.pulse_cells):
            bump = bump_interval(F(j,args.pulse_cells),F(j+1,args.pulse_cells))
            b0 = b0+F(1,args.pulse_cells)*bump
        r.record("pulse_normalization",interval_text(b0))
        need(b0.lo > 0,"Pulse lower bound unresolved")
        kap = [pi*bump_interval(t[j],t[j+1])/(2*b0) for j in range(n)]
        av = [enclosure(a,t[j],t[j+1]) for j in range(n)]
        bv = [enclosure(b,t[j],t[j+1]) for j in range(n)]
        cv = [av[j]+bv[j]*kap[j] for j in range(n)]
        jv = [av[j]*kap[j] for j in range(n)]
        kg = {d:kernel(I(F(d-1,n),F(d+1,n))) for d in range(1,n)}
        kp = {d:phase(I(F(d-1,n),F(d+1,n))) for d in range(1,n)}
        partial_g,partial_p = kernel(I(0,h)),phase(I(0,h))
        epsilon = F(0)
        records = []
        for j in range(n):
            ia,ib = C(),C()
            for k in range(j):
                ia = ia+(kg[j-k]*cv[k])*h
                ib = ib+(kp[j-k]*jv[k])*h
            ia = ia+(partial_g*cv[j])*I(0,h)
            ib = ib+(partial_p*jv[j])*I(0,h)
            da = av[j]-kernel(I(t[j]+1,t[j+1]+1))+C(0,1)*ia
            db = bv[j]+C(0,1)*ib
            local = max(da.bound(),db.bound())
            epsilon = max(epsilon,local)
            record = {"cell":j,"dA":complex_text(da),"dB":complex_text(db),
                      "modulus_upper":text(local),
                      "rectangle_width":text(max(da.width(),db.width()))}
            records.append(record)
            r.record("cell_%d"%j,record)
        atomic_json(root/"cell_defects.json",records)
        denom = exp_minus(1+pi.hi/2).lo
        need(denom > 0,"Amplification enclosure unresolved")
        amplification = 1/denom
        radius = epsilon*amplification
        qr,qi = b[-1]
        modlo,modhi = sqrt_bounds(qr*qr+qi*qi)
        etalo = max(F(0),modlo-radius)**2
        etahi = min(F(1),(modhi+radius)**2)
        need(0 <= etalo <= etahi <= 1,"Inconsistent amplitude enclosure")
        verdict = ("meets_quarter_error" if etalo >= F(3,4) else
                   "does_not_meet_quarter_error" if etahi < F(3,4) else
                   "unresolved")
        sphase = min(F(1),radius/modlo) if modlo > radius else F(1)
        certificate = {
            "arithmetic":"exact_rational_with_outward_dyadic_rounding",
            "bits":BITS,"Taylor_terms":TERMS,
            "original_cells":m,"validation_cells":n,
            "pulse_cells":args.pulse_cells,
            "rounding_grid":text(F(1,SCALE)),
            "B0":interval_text(b0),
            "B0_relative_width_upper":text(b0.width()/b0.lo),
            "pi":interval_text(pi),
            "uniform_defect_upper":text(epsilon),
            "amplification_upper":text(amplification),
            "q_center":[text(qr),text(qi)],
            "center_modulus":{"lo":text(modlo),"hi":text(modhi)},
            "amplitude_radius":text(radius),
            "eta":{"lo":text(etalo),"hi":text(etahi)},
            "specified_error":{"lo":text(1-etahi),"hi":text(1-etalo)},
            "ideal_phase_verdict":verdict,
            "estimated_phase_error_upper":text(1-etalo*(1-sphase)),
            "JSON_NPZ_link":"requires separate successful inspection",
            "independently_inspected":False,
            "physical_implementation_certified":False}
        atomic_json(root/"certificate.json",certificate)
        return certificate
    
    def main():
        parser = argparse.ArgumentParser()
        parser.add_argument("--nodes",required=True)
        parser.add_argument("--out",required=True)
        parser.add_argument("--bits",type=int,default=48)
        parser.add_argument("--refine",type=int,default=1)
        parser.add_argument("--pulse-cells",type=int,default=512)
        args = parser.parse_args()
        execute(args,calculate,__file__,numerical=False,
                success="BOUND_COMPUTED_INSPECTION_REQUIRED")
    
    if __name__ == "__main__":
        main()
  • sectionRepaired exact-rational defect checkerRepaired exact-rational defect checker · lines 3123–3141
    Open as its own page

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

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

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

Selected historical identifiers and artifact requirements

  • sectionSelected historical identifiers and artifact requirementsSelected historical identifiers and artifact requirements · lines 3143–3204
    Open as its own page

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

    Historical fileReported SHA-256
    Historical fileReported SHA-256
    03h_tools.py{ c4d8418aae9c64311196237f6d08136b8332abea0912425ffb58d18958cac9ec}
    -input.tex{ e8e2bdfca338ca09fbc6e9684fccdf4290aabc2a720de90cff51a242c8a4470d}
    .txt{ c02b35f1d7116824a9c367e447ef162b7fcdf7842e49916944ac4490b55a9af6}
    _hamiltonian.npz{ 03ddb79af822cdcf4e422d26e35eae34f0eadd15bbbf43868065be574d41f457}
    _and_quench_exploratory.npz{ 473b7c90a6280d246d0873783f491e1ed4ac4783cb46572856988bd3eee9ac1e}
    _exploratory.npz{ 210179902ce213732f304549124a811d42a647f4408bdfb1480e895c412257c6}

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

    To authenticate the new summary, obtain:

    1. its actual candidate archive and invocation manifest;

    2. the patched v7 checker source and source hash;

    3. the exact rational .json and cell records;

    4. the prior successful P8 inspection report;

    5. the failed v7 inspection traceback and surviving partial records.

    To upgrade the numerical conclusions, additionally establish:

    1. exhaustive P8 spectral ordering and selected-code identification;

    2. exact normalization and phase conventions;

    3. central diagnostic intervals and occupation-rank certificates;

    4. exact candidate JSON/NPZ correspondence;

    5. a nontrivial true-pulse continuum amplitude enclosure;

    6. a decoder verdict including phase and any implementation allowances.

Declarations

  • sectionDeclarationsDeclarations · lines 3205–3238
    Open as its own page

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

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

    conclusion. The exploratory candidate estimate suggests specified-decoder error near . The reported coarse interval does not validate that estimate or a quarter-error exclusion. Certified P8 ranks and the exact reached-space dimension remain unresolved.

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

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

  • bibliographyReferencesDeclarations · lines 3239–3377
    Open as its own page

    Baseline

    N. Cheung, Em03-H: Fixed-Instance Diagnostics, Exact Extraction, and Stored-Packet Excitation-Channel Recovery, supplied -input.tex, dated 9 October 2026.

    V7

    N. Cheung, Em03-H-v7: Exact Fermionic Extraction, Quench Diagnostics, and Stored-Packet Excitation-Channel Recovery, supplied 03-H-v7.tex, dated 9 October 2026.

    P8Record

    Author-supplied P8-new .json, .txt, .txt, _configuration.txt, .json, and 03h_tools.py. Reported status _NOT_VALIDATED. These are execution materials, not numerical certificates.

    NewSummary

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

    Watrous

    J. Watrous, The Theory of Quantum Information, Cambridge University Press, 2018. https://jhwatrous.github.io/TQI.pdf.

    FuchsVandeGraaf

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

    BenyOreshkov

    C. Bény and O. Oreshkov, General conditions for approximate quantum error correction and near-optimal recovery channels, Physical Review Letters 104 (2010), 120501. arXiv:0907.5391. doi:10.1103/PhysRevLett.104.120501.

    KSW

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

    MaldacenaStanford

    J. Maldacena and D. Stanford, Comments on the Sachdev–Ye–Kitaev model, Physical Review D 94 (2016), 106002. arXiv:1604.07818. doi:10.1103/PhysRevD.94.106002.

    MSY

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

    EMV

    J. Engelsöy, T. G. Mertens, and H. Verlinde, {An Investigation of Backreaction and Holography}, Journal of High Energy Physics 07 (2016), 139. arXiv:1606.03438. doi:10.1007/JHEP07(2016)139.

    MTV

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

    NumPyEigh

    NumPy Developers, numpy.linalg.eigh, NumPy v2.2 Manual. https://numpy.org/doc/2.2/reference/generated/numpy.linalg.eigh.html. Interface documentation aligned with the reported NumPy 2.2.6 runtime.

    NumPyConfig

    NumPy Developers, numpy.show_config, NumPy v2.2 Manual. https://numpy.org/doc/2.2/reference/generated/numpy.show_config.html.

    FLINTMat

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

    JohanssonArb

    F. Johansson, Arb: Efficient Arbitrary-Precision Midpoint-Radius Interval Arithmetic, arXiv:1611.02831, 2016. https://arxiv.org/abs/1611.02831.

    JohanssonIntegration

    F. Johansson, Numerical integration in arbitrary-precision ball arithmetic, arXiv:1802.07942, 2018. https://arxiv.org/abs/1802.07942.

    PythonNumeric

    Python Software Foundation, The Python Language Reference: Data model, Emulating numeric types, Python 3.10 documentation. https://docs.python.org/3.10/reference/datamodel.html.

    PythonIO

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