Quantum lattice Boltzmann method for several time steps: A local Carleman linearization algorithm

1. Problem Statement

The Lattice Boltzmann Method (LBM) is a powerful tool for simulating fluid dynamics (solving Navier-Stokes equations), but it faces severe computational bottlenecks when scaling to the number of lattice sites required for high Reynolds number industrial applications (e.g., aerospace, automotive). While classical supercomputers have achieved massive scales, they remain limited by cost and power.

Quantum computing offers a potential solution via the Quantum Lattice Boltzmann Method (QLBM). However, previous attempts to simulate nonlinear LBM on quantum computers using Carleman Linearization (CL) faced two critical limitations:

1. Non-locality and High Depth: Previous encodings (e.g., Sanavio & Succi) required non-local collision operators where the circuit depth scaled poorly ($O(N^4 Q^4)$ or $O(N^2 Q^4)$) with the number of lattice sites ($N$) and channels ($Q$). This negated the quantum advantage.
2. Low Success Probability: Alternative approaches using matrix access oracles achieved locality but suffered from an extremely low probability of measuring the correct result (order of $10^{-5}$), making multi-step simulations practically impossible due to the exponential cost of repetition.

The core problem addressed is how to design a local quantum encoding for Carleman-linearized LBM that maintains a high success probability (order of $10^{-2}$) while enabling simulations over multiple time steps.

2. Methodology

The authors propose a novel encoding scheme that renders the collision operator local, thereby reducing circuit depth and improving success probability.

A. Carleman Linearization (CL)

The nonlinear LBM collision operator is transformed into a system of linear equations by introducing higher-order dynamical variables:

• $f_i$: First-order distribution functions (density/momentum).
• $g_{ij} = f_i f_j$: Second-order variables (products of distributions).
  The system is truncated at the second order. The evolution equations become linear but involve coupling between $f$ and $g$.

B. Novel Local Encoding

The key innovation is a new way to encode the lattice sites into quantum registers to ensure the collision operator acts locally (independent of specific lattice site indices in a non-structured way).

• Registers: The system uses five registers: $|x_1\rangle_{p1}$ (first lattice), $|x_2\rangle_{p2}$ (second lattice), $|i\rangle_{c1}$ (channel 1), $|j\rangle_{c2}$ (channel 2), and $|\tau\rangle$ (Carleman order: 0 for $f$, 1 for $g$).
• The Shift Trick: To make the operator local, the authors encode the second lattice variable $x_2$ as a relative coordinate with respect to $x_1$. Specifically, for the $g$ terms ($\tau=1$), the state is shifted such that $g(x_1, x_2)$ is stored as $|x_1\rangle |x_2 - x_1\rangle$.
• Effect: This transformation ensures that the collision operator depends only on the channel registers and the relative distance, not on the absolute position of the lattice sites. This allows the operator to be applied uniformly across the superposition of all lattice sites without requiring complex, site-dependent CNOT gates.

C. Algorithm Steps

1. State Preparation: Encode initial $f$ and $g$ distributions. $g$ is initialized using a controlled rotation based on the tensor product of $f$.
2. Permutation: A shift operation is applied to the $p2$ register controlled by $p1$ to establish the relative coordinate encoding ($x_2 \to x_2 - x_1$).
3. Collision: The linearized collision operator is applied. Since the operator is non-unitary, it is embedded using a Linear Combination of Unitaries (LCU) technique with an ancilla qubit.
   • The operator acts locally on the channel registers.
   • The diagonal terms ($g(x_1, x_1)$) are handled by mapping them to a specific state where the second lattice register is zero.
4. Propagation: Standard shift operations are applied to move particles. Due to the relative encoding, the propagation of $g$ requires a conditional shift: $x_2 \to x_2 + u_2 - u_1$.
5. Measurement: The final state is measured to extract macroscopic quantities (density, velocity).

3. Key Contributions

• Local Collision Operator: The paper introduces an encoding that makes the collision operator local, eliminating the $O(N^4)$ scaling of previous methods.
• Improved Success Probability: The new encoding increases the probability of measuring the correct result to approximately $10^{-2}$ per time step, a significant improvement over the $10^{-5}$ of oracle-based methods.
• Complexity Analysis:
  • Qubit Count: Scales as $O(\log_2 N)$ (logarithmic with lattice sites).
  • Circuit Depth: Scales as $O(\log_2^2 N + Q^3)$ per time step.
  • This represents a substantial reduction in depth compared to previous non-local approaches, making multi-step simulations feasible on near-term devices (in theory).
• Validation: The authors provide a rigorous proof (Appendix A) that the encoding preserves the physics of the original LBM and that the permutation/shift operations correctly implement the propagation for the relative coordinates.

4. Results and Validation

The algorithm was validated using the Qiskit quantum emulator:

• Small Scale Tests ($L_x = 2, 4$):
  • Compared quantum statevector simulations against classical matrix multiplication.
  • Accuracy: For the primary distribution $f$, relative errors were minimal (<5%). For the secondary variable $g$, errors were higher due to the low probability amplitude of $g$ relative to $f$, but the trend remained consistent.
  • Macroscopic Variables: When measuring total mass/density ($\sigma_f$), the quantum results matched classical simulations with high fidelity.
• Larger Scale Simulation ($L_x = 32$):
  • Simulated a Taylor-Green vortex for 10 time steps using the classical linearized operator (to verify the physics of the linearization itself).
  • The linearized Carleman approach successfully reproduced the velocity field of the standard LBM, confirming the validity of the truncation and linearization for weakly compressible flows.
• Shot Noise: The authors noted that achieving high accuracy requires a large number of shots ($5 \cdot 10^8$) due to the $10^{-2}$ success probability and the small amplitude of $g$ terms.

5. Significance and Limitations

Significance:
This work bridges a critical gap in quantum fluid dynamics. By solving the locality and probability issues simultaneously, it demonstrates a viable path toward running QLBM simulations for multiple time steps on quantum hardware. It moves beyond single-step proofs-of-concept to a scalable algorithm structure.

Limitations & Future Work:

• Success Probability: While improved to $10^{-2}$, this is still low. For long simulations (many time steps), the cumulative probability of success drops exponentially, requiring error mitigation or amplitude amplification techniques.
• Non-Unitarity: The collision operator is inherently non-unitary. The reliance on LCU introduces overhead and limits the success probability.
• Linearization Truncation: The method relies on a second-order Carleman truncation. While valid for low Mach numbers and moderate Reynolds numbers, it may struggle with highly turbulent or high-Reynolds-number flows where higher-order terms are significant.
• Hardware Constraints: Current quantum hardware cannot yet run the full depth required for large $N$ and $Q$ with sufficient fidelity, though the algorithm is designed to be compatible with dynamical circuits.

In conclusion, the paper presents a theoretically sound and experimentally validated algorithm that significantly advances the state-of-the-art in Quantum Lattice Boltzmann Methods, offering a promising route for future quantum advantage in computational fluid dynamics.