Forward-time, centre-space (FTCS)

What it fills

• Discretize a PDE into one linear system

  Replace every continuous variable at once — space together with time, or space together with velocity — so that the whole problem becomes a single matrix equation. Nothing is left to march: the grid values at every recorded point are unknowns of one system, solved in one go.

When it applies

Stability requires the step sizes to satisfy $\Delta t \le \Delta x^2/(2d\alpha)$, which is exactly the condition under which Linden, Montanaro and Shao's one-step operator is stochastic — and the whole error argument runs through that stochasticity, because it is what stops earlier errors being amplified as the march proceeds. Under that choice the one-step operator is precisely a simple random walk on the grid, which is the observation their fastest classical and quantum algorithms are built on. The bound also assumes the solution's fourth spatial derivatives are bounded.

Requires

Every step this method names moves its route along, so there is nothing it needs alongside them.

Example

given  heat equation  du/dt = alpha * ( d^2u/dx1^2 + ... + d^2u/dxd^2 )    (Eq. 1)
       on the hypercubic region  [0,L]^d x [0,T],  periodic in each xi,
       diffusivity alpha > 0
       initial data  u_tilde(x, 0) = u0(x),  u0 assumed nonnegative
       grid: xi = 0, Deltax, ..., n*Deltax = L;  t = 0, Deltat, ..., m*Deltat = T
       smoothness bound zeta on the 4th spatial derivatives of the SOLUTION u,
         not of u0 -- a bound on u0 implies one on u, which the paper proves
         separately                                              (remark after Cor. 2)

requires  Deltat <= Deltax^2 / (2*d*alpha)                                (Eq. 14)
    # this is exactly the condition the paper needs for the one-step
    #   operator L built below to be stochastic -- "L is stochastic if
    #   1 - 2*d*alpha*Deltat/Deltax^2 >= 0, i.e. Deltat <= Deltax^2/(2*d*alpha)",
    #   and the discretization-error bound (Thm. 1) is proved only under
    #   this same condition, not in general                      (Eq. 14, proof of Thm. 1)

# --- discretize: forward difference in time, central difference in space --
du/dt      ~=  ( u(t + Deltat) - u(t) ) / Deltat                          (Eq. 6)
    # first order in Deltat; the Taylor remainder is bounded by
    #   (Deltat/2) * sup |d^2u/dt^2|, not dropped without comment         (Eq. 8)
d^2u/dxi^2 ~=  ( u(xi + Deltax) + u(xi - Deltax) - 2*u(xi) ) / Deltax^2   (Eq. 7)
    # second order in Deltax; the Taylor remainder is bounded by
    #   (Deltax^2/12) * sup |d^4u/dxi^4|                                  (Eq. 9)

# --- combine into one explicit update per grid point, every i summed -------
u_tilde(x, t+Deltat) =
    ( 1 - 2*d*alpha*Deltat/Deltax^2 ) * u_tilde(x, t)
    + ( alpha*Deltat/Deltax^2 ) * sum_{i=1}^{d} (
          u_tilde(..., xi+Deltax, ..., t) + u_tilde(..., xi-Deltax, ..., t) )
                                                                       (Eq. 11, 13)
    # write this one step as  u_tilde_{k+1} = L u_tilde_k  for the linear
    #   operator L defined by the right-hand side of (13)                (Eq. 13)
    # L is stochastic exactly under the `requires` condition above --
    #   proved from (13), not assumed independently                     (Eq. 14)

# --- stack every timestep into one block lower-bidiagonal system -----------
# unknowns are u_tilde_1 .. u_tilde_m together -- all recorded times at
#   once, not produced by iterating L forward one step at a time
assemble A =
    [  I                    ]
    [ -L   I                ]
    [      -L   I           ]
    [           ..   ..     ]
    [                -L   I ]                                            (Eq. 38)
assemble b = ( L*u_tilde_0,  0,  0,  ...,  0 )^T                          (Eq. 38)
    # L*u_tilde_0 is the one nonzero block on the right -- u_tilde_0 is
    #   the given initial data, not an unknown of the system

