M05: global Gibbs preparation with explicit binary input overhead
22 October 2026. /root/qualification_backlog.
Prospective global-composition theorem, subject to independent review.
No original status, manuscript, or round file is changed by this packet.

THEOREM AND OPERATIONAL MODEL

Fix local dimension and finite interaction range. Let H_N be a one-dimensional
Hamiltonian given by ordinary local binary matrices, beta>=0, and 0<epsilon<1/4.
Let J_int bound intersite interaction strength, excluding onsite fields, and
x=1+beta J_int. Let b include the supplied local/scalar input bit lengths,
integer magnitude bits, and the full raw description length per fixed local
neighborhood if repeated supports are listed. Site labels cost O(log N)
bits separately. Source inputs are supplied to the absolute accuracy
specified below, not as free exact real oracles.

Using the frozen R44, R45 and R46 constructions as algorithmic lemmas, there
is a uniform randomized quantum preparation algorithm whose output density
matrix, averaged over its discarded classical random choices, satisfies
  (1/2)||rho_out-exp(-beta H_N)/Z||_1 <= epsilon.
Both its number of elementary gates and its classical bit-operation count,
including input processing and expanded circuit output, obey
  exp(C x^3) N (1+b)^c [1+log(N/epsilon)]^(C x+c).                 (G1)
Here C,c depend only on fixed local parameters and fixed arithmetic/gate
conventions, not onsite energy values, N, epsilon or b. Increasing them
absorbs constant-factor grouping and rounding changes in x. The degree of
the polynomial in b is fixed; the precision-log exponent is explicitly O(x).
Randomness requires a bounded number of fair bits, not an expected-runtime
rejection procedure. The local quantum circuits need no quantum random-access
memory or coherent table of N block circuits.

This theorem is a composition of pinned mathematical and circuit results,
not a fresh proof of rapid mixing, QBP, Hamiltonian simulation, or LCU.
Its new work is to discharge the global input/sampling/preprocessing/error
contracts left open in R46, including the small-chain branch. It is one
prospective M05 result, not separate credit for each bookkeeping lemma.

1. INPUT NORMALIZATION AND ONE GLOBAL ROUNDING BUDGET

Group a fixed number of sites to obtain a nearest-neighbor chain of n<=N
sites of fixed dimension. The resulting crossing strength is at most a
fixed multiple of J_int. Preserve the original site tensor factors when
reporting the output. Reading, sorting labels, and aggregating duplicate
supports costs O(N poly(b,log N)) with the stated raw-input convention;
an arbitrarily long repeated-support list is never given a free O(N) cost.

Work at inverse temperature one with dimensionless terms k_X=beta h_X.
Multiply and round them to Hermitian dyadic matrices ktilde_X once, before
constructing any block circuit. With s=O(N) aggregated terms, require
  ||ktilde_X-k_X|| <= epsilon/(128s).
Their sum Ktilde then obeys ||Ktilde-beta H_N||<=epsilon/128.
For Hermitian K,V, differentiating the normalized exponential yields
  d rho(K+tV)/dt = -integral_0^1 rho^(1-u)
                [V-Tr(rho V)I] rho^u du.
Schatten Holder gives trace norm at most 2||V||. Integrating along the
line segment therefore gives
  ||rho(Ktilde)-rho(beta H_N)||_1 <= epsilon/64.                (G2)
This conservative constant follows directly from source Section 6.1 and
does not require the sharper previously inherited R30 bound.

For real input values supplied to finite precision, a sufficient separate
allocation is ||h_X-hhat_X||<=epsilon/[C s max(1,beta)] and
|beta-betahat|<=epsilon/[C(1+sum_X||hhat_X||)], with C enlarged for fixed
matrix dimension and product rounding. Thus the needed fractional bits
are O(log(N/epsilon)+log(1+beta)+log(1+sum_X||h_X||)); integer magnitude
bits and all original input-reading costs remain in b. For exact rational
input data these are ordinary polynomial-bit multiplications and rounding.
All later circuit approximations target the SAME Ktilde, so no perturbation
of a huge chain Hamiltonian is paid again at every update.

Compute a conservative upper bound Jbar on the intersite strength of
Ktilde using absolute entry sums in its constant-dimensional interaction
matrices and maxima of incident sums. It is computable in O(N poly(b,Q))
work, Q=1+ceil(log_2(64N/epsilon)), and satisfies Jbar<=C beta J_int+1.
Set X=1+Jbar>=1. Then X<=C x, while onsite terms remain excluded. Working
with Ktilde at beta=1 eliminates a separate approximate-temperature oracle.
The zero-temperature-parameter case beta=0 is a product maximally mixed
state. Zero interactions may be treated directly by the R45 leaf circuits.

