Time-Marching Quantum Algorithm for Simulation of Nonlinear Lorenz Dynamics

Abstract

Simulating nonlinear classical dynamics on a quantum computer is an inherently challenging task due to the linear operator formulation of quantum mechanics. In this work, we provide a systematic approach to alleviate this difficulty by developing an explicit quantum algorithm that implements the time evolution of a second-order time-discretized version of the Lorenz model. The Lorenz model is a celebrated system of nonlinear ordinary differential equations that has been extensively studied in the contexts of climate science, fluid dynamics, and chaos theory. Our algorithm possesses a recursive structure and requires only a linear number of copies of the initial state with respect to the number of integration time-steps. This provides a significant improvement over previous approaches, while preserving the characteristic quantum speed-up in terms of the dimensionality of the underlying differential equations system, which similar time-marching quantum algorithms have previously demonstrated. Notably, by classically implementing the proposed algorithm, we showcase that it accurately captures the structural characteristics of the Lorenz system, reproducing both regular attractors–limit cycles–and the chaotic attractor within the chosen parameter regime.

1. Introduction

Quantum computing provides a paradigm shift in how we perceive computation by offering the prospect of accelerating certain computational tasks beyond the capabilities of classical computers. In this direction, there is much interest in seeing how quantum computing and information science can be employed to solve important problems in classical physics, and in particular, whether quantum computers can be harnessed to speed-up the simulation of complex, nonlinear dissipative classical systems exhibiting classical turbulence and chaos [1]. Naturally, these systems pose significant challenges for integration into the linear and unitary quantum algorithmic framework, as their dynamics are non-norm preserving and nonlinear.

Although the quantum algorithmic study of dissipative nonlinear classical systems is still in its infancy, various techniques have been employed to adapt the underlying nonlinear differential equations and corresponding dynamics to the framework of quantum simulation. These include Carleman linerization [2,3,4,5], the Koopman–von Neumann (KvN) formulation of classical mechanics [6,7], second quantization methods [8,9,10], measurement-based approaches [11], quantum variational algorithms [12,13,14], and quantum time-marching schemes [15,16,17,18,19]. While each method offers certain advantages, the first three are impeded, both in terms of quantum algorithmic advantage and correct physics, when applied to chaotic systems [11,20,21,22].

Carleman and KvN-based techniques involve an analytic expansion of the solution to a partial differential equation in terms of an order parameter, thereby embedding the finite-dimensional nonlinear system into an infinite-dimensional linear one [23]. By truncating the resulting hierarchy of linear equations, quantum simulation algorithms can then be applied to the finite-dimensional linear approximation. However, intuitively speaking, the effectiveness of such linear embedding techniques depends critically on the presence of the Painlevé property [24], which ensures the convergence of the analytic expansion. This typically restricts the successful application of linear embeddings to regular dynamics [20], such as the one-dimensional Burgers equation [2] and the advection–diffusion equation [7], both known to possess the Painlevé property. Another issue with these linear embedding techniques is that, while they enable the quantum simulation of nonlinear classical systems in specific regimes, the necessary projection into a finite-dimensional space can introduce numerical artifacts that lead to inaccurate results [22]. Finally, measurement-based and second quantization techniques are dominated by quantum information scrambling for long simulation times [9,11,25].

Meanwhile, quantum implementations of time-marching schemes have shown promising applications in solving nonlinear differential equations, such as a 1D cubic nonlinear ordinary differential equation [18], as well as Burgers equation for high speed flows [19]. In this paper, we consider the latter approaches by proposing a quantum implementation of classical explicit and high-order time-advancement schemes, aiming to develop a quantum solver capable of accurately capturing the chaotic behavior of the Lorenz system. Despite its simplicity, the Lorenz system remains one of the most extensively studied chaotic systems, exhibiting all the essential features of non-Hamiltonian chaos. It has found widespread applications in fluid dynamics, weather forecasting, and chaos theory, among other areas.

To implement the time-advancement of a system of nonlinear differential equations, we propose a two-stage approach similar to the method presented in [15]. Specifically, by selecting a temporal discretization scheme, the update of the state vector is expressed as a linear operator acting on an augmented nonlinear state in closed form. The single-time-step evolution employs the Hadamard product to prepare the nonlinear state, followed by a block encoded version of the linear time-update operator. A key feature of the proposed quantum solver is the adoption of a quantum re-usage of states [19], resulting in a recursive structured quantum time-marching algorithm that maintains the previously established quantum speed-up while requiring only a linear number of state copies with respect to the total number of integration steps $N_t$. We demonstrate the effectiveness of our construction for a second-order discretized version of the Lorenz system by reproducing the correct qualitative behavior of both chaotic and regular attractors.

The structure of the paper is as follows: Section 2 introduces the basic equations describing the Lorenz dynamics and the respective first- and second-order discretization schemes. The two-stage single-time-step evolution is presented at the beginning of Section 3, consisting of a nonlinear state preparation followed by a non-unitary linear evolution. To create the nonlinear states, we build on the Hadamard product in Section 3.1.1 and Section 3.1.2, while the block encoding technique for implementing the non-unitary evolution operator is presented in Section 3.2. In Section 3.3 the complete quantum time-marching algorithm is illustrated. Then, in Section 3.4, the complexity of the quantum algorithm, both in terms of quantum resource scaling and the number of oracle queries, is analyzed. Its recursive and post-selective features are also discussed. A comparison of the classically implemented results with those generated by an adaptive, high-order $Mathematica$ solver is given in Section 4. Finally, in Section 5, we summarize our findings and outline directions for future research.

2. The Lorenz Model

The Lorenz model [26] was first explored in the study of heat conduction in atmospheric physics. It consists of a set of 3 ordinary differential equations with two quadratic nonlinear terms and 3 positive free parameters $\sigma ,\rho ,\beta$,

$$\frac{\mathrm{d}x}{\mathrm{d}t}=\sigma (y-x),$$

(1)

$$\frac{\mathrm{d}y}{\mathrm{d}t}=x(\rho -z)-y,$$

(2)

$$\frac{\mathrm{d}z}{\mathrm{d}t}=xy-\beta z.$$

(3)

The constants $\sigma$ and $\rho$ are the system’s parameters proportional to the Prandtl number and Rayleigh number, and $\beta$ is the ratio of width to height of the fluid layer. The Lorenz Equations (1)–(3) are dissipative since the volume $V\left(t\right)$ in phase space enclosed by a surface $S\left(t\right)$ evolves as

$${\displaystyle \frac{dV\left(t\right)}{dt}}={\int }_{S\left(t\right)}\mathit{F}·d^2\mathit{a}={\int }_{V\left(t\right)}\nabla ·\mathit{F}{d}^3\mathit{v}=-(\sigma +1+\beta )V\left(t\right),$$

(4)

where the vector field $\mathit{F}$ has components $(dx/dt,dy/dt,dz/dt)$ and $d^2\mathit{a},d^3\mathit{v}$ are the corresponding differential surface and volume elements. Thus, there is an exponential contraction of the three dimensional phase space volume to a set of measure zero

$$V\left(t\right)=e^{-(\sigma +1+\beta )t}V\left(0\right)\to 0\mathrm{as}t\to \infty .$$

(5)

Varying the free parameters in the system leads to an incredibly rich bifurcation phenomena, from periodic limit cycles to chaotic attractors with dimension less than 3.

Selection of the Time-Marching Scheme

Applying a first-order forward Euler finite difference scheme to Equations (1)–(3) in the temporal domain $[t,t+T]$ we obtain in vector form,

$${\mathbf{x}}_{n+1}={\mathbf{x}}_n+\delta t\mathit{f}\left({\mathbf{x}}_n\right),{\mathbf{x}}_n=\left[\begin{array}{c}{x}_n\\ y_n\\ z_n\end{array}\right],$$

(6)

where ${\mathbf{x}}_n\equiv \mathbf{x}(t+n\delta t),n=1,2,\dots ,N_t,N_t=T/\delta t$ and $\mathit{f}$ is a polynomial vector function such that $\mathit{f}\left(\mathbf{x}\right)={\widehat{C}}_1\mathbf{x}+{\widehat{C}}_2{\mathbf{x}}^{\otimes 2}$ with ${\widehat{C}}_{1,2}$ being the coefficient matrices. By embedding the nonlinear terms of Equation (6) into the state vector ${\mathit{\psi }}_n^{nl}$ a closed set of linear recursive equations is obtained,

$${\mathit{\psi }}_{n+1}={\widehat{\mathcal{A}}}_1{\mathit{\psi }}_n^{nl},$$

(7)

with

$${\mathit{\psi }}_{n+1}=\left[\begin{array}{c}{\mathbf{x}}_{n+1}\\ {\mathbf{0}}_{5\times 1}\end{array}\right],{\mathit{\psi }}_n^{nl}=\left[\begin{array}{c}{\mathbf{x}}_n\\ x_n{y}_n\\ x_n{z}_n\\ {\mathbf{0}}_{3\times 1}\end{array}\right],$$

(8)

and

$${\widehat{\mathcal{A}}}_1=\left[\begin{array}{cc}{\widehat{A}}_1& 0_{3\times 3}\\ 0_{5\times 3}& 0_{5\times 5}\end{array}\right],{\widehat{A}}_1=\left[\begin{array}{ccccc}1-\sigma \delta t& \sigma \delta t& 0& 0& 0\\ \rho \delta t& 1-\delta t& 0& 0& -\delta t\\ 0& 0& 1-\beta \delta t& \delta t& 0\end{array}\right].$$