return  the pair (A, b)
    # ||A|| = Theta(1), ||A^-1|| = Theta(m), so the condition number of A
    #   is Theta(m)                                                       (Thm. 3)
    # discretization error, proved outright (not just observed):
    #   ||u_tilde - u||_inf <= (zeta*alpha*d*T/L^d) *
    #                          (alpha*d*Deltat/2 + Deltax^2/12)          (Thm. 1, Eq. 12)
    # L itself can be ill-conditioned, even noninvertible, in general,
    #   which matters because L*u_tilde_0 has to be prepared.  The paper's
    #   remedy is proved only at the SATURATED step size, NOT across the
    #   `requires` inequality above: Lemma 4 takes Deltat = Deltax^2/(2*d*alpha)
    #   exactly, the choice fixed in Corollary 2, and then for nonnegative u
    #   gives ||Lu||_2^2/||u||_2^2 >= 1/(2*d).  At that choice L is
    #   precisely a simple random walk on Z_n^d, which is what the proof
    #   leans on.  A step size strictly below the bound satisfies `requires`
    #   and still carries no conditioning guarantee from this paper.
    #                                              (Lemma 4, Cor. 2, Appendix C)
# solving the assembled (A, b) -- by conjugate gradient, a quantum linear-
#   equations algorithm, or by exploiting the bidiagonal structure
#   directly (computing L^m u_tilde_0) -- is deliberately NOT part of this
#   discretization step                                          (Sec. I A vs. Sec. II A)

Cost, as the source states it

Linden, Montanaro and Shao's Theorem 1 bounds the discretization error outright: for $\Delta t \le \Delta x^2/(2d\alpha)$, $\lVert \tilde{u} - u\rVert_\infty \le \frac{\zeta\alpha d T}{L^d}\left(\frac{\alpha d \Delta t}{2} + \frac{\Delta x^2}{12}\right)$. Their Corollary 2 inverts it into the grid a target accuracy demands — $\Delta t = 3\epsilon/(2d^2\alpha^2\zeta T)$ and $\Delta x = \sqrt{3\epsilon/(d\alpha\zeta T)}$, giving $m = 2T^2d^2\alpha^2\zeta/(3\epsilon)$ timesteps and $n = L\sqrt{d\alpha\zeta T/(3\epsilon)}$ points per dimension. Their Theorem 3 gives the condition number of the assembled system as $\Theta(m)$, with $\lVert A\rVert = \Theta(1)$ and $\lVert A^{-1}\rVert = \Theta(m)$.

Implementations

