Schrödinger-Navier-Stokes Equation for the Quantum Simulation of Navier-Stokes Flows

This paper revisits the Schrödinger-Navier-Stokes formulation of classical fluids to propose a novel quantum algorithm based on tensor-network Carleman embedding of the Hamilton-Jacobi equations, which overcomes dissipator challenges and demonstrates convergence for Kolmogorov-like flows in a classical emulation.

The Gist

Imagine you are trying to predict how a cup of coffee swirls when you stir it, or how smoke rises from a candle. These are problems involving fluid dynamics (the Navier-Stokes equations). For centuries, scientists have used powerful supercomputers to simulate these flows. But what if we could use a quantum computer to do it? Quantum computers are famous for solving problems that are impossible for classical machines, but they have a major weakness: they hate nonlinearity and dissipation (friction/energy loss). Fluids are full of both, making them very hard to simulate on a quantum device.

This paper presents a clever new recipe to cook up a quantum simulation of fluids. Here is the breakdown in simple terms:

1. The Problem: The "Square Peg in a Round Hole"

Think of a quantum computer as a very strict librarian who only understands linear stories (where A + B = C, and everything adds up neatly). Real-world fluids, however, are chaotic non-linear stories (where A + B might equal C, or D, or a tornado). Furthermore, fluids lose energy to friction (dissipation), which quantum computers don't naturally handle.

Previous attempts tried to force fluids into a quantum shape, but they either missed the "friction" part or made the math so complicated it was impossible to run.

2. The Solution: The "Madelung" Magic Trick

The authors go back to a 1985 idea by Dietrich and Vautherin. They use a mathematical "magic trick" called the Inverse Madelung Transformation.

• The Analogy: Imagine you have a complex, messy knot of rope (the fluid). Instead of trying to untie it directly, you realize the knot looks exactly like a wave if you squint at it from a specific angle.
• The Trick: They rewrite the messy fluid equations into a wave equation (like the Schrödinger equation used for electrons). This makes the problem look like something a quantum computer loves to solve.
• The Catch: This wave equation still has a "friction" term that is too messy for quantum computers.

3. The Fix: The "Carleman" Ladder

To fix the messy friction part, they use a technique called Carleman Linearization.

• The Analogy: Imagine you are trying to climb a steep, curved hill (the non-linear problem). You can't walk up the curve directly. So, you build a ladder with many rungs.
  • The bottom rung is your current state.
  • The next rung is your state squared.
  • The next is your state cubed, and so on.
• The Result: By climbing this ladder, you turn the curved, messy hill into a series of straight, flat steps (linear equations). A quantum computer can easily walk up these straight steps.

4. The Innovation: The "Tensor Network" Backpack

Here is where the authors really shine. Building this ladder usually creates a massive amount of data.

• The Problem: If you try to write down every rung of the ladder for a fluid simulation, the memory required is like trying to store all the books in the Library of Congress on a single thumb drive. It's impossible.
• The Solution: They use a Tensor Network.
  • The Analogy: Instead of carrying a giant, heavy backpack full of every single book (the full data), you carry a folded map (the tensor network). The map tells you how to reconstruct the books only when you need them.
  • The Benefit: This technique shrinks the memory requirement from "impossible" to "manageable." It allowed them to run simulations on a regular laptop that would have otherwise required a supercomputer.

5. The Results: A New Path Forward

They tested this new method (which they call CHJ) on a computer to see if it worked.

• Short Term: For a short time, using a "taller ladder" (higher order truncation) gave very accurate results, beating previous methods.
• Long Term: Interestingly, after a while, the "taller ladder" started to wobble and lose accuracy. However, the shortest ladder (second-order) turned out to be the most reliable for predicting the long-term behavior of the fluid (like how the coffee eventually stops swirling).

The Big Picture

This paper is significant because:

