Qubitization walk simulation

What it fills

• Simulate Hamiltonian evolution

  Implement $e^{-iHt}$ to error $\varepsilon$ given some access model for $H$. It is an application in its own right and also the engine inside phase estimation and several linear-system solvers.

When it applies

Applies to Hermitian $H$, and consumes a block-encoding-like access model rather than raw data, so it does not solve the data-input problem by itself. The subnormalization $\alpha$ is inherited from whatever built the encoding and downstream cost is linear in it. The arccos spectral relation means eigenvalues near the edges of the spectrum are resolved differently from those near zero. On provenance: Low and Chuang build on Childs' extension of Szegedy's quantum walk rather than introducing the walk themselves.

Requires

These do not move the route along. The method needs each of them alongside its own work, and the cost of getting them is part of what the method costs.

• QSP phase factors

  Given an admissible polynomial, compute the phase sequence $Φ$ that makes the quantum-signal-processing product reproduce it to accuracy $\varepsilon$ in classical finite-precision arithmetic.

  This method asks the slot for one classical computation, done before the circuit runs: given a target pair $(A, C)$ approximating $e^{-i\lambda t}$, return the phase vector $\vec{\phi} \in \mathbb{R}^Q$ that drives the $Q = O(t + \log(1/\varepsilon))$ phased walk iterates. The coefficients handed over are those of the Jacobi-Anger expansion, printed at their Eq. (32) as $e^{-i\lambda t} = J_0(t) + 2\sum_{k\,\mathrm{even}>0}(-1)^{k/2} J_k(t) T_k(\lambda) + i2\sum_{k\,\mathrm{odd}>0}(-1)^{(k-1)/2} J_k(t) T_k(\lambda)$, truncated at order $q = O(t + \log(1/\varepsilon))$ and rescaled. That right-hand side is the expansion of $e^{+i\lambda t}$, not of the left: it is what collapsing the very form the paper quotes one line above, $e^{i\cos(z)t} = \sum_k i^k J_k(t) e^{ikz}$, gives — and for $e^{-i\lambda t}$ the odd sum carries $-i2$, since $(-i)^k = -i(-1)^{(k-1)/2}$ at odd $k$ while the even terms are real and unchanged. Nothing downstream turns on it, because $A$ and $C$ are fitted to whichever target is wanted; the identity as printed is simply the conjugate of the one it claims. Existence and efficient computability of $\vec{\phi}$ are not this method's own result: they are Theorem 1 of Low and Chuang's earlier QSP letter, restated by number here as Lemma 13 — for even $Q > 0$, $A(\theta) = \sum_{k=0}^{Q/2} a_k \cos(k\theta)$ and $C(\theta) = \sum_{k=1}^{Q/2} c_k \sin(k\theta)$ are achievable by some $\vec{\phi} \in \mathbb{R}^Q$ iff $A(0) = 1$ and $A^2(\theta) + C^2(\theta) \le 1$ for all $\theta$, and then $\vec{\phi}$ is computable in classical $O(\mathrm{poly}(Q))$ time. approximation: the truncated pair is only $\varepsilon$-close to admissible rather than exactly admissible; a stability lemma perturbs it into an admissible pair within $O(\sqrt{\varepsilon})$.

  approximation

Example

given  a block-encoding pair (U, |G>) with H = (<G| x I) U (|G> x I),
       H Hermitian, and the subnormalisation alpha inherited from whatever
       built that encoding

build the walk operator W from (U, |G>)
    # W splits the space into invariant two-dimensional SU(2) subspaces, one
    # per eigenvalue of H, with eigenvalues exp(+- i arccos(H/alpha))

apply the quantum signal processing phases to W

return exp(-iHt)

# consumes a block-encoding-like access model rather than raw data, so it
# does not solve the data-input problem by itself
# downstream cost is linear in alpha
# the arccos relation means eigenvalues near the edges of the spectrum are
# resolved differently from those near zero

Cost, as the source states it