• The forward-Euler lane of Ingelmann, Bharadwaj, Pfeffer, Sreenivasan and Schumacher's advection-diffusion comparison — Eq. (14) and the variational cost function Eq. (38)

  • Two quantum algorithms for solving the one-dimensional advection-diffusion equation

  A point-by-point comparison of two quantum algorithms on one linear PDE, in which the two algorithms are split by their time discretization and only one of them is FTCS. The problem is Eq. (2), $\partial_t c(x, t) = D\partial_x^2 c(x, t) - U\partial_x c(x, t)$ on $x \in [-L, L]$ with periodic boundary conditions and the delta initial condition $c(x, 0) = \delta(x)$, so that a closed-form reference exists — Eq. (10), which the paper describes as "a Gauss-shaped pulse that diffuses while moving to the right given that $U > 0$". Section 3 sets up both first-order Euler schemes side by side and the closing discussion states which algorithm got which: "The accuracy of the time evolution in both quantum algorithms, i.e., the forward Euler (FTCS) for VQA and backward Euler (BTCS) for QLSA is bounded from below by the round-off errors of the corresponding classical integration schemes." This entry records the forward-Euler half only; the backward-Euler half is a different discretization and is solved by a modified HHL on a different code base. One qualifier matters and is easy to lose: this is FTCS applied one step at a time, not the all-at-once stack this method records — the paper mentions the alternative once, in a sentence broken by a page break in Section 4.1, "The solution $c(t)$ can be obtained either iteratively at every time-step or by one-shot QLSA algorithms that would offer higher quantum" advantage, and takes the iterative route.

  Section 3 writes the scheme out first in matrix form. "When the forward difference in time and the centered difference in space is taken, one gets the forward in time and centered in space (FCTS) method. It is of 1st order accuracy in time, of 2nd order accuracy in space" — the FCTS spelling is the paper's, and it is the paper's twice, here and again in the same section at "The comparison of the analytical solution (ANA) with those of FCTS and BCTS is shown in Fig. 1", where BTCS is transposed the same way; Fig. 1's caption, Section 4.1 and Section 6 all write FTCS. Eq. (11) is the stencil, Eq. (12) names $r = D\tau/(\Delta x)^2$ as "the stability parameter" and $s = U\tau/(2\Delta x)$ as "the parameter of the convective part", and the text states the constraint outright: "For this explicit scheme $r \le 1/2$ should hold." Eq. (14) is the resulting one-step matrix, circulant with $1 - 2r$ on the diagonal, $r - s$ above it, $s + r$ below it, and the two corner entries that carry the periodicity; with $U = 0$ the convective parameter $s$ vanishes and what is left is exactly the periodic one-step heat operator of this method. The variational algorithm never inverts that matrix. Section 4.2 rewrites the same step as Eq. (28), $\lvert c(t + \tau)\rangle = (1 + \tau\hat{O})\lvert c(t)\rangle$ with $\hat{O} = D\partial_x^2 - U\partial_x$, and minimizes the residual instead: Eq. (29) is $C(\lvert c(t+\tau)\rangle) = \lVert \lvert c(t + \tau)\rangle - (1 + \tau\hat{O})\lvert c(t)\rangle\rVert_2^2$, and Eq. (33) carries the two normalization parameters $\lambda_0$ and $\tilde{\lambda}_0$ that let a normalized quantum state stand in for an unnormalized concentration profile. The centre-space half then enters as shift operators — "Rather than implementing these terms directly, a 2nd-order finite difference discretization of both operators is used, which is in line with the discussion in Sec. 3" — giving Eq. (36), $\hat{O} = DN^2(\hat{S}_+ - 2\cdot\mathbb{1} + \hat{S}_-) - U\frac{N}{2}(\hat{S}_+ - \hat{S}_-)$, and the final cost Eq. (38) is a sum of five overlaps, $C_1$, $C_{S+}$, $C_{S-}$, $\tilde{C}_{S+}$ and $\tilde{C}_{S++}$, of which the last two "depend on the solution of the previous time step only, and are hence constants". Every overlap is read out by a Hadamard test, but Fig. 4 draws only three of them — its caption is "Quantum circuits for the evaluation of the main cost contributions" $C_1$, $C_{S+}$ and $C_{S-}$, with $\hat{S}_{+/-}$ built from CNOT and Toffoli gates; the remaining two implement $\hat{\tilde{U}}$ in place of $\hat{U}(\lambda)$, and $\tilde{C}_{S++}$ needs the shift applied twice or the processing structure started one qubit lower. The terms "are evaluated separately and summed classically to give the cost function". The ansatz is the "universal" $R_y$-and-CNOT structure of Fig. 5, and it is retained rather than chosen: Section 5.4 opens with it as "The currently applied universal ansatz", notes that its $2n - 1$ parameterized gates rule out an advantage, tests two staggered tensor-network structures TN1 and TN2 against it as replacements, and concludes that "the investigated TN structures for $n = 4$ and 6 qubits could not achieve the required accuracy for the state vector generation. Thus, we proceed with the universal ansatz". The classical minimizer is Nelder-Mead, which Section 6 says "gave the best results" among those tried; what that section names as the bottleneck is the classical optimization step itself rather than that choice of algorithm.

  No dataset and no measured input. The initial condition is a delta function, $c(x, 0) = \delta(x)$, which fixes the Fourier coefficients of Eqs. (6) to (8) and hence the analytical solution Eq. (10) that every error is measured against. Section 5.2 fixes the physical parameters at $D = 1$ and $U = 10$, and Section 6 records the regime as "The Péclet number is $\mathrm{Pe} = 10$". Resolution runs over "computational grids varying between $N = 8$ and 64, which correspond to 3 and 6 qubits, respectively". The time steps are chosen per grid and are stated as $\tau = 4\times 10^{-3}$ for $N = 8$, $\tau = 10^{-3}$ for $N = 16$ and $\tau = 2.4\times 10^{-4}$ for $N = 32$, each satisfying both the requirement that the cost function's own prefactor $(1 - 2DN^2\tau)$ imposes, $\tau < 1/(2DN^2)$, and the Courant-Friedrichs-Lewy condition $\tau < 1/(NU)$; the paper adds that at a CFL number of 0.5 "the time steps are smaller by about a factor of 1.5, 3, and 7 than would be classically possible for the first-order scheme". Times are reported in units of the advection time $\tau_a = 2L/U$, the paper's default where nothing else is stated.

  No repository. The quantum half of the variational algorithm is stated to run on a released framework and nothing else: "The quantum part of the VQA is implemented in the quantum simulation environment Qiskit [34]", and reference [34] is "Qiskit version 0.23.2 (2023)". The comparison arm runs on the group's own solver — "The QLSA is done with QFlowS, a C++ based simulation package [18]" — which the abstract describes as in-house and which is not published alongside this paper. The absence of a code or data availability statement was checked rather than assumed, and the check is small enough to rerun: a case-insensitive search of the v1 text extraction, 1889 lines, for "github", "gitlab", "zenodo", "repositor" and "available" returns exactly one line, and it is "available in this case", about the analytical solution. The only software named anywhere in the paper is Qiskit and the in-house QFlowS, neither with a URL. What a reader can open here is the paper's equations and figures, not a file: re-running this lane means rebuilding Eqs. (36) and (38), the Hadamard-test circuits of Fig. 4 and the universal ansatz of Fig. 5 from the text.

  All figures are simulation, not hardware. On the ideal statevector simulator at the finest grid, $N = 64$, the total register is $n_{\mathrm{tot}}^{\mathrm{VQA}} = \log_2(N) + 1 = 7$ qubits — "6 qubits for the spatial discretization plus 1 ancilla qubit" — with 64 parameters optimized per time step and $\tau = 6.1\times 10^{-4}\tau_a$; Fig. 8 shows the profiles at $t = 6.1\times 10^{-3}\tau_a$ and $t = 1.22\times 10^{-2}\tau_a$, of which the text says "the advection-diffusion dynamics can be reproduced very well by the VQA". Resolution helps and time hurts, and Section 5.2 separates the two axes rather than trading one for the other: over $t = 0.04$ to $0.24\tau_a$ "a larger number of qubits lead to smaller errors", and "For a time $t \le 0.12\tau_a$, it can be shown that the error decreases for cases with a higher number of qubits" — but no single curve is monotone in time, "the error for $N = 8$ decreases while the curves for $N = 16$ and 32 show a rapid increase", which the authors put down to "the crossing of the periodic boundary of the bulk of the concentration profile" and, as an assumption rather than a measurement, to a global minimum that "in the higher-dimensional parameter space of the optimization is harder to find". Section 5.1 reports the same non-monotone behaviour "for system sizes $N \ge 16$", and Section 6 calls it "a non-monotonic time evolution of the MSE". The comparison against the other lane runs through the classical schemes rather than the quantum ones: "the MSE of the BTCS is in general higher than the FTCS scheme which forms the basis to the VQA solutions". Section 5.5 repeats the $N = 8$ case on the Qiskit QASM simulator with $N_S = 2^{20}$ shots and a decoherence model at $p_{\mathrm{gate}} = 0.008$, $p_{\mathrm{meas}} = 0.03$ and $p_{\mathrm{reset}} = 0.0003$; there "the concentration profile with the QASM simulator can reproduce advection and diffusion, but the profile differs slightly from the those of the ideal simulation and the analytical solution", the mangling being the paper's, and the MSE sits above the ideal case and rises in time, which the paper explains "by the error propagation from the previous step, which is included in this iterative framework". To reduce noise the authors drop the last term of Eq. (34), "which is always a constant term", cutting the circuits per step "from 5 to 3" so that the minimum of the cost "is technically no longer at zero, but at a negative constant value". No run on a physical device is reported anywhere in the paper.

