Pith. sign in

REVIEW 4 major objections 6 minor 19 references

Implementation of a quantum linear solver for the Vlasov-Ampere equation

T0 review · 4 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper constructs an explicit quantum block encoding of the linearized Vlasov-Ampere operator $i\omega_0+A$ and reports that the synthesized circuit needs about two orders of magnitude fewer CX gates than a fixed reference…

desk verdict An honest and reproducible compiler application paper that is strong on engineering but does not yet prove its central circuit is the right one; a small simulation check would settle it. read the letter →

arxiv 2507.22257 v2 pith:F3HXUVZR submitted 2025-07-29 quant-ph

Tomer Goldfriend , Or Samimi Golan , Amir Naveh This is my paper
classification quant-ph
keywords quantumlinearsolverblockencodingVlasov-AmpereequationsingularvaluetransformationcombinationofunitariesplasmakineticsimulationCXgatecountresourceestimation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to build the quantum block encoding that a quantum linear solver needs for the linearized one-dimensional Vlasov-Ampere system, and to show that this encoding can be implemented with substantially cheaper circuits than a fixed reference implementation. The target is the matrix $i\omega_0 + A$ that comes from discretizing the driven kinetic equations, and the construction assembles it from three pieces: the advective derivative with boundary corrections, the off-diagonal force and current terms, and the $i\omega_0$ identity. The reported result is that a single step of the quantum singular value transformation inversion routine on the encoded matrix uses roughly two orders of magnitude fewer CX gates than the baseline, while the overall normalization factor stays independent of the phase-space grid size. The authors point out that no quantum advantage is expected in one dimension because the condition number grows with the grid, but the explicit encoding is a step toward higher-dimensional kinetic problems.

What carries the argument

The load-bearing object is the block encoding $U_{B,s}$, which places $B/s$ as the top-left block of a larger unitary. For $B = i\omega_0 + A$, the encoding is assembled from three sub-encodings: $U_{F,s_F}$, built from a fixed-diagonal bulk derivative and boundary corrections implemented by inverse state preparation; $U_{C,s_C}$, from single-column and single-row operators over velocity space; and $U_{i\omega_0 I,\omega_0}$. These are combined by a prepare-and-select LCU on two block qubits, so the total normalization is a sum of physical constants, $s = s_F + s_C + \omega_0$, independent of $n_x$ and $n_v$. This grid-independence of $s$ is what keeps the quantum data embedding from adding a vanishingly small acceptance probability or an extra condition-number overhead.

What would settle it

Run the synthesized block-encoding circuit for a small grid, project onto the zero block state, and compare the resulting submatrix entry-by-entry with the explicitly discretized $i\omega_0 + A$; any disagreement beyond the target error tolerance would falsify the resource claim. A quicker check is to test the two boundary versions described in Appendix A --- the text's $x \neq 1$ condition versus Listing 4's $x \neq 0$ --- and see which one realizes the intended one-sided derivative.

Watch

Extended reading notes

Core claim

The paper's central claim is that the matrix $i\omega_0 + A$ obtained by discretizing the linearized Vlasov-Ampere equations can be block-encoded with a fixed number of block qubits and a scaling factor that does not grow with the grid. The construction splits $A$ into three block-encodable pieces --- the advective term $F$ (a bulk derivative plus low-rank boundary corrections), the off-diagonal force and current terms $C_E$ and $C_g$, and the identity $i\omega_0 I$ --- and combines them through the linear combination of unitaries method. In the synthesized circuits, a single QSVT step costs on the order of $10^3$--$10^5$ CX gates depending on the grid, about two orders of magnitude below the fixed baseline at every size tested. Since the final scaling factor is $s = s_F + s_C + \omega_0$, with $s_F = v_{\max}(1+\sqrt{26})\Delta x^{-1}$ and $s_C = \max\{|v\,dv|, |\partial_v F|\}$, the encoding does not inflate the effective condition number as the grid refines.

Load-bearing premise

The resource comparison assumes the generated circuits really implement the intended matrix; the paper reports no end-to-end numerical check, and the boundary-derivative text and code listing disagree about a condition ($x \neq 1$ versus $x \neq 0$).

Editorial extensions