2. COMPUTABLE MIXING PARAMETERS, INCLUDING THEIR CONSTANTS

The imported source is Rouze--Stilck Franca 2610.03578v1. Proposition 5.11
proves a DS contraction kappa=1/2 for the labelled interval family; its
proof Eq. (5.31), not merely the existence assertion in Theorem 5.1,
is used to choose parameters. All source constants below depend only on
the fixed local dimension/range and can be hardwired in the algorithm.
No instance-dependent uncomputed threshold is supplied as an oracle.

For the rounded dimensionless Hamiltonian, the source gives
  M^4<=exp(2(X-1)), lambda=c_0/X,
  K_loc<=C_0 exp(2(X-1)) X^7,
  A_u<=C_1[(u+1)+X^2 exp(8(X-1))(u+X)^2].
The first is the dressing bound, K_loc is the source transport-locality
constant K_beta, and A_u is the boundary-influence sum. The infinite sum
defining A_u need not be evaluated: its explicit upper bound is enough.

Choose fixed positive integers A,C_L sufficiently large, and set
  u_0=ceil(A X^2),
  ell=ceil(C_L X^2 (u_0+2)^3) * 2^ceil(12X),
  T=(u_0+2) * 2^ceil(4X).                                    (G3)
These are integers obtained by polynomial-bit arithmetic. In particular
ell>=2, ell<=exp(CX), T<=exp(CX), and log ell=O(X). This conservative
choice differs from the source's sharper Eq. (5.32), but is checked below
in the SAME source influence inequality. It does not assume increasing
T arbitrarily preserves a proved DS condition.

Take C_L>=max(256,160 C_1), increasing the integer if necessary, so that
ell>=32(u_0+1)A_(u_0) and
ell>=256(u_0+1)^2. This follows from the displayed A_u bound because
u_0>=X and 2^(12X)>=exp(8X). Next
  M^(-4) T >= exp(2) exp((4 log 2-2)X)(u_0+2),
which exceeds log(8[1+16(u_0+1)]). Consequently the first two positive
terms in source Eq. (5.31) are each at most ell/8.

For the remaining term let
  g_0=(1-exp(-lambda/2))^(-1)<=C X,
  g_1=exp(-lambda/2)/(1-exp(-lambda/2))^2<=C X^2.
Dividing its exact expression in Eq. (5.31) by ell bounds it by
  C K_loc T (u_0+1) exp(-c_0 u_0/(2X))
  <= C'(A+2)^2 X^11 exp((2+4 log 2)X-c_0 A X/2)
  <= C'(A+2)^2 exp(-(c_0 A/2-17)X).                           (G4)
Here X^11<=exp(11X), and harmless fixed factors are in C'. Choose A
so that c_0 A/2>17 and C'(A+2)^2 exp(-(c_0 A/2-17))<=1/4.
Such a fixed integer exists because exponential decay beats A^2. The
same bound then holds for all X>=1. This verifies the last term is
at most ell/4. Eq. (5.31) yields sum_B[D_B(j)-1]<=-ell/2 for every j.
Only explicit integer operations in (G3) depend on the input; the proof's
fixed constants are ordinary algorithm constants, as in the source theorem.

3. SMALL CHAIN AND DISCRETE MIXING BRANCHES

If n<ell, use R45 directly to prepare the Gibbs purification of the entire
rounded chain at vector error epsilon/16. Its balanced tree has
h=ceil(log_2 n)<=O(X), so the frozen R45 recurrence is at most
exp(C X^3)(1+b)^c Q^(C X+c), covered by (G1). This branch does not purify
a region whose height grows with log log(N/epsilon); it has n<ell.
Trace norm is at most twice vector error, and (G2) completes its error
budget. Initializing its work registers and discarding the environment
are included. This also handles every finite chain shorter than the source
block scale without enumerating ell labels or ell identical full-chain blocks.

Suppose n>=ell. Let m=n+ell-1<=2n and retain all source block labels
  a=2-ell,...,n, B_a=[a,a+ell-1] intersect [n].
Every site lies in exactly ell labelled blocks. Put
  P=(1/m) sum_a Phi_(B_a), a_tot=m/ell,
  k=ceil(4 a_tot Q).