(9)

However, the first-order Euler scheme runs into numerical problems for stiff differential equations, which are not eliminated even for $\delta t<<1$ [14,27]. These computational inaccuracies lead to an inability to reproduce the correct Lorenz dynamics. For instance, the first-order Euler method for the parameters $\sigma =10,\rho =28,\beta =0.55$ does not reproduce the period-2 limit cycle as found by standard fourth-order Runge–Kutta solvers. Since we seek an accurate quantum algorithm for the nonlinear dissipative Lorenz system, we consider a 2nd order two-stage Runge–Kutta extension of the simple Euler scheme.

The employed second-order difference scheme is a predictor-corrector of the form [28],

$$\begin{array}{cc}\hfill {\tilde{\mathbf{x}}}_{n+1}& ={\mathbf{x}}_n+\delta t\mathit{f}\left({\mathbf{x}}_n\right),\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill {\mathbf{x}}_{n+1}& ={\mathbf{x}}_n+{\displaystyle \frac{\delta t}{2}}[\mathit{f}\left({\mathbf{x}}_n\right)+\mathit{f}\left({\tilde{\mathbf{x}}}_{n+1}\right)].\hfill \end{array}$$

(11)

Notice that the second-order time marching scheme in Equations (10) and (11) is explicit and can be written in an analogous form to that of Equation (7),

$${\mathit{\psi }}_{n+1}={\widehat{\mathcal{A}}}_2{\mathit{\psi }}_n^{nl},$$

(12)

where now

$${\mathit{\psi }}_{n+1}=\left[\begin{array}{c}{\mathbf{x}}_{n+1}\\ {\mathbf{0}}_{13\times 1}\end{array}\right],{\mathit{\psi }}_n^{nl}=\left[\begin{array}{c}{\mathbf{x}}_n\\ x_n{y}_n\\ x_n{z}_n\\ y_n{z}_n\\ x_n{y}_n^2\\ x_n^2{y}_n\\ x_n^2{z}_n\\ x_n{y}_n{z}_n\\ {\mathbf{0}}_{6\times 1}\end{array}\right],$$

(13)

and

$${\widehat{\mathcal{A}}}_2=\left[\begin{array}{cc}{\widehat{A}}_2& 0_{3\times 6}\\ 0_{13\times 10}& 0_{13\times 6}\end{array}\right],{\widehat{A}}_2=\left[\begin{array}{cccccccccc}{a}_1& a_2& 0& 0& a_5& 0& 0& 0& 0& 0\\ b_1& b_2& 0& 0& b_5& b_6& b_7& b_8& 0& 0\\ 0& 0& c_3& c_4& 0& 0& 0& 0& c_9& c_{10}\end{array}\right].$$

(14)

The elements of matrix ${\widehat{A}}_2$ in Equation (14) read,

$$\begin{array}{cc}\hfill & a_1=1-\sigma \delta t+{\displaystyle \frac{\sigma \delta t^2}{2}}(\rho +\sigma ),a_2=\sigma \delta t\left(1-{\displaystyle \frac{\delta t}{2}}-{\displaystyle \frac{\sigma \delta t}{2}}\right),a_5=-{\displaystyle \frac{\sigma \delta t^2}{2}},\hfill \end{array}$$

(15)

$$\begin{array}{cc}\hfill & b_1=\rho \delta t\left(1-{\displaystyle \frac{\delta t}{2}}-{\displaystyle \frac{\sigma \delta t}{2}}\right),b_2=1-\delta t+{\displaystyle \frac{\delta t^2}{2}}+{\displaystyle \frac{\rho \sigma \delta t^2}{2}},b_5={\displaystyle \frac{\delta t}{2}}\left[-1+\delta t-(1-\beta \delta t)(1-\sigma \delta t)\right],\hfill \end{array}$$

(16)

$$\begin{array}{cc}\hfill & b_6=-{\displaystyle \frac{\sigma \delta t^2(1-\beta \delta t)}{2}},b_7=-{\displaystyle \frac{\sigma \delta t^3}{2}},b_8=-{\displaystyle \frac{\delta t^2(1-\sigma \delta t)}{2}},\hfill \end{array}$$

(17)

$$\begin{array}{cc}\hfill & c_3=1-\beta \delta t+{\displaystyle \frac{{\beta }^2\delta t^2}{2}},c_4={\displaystyle \frac{\delta t}{2}}\left[1-\beta \delta t+(1-\delta t)(1-\sigma \delta t)+\sigma \rho \delta t^2\right],\hfill \end{array}$$

(18)

$$\begin{array}{cc}\hfill & c_9=-{\displaystyle \frac{\delta t^2}{2}}(1-\sigma \delta t),c_{10}=-{\displaystyle \frac{\sigma \delta t^2}{2}}.\hfill \end{array}$$

(19)

As expected, these coefficients agree with the Euler 1st order coefficients in Equation (9), up to terms of $O\left(\delta t^2\right)$.

In the next section, the building blocks of the quantum algorithm for implementing the second-order scheme in Equation (12) are presented.

3. The Quantum Algorithm

Based on Equations (7) or (12), the single-time-step evolution ${\mathit{\psi }}_n\to {\mathit{\psi }}_{n+1}$ involves the operations outlined in

Table 1. Operations required for a single-time-step update of Equations (7) or (12).

Single-Step Evolution $\mathit{n}\to \mathit{n}+1$.
1. Initial state ← ${\mathit{\psi }}_n$
2. Preparation of the nonlinear state ${\mathit{\psi }}_n^{nl}$, $\mathit{f}\left({\mathit{\psi }}_n\right)={\mathit{\psi }}_n^{nl}$
3. Evolution with the time-advancement matrix $\widehat{\mathcal{A}}$, ${\mathit{\psi }}_{n+1}=\widehat{\mathcal{A}}{\mathit{\psi }}_n^{nl}$

.

From a classical computing perspective, the single-time-step evolution shown in Table 1 is explicit and straightforward; however, its implementation on a quantum computer requires careful treatment. This is because steps 2 and 3 are not compatible with the linear and unitary framework of quantum computing. From this point onward we adopt the Dirac bra–ket notation $|\mathit{\psi }\rangle$ to indicate the normalized, amplitude encoded, quantum variant of the classical state $\mathit{\psi }$. For instance, the discretized classical state ${\mathit{\psi }}_n$ from Equation (8) is amplitude encoded as a 3-qubit normalized quantum state $|{\mathit{\psi }}_n\rangle$:

$$|{\mathit{\psi }}_n\rangle ={\displaystyle \frac{x_n|0\rangle +y_n|1\rangle +z_n|2\rangle }{\sqrt{x_n^2+y_n^2+z_n^2}}},$$

(20)

with the binary representation of the basis states |i〉 given by $|0\rangle ={|000\rangle }_b,|1\rangle ={|001\rangle }_b,|2\rangle ={|010\rangle }_b$, etc. Each classical state $\mathit{\psi }$ corresponds to a unique amplitude encoded quantum state $|\mathit{\psi }\rangle$. However, the reverse is not true: a $|\mathit{\psi }\rangle$ state can represent a whole family of classical states of the form $r\mathit{\psi }$ with $r>0$. Nevertheless, $\mathit{\psi }$ is a solution of the Lorenz system, whereas $r\mathit{\psi }$ for $r\ne 1$ is not. Thus, this ambiguity is resolved by choosing $r=1$. Since the linear matrix $\widehat{\mathcal{A}}$ is non-unitary, $\langle \mathit{\psi }|{\widehat{\mathcal{A}}}^{†}\widehat{\mathcal{A}}|\mathit{\psi }\rangle \ne \langle \mathit{\psi }|\mathit{\psi }\rangle$, and the mapping $|{\mathit{\psi }}_n\rangle \to |{\mathit{\psi }}_n^{nl}\rangle$ is nonlinear it is necessary to express these operations within the admissible linear and unitary quantum framework.

In addition to these challenges, extending the single-time-step procedure to consecutive applications on a quantum computer is not straightforward. This stems from the fact that to prepare the nonlinear state $|{\mathit{\psi }}^{nl}\rangle$, one must create multiple copies of the initial state $|{\mathit{\psi }}_n\rangle$, i.e., this initial state can be quantum prepared and is known.

We address these issues explicitly by presenting the quantum blocks for a single-step evolution and then building them into a complete quantum algorithmic multi-step evolution.

3.1. Preparation of the Nonlinear States

The corresponding nonlinear states ${\mathit{\psi }}_n^{nl}$ for the first- and second-order discretized Lorenz system in Equations (8) and (13), exhibit polynomial nonlinearities with respect to the amplitudes $x_n,y_n,z_n$ of the ${\mathit{\psi }}_n$ state. Therefore, the first step is to determine how to implement on a quantum computer the following nonlinear transformation of the amplitudes ${\psi }_i$, for an n-qubit quantum state $|\psi \rangle ={\sum }_{i=0}^{2^n-1}{\psi }_i|i\rangle$,

