⚛️ quantum physics

Functional matrix product state simulation of continuous variable quantum circuits

This paper introduces a functional matrix product state (FMPS) method that efficiently simulates real-space continuous-variable quantum circuits with non-Gaussian states and loss, demonstrating superior performance over existing techniques for shallow, multi-mode systems.

Original authors: Andreas Bock Michelsen, Frederik K. Marqversen, Michael Kastoryano

Published 2026-03-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Andreas Bock Michelsen, Frederik K. Marqversen, Michael Kastoryano

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to simulate a complex dance performance on a computer. In the world of quantum computing, there are two main styles of dancers:

Discrete Dancers (The "Pixel" Style): These dancers move in distinct, blocky steps (like 0s and 1s). We have excellent software to simulate them.
Continuous Dancers (The "Flow" Style): These dancers move in a smooth, fluid motion, like water flowing down a river or a violin string vibrating. This is called Continuous Variable (CV) quantum computing.

The problem is that while we have great tools for the blocky dancers, simulating the fluid dancers—especially when they do tricky, non-standard moves (called "non-Gaussian" operations)—is incredibly hard. It's like trying to predict the exact path of every single water molecule in a tsunami; the computer gets overwhelmed and crashes.

This paper introduces a new, clever way to simulate these fluid quantum dancers. They call it Functional Matrix Product State (FMPS).

Here is the breakdown using everyday analogies:

1. The Problem: The "Infinite" Mess

Traditional methods try to simulate these fluid systems by chopping the smooth wave into tiny, discrete chunks (like turning a smooth curve into a staircase).

The Issue: If the wave gets too wiggly or complex (which happens with "non-Gaussian" states like GKP or Cat states), you need so many tiny chunks that your computer runs out of memory instantly. It's like trying to count every grain of sand on a beach to predict how the tide will move.

2. The Solution: The "Functional" Shortcut

The authors realized that instead of counting every grain of sand, we should look at the shape of the wave itself.

The Analogy: Imagine you want to describe a complex painting.
- Old Way: You list the color of every single pixel (millions of numbers).
- New Way (FMPS): You describe the painting as a series of brushstrokes. You say, "Here is a blue curve, here is a red swirl, here is a green line."
How it works: The FMPS method treats the quantum state as a "function" (a mathematical recipe for a shape) rather than a giant list of numbers. It breaks this recipe down into a chain of simple, connected parts (like a train of cars). This allows the computer to handle the complexity without needing infinite memory.

3. The "Bounding Box" Trick

When these quantum dancers move, they might stretch out or spin around.

The Challenge: If you simulate them in a fixed room, they might run out of space. If you make the room huge to be safe, you waste a lot of computer power on empty space.
The Fix: The authors developed a smart "smart-box" system. As the dancers move, the box shrinks or expands to fit them perfectly, like a camera zooming in and out to keep the subject in frame. This ensures the computer only calculates the parts of the wave that actually exist, ignoring the empty void.

4. Handling Noise (The "Static" on the Line)

In real life, quantum systems are messy. Light gets lost, and signals get fuzzy (noise).

The Old Way: To simulate noise, you usually have to simulate the "environment" (the air, the heat, the lost photons) alongside the main system, which doubles or triples the work.
The New Way: The authors found a mathematical trick. They realized that for certain types of noise (like photon loss), you can push the "messiness" to the very end of the simulation. You simulate the perfect dance first, and then apply the "static" at the finish line. This saves a massive amount of time.

5. The Results: Why It Matters

The team tested their new method against the current industry standard (a software called Strawberry Fields).

The Test: They simulated circuits with "Cat States" (quantum cats that are both dead and alive) and "GKP States" (grid-like quantum codes used for error correction).
The Outcome:
- The old software got stuck or took hours/days as the number of dancers increased.
- The new FMPS method stayed fast and accurate, even with many complex dancers.
- It was particularly good at simulating "shallow" circuits (short dances), which are the most relevant for building real quantum computers right now.

The Big Picture

This paper is like inventing a new type of GPS for quantum waves.
Previously, simulating complex quantum light was like trying to navigate a city by counting every single brick in every building. The new method (FMPS) is like using a map that understands the flow of traffic and the shape of the roads.

This is a huge step forward because it allows scientists to design and test quantum computers that use light (photons) much more efficiently. It helps us figure out how to build machines that can solve problems we can't solve today, without needing a supercomputer the size of a city just to run the simulation.

1. Problem Statement

Continuous Variable (CV) quantum systems, particularly those utilizing photonic or vibrational modes (Bosonic qubits), are promising candidates for fault-tolerant quantum computing. Key encodings like Gottesman-Kitaev-Preskill (GKP) states and cat states offer intrinsic resilience to noise. However, simulating these systems is computationally challenging, especially when non-Gaussian operations or input states are involved.

Limitations of Existing Methods:
- Fock Space Representations: Tensor network methods applied to Fock space (discrete photon number basis) scale poorly with the number of non-Gaussian states and high photon numbers.
- Gaussian Approximations: Methods like the Bosonic backend in Strawberry Fields (SF) rely on Gaussian approximations which fail to capture the high precision required for non-Gaussian states (e.g., GKP states).
- Scaling Bottlenecks: Current techniques often exhibit exponential scaling in the number of modes or non-Gaussian resources, making the simulation of shallow, multi-mode circuits with realistic non-Gaussian inputs intractable.

