R88 G02 working derivation 2 — a computable approximate flow and its localization
Conditional on the exact-parent gap candidate of R87 and the efficient access derivation in work-01. This avoids treating an unspecified quasi-adiabatic filter as a free numerical primitive.

1. Abstract quantitative assumptions, already tied to the parent.
After the work-01 truncation, each of the two path segments has
 Q(s)=sum_x q_x(s), 0<=s<=1,
with one anchor per doubled site, declared support radius r0=O(M), and
 ||q_x||, ||q_x'||, ||q_x''|| <= C0.
There are N anchors, O(1) qubits per physical lattice cell, and spatial dimension d=2. The ground state is unique and its gap is at least gamma, with 0<gamma<=1. Here gamma can be chosen as a fixed fraction of the R87 lower bound c min(1,delta)^q0. All constants C0 are independent of N and delta; very conservative LCU constants are allowed. The initial state of the first segment is the Bell product, and the two segment ground states agree at their join. The final truncated-parent ground state is O(epsilon)-close to the exact TFD, with that error budget explicitly reserved.

Throughout this file, gamma denotes the lower bound AFTER parent truncation, not the larger untruncated gap. No local patch is assumed gapped.

2. An elementary Gaussian approximate inverse-frequency filter.
For sigma>0 define the real odd function
 F_sigma(t)=(1/2) sign(t) erfc(sigma |t|/sqrt(2)).
With Fourier convention integral F(t)exp(i omega t)dt,
 hat F_sigma(omega)=i[1-exp(-omega^2/(2sigma^2))]/omega,
with value 0 at omega=0. Indeed integrate the sine transform by parts and use the elementary Gaussian cosine transform. Its L1 norm is sqrt(2/pi)/sigma. Let
 A_sigma(s)=int_R F_sigma(t) exp(itQ(s)) Q'(s) exp(-itQ(s))dt.
This is Hermitian. Define U_sigma'(s)=i A_sigma(s)U_sigma(s), U_sigma(0)=I. The sign is chosen so that an excited-ground matrix element of i A_sigma is
 -[1-exp(-Delta^2/(2sigma^2))] Q'_{m0}/Delta.
In parallel-transport gauge the exact ground derivative is -Q'_{m0}/Delta. Hence
 ||Omega'(s)-i A_sigma(s)Omega(s)||
 <= ||Q'(s)|| gamma^-1 exp[-gamma^2/(2sigma^2)]
 <= C0 N gamma^-1 exp[-gamma^2/(2sigma^2)].                            (1)
This uses only the off-ground reduced resolvent, so it also holds when the truncated parent's ground energy is nonzero and unknown. The odd filter gives zero diagonal contribution. Integrating (1) by variation of constants for unitary evolution bounds the final vector error by its integral; no exponential in ||A_sigma|| or N appears.

Choose
 ell=log(C1 N/(epsilon gamma)),
 sigma=gamma/sqrt(8 ell),   T=8 ell/gamma,
where C1 is a sufficiently large fixed constant and ell>=1. Both the inverse-frequency error and the Gaussian time tail have exponent at least 4ell. More explicitly,
 int_{|t|>T}|F_sigma(t)|dt <= C/(sigma^2 T) exp(-sigma^2 T^2/2)
 <= C gamma^-1 exp(-4ell).
Thus replacing A_sigma by its integral over [-T,T] adds at most C N gamma^-1 exp(-4ell) in integrated operator norm. Each error can be made <=epsilon/100 by increasing C1. The filter is only approximate, which is sufficient for the requested global trace error. We do not claim exact spectral flow with a Gaussian frequency cutoff.

3. A crude finite-range LR bound with polynomial parameters.
For the truncated Q, use spatial weight mu=1/r0. At a site z, at most C r0^d anchored terms contain z; each has at most C r0^d sites and norm <=C0. The standard finite-range commutator iteration therefore has rate
 kappa <= C C0 r0^(2d)
and an exponential spatial factor exp[-dist/r0]. This is a deliberately loose Lieb–Robinson bound. Its rate is polynomial in r0, not an unknown function of a growing local Hilbert-space dimension.

Let B_R(x) be a physical ball, R>4r0, and let Q_B(s) include only q_y(s) whose declared supports are wholly in B_R(x). Compare evolution of q_x'(s) under Q(s) and Q_B(s). Duhamel expresses the difference as an integral of commutators with omitted terms. An omitted term's anchor is beyond R-r0, and its support can extend another r0 inward; the initial observable also has radius r0. Thus the support-to-support distance is at least R-3r0. We use the looser R-4r0 below to keep a margin. The LR estimate bounds the commutator's support factors by C r0^(2d). Bounding the number of omitted terms by N, rather than optimizing a boundary sum, gives for |t|<=T
 ||tau_t^Q(q_x')-tau_t^QB(q_x')||
 <= C N T r0^(2d) exp[kappa T-(R-4r0)/r0].                           (2)