• Diffusion1D and Diffusion2D in Daniele Cucurachi's quantum-pde-solver — one forward-Euler step written as a variational cost function

  • Variational quantum algorithms for nonlinear problems

  A standalone Python package that implements somebody else's algorithm, and in doing so adds the linear case the original paper did not run. Its README states the scope in one sentence: "A research-oriented Python package that implements a variational quantum algorithm for solving nonlinear PDEs using a forward Euler time-stepping scheme as proposed in [Lubasch et al., “Variational quantum algorithms for nonlinear problems” (PR A, 2019)]", the bracket being a link to arXiv:1907.09032. That paper's only time-dependent demonstration is the nonlinear Burgers equation, Eq. (S1), $\frac{\partial}{\partial t} f(x, t) = \nu\frac{\partial^2}{\partial x^2} f(x, t) - f(x, t)\frac{\partial}{\partial x} f(x, t)$; neither "diffusion" nor "heat equation" occurs anywhere in its v3. The repository carries Burgers as Burgers1D and Burgers2D and then adds Diffusion1D and Diffusion2D, which are the same forward-Euler step with the advection term deleted — the FTCS instance. The qualifier Entry 1 carries applies here too, and the code makes it sharper: this is FTCS taken one step at a time inside a variational loop, not the single block lower-bidiagonal system over every timestep that this method's summary describes, because Diffusion1D.cost assembles no matrix at any point and returns a scalar. It is a one-author proof of principle and reads like one: no releases and no tags, and its own validation document is unfinished — Section 5 of docs/method_description_and_validation.md is headed "Validation and Consistency Checks (!WORK IN PROGRESS!)" and two of its five subheadings, "Norm Conservation" and "Cost Function Monitoring", carry no text at all.

  The time half is Lubasch's, from the cited paper's supplement rather than from the repository: "the Euler method identifies $\lvert f(t+\tau)\rangle = (1 + \tau O(t))\lvert f(t)\rangle$", turned by Eq. (S3) into a residual and by Eq. (S4) into $C(\lambda_0, \lambda) = \lvert\lambda_0\rvert^2 - 2\mathrm{Re}\{\lambda_0\tilde{\lambda}_0^{*}\langle 0\rvert\hat{\tilde{U}}^{\dagger}(1 + \tau\hat{O})\hat{U}(\lambda)\lvert 0\rangle\} + \mathrm{const}$, with $\hat{O} = \nu\Delta - \tilde{\lambda}_0\hat{D}_{\tilde{\psi}}\nabla$ for Burgers. The centre-space half is in the repository rather than in the paper, and it is three lines of Python: Diffusion1D.cost builds three Hadamard-test circuits with circuit_overlap and circuit_adder_overlap_1d, reads each one out through ancilla_z_exp, then assembles the three-point central second difference as LapVal = wA + wAinv - 2.0 * w0 and the forward-Euler combination as s = w0 + self.tau * self.D * LapVal, at src/pdes.py lines 366 and 369. Diffusion2D subclasses Diffusion1D and overrides cost, swapping in circuit_adder_overlap_2d and the five-point stencil, LapVal = (wA_x + wAinv_x + wA_y + wAinv_y) - 4.0 * w0 at line 430; the forward-Euler line after it is identical. The shift operator behind wA is build_adder_block in src/circuit.py line 47, the ripple-carry increment of Lubasch's Fig. S2 whose caption defines $\hat{A}\sum_{k=0}^{N-1}\psi_k\lvert\mathrm{binary}(k)\rangle = \sum_{k=0}^{N-1}\psi_{k+1}\lvert\mathrm{binary}(k)\rangle$ under "periodic boundary conditions where $\psi_N = \psi_0$", and whose gate count that paper gives as "$n - 2$ ancilla qubits, $n - 2$ CNOT and $2n - 2$ Toffoli gates" for $n > 2$ — the code allocates a register of exactly $n-2$ ancillas on that branch, at src/circuit.py line 66. Wrapping it are HEAnsatz, a hardware-efficient $R_y$-and-CNOT ladder in src/ansatz.py whose docstring calls it "depth layers of Ry rotations + CNOT chain entanglers" and whose parameter count is the qubit count times the depth, and run_time_evolution in src/time_evo.py, which at each step re-minimizes the cost with SciPy's COBYLA through optimize_step and then calls pde.update_state so that this step's optimum becomes the fixed $\hat{\tilde{U}}$ of the next one.

  No dataset; everything is generated in the script. The initial condition is a normalized Gaussian built by gaussian_state in src/utils.py and fitted to the ansatz by maximizing fidelity in prepare_initial_state, again with COBYLA and capped at 200 iterations, and the classical reference is FiPy, wrapped as DiffusionFiPySolver in src/ref_solutions.py. The grid is $2^n$ points from the qubit count, and the defaults in examples/diffusion_1d.py are 4 qubits, ansatz depth 2, $\tau = 0.5$, $D = 0.1$, final time 5.0, Gaussian width $\sigma = 0.15$ and seed 42. One property of the discretization is worth reading off the source rather than the docs: src/pdes.py contains no grid spacing at all, so the stencil is unscaled and the quantity an FTCS stability bound would constrain is the product of the two flags, $\tau D$, rather than $\alpha\Delta t/\Delta x^2$ — and nothing enforces it, since a case-insensitive grep of src for "stab", "CFL" and "assert" returns one assertion, and it is a perfect-square check on the plot grid in src/plot.py.

  https://github.com/DanieleCucurachi/quantum-pde-solver, Python on Qiskit and Qiskit Aer, MIT licensed — the LICENSE file is 21 lines opening "MIT License" and "Copyright (c) 2025 Daniele Cucurachi", with the usual all-caps disclaimer beginning at line 15 that the software is provided AS IS, "WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED". environment.yml pins python=3.10 and asks for qiskit at 0.45.0 or above, qiskit-aer at 0.13.0 or above and fipy at 3.4.0 or above. requirements.txt is one byte and effectively empty, but nothing reads it and the emptiness costs a reader nothing: the README's install path is a clone followed by an editable pip install of the package itself, and setup.py carries its own complete install_requires of numpy, scipy, matplotlib, qiskit, qiskit-aer, pandas, fipy and typing_extensions. Read on 2026-08-27 at the tip of main: src/pdes.py 437 lines, src/circuit.py 408, src/time_evo.py 116, src/ansatz.py 126, examples/diffusion_1d.py 66. The most recent commit touching src/pdes.py is c5c1bebb20 of 2025-10-05, "implemented diffusion 1 and 2D"; the newest commit on the branch is 13b022048b of 2025-10-12, "Remove detailed MIT License text from README". There are no tags and no releases. The files a reader should open are src/pdes.py for BasePDE, Burgers1D, Burgers2D, Diffusion1D and Diffusion2D, src/circuit.py for build_adder_block, circuit_overlap, circuit_adder_overlap_1d and circuit_adder_overlap_2d, and src/time_evo.py for prepare_initial_state, optimize_step and run_time_evolution.

  The repository publishes no error figure of its own, and says so by omission rather than by claim. Section 5 of docs/method_description_and_validation.md is titled "Validation and Consistency Checks (!WORK IN PROGRESS!)"; two of its five subheadings, "Norm Conservation" and "Cost Function Monitoring", carry no text, and the three that do — on visualization, on validation against classical solvers, and on sanity checks — describe metrics to compute rather than metrics computed, the quantitative one asking for "Mean Absolute Error (MAE)" and $L^2$ norms against a classical solution without reporting either. docs/erros_and_consistency_checks.md and docs/pdes.md are both zero-byte files, and the examples/exp_results directory the README's structure block names as the output location is not committed. The one executed run in the repository is examples/tutorial.ipynb, a 2D diffusion case at 4 qubits, depth 2, $\tau = 0.25$, $D = 0.1$, final time 5.0 and seed 88983, whose state-preparation cell prints "Final fidelity: 0.9583854346492209" and whose figures put the variational time evolution next to a FiPy solution of the same problem; the notebook computes no error metric between the two, and it has eight cells and ends there. Everything runs on Qiskit Aer: BasePDE.ancilla_z_exp selects "statevector_simulator" when its shots argument is None and "qasm_simulator" otherwise, and no call site in src/pdes.py passes shots, so every published cost evaluation is exact statevector. No hardware backend and no IBM Runtime import appears anywhere in src — a case-insensitive grep for IBMQ, ibm_runtime and hardware over src returns three docstring lines, two in src/ansatz.py and one in src/utils.py, all of them describing the "hardware-efficient ansatz".

What it needs

Nothing below this — it bottoms out here.

Other ways to fill the same slot

Different approaches

• Phase-space grid for a boundary-value problem

  Grid the position and velocity coordinates together and take central differences in both, with the derivatives at the edges obtained from Lagrange interpolating polynomials. Because the problem is posed at a fixed drive frequency rather than as an evolution, what results is directly the matrix equation to be solved — there is no time axis left to march along.

In the Atlas

• Quantum and classical algorithms for the heat equation

  Solve the heat equation in a rectangular region of spatial dimension d, in the sense of approximately computing the amount of heat in a given region.

Sources

• Quantum vs. classical algorithms for solving the heat equation↗Noah Linden, Ashley Montanaro, Changpeng Shao · 2020theory yes · simulation ? · hardware no