If this is right

  • A single QSVT step on the block-encoded $i\omega_0 + A$ costs roughly two orders of magnitude fewer CX gates than the fixed reference circuit at every tested grid size, with comparable or smaller qubit width.
  • The final LCU normalization $s = s_F + s_C + \omega_0$ contains no dependence on the phase-space grid, so refining the grid does not shrink the encoded matrix's singular values through the embedding.
  • Because the block-encoding construction uses a fixed number of block qubits, the total width of the synthesized program is set by the grid qubits $n_x + n_v$, leaving room inside standard QSVT inversion loops.
  • Replacing the two deliberately naive primitives (state preparation and amplitude assignment) with scalable implementations would make the whole encoding scalable to larger grids without changing its structure.
  • In higher-dimensional kinetic models, where quantum linear solvers may offer speedups, the authors expect the savings over a rigid implementation to be even larger.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same assembly pattern --- a fixed-diagonal bulk operator, low-rank boundary corrections, and diagonal force/current terms joined by LCU --- should apply to other grid-discretized plasma or fluid operators while keeping the normalization grid-independent.
  • The resource claims would be materially strengthened by a small statevector check that extracts the top-left block of the synthesized unitary and compares it to the explicit matrix $i\omega_0 + A$; the paper does not report such a check.
  • Swapping in scalable amplitude-encoding methods would change the reported crossover sizes and likely move the advantage of the high-level synthesis approach to larger grids, a prediction that can be tested with the same benchmark.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. This paper presents a Qmod/Classiq implementation of a block encoding for the matrix iω0 + A arising from a discretized one-dimensional Vlasov–Ampère model, following the linearization and block-encoding framework of Novikau et al. The authors construct U_{iω0+A,s} from block encodings of the advective term F, the off-diagonal terms C_E and C_g, and the identity term iω0 I, using LCU and prepare/select techniques. They report CX-count and qubit-width comparisons for a single QSVT step against a Qiskit baseline and claim a two-orders-of-magnitude reduction in CX counts. The paper is explicit that no quantum advantage is expected for the one-dimensional problem and that the scaling factor s in Eq. (A11) is grid-size independent.

Significance. If the resource counts are correct and the synthesized circuits truly block-encode iω0 + A, the paper provides a useful worked example of high-level quantum program synthesis for a plasma-physics linear system, with an honest discussion of the regime in which quantum advantage is not expected. The construction itself is standard LCU-based block encoding; its value lies in the explicit Qmod implementation and the resource comparison. Strengths include a reproducible code link, explicit scaling-factor formulas with no fitted constants, and the observation that s does not grow with grid size. The claim of a factor-100 reduction in CX count, however, rests on circuit synthesis choices and has not been validated numerically, so the significance of the headline result is currently conditional.

major comments (4)
  1. [Section V, Fig. 1] The central claim that the Classiq-synthesized circuit reduces CX counts by two orders of magnitude relative to Qiskit presupposes that both circuits block-encode the same matrix iω0 + A. No state-vector check, matrix-element test, or simulator validation of U_{iω0+A,s} is reported anywhere in the paper. Given that the Appendix contains inconsistencies in the boundary-condition logic (see below), the resource comparison is not yet supported. Please add a numerical verification for small sizes (e.g., reconstruct the top-left block of U from a compiled circuit and compare with (iω0 + A)/s) and report the resulting fidelity or norm error.
  2. [Appendix A, Eq. (A1) and Listing 1] Eq. (A1) sets ζbc = 0 at x = 2^nx − 1, v < 0, but Listing 1 flips the block flag for (x == 2**x.size-1) & (v <= 0). Since the v-grid as defined in Listing 5 contains v = 0, the two prescriptions differ at the boundary point (x_max, v = 0). The text and code must be reconciled; if the code is what was synthesized, the boundary condition used in the resource counts is not the one stated in the model.
  3. [Appendix A, Listing 4 and surrounding text] The text after Eq. (A4) describes the boundary-derivative projector as b = b ⊕ (x ≠ 1), while Listing 4 uses b ^= (x != 0) and Fig. 3 shows b1⊕= (x≠1). Moreover, Listing 4 invokes undefined functions `derivative_boundary_min_be` and `derivative_boundary_max_be`, and Listing 2 applies `X(ind)` to an undefined variable. These discrepancies make the documented block-encoding construction ambiguous and prevent a reader from independently confirming what circuit was generated. Please correct the listings and align the prose, figure, and code.
  4. [Section V, baseline comparison] The Qiskit comparison is not like-for-like: the Qiskit baseline is constructed by the same authors, uses a fixed QFT-based adder while the Classiq optimizer can select between QFT and ripple-carry adders, and the paper does not report the baseline's correctness. The claimed improvement may therefore be an artifact of compiler or synthesis choices rather than of the Qmod block-encoding structure. The authors should compare against a Qiskit implementation with the same adder type and the same state-preparation primitives, or report resource counts from a published or standard-library baseline.