The N factor here is harmless because it enters a logarithm when choosing R; it is not a simulation cost. Terms entirely disjoint from the restricted dynamics commute and contribute zero. Periodic wraparound is handled using the torus metric; if the ball covers the system, take Q_B=Q and the error is exactly zero.

Define the strictly supported flow terms
 d_x(s)=int_-T^T F_sigma(t) tau_t^QB(q_x'(s))dt,
 A_R(s)=sum_x d_x(s).
They are Hermitian, supported in B_R(x), and ||d_x||<=C0 sqrt(2/pi)/sigma <=C T. Sum (2) over x and integrate |F_sigma|. Choosing, for example,
 R=ceil(4r0+r0[kappa T+log(C2 N^2 T r0^(2d)/(epsilon sigma))])          (3)
makes ||A_sigma,T-A_R||<=epsilon/100 uniformly in s. With M=O(ell), r0=O(ell), d=2,
 R <= C gamma^-1 ell^6,  |B_R|<=C R^2.                               (4)
Constants in ell can absorb log C0. All finite-size cases are included: if R is larger than the torus, its total N is itself bounded by C R^2. The locality approximation never assumes a gap for Q_B and never diagonalizes it.

Combining (1), time truncation and (3), the state produced by the unitary generated by -A_R is within O(epsilon) of the truncated-parent ground state. Each error is separately adjustable by fixed budget fractions. Both path segments use the same worst-case gamma and cutoffs.

4. Differentiability needed by the next simulation layer.
The cutoffs r0,R,T,sigma are fixed along each segment. A patch contains at most V_R=C R^2 anchors, so ||Q_B'||<=C V_R. Differentiating a real-time conjugation gives
 ||partial_s tau_t^QB(q_x')|| <= C+2C |t| ||Q_B'||.
Consequently the deliberately loose bound
 ||d_x'(s)|| <= C[T+V_R T^2]                                        (5)
holds. It is polynomial in gamma^-1 and ell. There is no exp(V_R T) derivative loss: all propagators in the Duhamel derivative are unitary. This distinction matters for both the classical precision calculation and the time-dependent Dyson oracle.

5. Efficient block encoding of d_x(s), including coherent parameters.
Use the positive-time form
 d_x(s)=(1/2)int_0^T erfc(sigma t/sqrt(2))
          [tau_t^QB(q_x')-tau_-t^QB(q_x')]dt.                         (6)
Prepare a uniform grid time on [0,T] and a uniform sign bit. The erfc value is a bounded scalar amplitude, computed reversibly with polynomial bit complexity. Its argument is O(sqrt(ell)); evaluating it does not require an oracle. The normalization in (6) is at most C T, even if the sharper C/sigma bound is not used by the circuit. The two signs are encoded coherently.

The derivative of the integrand is bounded by C(sigma+V_R), using ||Q_B||<=C V_R. An integration grid of size
 Q_time >= C T^2 (sigma+V_R)/eta
therefore gives operator error <=eta. Choose a power of two so uniform state preparation uses Hadamards. Its number of bits is logarithmic in this expression. There is no gate cost proportional to Q_time.

Each conjugation in (6) uses a block encoding of Q_B(s) with normalization <=C V_R, obtained in work-01. Hamiltonian simulation implements exp(+-it Q_B(s)) at cost polynomial in V_R,T,M,b,log N,log(1/eta). When t is held coherently in a binary register, implement its binary-weight controlled evolutions; their total simulated time is O(T), with an additional logarithmic number of precision overheads. When the outer path parameter s is also in a quantum register, the same circuit computes coefficients for that s. The normalization bound and simulation-polynomial phases are chosen uniformly in s; they do not depend on a classically measured value of s. Thus superposition access is paid by reversible arithmetic, not assumed.

Use fresh work registers or uncompute them. If a simulation primitive gives top-left operator error eta^2, its deviation as an isometry with clean ancillas is O(eta); choosing squared internal errors changes only precision logarithms. The complete construction can be a unitary circuit followed by discarding work, with no free postselection. Approximate Hermitian oracles may be symmetrized at constant overhead; all underlying ideal expressions in (6) are already Hermitian.

Primary algorithmic ingredients, used with their access costs paid: Haah–Hastings–Kothari–Low, arXiv:1801.03922v4, Lemma 6 and its time-dependent decomposition; Low–Wiebe, arXiv:1805.00675v2, Theorem 3 / Corollary 4 for time-dependent simulation with logarithmic discretization overhead. The Gaussian filter and the resource substitution above are derived here. The source's constant-range simulation theorem cannot simply be quoted with a growing ball declared a free constant-dimensional site.

Remaining work: apply the spatial decomposition to A_R itself and account for its patch simulations explicitly. A global block encoding of A_R would have normalization O(NT), and each call could cost O(N); that would lose near-linearity. The next step must avoid that nested global cost.