$$|\psi \rangle \to \sum _i{P}_i\left({\psi }_i\right)|i\rangle ,P_i\left({\psi }_i\right)=\sum _{j=1}^K{a}_j{\psi }_i^j,$$

(21)

where $a_j$ are the coefficients and K the degree of the polynomials $P_i\left({\psi }_i\right)$.

In the following section we describe the implementation procedure of the nonlinear transformation in Equation (21), by using the Hadamard product. Then, we showcase how this approach can serve as a foundation for constructing arbitrary polynomially nonlinear states, and in particular, those arising in the Lorenz system.

3.1.1. The Hadamard Product

The Hadamard product of two n and m qubit states $|\mathit{\psi }\rangle$ and $|\mathit{\varphi }\rangle$ respectively, is defined as follows

$$|\mathit{\psi }\rangle \odot |\mathit{\varphi }\rangle \equiv |\mathit{\psi }\odot \mathit{\varphi }\rangle =\sum _{i=0}^{2^k-1}{\psi }_i{\varphi }_i|i\rangle ,k=max\{n,m\}.$$

(22)

Boldface quantum states denote multi-qubit states, while non-boldface bra–kets refer to the computational basis. Quantum implementation of the Hadamard product (22) for the case of single-qubit states was first presented in [29] and is illustrated in Figure 1.

As depicted in Figure 1, successful implementation of the Hadamard product is conditioned on the measurement of the 0-bit in the first register. Hereafter, the normalization factor in the successful post-measurement outcome will be omitted. For $|\psi \rangle =|\varphi \rangle$, we obtain $|\psi \odot \psi \rangle ={\psi }_0^2|0\rangle +{\psi }_1^2|1\rangle$ after tracing out the ancillary |0〉 state.

Generalizing the Hadamard product implementation to two n-qubit states requires—instead of just a single Controlled-NOT (CNOT) gate—the introduction of a multi-control variant ${\widehat{U}}_{select}^h$ through powers of the shift operator ${\widehat{S}}_{-}$,

$${\widehat{U}}_{select}^h=\sum _{k=0}^{2^n-1}{\widehat{S}}_{-}^k\otimes |k\rangle \langle k|,{\widehat{S}}_{-}^0=\widehat{1},{\widehat{S}}_{-}|k\rangle =|k-1\rangle .$$

(23)

Indeed, with operator ${\widehat{U}}_{select}^h$ acting on the $2n$-qubit composite state $|\mathit{\psi }\rangle \otimes |\mathit{\varphi }\rangle$ one obtains

$$\begin{array}{cc}\hfill {\widehat{U}}_{select}^h(|\mathit{\psi }\rangle \otimes |\mathit{\varphi }\rangle )& =\sum _{ijk}{\psi }_i{\varphi }_j{\widehat{S}}_{-}^k|i\rangle \langle k|j\rangle |k\rangle =\sum _{ij}{\psi }_i{\varphi }_j|i-j\rangle |j\rangle \hfill \end{array}$$

(24)

$$\begin{array}{cc}\hfill & =\sum _{i=j}{\psi }_i{\varphi }_i|0\rangle |i\rangle +\sum _{i\ne j}{\psi }_i{\varphi }_j\underset{\ne |0\rangle }{\underbrace{|i-j\rangle }}|j\rangle .\hfill \end{array}$$

(25)

From Equation (25), a successful measurement in the first register with respect to the 0-bit provides the Hadamard product transformation between the two n-qubit states. Figure 2 presents the schematic quantum circuit implementations of the $|\mathit{\psi }\odot \mathit{\psi }\rangle$ transformation in terms of powers of the shift operator ${\widehat{S}}_{-}^k$ along with the corresponding circuit implementation for the ${\widehat{S}}_{-}$.

Decomposition of the ${\widehat{S}}_{-}$ operator (Figure 2) into CNOTs and single-qubit gates scales as $\mathit{O}\left(n^2\right)$ [32]. Therefore, the implementation cost of the full sequence of ${\widehat{S}}^k$ gates in Figure 2 scales as $\mathit{O}\left(n^2{2}^{n+1}\right)$. Given that the n-qubit uniformly controlled operations can be implemented within $\mathit{O}\left(2^n\right)$ elementary gates [33], the overall implementation cost for the ${\widehat{U}}_{select}^h$ which realizes the n-qubit Hadamard product is $\mathit{O}\left[2^n(2n^2+1)\right]$.

Extension of the Hadamard product to an N-tuple of the n-qubit state $|\mathit{\psi }\rangle$,

$$|\underset{N\mathrm{times}}{\underbrace{\mathit{\psi }\odot \mathit{\psi }\odot \dots \odot \mathit{\psi }}}\rangle \equiv |{\odot }^N\mathit{\psi }\rangle =\sum _{i=0}^{2^n-1}{\psi }_i^N|i\rangle ,N\ge 2,$$

(26)

can be realized through N copies of the $|\mathit{\psi }\rangle$ acting with the ${\widehat{U}}_h^N$ operator as in Equation (23),

$${\widehat{U}}_h^N=\sum _{k=0}^{2^n-1}\underset{N-1\mathrm{times}}{\underbrace{{\widehat{S}}_{-}^k\otimes \dots \otimes {\widehat{S}}_{-}^k}}\otimes |k\rangle \langle k|.$$

(27)

Notice that for $N=1$, ${\widehat{U}}_h={\widehat{1}}_{2^n\times 2^n}$ and for $N=2$, ${\widehat{U}}_h^2={\widehat{U}}_{select}^h$ from Equation (22). Based on the previous discussion, operator ${\widehat{U}}_h^N$ can be implemented within $\mathit{O}\left[2^n(2n^{2}N+1)\right]$ single-qubit and CNOT gates.

Finally, we adopt the following notation

$${\widehat{U}}_h^k|{\mathit{\psi }}^{\otimes l}\rangle \equiv |{\odot }^k\mathit{\psi }\rangle ,k\le l,$$

(28)

indicating that the ${\widehat{U}}_h^k$ operator acts locally on the first k copies from the l-fold tensor product of the $|\mathit{\psi }\rangle$ states, with rest of the $l-k$ states omitted to keep the notation uncluttered.

3.1.2. Implementing the Lorenz Nonlinear States

Having established the essential elements for the unitary representation of the Hadamard product, the nonlinear transformation in Equation (21) can be implemented by employing the Hadamard product in conjunction with the Linear Combination of Unitaries (LCU) method [34]. Specifically, using the definition in Equation (27), the nonlinear polynomial transformation in Equation (21) can be expressed as a weighted sum of Hadamard product ${\widehat{U}}_h^j$ gates [35],

$${\widehat{U}}_{nl}=\sum _{j=1}^K{a}_j{\widehat{U}}_h^j,a_j>0.$$

(29)

Acting with ${\widehat{U}}_{nl}$ on the state $|{\mathit{\psi }}^{\otimes K}\rangle$ and using the definitions in Equations (26) and (28) we obtain

$${\widehat{U}}_{nl}|{\mathit{\psi }}^{\otimes K}\rangle =\sum _{j=1}^K{a}_j|{\odot }^j\mathit{\psi }\rangle =\sum _{j=1}^K\sum _{i=0}^{2^n-1}{a}_j{\psi }_i^j|i\rangle ,$$

(30)

which coincides with the transformation of Equation (21).

Following the LCU implementation lemma [36], we define the following unitary operators,

$$\begin{array}{cc}\hfill & {\widehat{U}}_{prep}^{LCU}|0^{\otimes m}\rangle ={\displaystyle \frac{1}{\sqrt{a}}}\sum _{j=1}^K\sqrt{a_j}|j\rangle ,m={log}_{2}K,a=\sum _{j=1}^K{a}_j,\hfill \end{array}$$

(31)

$$\begin{array}{cc}\hfill & {\widehat{U}}_{select}^{LCU}=\sum _{j=1}^K|j\rangle \langle j|\otimes {\widehat{U}}_h^j,\hfill \end{array}$$

(32)

which facilitate the circuit implementation of operator ${\widehat{U}}_{nl}$ from Equation (29), as illustrated in Figure 3.

Introducing into Equation (29) the unitary multi-CNOT gates $\widehat{G}$ that appropriately alternate the amplitudes ${\psi }_i$ within the state $|\mathit{\psi }\rangle$, we can prepare any nonlinear polynomial state. For example, suppose we wish to implement the following nonlinear 2-qubit state,

$$|{\mathit{\psi }}^{nl}\rangle =|\psi \rangle \otimes |\psi \rangle =\left[\begin{array}{c}{\psi }_0^2\\ {\psi }_0{\psi }_1\\ {\psi }_1{\psi }_0\\ {\psi }_1^2\end{array}\right].$$

(33)

This type of term arises in the first-order difference scheme, Equation (8). Then, the nonlinear state (33) can be written,

$$|{\mathit{\psi }}^{nl}\rangle ={\widehat{G}}_2|\mathit{\varphi }\rangle \odot {\widehat{G}}_2|\mathit{\varphi }\rangle +{\widehat{G}}_1|\mathit{\varphi }\rangle \odot {\widehat{G}}_0|\mathit{\varphi }\rangle ,|\mathit{\varphi }\rangle =|0\rangle |\psi \rangle ,$$

(34)

where the operators $\widehat{G}$ are