Low and Chuang state a query complexity $O(t + \log(1/\varepsilon))$ to both oracles "that is optimal with respect to all parameters in both the asymptotic and non-asymptotic regime", using at most two additional ancilla qubits. The approach subsumes prior sparse-Hamiltonian and linear-combination-of-unitaries approaches with significant improvements in space and gate complexity, such as a quadratic speed-up for precision simulations.

Implementations

• Qualtran's `QubitizationWalkOperator` and `HamiltonianSimulationByGQSP` bloqs

  • Expressing and Analyzing Quantum Algorithms with Qualtran
  • Generalized Quantum Signal Processing

  Qualtran is Google Quantum AI's Python library, described in its own repository metadata as "a Python library for expressing and analyzing Fault Tolerant Quantum algorithms". It carries this method as two separate bloqs rather than one, and the split matches this record's own hop — walk the encoding, then phase the walk. `qualtran/bloqs/qubitization/qubitization_walk_operator.py` builds the walk from a block-encoding it is handed rather than one it builds, so it begins where the block-encoding step ends; `qualtran/bloqs/hamiltonian_simulation/hamiltonian_simulation_by_gqsp.py` phases that walk to reach $e^{-iHt}$. The first module's header states the purpose in the same order this record does: "The spectrum of a quantum Hamiltonian can be encoded in the spectrum of a quantum 'walk' operator", and "We first document the SelectOracle and PrepareOracle abstract base bloqs, and then show how they can be combined in `QubitizationWalkOperator`." One qualifier belongs at the top, because the artefact does not phase the walk the way this method's own source does: the simulation bloq's References field names Motlagh and Wiebe's Generalized QSP, "Theorem 7, Corollary 8", not Low and Chuang's phased iterate $W_\phi$. The walk-operator docstring likewise credits its construction to "Babbush et al. (2018). Figure 1", not to Low and Chuang.

  `QubitizationWalkOperator` is an `attrs.frozen` `GateWithRegisters` holding a single field, `block_encoding: Union[SelectBlockEncoding, LCUBlockEncoding]`. Its docstring states the LCU precondition before anything else — "For a Hamiltonian $H = \sum_l w_l H_l$ (where coefficients $w_l > 0$ and $H_l$ are unitaries)" — and then gives the construction as $W = R_{L} \cdot \mathrm{SELECT}$, "a product of two reflections: $R_L = (2|L\rangle\langle L| - I)$ and $\mathrm{SELECT}=\sum_l |l\rangle\langle l|H_l$", with $|L\rangle$ the PREPARE output, "$\mathrm{PREPARE}|0\dots 0\rangle = \sum_l \sqrt{\frac{w_{l}}{\lambda}} |l\rangle = |L\rangle$". It states the qubitization property in this method's own terms: "The action of $W$ partitions the Hilbert space into a direct sum of two-dimensional irreducible vector spaces giving it the name 'qubitization'"; for an eigenstate $|k\rangle$ of $H$ with eigenvalue $E_k$ that space is spanned by $|L\rangle|k\rangle$ and an orthogonal state $\phi_k$, and the rotation claim is confined to it — "In this space, $W$ implements a Pauli-Y rotation by an angle of $-2\arccos(E_k / \lambda)$ where $\lambda = \sum_l w_l$." The header's strict positivity is not what the code carries: `sum_of_lcu_coefficients` is documented as the "value of $\lambda$, i.e. sum of absolute values of coefficients $w_l$" and returns `self.block_encoding.alpha`. In code the reflection is not written out either; `reflect` returns `ReflectionUsingPrepare(self.block_encoding.signal_state, global_phase=-1)`, `build_composite_bloq` adds the block encoding and then that reflection, and `build_call_graph` charges exactly `{self.block_encoding: 1, self.reflect: 1}`. `HamiltonianSimulationByGQSP` is a `@frozen` `Bloq` over `(walk_operator, t, precision)`. It approximates $e^{i\theta} \mapsto e^{it\cos\theta}$ by the Jacobi-Anger expansion $e^{it\cos\theta} = \sum_{n = -\infty}^{\infty} i^n J_n(t) (e^{i\theta})^n$, truncated to $P[t](z) = \sum_{n = -d}^d i^n J_n(t) z^n$; the truncation degree comes from `degree_jacobi_anger_approximation(self.t * self.alpha, precision=self.precision / 2)` in `qualtran/linalg/polynomial/jacobi_anger_approximations.py`. Because "the eigenphases of the walk operator above are $e^{-i\arccos(E_k / \|\alpha\|_1)}$, we can use the GQSP polynomial with $P = P[-\|\alpha\|_1 t]$ to obtain $P(U) = e^{-iHt}$", and the resulting operator is sandwiched: $(I \otimes \text{PREPARE}^\dagger \otimes I) G (I \otimes \text{PREPARE} \otimes I) |0\rangle|0\rangle|\psi\rangle = |0\rangle|0\rangle e^{-iHt}|\psi\rangle$. `build_call_graph` charges, for degree $d$: one `Always(prepare)`, one `Always(prepare.adjoint())`, $d$ copies of the walk operator controlled on `CtrlSpec(cvs=0)`, $d$ copies of `walk_operator.adjoint().controlled()`, and $2d + 1$ arbitrary `SU2RotationGate`s. The `precision` argument is documented as "Split into two: half to approximate $e^{it\cos\theta}$ to a polynomial, and half to synthesize the underlying GQSP rotations."

  No physical dataset — the inputs are Hamiltonians constructed in code. The registered `bloq_example`s for the walk operator are three: a 1D Ising model, `get_walk_operator_for_1d_ising_model(4, 2e-1)`; a tensor-hypercontraction chemistry Hamiltonian on `num_spinorb = 152`, `num_bits_state_prep = 10`, `num_bits_rot = 20`, `thc_dim = 450`, with random integrals from `build_random_test_integrals(thc_dim, num_spinorb // 2, seed=7)` and a source comment reading "Li et al parameters from openfermion.resource_estimates.thc.compute_cost_thc_test"; and a sparse chemistry Hamiltonian on `num_spin_orb = 8`, `num_bits_rot_aa = 8`, `num_bits_state_prep = 12`. The simulation bloq's own example is a $2\times2$ Fermi-Hubbard lattice, `get_walk_operator_for_hubbard_model(2, 2, 1, 1)` — the signature is `(x_dim, y_dim, t, u)` — wrapped as `HamiltonianSimulationByGQSP(walk_op, t=5, precision=1e-7)`, plus a fully symbolic twin over `sympy` symbols $\tau$, $t$, $\epsilon^{-1}$. The tests add randomly generated Hamiltonians: `random_qubitization_walk_operator` builds a "Szegedy Walk operator for a randomly generated Hamiltonian $H$ of $2^n$ $m$-qubit Paulis" with $\alpha_j \ge 0$ summing to 1, drawn from a `np.random.RandomState(42)` seeded in the test.

  https://github.com/quantumlib/Qualtran, Python, Apache-2.0. The two modules are `qualtran/bloqs/qubitization/qubitization_walk_operator.py` (class `QubitizationWalkOperator`, plus `_walk_op`, `_thc_walk_op`, `_walk_op_chem_sparse`) and `qualtran/bloqs/hamiltonian_simulation/hamiltonian_simulation_by_gqsp.py` (class `HamiltonianSimulationByGQSP`, plus `_hubbard_time_evolution_by_gqsp` and `_symbolic_hamsim_by_gqsp`). Each ships a Jupyter notebook beside it — `qubitization_walk_operator.ipynb` and `hamiltonian_simulation_by_gqsp.ipynb` — and the walk-operator test suite executes its notebook as a test. Supporting modules read for this entry: `qualtran/linalg/polynomial/jacobi_anger_approximations.py`, `qualtran/bloqs/chemistry/hubbard_model/qubitization/walk_operator.py`, and `qualtran/bloqs/for_testing/random_select_and_prepare.py`. Files read from the repository's default branch `main` on 2026-08-26.

  Two numerical checks by classical simulation of the circuits, and one symbolic cost assertion; no hardware anywhere. First, the walk relation itself: `test_qubitization_walk_operator` — carrying `@pytest.mark.slow`, so it is excluded from the default suite — runs the 1D Ising model at `(num_sites, eps)` of `(3, 0.5)` and `(4, 0.5)`, prepares $|L\rangle|k\rangle$ for each eigenvector of the Hamiltonian, applies the walk circuit, and asserts the overlap against $E_k/\lambda$ — the source comment reads "Overlap: <L|k|W|k|L> = E_{k} / lambda" — with `assert_allclose_up_to_global_phase(..., atol=1e-6)`; the same test also asserts `qubitization_lambda` equals `sum(ham_coeff)` and that the circuit uses fewer than 23 qubits. Second, the simulation itself: `verify_hamiltonian_simulation_by_gqsp` densifies the bloq and asserts its top-left $N \times N$ block against `scipy.linalg.expm(-1j * H * t)` with `atol=1e-4`, run over `select_bitsize` 1, `target_bitsize` 1 and 2, $t \in \{2, 5\}$ and `precision` $\in \{10^{-5}, 10^{-7}, 10^{-9}\}$, five random Hamiltonians each. Third, and not a simulation at all: `test_symbolic_t_cost` takes the symbolic example's `QECGatesCost` total T count and compares its `sympy.O` against `big_O(tau * t + sympy.log(2 * inv_eps) / sympy.log(sympy.log(2 * inv_eps)))`, i.e. $O(\tau t + \log(2/\varepsilon)/\log\log(2/\varepsilon))$ — a T count including rotation synthesis, not the query count $O(t + \log(1/\varepsilon))$ recorded as this method's cost. All three are read off the source as assertions; none was executed for this entry.