2. Methodology: Functional Matrix Product State (FMPS)

The authors propose a novel numerical method based on the Functional Matrix Product State (FMPS) decomposition. Instead of working in the discrete Fock basis, FMPS operates directly in the real-space (position) representation of the wave function.

Core Concepts

Functional Decomposition: The wave function $f(q)$ of an $m$ -mode system is decomposed using a continuous Schmidt decomposition, analogous to the discrete Matrix Product State (MPS) used in discrete-variable systems.
$f(q) \approx \sum_{\alpha_1, \dots, \alpha_{m-1}} \gamma_1(\alpha_0; q_1; \alpha_1) \cdots \gamma_m(\alpha_{m-1}; q_m; \alpha_m)$
Here, $\gamma$ are tensor cores with one continuous variable ( $q_i$ ) and two discrete indices ( $\alpha$ ) representing the bond dimension.
Discretization Strategy:
- The continuous position space is truncated to a finite bounding box and discretized into a grid of $N$ points.
- Interpolation: Cubic splines with Dirichlet boundary conditions are used to evaluate wave functions between grid points, ensuring smoothness and preserving symmetry.
- Nyquist Criterion: The grid density is chosen to satisfy the Nyquist theorem in momentum space to prevent aliasing, ensuring the Fourier transform (momentum representation) remains faithful.
Handling Operations:
- Gaussian Gates: Displacement, squeezing, and beam splitters are implemented by transforming the wave function arguments and updating the bounding box (domain) of the simulation.
- Non-Gaussian Gates: The cubic phase gate is applied as a diagonal phase multiplication in position space.
- Domain Management: A critical innovation is the dynamic adjustment of the bounding box. For operations like beam splitters (rotations), the authors track the original domain to prevent the bounding box from growing unnecessarily large, which would degrade resolution.
Noise Simulation: Photon loss is simulated by commuting the loss channel to the end of the circuit. The method utilizes a purification picture where the system is beam-split with vacuum modes, followed by a Schmidt decomposition to return to FMPS form, avoiding the exponential cost of full density matrix evolution.

3. Key Contributions

Real-Space Tensor Network: Introduction of FMPS, which leverages the functional form of CV states to simulate non-Gaussian systems efficiently, bypassing the need for high-dimensional Fock space truncation.
Algorithmic Framework: A complete framework for simulating universal CV quantum circuits, including:
- Implementation of all Gaussian operators (displacement, squeezing, rotation, beam splitters).
- Implementation of the non-Gaussian cubic phase gate.
- Protocols for various measurements (Photon number, Homodyne, Heterodyne) using tensor contractions.
Noise Handling: An efficient strategy to simulate photon loss by separating the noiseless circuit evolution from the final loss channel simulation, maintaining sub-exponential scaling.
Error Analysis: A systematic analysis of errors arising from discretization, bounding box truncation, and bond dimension truncation, showing that errors can be controlled independently.

4. Results and Performance

The authors benchmarked FMPS against the Strawberry Fields (SF) Bosonic backend using random shallow and cascaded circuits with highly non-Gaussian inputs (Squeezed, Cat, and GKP states).

Scaling Behavior:
- FMPS: Exhibits sub-exponential scaling with the number of modes ( $m$ ). The bond dimension saturates for shallow circuits, meaning computational cost grows polynomially with system size.
- SF (Bosonic Backend): Exhibits exponential scaling for non-Gaussian input states. The simulation time and memory requirements explode as the number of modes increases.
Specific Benchmarks:
- Cascaded Circuits: FMPS successfully simulated circuits with up to 12 modes for GKP and Cat states, whereas SF failed due to memory limitations (32 GB RAM) or time constraints (>1000s) for similar configurations.
- Wide Circuits: For 3-layer wide circuits, FMPS outperformed SF for Cat and GKP states starting around 8 modes. For squeezed (Gaussian) states, SF remained competitive, as expected.
- Noise: Simulating 10% photon loss increased the runtime but preserved the sub-exponential scaling of FMPS.
Accuracy: The method achieved high fidelity (gate fidelity > 0.999) with manageable grid sizes ( $N \approx 200$ ) and bond dimensions ( $r \approx 40-50$ ), with quadrature errors ( $\epsilon$ ) around $10^{-6}$ compared to analytical solutions.

5. Significance

Enabling High-Precision Simulation: FMPS fills a critical gap in quantum simulation tools, allowing for the high-fidelity simulation of non-Gaussian CV circuits that were previously intractable.
Scalability for Bosonic Qubits: The method is particularly well-suited for characterizing protocols involving GKP and cat qubits, which are central to fault-tolerant photonic quantum computing architectures.
Resource Efficiency: By exploiting the low entanglement structure of shallow circuits in real space, FMPS offers a path to simulate larger systems on classical hardware than current Fock-space-based methods.
Practical Application: The authors note that this method has already been applied to study the impact of finite squeezing on measurement-based quantum computing with GKP qubits, demonstrating its immediate utility in research.

In conclusion, the paper establishes Functional Matrix Product States as a superior alternative for simulating non-Gaussian continuous variable quantum circuits, offering a scalable, accurate, and noise-resilient framework essential for the development of next-generation photonic quantum technologies.