1. It is the first time a quantum algorithm has been proposed that handles the real Navier-Stokes equations (including pressure, friction, and swirling vortices) in a way that is actually feasible.
2. It solves the "memory crisis" using the Tensor Network backpack, making these simulations possible on smaller devices.
3. It suggests a hybrid strategy: Use a complex, high-order ladder for short-term precision, and a simple, low-order ladder for long-term trends.

In summary: The authors found a way to translate the chaotic language of fluid dynamics into the clean, linear language of quantum mechanics, and then built a "memory-saving backpack" to carry the heavy data. This opens the door for future quantum computers to simulate weather, aerodynamics, and ocean currents with unprecedented efficiency.

Technical Summary

1. Problem Statement

The simulation of classical fluid dynamics (Navier-Stokes equations, NSE) on quantum computers faces two fundamental hurdles: nonlinearity and dissipation.

• Nonlinearity: Quantum mechanics is inherently linear; simulating nonlinear classical systems requires complex embedding techniques.
• Dissipation: Classical fluids lose energy (viscosity), whereas standard quantum evolution is unitary (energy-conserving).
• The Gap: Previous attempts to formulate a "quantum-like" wave equation for fluids (e.g., Madelung formulation) either failed to capture vorticity correctly, relied on artificial forces to model dissipation, or required purely classical algorithms to handle the dissipative terms. The authors aim to bridge this gap by developing the first viable quantum algorithm for the genuine Navier-Stokes equations, including pressure, dissipation, and vorticity.

2. Methodology

The authors propose a three-step methodology to overcome the challenges of nonlinearity and dissipation:

A. Theoretical Framework: Schrödinger-Navier-Stokes (SNS) & Hamilton-Jacobi (HJ)

Instead of using the standard Madelung transformation (which leads to a quantum potential not present in classical fluids), the authors utilize the Dietrich-Vautherin (1985) formulation.

• Wave Equation: They start with a Schrödinger-like equation where the fluid velocity is decomposed into an irrotational part ($\nabla \chi$) and a rotational part ($A$), where $A$ is a vector field coupled to the wavefunction.
• The Dissipator Challenge: The direct SNS equation contains a dissipative term dependent on the Laplacian of the phase, which is non-polynomial and non-local, making it difficult to linearize for quantum algorithms.
• The HJ Reformulation: To bypass this, the authors perform an "inverse Madelung transformation" to derive a Navier-Stokes Hamilton-Jacobi (NSHJ) system. In this formulation:
  • The quantum potential is removed.
  • The viscous term is recast as a series of non-local polynomial nonlinearities (specifically second-order).
  • The system variables are the density ($\rho$), phase ($\chi$), and the vector potential components ($A_x, A_y$).

B. Linearization: Carleman Embedding

To make the nonlinear NSHJ system amenable to quantum simulation, the authors apply Carleman linearization.

• This technique maps the finite-dimensional nonlinear system into an infinite-dimensional linear system by introducing higher-order moments (tensor products) of the state variables.
• Truncation: The infinite hierarchy is truncated at a finite order $N_C$. The authors analyze truncations up to the fourth order ($N_C=4$).
• Discretization: The NSHJ equations are discretized in space and time using a first-order Euler scheme and centered finite differences.

C. Computational Optimization: Tensor Network Representation

A major bottleneck in Carleman embedding is the exponential growth of memory requirements with the truncation order ($O((4G)^{N_C})$).

• Innovation: The authors introduce a Tensor Network (TN) representation for the Carleman embedding.
• Mechanism: Instead of storing the full high-order tensor, the state is represented as a sum of rank-1 tensors (factorized components).
• Complexity Reduction: This reduces the memory complexity from $O((4G)^{N_C})$ to approximately $O((N_t 4G)^{N_C-2}(N_C-2)!)$, where $N_t$ is the number of time steps. This allows simulations of $N_C=4$ on classical hardware that would otherwise require petabytes of memory.

D. Quantum Algorithm Formulation