The source Theorem 4.4 gives, from any state rho_0,
  ||P^k(rho_0)-rho(Ktilde)||_1
    <=2n(1-1/(2a_tot))^k <=2n exp(-k/(2a_tot))
    <=2N exp(-2Q) < epsilon/32.                              (G5)
Choose rho_0 as a computational-basis product state. The number of updates
is deterministically k=O(NQ/ell+1)<=O(NQ). This is the source's discrete
contraction result, not an inference from the continuous mixing time.
There is no need to simulate exp(t L), draw a Poisson count, or approximate
its CDF for the Gibbs-preparation target. We make no claim here about the
stronger task of simulating the entire global semigroup on arbitrary inputs.

4. LOCAL UPDATE ACCURACY AND THE ACTUAL ORACLE CHAIN

Let delta=epsilon/(64k). The source Proposition 5.7 and Appendix B.1
give chain constants
  mu=c_0/(2X), C_loc<=exp(CX),
and channel localization error <=T C_loc exp(-mu v) for
v>=max(range,ell). Choose v conservatively by integer upper arithmetic so
that this is <=delta/2. It suffices to take
  v=max(range,ell,ceil(C X[X+1+log(1/delta)])),
where fixed C incorporates c_0 and the explicit bounds on T,C_loc.
The region R=B_a^{<=v} has size <=exp(CX)(1+log(1/delta)).
All constructions use the restricted rounded Hamiltonian Ktilde_R and
retain the reset Gibbs state on B_a, exactly as in source Appendix B.1.

The pinned local chain of constructions is:
  R44: actual coherent interacting QBP filter from local binary matrices;
  R45: ordered Dyson dressing and separately constructed inverse, charged
       amplified recursive purification of B_a, collective reset stack V;
  R46: exact correction G_(Ktilde_R)(V*V) via the binary csch inverse CDF,
       its exact Hermitian involutive completion, and stacked simulation.
All these are algorithms, including classical compilation and their
specified approximation accuracies; they are not new unit-cost oracles.

Invoke R46 local simulation at diamond error delta/2. Its compiled stack
and Hermitian block define an exact nearby Lindblad generator, and its
diamond error is bounded by the explicit nearby-generator/Duhamel argument
in that frozen proof. Hence the implemented channel Lambda_a obeys
  ||Lambda_a-Phi_(B_a)||_diamond <=delta.                       (G6)
This holds on every input and reference, not only on the eventual Gibbs
state. It pays for the exact coherent correction as well as jump/loss terms.
Its elementary-gate count, number of ancillas, and classical construction
cost are bounded by
  C_upd <=exp(C X^3)(1+b)^c [1+log(1/delta)]^(C X+c).           (G7)
Temporary scalar/input accuracy increases by O(X+log(1+b)+log(1/delta))
bits in the local composition. The R46 proof explicitly absorbs powers
of log(1+b) into exp(poly(X)) times a fixed-degree polynomial in b. No
onsite ENERGY normalization or enumeration of d^(2ell) jumps is hidden.
Since log(1/delta)=O(Q), (G7) has precisely the stated temperature-dependent
power of Q. Circuit inverses reverse compiled gates; approximation errors
are not multiplied as independent black-box errors without that analysis.

5. BOUNDED FINITE-BIT LABEL SAMPLING

For each of k updates, independently draw a p-bit uniform integer j and
choose the label index f(j)=floor(m j/2^p), where
  p=ceil(log_2(64 k m/epsilon)).
Then add 2-ell to obtain the source label a. Each output has either floor
or ceil(2^p/m) preimages. The induced law q differs from uniform in total
variation by at most m/2^p<=epsilon/(64k). This exact count, rather than
unbounded rejection sampling or a free categorical oracle, supplies the
sampling guarantee. Multiplication, division by a power of two, and label
arithmetic cost polynomial(p,log m) bit operations; p=O(Q).

Let P_q=sum_a q_a Phi_(B_a) and Lambda_q=sum_a q_a Lambda_a. Because
channels have diamond norm one,
  ||P_q-P||_diamond<=2 TV(q,uniform)<=epsilon/(32k),
  ||Lambda_q-P_q||_diamond<=delta.
Contractivity and telescoping yield
  ||Lambda_q^k-P^k||_diamond<=epsilon/32+k delta
                           <=3epsilon/64.                    (G8)
No hypothesis that every sampled trajectory is itself close to the Gibbs
state is made. The output state of the randomized algorithm is the density
matrix after discarding its random bits, exactly Lambda_q^k(rho_0).
This is the same classical random-update operational model used by source
Appendix B, specialized to a fixed number of updates. If fair bits are
generated quantum mechanically, p Hadamards and measurements per update
are counted; classical random bits have the same linear bit count.