$${\widehat{G}}_0=\left[\begin{array}{cccc}0& 0& 0& 1\\ 1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\end{array}\right],{\widehat{G}}_1=\left[\begin{array}{cccc}0& 0& 1& 0\\ 0& 1& 0& 0\\ 1& 0& 0& 0\\ 0& 0& 0& 1\end{array}\right],{\widehat{G}}_2=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\\ 0& 1& 0& 0\end{array}\right].$$

(35)

Therefore, the implementation operator ${\widehat{U}}_{nl}$ is given by

$${\widehat{U}}_{nl}={\widehat{U}}_h^2{\widehat{G}}_2^{\otimes 2}+{\widehat{U}}_h^2({\widehat{G}}_1\otimes {\widehat{G}}_0).$$

(36)

Quantum circuit implementation of ${\widehat{U}}_{nl}$ in Equation (36) follows the same application of the LCU method as in Figure 3 and is explicitly depicted in Figure 4.

The $\widehat{G}$ gates alternating the amplitudes can be explicitly implemented through the Gray code [37]. In particular, ${\widehat{G}}_0={\widehat{1}}_{2\times 2}\otimes |1\rangle \langle 0|+\widehat{X}\otimes |0\rangle \langle 1|$, ${\widehat{G}}_1={\widehat{1}}_{2\times 2}\otimes |1\rangle \langle 1|+\widehat{X}\otimes |0\rangle \langle 0|$ and ${\widehat{G}}_2={\widehat{1}}_{2\times 2}\otimes |0\rangle \langle 0|+\widehat{X}\otimes |1\rangle \langle 1|$.

Finally, the full nonlinear state $|{\mathit{\psi }}_n^{nl}\rangle$ for the first-order discretized Lorenz model in Equation (8) is determined though the operator,

$${\widehat{U}}_{nl}={\widehat{U}}_h^1+{\widehat{U}}_h^2({\widehat{G}}_1\otimes {\widehat{G}}_0),{\widehat{U}}_h^1={\widehat{1}}_{8\times 8},$$

(37)

with

$${\widehat{G}}_0=\left[\begin{array}{cccccccc}0& 0& 0& 1& 0& 0& 0& 0\\ 0& 0& 0& 0& 1& 0& 0& 0\\ 0& 0& 0& 0& 0& 1& 0& 0\\ 1& 0& 0& 0& 0& 0& 0& 0\\ 0& 1& 0& 0& 0& 0& 0& 0\\ 0& 0& 1& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 1& 0\\ 0& 0& 0& 0& 0& 0& 0& 1\end{array}\right],{\widehat{G}}_1=\left[\begin{array}{cccccccc}0& 0& 0& 1& 0& 0& 0& 0\\ 0& 0& 0& 0& 1& 0& 0& 0\\ 0& 0& 0& 0& 0& 1& 0& 0\\ 0& 1& 0& 0& 0& 0& 0& 0\\ 1& 0& 0& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 1& 0\\ 0& 0& 1& 0& 0& 0& 0& 0\\ 0& 0& 0& 0& 0& 0& 0& 1\end{array}\right].$$

(38)

Therefore, to implement the nonlinear state $|{\mathit{\psi }}_n^{nl}\rangle$ for the second-order Lorenz discretization in Equation (13), one simply replaces the two 2-qubit copies in Figure 4 with three 4-qubit copies of state $|{\mathit{\psi }}_n\rangle$.

3.2. Block Encoding of Non-Unitary Matrix $\widehat{\mathcal{A}}$

Implementing a non-unitary $2^n\times 2^n$ matrix $\widehat{\mathcal{A}}$ requires a $(m,a)$-block encoding of the form,

$${\widehat{U}}_{\mathcal{A}}=\stackrel{2^m\mathrm{matrix}\mathrm{elements}}{\overbrace{\left[\begin{array}{cccc}\widehat{\mathcal{A}}/a& \ast & \dots & \ast \\ \ast & *& \dots & \ast \\ ⋮& ⋮& \ddots & ⋮\\ \ast & \ast & \dots & \ast \end{array}\right]}},$$

(39)

which corresponds to a dilation of the $2^n\times 2^n$ matrix $\widehat{\mathcal{A}}$ into a larger, $2^{n+m}\times 2^{n+m}$ unitary matrix ${\widehat{U}}_{\mathcal{A}}$ with $||\widehat{\mathcal{A}}/a||\le 1$. The * elements in Equation (39) represent proper sub-matrices so that the ${\widehat{U}}_{\mathcal{A}}$ matrix is unitary and are of no direct relevance to our calculations. Additionally, a is an appropriate renormalization factor of the matrix $\widehat{\mathcal{A}}$. In what follows, we will use the spectral norm, i.e., the largest singular value, $||\widehat{\mathcal{A}}||=max\left\{{\sigma }_{\mathcal{A}}\right\}$. Then, the application of ${\widehat{U}}_{\mathcal{A}}$ on the composite state $|0^{\otimes m}\rangle |\mathit{\psi }\rangle$ has the orthogonal decomposition

$${\widehat{U}}_{\mathcal{A}}|0^{\otimes m}\rangle |\mathit{\psi }\rangle ={\displaystyle \frac{1}{a}}|0^{\otimes m}\rangle \widehat{\mathcal{A}}|\mathit{\psi }\rangle +|\perp \rangle ,$$

(40)

where $\langle \perp |0^{\otimes m}\rangle =0$. As with the Hadamard product implementation in Figure 1 and Figure 2, a successful projective measurement $\widehat{P}=|0^{\otimes m}\rangle \langle 0^{\otimes m}|\otimes {\widehat{1}}_{2^n\times 2^n}$, in the first register with respect to the 0-bit results in the normalized state ${\displaystyle \frac{\widehat{\mathcal{A}}|\mathit{\psi }\rangle }{||\widehat{\mathcal{A}}|\mathit{\psi }\rangle ||}}$ with success probability $p_{success}={\displaystyle \frac{{||\widehat{\mathcal{A}}|\mathit{\psi }\rangle ||}^2}{a^2}}$. The respective quantum circuit for this post-selective process is depicted in Figure 5.

Of the various dilation techniques [38,39,40,41,42] for ${\widehat{U}}_{\mathcal{A}}$, we employ an $m=1$ block encoding constructed via classical Singular Value Decomposition (SVD), combined with the LCU method [39]. This selection is motivated because the non-trivial sub-matrices ${\widehat{A}}_1$ and ${\widehat{A}}_2$ in Equations (9) and (14) are of small finite dimension. This leads to a classical SVD implementation complexity of $\mathit{O}\left(8^3\right)$ and $\mathit{O}\left({10}^3\right)$, for the 1nd and 2nd order schemes, respectively. Therefore, the SVD decomposition of ${\widehat{\mathcal{A}}}_1$ and ${\widehat{\mathcal{A}}}_2$ in Equations (9) and (14) can be performed efficiently using a classical computer as part of a preprocessing routine.

The SVD decomposition of the matrix $\widehat{\mathcal{A}}$ is $\widehat{\mathcal{A}}={\widehat{V}}^{†}\widehat{\Sigma }\widehat{W}$ where $\widehat{V}$ and $\widehat{W}$ are unitary matrices and $\widehat{\Sigma }=diag\left(\sigma \right)$ is a diagonal matrix containing the non-negative singular values ${\sigma }_i\ge 0$. It can then be split into the sum of two unitary terms,

$$\widehat{\mathcal{A}}={\displaystyle \frac{a}{2}}{\widehat{V}}^{†}{\widehat{\Sigma }}_{+}\widehat{W}+{\displaystyle \frac{a}{2}}{\widehat{V}}^{†}{\widehat{\Sigma }}_{-}\widehat{W},$$

(41)

where $a=||\widehat{\mathcal{A}}||$, and,

$${\widehat{\Sigma }}_{\pm }=diag\left(e^{\pm i\mathit{\theta }}\right),\mathit{\theta }=arccos\overline{\sigma },0<{\overline{\mathit{\sigma }}}_i\le 1.$$

(42)

By applying the LCU technique [36] to implement the two-term unitary sum in Equation (41), only one extra qubit ($m=1$) is required to provide a $(1,||\widehat{\mathcal{A}}||)$-block encoding ${\widehat{U}}_{\mathcal{A}}$,

$${\widehat{U}}_{\mathcal{A}}=(\widehat{H}\otimes {\widehat{V}}^{†}){\widehat{U}}_{select}(\widehat{H}\otimes \widehat{W}),$$

(43)

where ${\widehat{U}}_{prep}^{LCU}=\widehat{H}$ is the Hadamard gate and ${\widehat{U}}_{select}^{LCU}$ is a diagonal matrix representing nested two-level z-rotations,

$${\widehat{U}}_{select}=|0\rangle \langle 0|\otimes {\widehat{\Sigma }}_{+}+|1\rangle \langle 1|\otimes {\widehat{\Sigma }}_{-}={\widehat{\mathcal{R}}}_z.$$

(44)

As a result, the explicit quantum decomposition for the SVD-LCU block encoding ${\widehat{U}}_{\mathcal{A}}$ is presented in Figure 6.