• Low and Chuang's own Appendix B — phase tables and queries per unit simulation time

  • Hamiltonian Simulation by Qubitization

  The paper that this method is recorded from computes something itself, in one appendix, and it is worth recording separately from the theorems because it is the only place in the paper where a number is produced rather than bounded. Appendix B is titled "Practical Details for Implementing Hamiltonian Simulation" and says what it is for: "This appendix illustrates a specific application of the quantum signal processing approach to a signal unitary that encodes the Hamiltonian $\hat{H}$ as a signal operator. In particular, a comparison of performance with the BCCKS approach is made. The details will be useful to readers interested in implementing our procedure on a quantum computer." The body points at it by name: "The exact the tradeoff between $\epsilon$, $t$, $Q$ in Eq. (33) is studied numerically in Appendix B, together with example phases $\vec{\phi}$ implementing $\hat{V}_{\vec{\phi}}$ for the polynomials in Eq. (34)." One convention note, because it is the same normalization split this record's own hop already warns about: the appendix works with the target $h(\theta) = t\sin(\theta)$, i.e. the $\arcsin$ normalization, while Eq. (32) in the body expands in $T_k(\lambda)$ with $\cos(z) = \lambda$.

  Two computed objects. (i) The truncation error of the Fourier approximation, plotted against the analytic bound the body derives: Eq. (33) reads $\epsilon = \max_{\lambda\in[-1,1]} \left| 2\sum_{k=q}^{\infty} (-1)^{k/2} J_k(t) T_k(\lambda) \right| \le \sum_{k=q}^{\infty} 2|J_k(t)| \le \frac{4t^q}{2^q q!} = O\left(\left(\frac{et}{q}\right)^q\right)$, whence "$q = O(t + \log(1/\epsilon))$". Figure 1 (Left) plots "Approximation error $\epsilon = \max_{\theta\in\mathbb{R}} |A[\theta] - iC[\theta] - e^{it\sin(\theta)}|$" where "$(A[\theta], C[\theta])$ are real Fourier series in $(\cos(k\theta), \sin(k\theta))$, $k = 0, ..., Q/2$", against three curves: "the upper bound $\frac{4t^q}{2^q q!}$ (blue), truncation $\sum_{k=q}^{\infty} 2|J_k[t]|$ (black), and best possible [51] (red)", at $q = 1 + Q/2$. (ii) A table of actual phase vectors, produced not by a construction of this paper but by an algorithm it cites to earlier work of two of the same authors: "a table of select phases $\vec{\phi}$ computed using the algorithm in [37] can be found in Table 3". The paper's Discussion is candid about that algorithm: it "was originally claimed to be polynomial time [37], but only when counting arbitrary-precision arithmetical operations, and appeared to be ill-conditioned in case studies [49]", with a later analysis proving "a runtime of $O(Q^3 \mathrm{polylog}(Q/\epsilon))$ with finite-precision arithmetic, provided that some subtleties were carefully managed to control this ill-conditioned behavior".

  No dataset and no Hamiltonian instance. Everything computed is a function of one real variable: the scalar target $h(\theta) = t\sin(\theta)$ and its Fourier approximants. The parameter grid is small and stated exactly — Figure 1 (Left) sweeps $Q = 2, 4, 8, 16, 32, 64, \infty$ queries to the controlled iterate $\hat{W}$, its horizontal axis being simulation time per query, labelled "Simulation time (t) / Queries to $\hat{W}$ (N)" and running 0.01 to 0.50; Table 3 sweeps $Q \in \{2, 4, 8, 16, 32\}$ crossed with $\epsilon \in \{10^{-2}, 10^{-4}\}$; Figure 1 (Right) sweeps target error $10^{-2}, 10^{-4}, 10^{-8}, 10^{-16}$ over simulation times running from 1 to 500 on its horizontal axis. Axis labels, tick values and table headers here are read off the rendered pages rather than off a text extraction, which drops the $\epsilon$ glyph systematically.

  No repository, no software name, no availability statement. The phases are attributed only to "the algorithm in [37]", which the paper's reference list gives as "G. H. Low, T. J. Yoder, and I. L. Chuang, 'Methodology of Resonant Equiangular Composite Quantum Gates,' Physical Review X 6, 041067 (2016)" — a prior paper of two of the same authors, and not the earlier quantum-signal-processing letter, which is reference [7] and is the paper this record already cites for the achievability of $\vec{\phi}$. Read from the Quantum-accepted version ("Accepted in Quantum 2019-07-08"), obtained as https://arxiv.org/pdf/1610.06546 and converted with `pdftotext -layout`, with Figure 1 and Table 3 confirmed against the same pages rendered to image at 200 dpi.

  Table 3 gives, under printed column headers $Q$, $\epsilon$, $t$ and $\vec{\phi}$, a simulation time and a phase vector that implements $h(\theta) = t\sin(\theta)$ to within that error. The paper calls these "select phases" and nowhere claims the tabulated $t$ is the largest reachable at a given $(Q, \epsilon)$. At $\epsilon = 10^{-2}$: $Q = 2$ carries $t = 0.0707$ with $\vec{\phi} = (-1.61, 1.67)$; $Q = 4$ carries $t = 0.311$; $Q = 8$, $t = 1.20$; $Q = 16$, $t = 3.78$; $Q = 32$, $t = 10.1$. At $\epsilon = 10^{-4}$ the same $Q$ carry $t = 0.0070711$, $0.066948$, $0.47498$, $2.2164$ and $7.3957$. The caption fixes what the error means: "Errors quoted refer to $\|\langle+|_b \hat{V}_{\vec{\phi}} |+\rangle_b - e^{-i\hat{H}t}\| \le \epsilon$." Figure 1 (Right) is the comparison, and the appendix states the handicaps it applies, the asymptote it reaches, and the direction of its own residual bias: "$\hat{U}$ is not assumed to be qubitized, thus incurring a factor 2 additional cost from querying $\hat{U}$ and $\hat{U}^\dagger$ each over the asymptotic limit of 2 queries per unit of simulation time", while "the BCCKS algorithm [22] incurs a factor 3 additional cost from querying $\hat{U}$ twice and $\hat{U}^\dagger$ in their use of oblivious amplitude amplification", and "An analysis of the procedure [22] shows that the error of its simulated evolution is a factor $\mathcal{O}(1) \gtrsim 2$ larger than $\epsilon$. Thus Fig. 1 slightly overestimates BCCKS performance as we take $\epsilon$ directly to be the error." The conclusion drawn from the plot is stated as a scaling, not as a measured ratio: "the queries per unit time of BCCKS scales like $O(\frac{\log(t/\epsilon)}{\log\log(t/\epsilon)})$, whereas our approach approaches 4 in the limit $t \to \infty$", and the regime is named — "As BCCKS is known to be optimal in the regime $t = O(\frac{\log(1/\epsilon)}{\log\log(1/\epsilon)})$, the improvement of our approach is most dramatic outside of it."

