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
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 pageWe 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 pageThe mathematical and physical tasks are separate:
The first two chains are constructed below. The third is conditional.
The supplied analytical sources are
-input.texand03-H-v7.tex. The supplied P8-new execution materials and the new03-H-v7-results-summary.txtare 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 pageA 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
Object Status 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 report Not supplied here Exact P8 occupation ranks and reached dimension Not numerically certified Candidate Volterra and spectral/RK outputs Newly reported, rounded summaries Patched v7 rational checker invocation Reported; exact output not supplied Reported transmission enclosure from that invocation , inconclusive New v8 software Printed, statically revised, unexecuted Validated candidate quarter-error verdict Unresolved P8 gravitational dictionary Not constructed Compilation and formal proof checking Not performed here 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 pageVersion 8:
incorporates the newly reported candidate values and coarse defect-check result;
distinguishes exploratory failure of the specified decoder from a validated exclusion and from optimal-recovery impossibility;
corrects the interval/complex multiplication dispatch defect in the printed v7 checker;
replaces repeated fixed-name checkpoint writes with a journal and unique temporary snapshot files;
retains exact JSON/NPZ node-link checks and complete saved spectral/RK states;
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 pageThe 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 pageUse , , 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 pageThese 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 pageFix 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 pageUse 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 pageTarget 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 pageThe 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 pageChoose 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 pageThe 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 pageTotal-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 pageSet , . 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 pageThe 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 pageThe 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 pageThe 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 pageStorage 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 pageFurthermore,
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 pageStorage 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 pageFor ,
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 pageA 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 pageFor 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 pageNonzero 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 pageTarget 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 pageWriting , , 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 pageSet
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 pageLet 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 pageEach 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 pageThe 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 pageThis 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 pageFor 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 pageLet 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 pageFor 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 pageFor 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 pageFor 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 pageFor 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 pageThe 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 pageNearly-, 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 pageSet
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 pageOn , set
propositionProposition: Well-posed evolutionRestricted continuum experiment › Exact one-species evolution · proof attached · lines 1204–1216
Open as its own pageFor 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 pageThe 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 pageLet , . 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 pageWrite . 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 pageIn 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 pageThe 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 pageFor , 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 pageIts 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 pageProof. 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 pageFor 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 pageThis 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 pageThe 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:00and2026-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 quantity Reported value, evidence P8 quantity Reported 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.
Occupation Reported singular values Exact rank 0 Unresolved 2 Unresolved 4 Unresolved 6 Unresolved 8 Unresolved 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
.jsonI/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 pageThe supplied results summary reports the following rounded values. Its numerical precision is not promoted to an error guarantee.
{}1.12
Candidate quantity Reported value, evidence Pulse normalization Volterra mesh Volterra mesh Reported finest spectral/RK endpoint Reported finite spectral-system norm Approximately one Reported spectral/finest-Volterra difference Approximately 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 pageThe 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 pageThe 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 pageUse 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:
approximate QR eigenvalues, with heuristic convergence only;
global spectrum coverage, without a one-to-one ball assignment;
successful all-simple isolation;
successful exhaustive counted clusters;
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 pageLet , , 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 pageThe 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 pageIf 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 pageIf 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 pageFor 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 pageIf , 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 pageInitial-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 pagePartition 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 pageLet . 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 pageIf 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 pageTo 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 pageUsing 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:
tighten when pulse-normalization uncertainty dominates;
refine validation cells when kernel/interpolant range wrapping dominates;
refine solver nodes when the approximation defect dominates;
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 pageFor , 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 pageThe 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 pageThe 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:
an append-only check journal, flushed and synchronized after each record;
unique temporary snapshot files in the destination directory;
bounded retries for selected transient I/O errors;
independent finalization attempts that do not replace the original numerical exception;
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 pageAn 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 pageIf 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 pageFor 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 pageThe 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 pageThe 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 pageExtract 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 pageThe 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 pageExtract 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 pagejustification. 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 pageThe following SHA-256 identifiers are copied from the supplied P8-new manifest. Original attachment bytes have not been independently rehashed here.
Historical file Reported SHA-256 Historical file Reported 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:
its actual candidate archive and invocation manifest;
the patched v7 checker source and source hash;
the exact rational
.jsonand cell records;the prior successful P8 inspection report;
the failed v7 inspection traceback and surviving partial records.
To upgrade the numerical conclusions, additionally establish:
exhaustive P8 spectral ordering and selected-code identification;
exact normalization and phase conventions;
central diagnostic intervals and occupation-rank certificates;
exact candidate JSON/NPZ correspondence;
a nontrivial true-pulse continuum amplitude enclosure;
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 pageBaseline
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, and03h_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.