For an arbitrary matrix $\widehat{\mathcal{A}}$, the decomposition cost of the SVD-LCU dilation within single qubit gates and CNOTs is $\mathit{O}\left[{(n+1)}^2{2}^{2n+1}\right]$ [39]. However, the Lorenz system is finite-dimensional, requiring 3 and 4 qubits to encode the first and second-order discretization schemes in Equations (7) and (12), respectively. Thus, the seemingly prohibitive exponential scaling becomes a constant, resulting in $\mathit{O}\left(2^{11}\right)$ and $\mathit{O}\left(5^2{2}^9\right)$ elementary gates, respectively.

3.3. Quantum Circuit Implementation of the Second-Order Time-Marching Scheme for the Lorenz Equations

The single-step quantum evolution $|{\mathit{\psi }}_n\rangle \to |{\mathit{\psi }}_{n+1}\rangle$ as outlined in the Table 1, for the second-order discretization scheme of the Lorenz model (Equations (12)–(19)) is given by

$${\widehat{U}}_{{\mathcal{A}}_2}{\widehat{U}}_{nl}{|0\rangle }_e|{0^{\otimes 2}\rangle }_{LCU}|{{\mathit{\psi }}_n^{\otimes 2}\rangle }_c|{\mathit{\psi }}_n\rangle ={|0\rangle }_e|{0^{\otimes 2}\rangle }_{LCU}{|0000\rangle }_c^{\otimes 2}|{\mathit{\psi }}_{n+1}\rangle +{|\perp \rangle }_{e,LCU,c},$$

(45)

with ${}_{e,LCU,c}\langle \perp |({|0\rangle }_e|{0^{\otimes 2}\rangle }_{LCU}{|0000\rangle }_c^{\otimes 2})=0$.

• The second-order Lorenz system, Equations (12)–(19), can be represented using 4 qubits and the amplitude encoding in Equation (20). Thus, any state $|{\mathit{\psi }}_n\rangle$ is a 4-qubit quantum state.
• The nonlinear state $|{\mathit{\psi }}_n^{nl}\rangle$ in Equation (13) consists of polynomial terms up to third degree in the amplitudes ${\mathbf{x}}_n$. Subsequently, as discussed in Section 3.1.2, implementing $|{\mathit{\psi }}_n^{nl}\rangle$ requires a sum of Hadamard products between three copies of $|{\mathit{\psi }}_n\rangle$ interleaved with amplitude alternating $\widehat{\mathcal{G}}$ gates,

  $${\widehat{U}}_{nl}=\sum _{j=1}^3{\widehat{U}}_h^j{\widehat{\mathcal{G}}}_j.$$

  (46)
  The ${\widehat{\mathcal{G}}}_j$ operators are tensor-fold gates acting on the 12-qubit composite space of the $|{\mathit{\psi }}^{\otimes 3}\rangle$ states, with ${\widehat{\mathcal{G}}}_j={\widehat{G}}_{2j}\otimes {\widehat{G}}_{1j}\otimes {\widehat{G}}_{0j}$.
• To implement ${\widehat{U}}_{nl}$ we define a copy register $\left(c\right)$ that stores the two additional copied states $|{{\mathit{\psi }}_n^{\otimes 2}\rangle }_c$ where the ${\widehat{U}}_h^j$ gates act and an LCU register $\left(LCU\right)$ to sum the respective terms, as in Figure 3 and Figure 4. The resulting evolution is

  $${\widehat{U}}_{nl}|{0^{\otimes 2}\rangle }_{LCU}|{{\mathit{\psi }}_n^{\otimes 2}\rangle }_c|{\mathit{\psi }}_n\rangle =|{0^{\otimes 2}\rangle }_{LCU}{|0000\rangle }_c^{\otimes 2}|{\mathit{\psi }}^{nl}\rangle +{|\tilde{\perp }\rangle }_{LCU,c}.$$

  (47)
• Finally, by augmenting the nonlinear preparation process in Equation (47) with the single qubit evolution register $\left(e\right)$, and applying the two-level variant of the block-encoding matrix ${\widehat{U}}_{{\mathcal{A}}_2}$ from Equation (43) that acts between $\left(e\right)$ and the target register, we obtain

  $${\widehat{U}}_{{\mathcal{A}}_2}({|0\rangle }_e{|0^{\otimes 2}\rangle }_{LCU}{|0000\rangle }_c^{\otimes 2}|{\mathit{\psi }}^{nl}\rangle +{|0\rangle }_e|\tilde{\perp }\rangle )={|0\rangle }_e|{0^{\otimes 2}\rangle }_{LCU}{|0000\rangle }_c^{\otimes 2}|{\mathit{\psi }}_{n+1}\rangle +{|\perp \rangle }_{e,LCU,c}.$$

  (48)

Figure 7 illustrates the quantum circuit implementation corresponding to the aforementioned tasks for the second-order, single-step, time advancement of the Lorenz dynamics.

We will now extend the single-time-step evolution into a full time-marching quantum solver. In order to implement the next time step $|{\mathit{\psi }}_{n+1}\rangle \to |{\mathit{\psi }}_{n+2}\rangle$ (all states are normalized after a successful measurement) it is required to act with ${\widehat{U}}_{nl}$ to prepare the intermediate nonlinear state $|{\mathit{\psi }}_{n+1}^{nl}\rangle$,

$${\widehat{U}}_c{|0000\rangle }_c^{\otimes 2}|{\mathit{\psi }}_{n+1}\rangle ={|{\mathit{\psi }}_{n+1}\rangle }_c^{\otimes 2}|{\mathit{\psi }}_{n+1}\rangle \stackrel{{\widehat{U}}_{nl}}{\to }{|0000\rangle }_c^{\otimes 2}|{\mathit{\psi }}_{n+1}^{nl}\rangle .$$

(49)

However, due to the quantum no-cloning theorem [37], no such operator ${\widehat{U}}_c$ exists that can satisfy Equation (49) because the state $|{\mathit{\psi }}_{n+1}\rangle$ is unknown.

Subsequently, to perform the nonlinear transformation $|{\mathit{\psi }}_{n+1}\rangle \to |{\mathit{\psi }}_{n+1}^{nl}\rangle$, multiple copies of the initial state $|{\mathit{\psi }}_n\rangle$ must be prepared and evolved in a parallel. Therefore, based on the single-step implementation $n\to n+1$ with ${\widehat{U}}_1={\widehat{U}}_{{\mathcal{A}}_2}{\widehat{U}}_{nl}$, the evolution operator ${\widehat{U}}_j$ that defines the j-step advancement, ${\widehat{U}}_j|{\mathit{\psi }}_n\rangle \to |{\mathit{\psi }}_{n+j}\rangle$ can only be defined recursively,

$${\widehat{U}}_j={\widehat{U}}_1{\widehat{U}}_{j-1}^{\otimes 3}.$$

(50)

Indeed,

$${\widehat{U}}_j{|0\rangle }_e|{0^{\otimes 2}\rangle }_{LCU}|{{\mathit{\psi }}_n^{\otimes 2}\rangle }_c|{\mathit{\psi }}_n\rangle \to {\widehat{U}}_1{|0\rangle }_e|{0^{\otimes 2}\rangle }_{LCU}|{{\mathit{\psi }}_{n-j-1}\rangle }_c^{\otimes 2}|{\mathit{\psi }}_{n-j-1}\rangle \to |{\mathit{\psi }}_{n+j}\rangle .$$

(51)

Taking into consideration the no-cloning theorem and Equation (50), a quantum time-marching algorithm is given in

Table 2. Quantum algorithm for the simulation of the second-order discretized Lorenz system (12).

Time-Marching Evolution $\mathit{n}\to \mathit{n}+\mathit{j}$.
1. Initial target state ← ${|{\mathit{\psi }}_n}_{\tau }$.
2. Prepare a clock-time $\left(t\right)$ register ← ${|0^{\nu }\rangle }_t$ with $\nu =\left[{log}_{2}j\right]+1$ and $2j-1$ copies of the $\left(e\right)$, $\left(LCU\right)$ and $\left(c\right)$ registers ← ${({|0\rangle }_e|{0^{\otimes 2}\rangle }_{LCU}|{{\mathit{\psi }}_n^{\otimes 2}\rangle }_c|{\mathit{\psi }}_n\rangle )}^{\otimes 2j-1}$. The target state is chosen to be the least significant.
3. Evolve the target state by acting with the single-step evolution operator ${\widehat{U}}_1$ using the least significant of the $\left(e\right)$,$\left(LCU\right)$,$\left(c\right)$-registers as dictated in Equation (45), $|{\mathit{\psi }}_n\rangle \to |{\mathit{\psi }}_{n+1}\rangle$.
4. Update the clock $\left(t\right)$ register, $C{\widehat{S}}^{+}{|0\rangle }_t\to {|1\rangle }_t$ to keep track of the time advancement of the target state controlled by the 0-bits in the previously used least significant, $i=1$ of the $\left(e\right)$,$\left(LCU\right)$,$\left(c\right)$-registers.
5. Replenish the states ${|{\mathit{\psi }}_n\rangle }_c^{\otimes 2}$ in the $\left(c\right)$ register with a control operator $C{\widehat{U}}_{{\psi }_n}^{\otimes 2}$ with respect to the 1-bit state in the $\left(t\right)$ register with ${\widehat{U}}_{{\psi }_n}|0000\rangle =|{\mathit{\psi }}_n\rangle$.
6. Recursively repeat $j-1$ times the steps 3, 4 and 5, using ${\widehat{U}}_j$ in Equation (50) and $2j-1$ ancillary registers for each iteration.
7. Initialize the clock $\left(t\right)$ register to the ${|0\rangle }_t$ state and measure all registers in respect to the 0-bit states to obtain $|{\mathit{\psi }}_n\rangle \to |{\mathit{\psi }}_{n+j}\rangle$.