• PennyLane's `qml.Qubitization` operator

  Xanadu's PennyLane ships the walk operator as a built-in operation, and only the walk operator: it builds $W$ from a Hamiltonian and stops, applying no phases. The v0.36.0 release note introduces it as "Performing qubitization is now easily accessible with the new `qml.Qubitization` operator" and states the intended use in the next sentence — "`qml.Qubitization` encodes a Hamiltonian into a suitable unitary operator. When applied in conjunction with quantum phase estimation (QPE), it allows for computing the eigenvalue of an eigenvector of the given Hamiltonian." That is the qualifier this entry turns on. No quantum signal processing phases are applied anywhere in the module, nothing in it produces $e^{-iHt}$, and the documented consumer is `qml.iterative_qpe`, not a phased iterate. It is recorded here because the object it builds is this method's $W$, though not written the way this record writes it: the reflection is about $|0\rangle$ rather than about $|G\rangle = \mathrm{Prep}|0\rangle$, and it stands to the right of the block-encoding rather than to the left, so what is printed is a conjugate of $W = (2|G\rangle\langle G| - I) U$ carrying the same spectrum, not the same expression. A provenance note: the word "Qubitization" in the class docstring is hyperlinked to https://arxiv.org/abs/2204.11890, whose arXiv abs page gives the title "Simulating key properties of lithium-ion batteries with a fault-tolerant quantum computer" — not to Low and Chuang.

  The class docstring writes the operator as $Q = \text{Prep}_{\mathcal{H}}^{\dagger} \text{Sel}_{\mathcal{H}} \text{Prep}_{\mathcal{H}}(2|0\rangle\langle 0| - I)$ and describes it as "implemented with a quantum walk operator that takes a Hamiltonian as input". The implementation is two lines of composition rather than a circuit: `compute_decomposition` appends `Reflection(identity)`, where `identity = prod(*[I(wire) for wire in control])`, then `PrepSelPrep(hamiltonian, control=control)`, and returns that list. The docstring's own worked call confirms the order the decomposition emits: `qp.Qubitization.compute_decomposition(hamiltonian=0.1 * qp.Z(0), control=Wires(1))` prints `[Reflection(3.141592653589793, wires=[1]), PrepSelPrep(lcu=0.1 * Z(0), control=[1])]` — the reflection first, the prepare-select-prepare second, which is the reverse of the left-to-right reading of the formula above. `__init__` takes `(hamiltonian, control)` and sets `wires = Wires(control) + hamiltonian.wires`, so the walk carries no ancilla beyond the control register the LCU index needs. The accepted input type is stated as "Union[.Hamiltonian, .Sum, .Prod, .SProd, .LinearCombination]", i.e. "The Hamiltonian written as a linear combination of unitaries", so the subnormalization is the coefficient 1-norm and the module never computes it — the docstring's own example computes it in post-processing with `lamb = sum([abs(c) for c in H.terms()[0]])`. A second, symbolic decomposition `_qubitization_decomposition` is decorated `@register_resources(_qubitization_resources)` and attached by `add_decomps(Qubitization, _qubitization_decomposition)`; `_qubitization_resources` charges exactly one `Reflection` and one `PrepSelPrep`.

  No dataset and no chemistry instance: one three-term qubit Hamiltonian in the docstring, `H = qp.dot([0.1, 0.3, -0.3], [qp.Z(0), qp.Z(1), qp.Z(0) @ qp.Z(2)])`, on `qp.device("default.qubit")` — PennyLane's state-vector simulator, so no hardware. The eigenvector is prepared by a single `qp.PauliX(2)`, the walk is controlled on wires `[3,4]`, and it is consumed by `qp.iterative_qpe(..., aux_wire = 5, iters = 3)`. The `Qubitization` operator itself spans five wires — the control pair and the Hamiltonian's 0, 1 and 2 — while the circuit touches six, the sixth being the QPE auxiliary. Three iterations.

  https://github.com/PennyLaneAI/pennylane, Python, Apache-2.0. The file is `pennylane/templates/subroutines/qubitization.py`, class `Qubitization(Operation)`, with `compute_decomposition`, `_qubitization_resources` and `_qubitization_decomposition`; it imports `PrepSelPrep` and `Reflection` from sibling modules in the same package. Shipped in PennyLane v0.36.0 (PyPI upload 2024-05-06), added by pull request 5500. Source read on 2026-08-26 from the repository's default branch, which `gh api` reports as `main`; the legacy `master` alias serves a byte-identical file. The release-note example differs slightly from today's docstring, which renames the QPE keyword `ancilla` to `aux_wire`.

  One number, and it is a docstring output rather than a benchmark. After `output = circuit()` and `lamb = sum([abs(c) for c in H.terms()[0]])`, the docstring shows `print("eigenvalue: ", lamb * np.cos(2 * np.pi * (np.argmax(output)) / 8))` returning `eigenvalue: 0.7`. That is an eigenvalue recovered through the $\lambda\cos(\cdot)$ inversion of the walk's eigenphase — the same $\arccos$ correspondence this method rests on — read off a 3-bit iterative phase estimate, hence the divisor 8. Nothing else numerical is reported anywhere in the module: no error figure, no timing, no T count and no qubit count. Its only cost statement is the symbolic resource declaration described above, one `Reflection` plus one `PrepSelPrep`.