minor comments (6)
  1. [Fig. 1 caption] The legend entry for the CX-optimized Classiq data is rendered as "classiq cx opt. (width 80)" in the figure, apparently missing the symbol ≤; also each point shows three widths while the caption says "the number" singular. Please clarify which width corresponds to which series.
  2. [Listing 2] The line `X(ind)` uses an undefined variable `ind`; it should presumably be `X(flag)`.
  3. [Listing 4] Function names are inconsistent: `derivative_boundary_left_be` is defined but `derivative_boundary_right_be` calls `derivative_boundary_min_be`, and `derivative_boundaries_be` calls both `derivative_boundary_min_be` and `derivative_boundary_max_be`, neither of which is defined in the listing.
  4. [Introduction] The sentence "A complete details on the implementation" should read "Complete details on the implementation".
  5. [Fig. 4 caption] The word "respectivaly" is a typo for "respectively".
  6. [Listing 5] Please specify the exact signed-number encoding of the v register and how the `np.roll` operation maps to the qubit ordering, since the boundary-condition discrepancy v < 0 versus v ≤ 0 depends on this mapping.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the block encoding is constructed from explicit matrix decompositions with computed scaling factors, and the resource reduction is a measured compiler benchmark rather than an equation-derived prediction.

full rationale

The paper's central derivation is the construction of the block encoding Uiω0+A,s. Each component is built from the matrix elements themselves: the derivative stencil fixes the boundary-state amplitudes, the velocity matrix uses amplitude assignment with η(v)=v/vmax, and the off-diagonal blocks use normalized vectors (−∂vF) and vdv. The scaling factors are computed as norms of these explicit quantities, sF=vmax(1+√26)Δx−1 and sC=max{|vdv|,|(∂vF)|}, and the final LCU scale is s=sF+sC+ω0 in Eq. (A11). No parameter is fitted to an output and then renamed as a prediction. The central resource claim in Section V is an empirical comparison of CX counts from synthesis of the Qmod model versus a fixed Qiskit baseline; it is measured from compiler output, not forced by an equation. Self-citations to the Classiq/Qmod toolchain (Refs. [2,13]) are references to the software used, not load-bearing uniqueness theorems or unverified premises of the derivation. The paper does contain correctness risks unrelated to circularity: no numerical/simulation check confirms that the synthesized circuit block-encodes iω0+A; Appendix A has an inconsistency between the text's boundary projector b=b⊕(x≠1) and Listing 4's b^=(x!=0); and Eq. (A11) suggests sF contains Δx−1, so the claim that s does not grow with grid size is not obviously supported. These are verification and correctness concerns, not a circular derivation.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The central claim introduces no fitted constants; all scaling factors are norms and grid-spacing quantities computed from the discretized operators. The load-bearing external inputs are the linearized plasma model from Ref [1], the QSVT/LCU framework from the literature, and the correctness of the Classiq synthesis toolchain. No new particles or forces are postulated.

assumptions (4)
  • domain assumption The linearized Vlasov-Ampere model (Eqs. 7-8) is a valid representation of the driven 1D plasma response.
    Introduced in Section II following Ref [1]; the quantum solver solves this linear system, so if the linearization or monochromatic-drive ansatz fails, the implementation solves the wrong problem.
  • standard math QSVT can perform matrix inversion with error eps and cost polylog in dimension and polynomial in condition number.
    Invoked in Section III.A; the paper relies on Ref [7] for this and does not rederive it.
  • domain assumption Block-encoding arithmetic primitives and Classiq synthesis correctly realize the Qmod descriptions.
    Used throughout Sections IV and V; no independent numerical verification that the compiled unitary corresponds to A is reported.
  • domain assumption The boundary treatment zeta_bc and finite-difference derivative (Eqs. A1-A4) correctly approximate the advective operator and suppress incoming waves.
    Copied or adapted from Ref [1] and stated in Section III and Appendix A; a discrepancy between the prose and Listing 4 makes this an item to verify.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Implementation of a quantum linear solver for the Vlasov-Ampere equation." pith.science (2026). https://pith.science/paper/F3HXUVZR