.

The respective quantum circuit implementation for the time-marching algorithm in Table 2 is presented in Figure 8. A characteristic feature of the algorithm is that the copies of the initial state $|{\mathit{\psi }}_n^{\otimes 2}\rangle$ in the $\left(c\right)$ registers are not discarded after each time step evolution. Instead, they are re-prepared using the $C{\widehat{U}}_{{\psi }_n}^{\otimes 2}$ operation such that the $\left(c\right)$ registers contain a sufficient number of $|{\mathit{\psi }}_n\rangle$ states to be used for creating the $|{{\mathit{\psi }}_{n+j-1}\rangle }_c^{\otimes 2}$ in the least significant of the $\left(c\right)$ registers. Then, applying ${\widehat{U}}_1$ on the $|{{\mathit{\psi }}_{n+j-1}\rangle }_c^{\otimes 2}|{{\mathit{\psi }}_{n+j-1}\rangle }_{\tau }$ state we obtain the j-time update. We build upon this logic by schematically presenting the re-usage of the copy register for a two-step, $n\to n+2$, advancement following Figure 8:

$$\begin{array}{cc}\hfill & \cdots |{{\mathit{\psi }}_n\rangle }_c^{\otimes 2}\cdots |{{\mathit{\psi }}_n\rangle }_c^{\otimes 2}\underset{\mathrm{target} \mathrm{state}}{\underbrace{{|{\mathit{\psi }}_n\rangle }_{\tau }}}\hfill \end{array}$$

(52)

$$\begin{array}{cc}\hfill \stackrel{{\widehat{U}}_1}{\to }& \cdots {|{\mathit{\psi }}_n\rangle }_c^{\otimes 2}\cdots \underset{\mathrm{re}\text{-}\mathrm{use}}{\underbrace{{|0000\rangle }_c^{\otimes 2}}}|{{\mathit{\psi }}_{n+1}\rangle }_{\tau }+\cdots \hfill \end{array}$$

(53)

$$\begin{array}{cc}\hfill \stackrel{C{\widehat{U}}_{{\psi }_n}^{\otimes 2}}{\to }& \cdots |{{\mathit{\psi }}_n\rangle }_c\underset{\mathrm{available}\mathrm{copies}}{\underbrace{|{{\mathit{\psi }}_n\rangle }_c\cdots |{{\mathit{\psi }}_n\rangle }_c}} \underset{\mathrm{intermediate}\mathrm{target}\mathrm{state}}{\underbrace{{|{\mathit{\psi }}_n\rangle }_c}}{|{\mathit{\psi }}_{n+1}\rangle }_{\tau }+\cdots \hfill \end{array}$$

(54)

$$\begin{array}{cc}\hfill \stackrel{{\widehat{U}}_1}{\to }& \cdots |{{\mathit{\psi }}_n\rangle }_c\underset{\mathrm{re}\text{-}\mathrm{use}}{\underbrace{|0000\rangle \cdots |0000\rangle }}|{{\mathit{\psi }}_{n+1}\rangle }_c|{{\mathit{\psi }}_{n+1}\rangle }_{\tau }+\cdots \hfill \end{array}$$

(55)

$$\begin{array}{cc}\hfill \stackrel{C{\widehat{U}}_{{\mathit{\psi }}_n}^{\otimes 2}}{\to }& \cdots \underset{\mathrm{available}\mathrm{copies}}{\underbrace{{|{\mathit{\psi }}_n\rangle }_c^{\otimes 2}}}\cdots \underset{\mathrm{intermediate}\mathrm{target}\mathrm{state}}{\underbrace{{|{\mathit{\psi }}_n\rangle }_c}}{|{\mathit{\psi }}_{n+1}\rangle }_c{|{\mathit{\psi }}_{n+1}\rangle }_{\tau }+\cdots \hfill \end{array}$$

(56)

$$\begin{array}{cc}\hfill \stackrel{{\widehat{U}}_1}{\to }& \cdots {|0000\rangle }_c^{\otimes 2}\cdots \underset{\mathrm{evolution}\mathrm{to}n+2}{\underbrace{|{{\mathit{\psi }}_{n+1}\rangle }_c^{\otimes 2}|{{\mathit{\psi }}_{n+1}\rangle }_{\tau }}}+\cdots \hfill \end{array}$$

(57)

$$\begin{array}{cc}\hfill \stackrel{{\widehat{U}}_1}{\to }& \cdots {|0000\rangle }_c^{\otimes 2}\cdots {|0000\rangle }_c^{\otimes 2}|{{\mathit{\psi }}_{n+2}\rangle }_{\tau }+\cdots \hfill \end{array}$$

(58)

This re-usage of qubits [19] allows for parallel processing of the quantum states and optimal scaling in the numbers of required copies of the state $|{\mathit{\psi }}_n\rangle$, as will be discussed in the next section.

3.4. Complexity Considerations and Discussion

In quantum algorithmic architectures incorporating many copies of the initial state $|{\mathit{\psi }}_n\rangle$, the important aspects dictating the efficiency of the algorithm are the number of copies that the algorithm requires (circuit width) and the number of elementary operations (circuit depth).

Due to the re-usage of the states in the $\left(c\right)$ registers, as presented in Equations (53)–(58), the required number of copies, ${\mathcal{N}}_{copies}$, of the 4-qubit state $|{\mathit{\psi }}_n\rangle$ scales linearly with respect to the number of time integration steps $N_t$ for a simulation $n\to n+N_t$,

$${\mathcal{N}}_{copies}\left(N_t\right)=4N_t-1.$$

(59)

This linear dependence of the number of copies on $N_t$ establishes an exponential improvement over the results of Ref. [15] and a quadratic improvement compared to Refs. [11,16]. This technique was first demonstrated in Ref. [19]. Taking into consideration the ancillary qubits in the $\left(t\right)$$\left(LCU\right)$ and $\left(e\right)$ registers, the total number of working quantum resources is

$${\mathcal{N}}_{qubits}\left(N_t\right)=(2N_t-1)(\underset{\left(c\right)}{\underbrace{8}}+\underset{\left(e\right)}{\underbrace{1}}+\underset{\left(LCU\right)}{\underbrace{2}})+\underset{\left(t\right)}{\underbrace{{log}_2{N}_t+1}}+\underset{\mathrm{target}}{\underbrace{4}}=22N_t+{log}_2{N}_t-6.$$

(60)

Therefore, the total number of operational qubits for the overall quantum time-integration scheme scales as ${\mathcal{N}}_{qubits}\left(N_t\right)=\mathit{O}\left(N_t\right)$.

On the other hand, the recursive structure of the time-marching algorithm in Table 2 enables a direct count of the operators ${\widehat{U}}_1$, $C{\widehat{U}}_{{\mathit{\psi }}_n}^{\otimes 2}$ and $\widehat{S}$ which are highlighted in blue, yellow and red respectively in Figure 8. Specifically, the number ${\mathcal{N}}_{U_1}$ of the ${\widehat{U}}_1$ gates that comprise each ${\widehat{U}}_j$ is

$${\mathcal{N}}_{U_1}\left(j\right)=3^{j-1}.$$

(61)

Thus, the total number of ${\widehat{U}}_1$ gates for $N_t$ time-steps reads

$${\mathcal{N}}_{U_1}\left(N_t\right)=\sum _{j=1}^{N_t}{3}^{j-1}={\displaystyle \frac{3^{N_t}}{2}}.$$

(62)

Accordingly, the number of $\widehat{S}$ gates (in red in Figure 8) acting on the clock $\left(t\right)$ register is ${\mathcal{N}}_S\left(N_t\right)=2N_t$ and, similarly with Equation (62) due to recurrence, the number of the ${\widehat{U}}_{{\psi }_n}^{\otimes 2}$ gates (in yellow in Figure 8) scales as

$${\mathcal{N}}_{U_{{\psi }_n}^{\otimes 2}}\left(N_t\right)=3^{N_t-1}-N_t.$$

(63)

As a result, the total number of queries to the building blocks of our algorithm is

$${\mathcal{N}}_{queries}={\displaystyle \frac{5}{6}}{3}^{N_t}+N_t=\mathit{O}\left(3^{N_t}\right).$$

(64)

Finally, since a second-order time-discretization scheme has been employed, the total simulation error $\epsilon$ in terms of the total simulation time T is $\epsilon =T^2/N_t$.

The decomposition cost of the ${\widehat{U}}_1$ and $C{\widehat{U}}_{{\mathit{\psi }}_n}$ operators into elementary gates is constant because each of the ${\widehat{U}}_{nl}$, ${\widehat{U}}_{{\mathcal{A}}_2}$ and ${\widehat{U}}_{{\mathit{\psi }}_n}$ operators act in the 4-qubit space (see Section 3.1.1, Section 3.1.2 and Section 3.2). The corresponding circuit implementation has been explicitly provided in Figure 3, Figure 6 and Figure 7. Thus, the resulting implementation scaling into CNOTs and single-qubit gates scales as $\mathit{O}(28·2^9{N}_t^2)=\mathit{O}(60·{16}^2)$. Implementation of the $\widehat{S}$ operator scales as $\mathit{O}\left({\nu }^2\right)=\mathit{O}\left({log}_2^2{N}_t\right)$.