What it needs

1. Block-encode a matrix 4 methods

   Wrap an operator $A$ inside a larger unitary $U$ so that $A/α$ sits in $U$'s top-left block, giving every routine above it one uniform way to touch the matrix. The subnormalization $α$ and the ancilla count are outputs of this layer, not free parameters.

Other ways to fill the same slot

Different approaches

• Product-formula (Trotter-Suzuki) simulation

  Split $H$ into terms that can each be exponentiated directly and alternate short evolutions of them — the Lie-Trotter formula and its higher-order generalizations. No block-encoding is built and there is no all-zeros flag to amplify.

• Truncated-Taylor LCU simulation

  Truncate the Taylor series of $e^{-iHt}$ over short segments and implement the truncated sum as a linear combination of unitaries — PREPARE loads the coefficients, SELECT applies the terms, PREPARE$†$ unprepares — with the all-zeros ancilla flag amplified.

In the Atlas

• Quantum signal processing

  A single-qubit rotation sequence that transforms an encoded signal into a polynomial response.

Sources

• Hamiltonian Simulation by Qubitization↗Guang Hao Low, Isaac L. Chuang · 2016theory yes · simulation ? · hardware no
• Optimal Hamiltonian Simulation by Quantum Signal Processing↗Guang Hao Low, Isaac L. Chuang · 2016theory yes · simulation ? · hardware no
• On the relationship between continuous- and discrete-time quantum walk↗Andrew M. Childs · 2008theory yes · simulation ? · hardware no