• Block Encoding: Since the evolution matrices in the Carleman system are non-unitary (due to dissipation), the authors propose using block-encoding techniques. This embeds the non-unitary matrix into a larger unitary operator using ancilla qubits.
• Success Probability: The algorithm succeeds probabilistically (post-selection on ancilla qubits being in the $|0\rangle$ state). The success probability depends on the sub-normalization factor, which scales with the ratio $\Delta t / \Delta x^2$.

3. Key Contributions

1. First Quantum Algorithm for Genuine NSE: This is the first work to propose a quantum algorithm based on a wave formulation of the actual Navier-Stokes equations, fully incorporating pressure, dissipation, and vorticity without artificial surrogates.
2. HJ Reformulation Strategy: The authors demonstrate that reformulating the problem into the Hamilton-Jacobi (NSHJ) form is superior to direct SNS linearization, as it converts the dissipative term into manageable polynomial nonlinearities.
3. Tensor Network Carleman Embedding: They developed a novel tensor-network strategy to handle the Carleman hierarchy, drastically reducing memory requirements and enabling high-order truncations ($N_C=4$) on classical computers for validation.
4. Comprehensive Benchmarking: The paper provides a rigorous comparison between the CHJ (Carleman-Hamilton-Jacobi) approach and existing methods:
   • CNS: Carleman linearization of the raw Navier-Stokes equations.
   • CLB: Carleman linearization of the Lattice Boltzmann formulation.

4. Results

The authors emulated the quantum algorithm on a classical computer using Kolmogorov-like flows at moderate Reynolds numbers ($Re \approx 5$ to $40$).

• Accuracy vs. Truncation Order:

  • Short Time: Higher-order truncations ($N_C=3, 4$) provide superior accuracy initially, keeping relative errors below $10^{-3}$ for $Re \approx 5$.
  • Crossover Time ($t_{cross}$): There exists a critical time $t_{cross}$ beyond which higher-order approximations diverge faster from the exact solution than lower-order ones. $t_{cross}$ decreases as the Reynolds number increases.
  • Long Time: The second-order truncation ($N_C=2$) proves most robust for long-time simulations, correctly capturing the stationary decay trends and asymptotic behavior, even when higher orders fail.

• Comparison with CNS and CLB:

  • vs. CNS: The CHJ approach significantly outperforms the Carleman linearization of the raw Navier-Stokes equations. While CNS diverges quickly, CHJ maintains agreement with the exact solution for over 150 time steps (vs. ~10 for CNS).
  • vs. CLB: CHJ performs comparably to the Carleman Lattice Boltzmann (CLB) method. However, CHJ uses fewer fields (4 variables vs. 9 for 2D Lattice Boltzmann), offering a potential memory advantage, though CLB is noted to be less sensitive to Reynolds number variations up to $Re \approx 100$.

• Resource Efficiency: The tensor network approach reduced memory usage for $N_C=4$ simulations from a theoretical $10^5$ GB to approximately $10^{-2}$ GB, making the validation feasible on standard hardware.

5. Significance and Conclusion

• Feasibility: The paper establishes a viable pathway for quantum simulation of classical fluids, moving beyond idealized models to the full Navier-Stokes equations.
• Hybrid Strategy: The results suggest a hybrid computational strategy: use high-order truncations for resolving short-time, high-frequency dynamics, and switch to second-order truncations for capturing long-time asymptotic behavior and steady states.
• General Applicability: The tensor-network technique for Carleman embedding is general and can be applied to other fluid formulations (e.g., improving CLB simulations), potentially reducing resource requirements for future quantum simulations.
• Open Challenges: The authors note that the success probability of the quantum algorithm is currently low for large time steps relative to grid spacing ($\Delta t / \Delta x^2$), requiring further optimization of block-encoding strategies or qubit mappings.

In summary, this work provides a critical theoretical and numerical foundation for the quantum simulation of dissipative fluid dynamics, demonstrating that the Hamilton-Jacobi formulation combined with tensor-network-enhanced Carleman linearization offers a promising route to overcoming the nonlinearity and dissipation barriers in quantum computing.