Consequently, the proposed quantum solver for the second-order discretized Lorenz system requires an operational circuit width that scales linearly with the time-integration steps and with overall complexity,

$$\mathit{O}(60d^2{p}^{N_t},T^2/ϵ),p=3,d=16,{\mathcal{N}}_{copies}\left(N_t\right)=4N_t-1.$$

(65)

Notice that $d=16$ is the dimension of the second-order discretized Lorenz system in Equation (13), and $p=3$ is the maximum polynomial degree in the nonlinear state $|{\mathit{\psi }}_n^{nl}\rangle$.

The complexity scaling presented in Equation (65) is characteristic of the proposed quantum algorithmic scheme. Consider a polynomial nonlinear system of ODEs of dimension $d_s$ with a maximum degree $p_s$. Then, employing a K-th order discretization scheme, the resulting nonlinear state $|{\mathit{\psi }}^{nl}\rangle$ has a polynomial degree of $p=p_s+K-1$ and dimension d. Therefore, the augmented system (similar to that of Equations (7) and (12)) can be represented within $n={log}_{2}d$ qubits. To prepare the state $|{\mathit{\psi }}^{nl}\rangle$ through the Hadamard product we need p copies. Therefore, the complexity of the general high order quantum solver in analogy with Equation (65) is given by

$$\mathit{O}\left[4^n{n}^2{p}^{N_t},{\left({\displaystyle \frac{T^K}{\epsilon }}\right)}^{{\displaystyle \frac{1}{K-1}}}\right]=\mathit{O}\left[d^2{log}_2^{2}d{p}^{N_t},{\left({\displaystyle \frac{T^K}{\epsilon }}\right)}^{{\displaystyle \frac{1}{K-1}}}\right],{\mathcal{N}}_{copies}\left(N_t\right)=\mathit{O}\left(N_t\right).$$

(66)

When the resulting ${\widehat{\mathcal{A}}}_K$ matrix is d-sparse, the scaling with respect the dimension of the original nonlinear system is $\mathit{O}[polylog\left(d_s\right)p^{N_t}]$. As a result, the quantum solver exhibits an exponential speed-up over classical ODE solvers, which typically scale linearly with the dimension $d_s$. However, as with all contemporary quantum algorithms for polynomial nonlinear ODEs, the present quantum solver exhibits an exponential lower bound in its time complexity (see, for example, Ref. [43], where the authors develop a quantum algorithm for nonlinear and norm-preserving ODEs). In contrast, classical Runge–Kutta solvers achieve polynomial complexity, $\mathit{O}\left[poly\left(N_t\right)\right]$, with respect to the number of integration steps [44].

The novelty of the complexity scaling in Equation (66) compared to other time-marching schemes, lies in its linear dependence on the number of state copies with respect to the integration steps $N_t$, even when employing higher-order explicit integration schemes rather than the simple Euler method used in previous studies. Using quantum compression gadgets [45,46], it is anticipated that the above scalings in Equations (59)–(66) can be further improved.

The final feature of the algorithm to be discussed is its post-selective, and therefore, probabilistic nature. As illustrated in Figure 8, obtaining the correct result $|{\mathit{\psi }}_{n+N_t}\rangle$ requires a single successful measurement at the output in all ancillary registers with respect to the 0-bits. While the continuum Lorenz nonlinear differential equations yield a contraction map in time, as shown in Equation (5), this does not hold for the discretized Lorenz system, i.e., for the operator ${\widehat{\mathcal{A}}}_2$ in Equation (14). As a result, a normalization factor $a={\sigma }_{max}$, where ${\sigma }_{max}$ is the maximum singular value of ${\widehat{\mathcal{A}}}_2$, dictates the success probability of the SVD-LCU block encoding ${\widehat{U}}_{{\mathcal{A}}_2}$, as described in Section 3.2. Since ${\widehat{U}}_{{\mathcal{A}}_2}$ is a component in the fundamental algorithmic composite block ${\widehat{U}}_1={\widehat{U}}_{{\mathcal{A}}_2}{\widehat{U}}_{nl}$ in Equation (45), and the number of ${\widehat{U}}_1$ repetitions scale according to Equation (62), then the overall success implementation probability is

$$p_{success}\left(N_t\right)\propto {\left({\displaystyle \frac{1}{{\sigma }_{max}^2}}\right)}^{3^{N_t}}\approx {(1-2{\epsilon }_{\sigma })}^{3^{N_t}},\mathrm{with}{\sigma }_{max}=1+{\epsilon }_{\sigma },{\epsilon }_{\sigma }>0.$$

(67)

In turn, the value of ${\sigma }_{max}$, for the ${\widehat{\mathcal{A}}}_2$ matrix depends on the chosen time-discretization step $\delta t$ as dictated in Equations (15)–(19). The behavior of ${\sigma }_{max}\left(\delta t\right)$ as a function of the time step $\delta t$ is shown in Figure 9. Selecting a time step $\delta t<<1$ improves the accuracy of the algorithm and results in a ${\sigma }_{max}<1.01$ according to Figure 9. Thus, the implementation success probability in Equation (67) is improved. However, choosing an extremely small $\delta t<<1$, it increases the number of iteration steps $N_t$ for a total simulation time $t\to t+T,T=N_t\delta t$. Because of the doubly exponential dependence of the success probability on $N_t$ in Equation (67), this leads to a significant reduction in the overall probability for a successful implementation of our quantum algorithm.

The issue of vanishing implementation probability also arises in time-marching algorithms for dissipative and linear ODEs [46]. Consequently, at the output of the algorithm, probability amplification techniques such as amplitude amplification [47], oblivious amplitude amplification [48] and uniform singular value amplification [46] are required to increase the success probability of measuring the state with all ancillary qubits in the 0-bit.

We close this section by highlighting that even after successfully post-selecting the state $|{\mathit{\psi }}_{n+N_t}\rangle$, the information about the solution vector $(x_{n+N_t},y_{n+N_t},z_{n+N_t})$ remains encoded in the amplitudes of $|{\mathit{\psi }}_{n+N_t}\rangle$, according to Equation (20). Subsequently, to retrieve the solution, it is necessary to apply amplitude estimation [47], which worsens the exponential time scaling of the algorithm. An alternative approach is to construct a time history state by creating the entangled state,

$$|{\mathit{\psi }}_h\rangle ={\displaystyle \frac{1}{\sqrt{N_t+1}}}\sum _{j=0}^{N_t}|j\rangle |{\mathit{\psi }}_n\rangle ,$$

(68)

and, upon applying the operator,

$${\widehat{U}}_{history}=\sum _{j=0}^{N_t}|j\rangle \langle j|\otimes {\widehat{U}}_j,{\widehat{U}}_j|{\mathit{\psi }}_n\rangle =|{\mathit{\psi }}_{n+j}\rangle ,$$

(69)

yields a time history state comprising all intermediate solutions within $[0,N_t]$,

$${\widehat{U}}_{history}|{\mathit{\psi }}_h\rangle ={\displaystyle \frac{1}{\sqrt{N_t+1}}}\sum _{j=0}^{N_t}|j\rangle |{\mathit{\psi }}_{n+j}\rangle .$$

(70)

The derivation in Equation (70) has been simplified in the sense that each |j〉 is entangled with unwanted contributions from the action of ${\widehat{U}}_j$. However, by defining a physically meaningful observable (Hermitian operator) $\widehat{D}$, we can compute its mean value $J_D$,

$$J_D=\langle \widehat{D}\rangle ={\displaystyle \frac{1}{N_t+1}}\sum _{j=0}^{N_t}\langle {\mathit{\psi }}_{n+j}|\widehat{D}|{\mathit{\psi }}_{n+j}\rangle \stackrel{\mathrm{continuous}\mathrm{limit}}{\to }{\displaystyle \frac{1}{T}}{\int }_0^T\langle \mathit{\psi }\left(t\right)|\widehat{D}|\mathit{\psi }\left(t\right)\rangle dt,$$

(71)

where $J_D$ is the instantaneous average of a physically interesting quantity such as the finite-time Lyapunov exponent [49] or other fluid dynamics related quantities [50]. In general, for chaotic and turbulent systems, especially in the infinite average time limit $N_t\to \infty$, the classical cost of an accurate computational estimate of $J_D$ is prohibitive [50]. Lastly, the time history state (70) can serve as the input for quantum data processing, enabling dynamical analysis in terms of principal components, power spectra, and wavelet decompositions [51].

4. Numerical Demonstrations

While the proposed quantum solver exhibits a quantum speed-up in terms of the dimension of the system compared to the classical ODE solvers, the exponential scaling in the number of operations with the integration steps in Equation (65) puts limitations to the quantum implementation of our algorithm in the Noisy Intermediate-Scale Quantum (NISQ) era, with relatively high error rates and relatively small number of allowed operations. Therefore, we resort to classical implementation of the quantum algorithm presented in Section 3.2 for the Lorenz second-order scheme, Equations (12)–(19), for various values of $\beta$ at $\sigma =10$ and $\rho =28$.