Combining (G2), (G5), (G8) gives trace error below
  epsilon/64+epsilon/32+3epsilon/64=6epsilon/64,
well within the required 2epsilon trace-norm budget. The slack permits
routine dyadic epsilon rounding downward by a factor at most two and any
remaining product-state initialization/discard conventions. The numerical
budgets are deliberately conservative. No per-step Gibbs-input rounding
term is added: the ideal target throughout (G5)--(G8) is Ktilde.

6. GLOBAL CLASSICAL PREPROCESSING AND CIRCUIT ASSEMBLY

To avoid a hidden N-cost controlled selection at each quantum step,
pre-sample the k labels classically. This produces a distribution of
ordinary finite circuits. Compilation is classical and may depend on the
sampled labels; their mixture is the preparation algorithm's output state.
Equivalently a classical controller runs those circuits sequentially. A
fully coherent control over N precomputed quantum circuits is not assumed.

There are at most m<=2N local block templates. Compile each once to the
common accuracy delta, with its region and initial/final work-register
conventions. Extracting/copying their overlapping neighborhoods costs at
most O(N |R| poly(b,Q)), already covered by N times (G7). A sequential
window scan or an offline sorted list join achieves this bound without
quantum memory. It is harmless to compile unused templates; this gives a
simple worst-case upper bound and makes randomness-independent compilation
cost explicit. Large integer onsite phases are compiled by the pinned
R44 arithmetic, not by enumerating their oscillations.

For completeness even classical random-access memory is unnecessary for
the cost class. Make request records (label,step) for the k sampled labels;
sort by label, merge with the sorted template file, and attach one copy of
the template for each request. Sort the resulting records by step. Merge
sorting variable-length records needs at most O(log(N+k)) passes, each
linear in their total written size, with polynomial-length label comparisons.
The total template/expanded-circuit size is O((N+k) C_upd poly(Q)). Thus
this explicit sequential-tape alternative stays within the claimed bit
bound. It pays for copying actual gate lists, not just recording oracle names.

Rebase each local system-wire address by the region offset, at O(poly(log N))
cost per gate. Fixed-size grouped sites unpack to the original wires with
constant overhead. Ancillas can be freshly initialized or reused after
measurement/reset/discard; their number per update is bounded by its circuit
size and is charged. Every worst-case random seed produces at most k update
circuits of the same size bound, so the work is bounded, not merely expected.

Since k<=C NQ and log(N+k)=O(Q), multiplication of (G7) by N+k and the
sorting/address/bit overhead proves (G1), after increasing c. Reading and
rounding the original matrices costs N poly(b,Q), also covered. The small
chain branch was already bounded in Section 3. There is no additional
temperature-dependent exponent on b or numerical onsite norm.

7. EXACT RELATION TO M05 AND CURRENT VERIFICATION STATUS

The exact original asks for exp[C(1+beta J_int)^c] N polylog(N/epsilon),
specifying all input-precision costs and the temperature dependence of the
polylog exponent. Equation (G1) is the explicit-input version of that bound:
the temperature prefactor is exp(Cx^3), and the precision exponent is O(x).
It does not claim the suggested stronger quadratic temperature exponent or
a temperature-uniform precision exponent.

The factor (1+b)^c cannot be erased for unrestricted binary input lengths.
If local/scalar inputs have the usual requested-precision descriptions with
b<=poly(x,1+log(N/epsilon)), it is absorbed into the displayed target shape.
For arbitrary onsite magnitude or redundant raw descriptions, it remains
an explicit polynomial input overhead. Source Theorem 3.11 itself fixes
local norm bounds and asks for sufficiently precise data, while its chain
mixing statement permits arbitrary onsite norms. Our theorem keeps that
distinction visible and extends the implementation bound to arbitrary
onsite magnitudes with logarithmic-magnitude/bit costs. It does not assert
an impossible input-reading bound independent of input length.

All algorithmic global contracts named in the frozen R46 remaining-gap
paragraph are discharged here for Gibbs preparation: input normalization,
computable source parameters, mixing from a product state, locality,
bounded label sampling, actual local circuits, and classical assembly.
The result remains a prospective theorem pending independent review of
this composition and its pinned R44/R45/R46 dependencies. Resolving the
original's input-overhead convention and promoting an original status are
separate owner/parent decisions; this helper makes neither decision.