@misc{pith2026250722257,
  author       = {Pith},
  title        = {Pith review of: Implementation of a quantum linear solver for the Vlasov-Ampere equation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/F3HXUVZR}},
  note         = {Machine review of arXiv:2507.22257}
}
read the original abstract

We implement a quantum linear solver for the one-dimensional Vlasov-Ampere equation, following the model presented in Novikau et. al. (I. Novikau, I. Y. Dodin, and E. A. Startsev, J. Plasma Phys. 90, 805900401 (2024)). We design the relevant block encoding operator with Qmod high-level language, and obtain optimized quantum programs using Classiq synthesis tools. Compared to a rigid baseline implementation, our approach yields a clear reduction in quantum resource requirements.

Figures

Figures reproduced from arXiv: 2507.22257 by the authors.

Figure 1
Figure 1. FIG. 1. The total number of CX gates in a single QSVT step, applied on the block encoding unitary [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. FIG. 2. Implementation of [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗
Figure 3
Figure 3. FIG. 3. Implementation of [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: FIG. 4. Schematic model for [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: FIG. 5. Schematic model for block encoding the off-diagonal matrices of [PITH_FULL_IMAGE:figures/full_fig_p010_5.png]
Figure 6
Figure 6. Figure 6: shows the final layout of the quantum model that implements the block encoding of iω0 + A. Now, this quantum function can be inserted to a QSVT routine for solving the linear system. |x⟩nx U(F,sF ) U(C,sC ) |v⟩nv |E⟩ |b0−3⟩ 4 |b3−5⟩ 2 U(iω0I,ω0) |b lcu⟩ 2 Prepare(⃗s ) …

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

19 extracted references · 15 canonical work pages

  1. [1]

    The upper left matrix F The upper left part of A refers to the discrete operation F = ζbc · (⃗ v⊗ I) · (I ⊗ ∇x), given by the product of the following matrices: ζbc · (|x⟩|v⟩) =      0, x = 0, v >0 0, x = 2nx − 1, v <0 1, otherwise   |x⟩|v⟩, (A1) (⃗ v⊗ I) · (|x⟩|v⟩) = v|x⟩|v⟩, (A2) ∇x (|x⟩|v⟩) = 1 2∆x      −3|0⟩ + 4|1⟩ − |2⟩, x = 0 3|2nx − 3⟩ ...

    work page

  2. [2]

    "" 4 Multiply amplitude of |E=1> by ratio, do nothing for |E=0> if ratio <=1 5 Multiply amplitude of |E=0> by 1/ratio, do nothing for |E=1> if ratio >1 6

    The off-diagonal sub-matrices C E and C g The matrices C E and C g apply a simple vector multiplication: C E · (|x⟩|v = 0⟩|E = 1⟩) = − (∂vF ) |x⟩ |v⟩ |E = 0⟩ , (A6) C E · (|x⟩|v ̸= 0⟩|E⟩) = 0, (A7) C E · (|x⟩|v⟩|E = 0⟩) = 0, (A8) C g · (|x⟩|v⟩|E = 0⟩) = − (vdv) |x⟩ |0⟩ |E = 1⟩ , (A9) C g · (|x⟩|v⟩|E = 1⟩) = 0, (A10) For a given |x⟩, these correspond to ma...

    work page

  3. [3]

    Block encoding the F ull matrix We have implemented UF,sF , and UC,sC , with sF = vmax(1 + √ 26)∆x−1, and sC = max {|vdv| , |(∂vF )|}. To construct the block encoding of the full matrix to be inverted, iω0 + A, we apply an LCU, with a block variable of size 2: Uiω0+A,s = sF s UF,sF + sC s UC,sC + ω0 s iI, s ≡ sF + sC + ω0. (A11) 10 |b0⟩ UCE,βE UCg,βg |v⟩n...

    work page

  4. [4]

    Prater, Heating and current drive by electron cyclotron waves, Physics of Plasmas 11, 2349 (2004)

    R. Prater, Heating and current drive by electron cyclotron waves, Physics of Plasmas 11, 2349 (2004)

    work page 2004

  5. [5]

    Novikau, I

    I. Novikau, I. Dodin, and E. Startsev, Encoding of linear kinetic plasma problems in quantum circuits via data compression, J. Plasma Phys. 90, 805900401 (2024). 11

    work page 2024

  6. [6]

    Goldfriend, I

    T. Goldfriend, I. Reichental, A. Naveh, L. Gazit, N. Yoran, R. Alon, S. Ur, S. Lahav, E. Cornfeld, A. Elazari, P. Emanuel, D. Harpaz, T. Michaeli, N. Erez, L. Preminger, R. Shapira, E. M. Garcell, O. Samimi, S. Kisch, G. Hallel, G. Kishony, V. van Wingerden, N. A. Rosenbloom, O. Opher, M. Vax, A. Smoler, T. Danzig, E. Schirman, G. Sella, R. Cohen, R. Garf...

    arXiv 2025

  7. [7]

    Qmod code for implementing linear solver (with qsvt) for the vlasov–amp´ ere equation., http://short.classiq.io/ vlasov-ampere (2025)

    work page 2025

  8. [8]

    Gonzalez-Conde, T

    J. Gonzalez-Conde, T. W. Watts, P. Rodriguez-Grasa, and M. Sanz, Efficient quantum amplitude encoding of polynomial functions, Quantum 8, 1297 (2024)

    2024

Show all 19 references
  1. [9]

    A. W. Harrow, A. Hassidim, and S. Lloyd, Quantum algorithm for linear systems of equations, Phys. Rev. Lett. 103, 150502 (2009)

    2009

  2. [10]

    P. C. Costa, D. An, Y. R. Sanders, Y. Su, R. Babbush, and D. W. Berry, Optimal scaling quantum linear-systems solver via discrete adiabatic theorem, PRX Quantum 3, 040303 (2022)

    2022

  3. [11]

    J. M. Martyn, Z. M. Rossi, A. K. Tan, and I. L. Chuang, A grand unification of quantum algorithms, PRX Quantum 2, 040203 (2021)

    2021

  4. [12]

    Montanaro and S

    A. Montanaro and S. Pallister, Quantum algorithms and the finite element method, Phys. Rev. A 93, 032324 (2016)

    2016

  5. [13]

    S. Ma, M. J. Woolley, I. R. Petersen, and N. Yamamoto, Preparation of pure gaussian states via cascaded quantum systems, in 2014 IEEE Conference on Control Applications (CCA)(2014) p. 1970

    2014

  6. [14]

    Gily´ en, Y

    A. Gily´ en, Y. Su, G. H. Low, and N. Wiebe, Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics, in Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing, STOC 2019 (Association for Computing Machinery...

    2019

  7. [15]

    For Qiskit, we fixed the QFT based one

    Classiq built-in adder supports two different implementation, QFT based adder and ripple-carry adder. For Qiskit, we fixed the QFT based one

  8. [17]

    M. Vax, P. Emanuel, E. Cornfeld, I. Reichental, O. Opher, O. Roth, T. Michaeli, L. Preminger, L. Gazit, A. Naveh, and Y. Naveh, Qmod: Expressive high-level quantum modeling (2025), arXiv:2502.19368 [quant-ph]

    2025 arXiv

  9. [18]

    S¨ underhauf, E

    C. S¨ underhauf, E. Campbell, and J. Camps, Block-encoding structured matrices for data input in quantum computing, Quantum 8, 1226 (2024)

    2024

  10. [19]

    When running a QSVT solver, we can eliminate them through the projector of the block encoding

    Notice that the values |E = 1⟩ |v ̸= 0⟩ are redundant. When running a QSVT solver, we can eliminate them through the projector of the block encoding

  11. [26]

    The code that implements this operation and the corresponding schematic model are given in listing 4 and Fig

    Finally, the block encoding of ∇bc−down x is achieved by adding a minus sign to U∇bc−up x ,α∆x−1 , and transposing the matrix along the opposite diagonal, using a series of X gates. The code that implements this operation and the corresponding schematic model are given in list...

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.