Following the work of Moysis [52], we plot the bifurcation diagram, Figure 10, for $z\left(\beta \right)$ as a function of the parameter $\beta$ in the range $0.54<\beta <0.58$ with $\sigma =10$ and $\rho =28$. This bifurcation diagram is a Poincare plot of the Lorenz attractor as its orbit intersects the plane $x=0$ with $dx/dt<0$. One can readily identify the bifurcation from period-1 $\left(P1\right)$ to period-2 $\left(P2\right)$ limit cycle for $\beta \approx 0.542$. A bifurcation from $P2$ - $P{2}^2$ around $\beta \approx 0.558$, and a $P{2}^2 \text{-} P{2}^3$ bifurcation for $\beta \approx 0.5624$. Indeed, in this small parameter window $0.54<\beta <0.58$, this bifurcation diagram is formally similar to the well-known period-doubling bifurcation route to chaos for the 1D discrete logistic map ${\eta }_{n+1}=\mu {\eta }_n(1-{\eta }_n)$ as the parameter $\mu$ is varied.

In the following, we will compare the Lorenz regular (limit cycles) and chaotic attractors as determined from our second-order fixed time scale solution to Equations (12)–(19) with those derived from the higher order adaptive time scale ODE solver in $Mathematica$. For values of $\beta$ giving rise to a chaotic attractor (e.g., $\beta =0.58$), the second-order finite difference scheme will require a smaller time step $\delta t=2.5\times {10}^{-4}$ than is needed to determine the periodic limit cycles (where $\delta t={10}^{-3}$).

4.1. Chaotic Attractor: $\beta =0.58$

The $\beta$-bifurcation diagram, Figure 10, indicates that we should expect chaos for $\beta =0.58$. Indeed, we find such an attractor using the higher order adaptive time ordinary differential equation (ODE) solver, as presented in Figure 11. The asymmetry in the lobes makes this attractor look considerably different than the standard picture of the “butterfly” attractor for the more common parameter value $\beta =8/3$. Here, both the 2D phase plot in the $y-z$ plane as well as the full 3D attractor in the $x-y-z$ plane for initial conditions $x\left(0\right)=0.1, y\left(0\right)=-1.1, z\left(0\right)=10.1$ are presented in Figure 11. Notice that, by changing just the initial z to $z\left(0\right)=1.1$, but keeping $x\left(0\right)=0.1$ and $y\left(0\right)=-1.1$, the resulting Lorenz attractor is still chaotic, but with mirror symmetry.

Implementing the quantum solver for the second-order finite difference scheme, we find excellent qualitative agreement between the second-order-generated chaotic attractor in Figure 12 and that generated by the adaptive grid higher order ODE solver used in Figure 11. This signifies that a successful quantum implementation of our method has the potential to resolve the chaotic region for the Lorenz system, preserving the basic structural characteristics of the chaotic attractor.

4.2. Limit Cycles

Aside from the chaotic attractors, different structures that arise in the region of regular dynamics of the Lorenz system are limit cycles. Limit cycles are isolated periodic orbits, which also exhibit sensitivity to perturbations. For example, in Figure 10, as the parameter $\beta$ increases, there is a transition through bifurcations from the regular dynamics limit cycles to chaos.

In the following, some of the period-doubling non-chaotic Lorenz attractors are considered, with initial conditions $x\left(0\right)=0.1$, $y\left(0\right)=-1.1$, $z\left(0\right)=1.1$, using the second-order scheme.

4.2.1. P1-Limit Cycle: $\beta =0.52$

The period-1 limit cycle for $\beta =0.52$ is shown in Figure 13, anchored about the two unstable fixed points $(\pm 3.75,\pm 3.75,27)$.

4.2.2. Period Doubling Limit Cycles

On increasing $\beta$, to $\beta =0.55$ we encounter a period-2 $\left(P2\right)$ limit cycle, depicted in Figure 14, and a period-4 $\left(P{2}^2\right)$ limit cycle at $\beta =0.56$ presented in Figure 15.

The period-doubling limit cycles found in Figure 13, Figure 14 and Figure 15 with the second-order method can be considered rudimentary in terms of their period-doubling behavior as the parameter $\beta$ increases toward the formation of the chaotic attractor. To further challenge the capabilities of the proposed second-order quantum integration method, we seek to verify whether we can generate a non-trivial limit cycle. Such non-trivial limit cycles arise as transitions from chaos to regular dynamics, as indicated in the bifurcation diagram.

For instance, at $\beta =0.5648$, the Lorenz attractor is a $P6$ limit cycle resulting from the period-doubling bifurcation of the two $P3$ attractors. Such isolated and fine-structured solutions cannot be obtained by series truncation techniques such as Carleman and KvN or by variational algorithms. In contrast, our method accurately captures the structure of the $P6$-limit cycle in Figure 16 when compared to the $Mathematica$ ODE solver in Figure 17.

The numerical demonstrations in Figure 11, Figure 12, Figure 13, Figure 14, Figure 15, Figure 16 and Figure 17 illustrate that the second-order discretization scheme captures the correct qualitative nonlinear Lorenz dynamics. In contrast, prior works [14,15,16,18] rely exclusively on the simple first-order Euler scheme, which is insufficient for accurately simulating the Lorenz dynamics [27]. Our algorithm offers a systematic framework for quantum implementation of second and higher-order explicit discretization schemes for reliable quantum simulation of nonlinear ODEs. Importantly, as shown in Equation (66), the quantum realization of these higher-order schemes consistently requires only a linear number of state copies. However, as discussed in Section 3.4, the quantum algorithm is not competitive in time complexity with the classical integration methods. Therefore, there is no practical motivation to quantitatively compare the second-order results to those of the higher-order adaptive $Mathematica$ solver in terms of the $L^2$ error.

5. Conclusions

In the present paper, we present a quantum algorithm that belongs to the class of quantum time-marching solvers and apply it to a second-order discretized Lorenz system of nonlinear differential equations. For a single-time-step update, a two-stage process is required: first, the preparation of a nonlinear quantum state, and then the linear evolution of the state. To construct the nonlinear 4-qubit Lorenz state $|{\mathit{\psi }}_n^{nl}\rangle$, the Hadamard product is employed, whereas the action of the linear non-unitary operator ${\widehat{\mathcal{A}}}_2$ is performed through a simple SVD-LCU block encoding technique. Extending the single-time-step evolution into a complete time-marching scheme requires evolving multiple copies of the initial state $|{\mathit{\psi }}_n\rangle$ in parallel due to the no-cloning theorem. By incorporating a re-usage of states [19] strategy, our algorithm obtains a recursive structure that allows for linear scaling in the number of state copies with respect to the number of iteration steps $N_t$ (Equation (59)). This represents an improvement over other quantum time-marching algorithms, which require exponential or quadratic resource scaling.

Additionally, the novelty of the algorithm can be summarized as follows: $\left(\mathbf{1}\right)$ it is explicit with respect to the gate decompositions (no oracle operations) and avoids any linearization techniques such as Carleman or KvN by providing a path for accurate simulation of system dynamics; $\left(\mathbf{2}\right)$ it is pertinent for developing higher order discretization schemes relevant to numerical implementation of stiff ODEs, such as the Lorenz system; $\left(\mathbf{3}\right)$ in spite of the exponential time scaling, the proposed quantum solver exhibits a quantum speed-up with respect to system dimensionality $d_s$, as implied by Equation (65)—this is particularly valuable for densely discretized partial differential equations (PDEs), resulting in huge-dimensional ODEs for resolving the multiscale structures in turbulent flows. The recursive structure of the proposed algorithmic scheme has been identified as a promising feature for developing novel quantum algorithms with a quantum advantage [53].

Classical implementation of the proposed quantum algorithm for the second-order discretized Lorenz system demonstrates strong agreement with the $Mathematica$-generated chaotic and regular attractors. Combined with the improved quantum resources scaling presented in Equation (60) and the aforementioned points $\left(\mathbf{1}\right)$–$\left(\mathbf{3}\right)$, these results suggest that the proposed time-marching quantum algorithm for discretized nonlinear differential equations has the potential to enable significant advances in the quantum simulation of classical nonlinear dynamics.

It is of great interest to extend the presented ideas to PDEs by employing a second-order time-discretization scheme but now within the framework of Qubit Lattice Algorithms (QLA). A Qubit lattice algorithm consists of a sequence of interleaved unitary collide-stream operators recovering the first-order time-discretized PDE up to second-order accuracy in spatial grid size $\delta x$. In the continuum limit, it recovers the correct partial differential equation, provided the time displacement $\delta t$ obeys a diffusion ordering: $\delta t\approx \delta x^2$. This thus leads to an essentially second-order QLA scheme.

Qubit lattice algorithms have been applied to the nonlinear Gross–Pitaevskii system of equations, which describe the ground-state dynamics of spinor Bose–Einstein condensates [54] and references therein. In particular, in one dimension, QLA was used to study the long-time evolution of both scalar and vector soliton collisions. The numerical results were compared to exact analytical solutions of the nonlinear equations, demonstrating excellent agreement, even though the time advancement scheme appears to be a simple Euler scheme.

Finally, QLA has also been employed for solving linear partial differential equations, such as Maxwell’s equations, exhibiting a quantum speed-up compared to classical finite time difference schemes [55].