⚛️ quantum physics

Light Cone Cancellation for Variational Quantum Eigensolver in Solving Noisy Max-Cut

This paper demonstrates that applying the Light Cone Cancellation method to the Variational Quantum Eigensolver (LCC-VQE) effectively mitigates device noise and improves approximation ratios for solving large-scale Max-Cut problems by reducing the number of required qubits and gates in a single-layer two-local ansatz.

Original authors: Xinwei Lee, Xinjian Yan, Ningyi Xie, Yoshiyuki Saito, Leo Kurosawa, Nobuyoshi Asai, Dongsheng Cai, Hoong Chuin LAU

Published 2026-04-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xinwei Lee, Xinjian Yan, Ningyi Xie, Yoshiyuki Saito, Leo Kurosawa, Nobuyoshi Asai, Dongsheng Cai, Hoong Chuin LAU

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 solve a massive, incredibly complex puzzle called Max-Cut. Your goal is to split a group of people (nodes) into two teams so that the number of friendships (edges) broken between the teams is as high as possible.

In the world of classical computers, this is like trying to find the perfect arrangement of a million puzzle pieces by checking every single possibility one by one. It takes forever.

Enter Quantum Computers. They are like super-powered puzzle solvers that can look at many possibilities at once. One popular method they use is called VQE (Variational Quantum Eigensolver). Think of VQE as a student trying to learn the solution to the puzzle. The student builds a "trial solution" (a quantum circuit), checks how good it is, and then a teacher (a classical computer) tells them how to tweak their approach to get better.

The Problem: The "Noisy" Classroom

Here's the catch: Current quantum computers are like students in a very noisy, chaotic classroom. They are prone to making mistakes (noise) because they are fragile.

Too many qubits (bits): If the puzzle is huge, the student needs a huge desk with thousands of tiny, fragile pieces. The more pieces you have, the more likely one will break or get mixed up.
Too many gates (steps): If the solution requires thousands of steps, the student gets tired and makes more mistakes along the way.

The paper argues that instead of trying to build a bigger, better classroom (which is hard and expensive), we should teach the student a smarter way to study that requires a smaller desk and fewer steps.

The Solution: "Light Cone Cancellation" (LCC)

The authors introduce a clever trick called Light Cone Cancellation (LCC).

Imagine you are trying to figure out the temperature of a specific room in a giant mansion (the quantum circuit).

The Old Way: You send a thermometer through every single room in the mansion, from the basement to the attic, just to measure that one room. This is slow, and the thermometer might break in the process.
The LCC Way: You realize that the temperature of the room you care about is only affected by the rooms immediately next to it. The rooms on the other side of the mansion don't matter at all! So, you cancel out the unnecessary trips to the far rooms. You only measure the "light cone" of influence around your target room.

In the paper's language:

Redundant Gates: Many steps in the quantum circuit cancel each other out mathematically when calculating the answer for a specific part of the problem.
Breaking it Down: Instead of running the whole massive circuit for the whole puzzle, LCC breaks the problem into tiny, independent mini-puzzles.
The Result: You can solve a problem with 100 nodes (a huge puzzle) using a quantum computer that only has 5 to 7 qubits (a tiny desk).

The Experiment: The "Fake" Noisy Backends

The researchers tested this idea using "fake" noisy quantum computers (simulations that act like real, broken hardware).

The Test: They tried to solve Max-Cut puzzles of various sizes.
The Comparison: They compared the "Old Way" (running the full, noisy circuit) vs. the "LCC Way" (breaking it into small, clean circuits).
The Outcome: The LCC method won every time. Even on a small, noisy 7-qubit device, it performed better than the method trying to use a larger 27-qubit device. By reducing the number of steps and the size of the circuit, they effectively "silenced the noise" in the classroom.

The "Layer" Question

The researchers also asked: "What if we make the student study harder by adding more layers of complexity?"

They found that adding more layers (making the circuit deeper) actually made things worse. It was like over-studying; the student got confused, got stuck in local "dead ends," and couldn't find the best solution.
Conclusion: A simple, single-layer approach combined with LCC was the sweet spot.

The Final Showdown: Quantum vs. The Classic Champion

Finally, they compared their new Quantum method (LCC-VQE) against the Goemans-Williamson (GW) algorithm, which is the current "Gold Standard" champion for solving this problem on classical computers.

On simple puzzles: The classic champion (GW) was still king.
On complex, dense puzzles: The Quantum method (LCC-VQE) started to catch up and even beat the champion! This suggests that as problems get harder and more interconnected, this quantum approach might have a special advantage.

The Big Picture

This paper is a blueprint for doing more with less.
Instead of waiting for quantum computers to become perfect and massive, we can use smart mathematical tricks (LCC) to shrink big problems down to fit on the small, noisy machines we have today. It's like realizing you don't need a giant crane to move a house; you just need to disassemble it into smaller, manageable boxes and move them one by one.

In short: They found a way to make quantum computers solve big, messy problems by ignoring the parts of the calculation that don't matter, resulting in faster, cleaner, and more accurate answers.

1. Problem Statement

The paper addresses the challenge of solving large-scale combinatorial optimization problems, specifically the Max-Cut problem, on Noisy Intermediate-Scale Quantum (NISQ) devices.

The Bottleneck: As problem sizes increase, the number of required qubits and circuit depth (gates) grows. This leads to:
1. Simulation Difficulty: Classical simulation of large quantum circuits scales exponentially with the number of qubits.
2. Hardware Noise: Real quantum devices suffer from gate errors and decoherence. Deeper circuits and more qubits accumulate more noise, degrading solution quality (Approximation Ratio).
The Goal: To solve Max-Cut problems with up to 100 nodes using fewer qubits and gates to mitigate noise and enable classical simulation of large instances, without sacrificing solution accuracy.

2. Methodology

The authors propose applying Light Cone Cancellation (LCC) to the Variational Quantum Eigensolver (VQE) algorithm.

A. Algorithmic Framework

VQE Ansatz: The study employs a single-layer two-local ansatz consisting of $R_y$ $R_{y}$ rotation gates and circular $CZ$ entanglement gates.
- Unlike QAOA, which uses a problem-dependent ansatz, VQE uses a static structure with high expressibility.
- The authors found that a single layer is sufficient for high-quality solutions; adding more layers increases the risk of local minima (barren plateaus) and over-parameterization.
Light Cone Cancellation (LCC):
- Principle: LCC exploits the commutativity of unitary gates with local observables. When calculating the expectation value $\langle \psi(\theta) | Z_i Z_j | \psi(\theta) \rangle$ for a specific edge $(i, j)$ in the Max-Cut Hamiltonian, gates that are not "connected" to qubits $i$ and $j$ within the light cone of the observable commute through and cancel out.
- Decomposition: Instead of running the full $N$ -qubit circuit, the expectation value is decomposed into a sum of sub-circuits.
- Qubit Reduction: For a single-layer two-local ansatz with circular entanglement, the maximum number of qubits required to simulate any local term $Z_i Z_j$ is 5 qubits (specifically $2k+1$ where $k=2$ is the locality, regardless of the total graph size $N$ ).
- Gate Reduction: Redundant gates are removed from the sub-circuits, significantly reducing circuit depth.

B. Workflow

Decomposition: The global cost Hamiltonian is broken down into local terms.
Sub-circuit Execution: Each local term is evaluated using a small sub-circuit (max 5 qubits) rather than the full $N$ -qubit circuit.
Reconstruction: The total expectation value is reconstructed by summing the results of these sub-circuits.
Optimization: A classical optimizer (COBYLA) updates the variational parameters $\theta$ based on the reconstructed expectation value.

3. Key Contributions

Scalability via Qubit Reduction: Demonstrated that VQE with LCC can solve Max-Cut problems of arbitrary size (up to 100 nodes) using a maximum of 5 qubits for simulation, shifting the complexity from exponential (in $N$ ) to polynomial (in the number of edges).
Noise Mitigation: Showed that reducing the number of gates and qubits via LCC directly mitigates the impact of hardware noise, leading to higher Approximation Ratios (AR) on noisy simulators.
Layer Analysis: Provided empirical evidence that a single-layer ansatz outperforms multi-layer ansatzes for Max-Cut in this context, as deeper circuits increase the "light cone" size (reducing the benefit of LCC) and introduce optimization difficulties.
Benchmarking: Established a rigorous comparison between LCC-VQE and the classical Goemans-Williamson (GW) algorithm under noiseless conditions.

4. Experimental Results

The study utilized Qiskit's fake noisy backends (FakeCasablanca with 7 qubits and FakeParis with 27 qubits) and noiseless statevector simulators.

A. Noisy Simulations (Noise Mitigation)

Device Comparison: LCC-VQE was run on the 7-qubit device (using 5 qubits for sub-circuits), while standard VQE was run on the 27-qubit device (using all $N$ $N$ qubits).
- Result: LCC-VQE achieved higher Approximation Ratios than standard VQE, even though the 7-qubit device is smaller. This confirms that the reduction in gate count and circuit depth outweighs the benefits of using a larger, noisier device.
Same Device Comparison: When both methods were run on the same 27-qubit backend, LCC-VQE consistently outperformed standard VQE.
- Observation: The performance gap widened as the problem size ( $N$ ) increased, indicating that LCC is increasingly effective at mitigating noise for larger circuits.
Scalability: LCC-VQE successfully solved Max-Cut instances up to 100 nodes on the 7-qubit simulator, a task impossible for standard VQE due to qubit limitations.

B. Noiseless Simulations (Comparison with GW)

Setup: Compared LCC-VQE against the Goemans-Williamson (GW) algorithm on 100-vertex graphs (Regular and Erdős-Rényi).
Findings:
- On low-degree graphs, GW performed slightly better or comparably.
- On high-degree (denser) graphs, LCC-VQE surpassed GW. Specifically, for regular graphs with degree $d \geq 9$ and Erdős-Rényi graphs with edge probability $p \geq 0.2$ , LCC-VQE achieved higher median and upper-quartile Approximation Ratios.
- This suggests that the expressibility of the VQE ansatz allows it to find better solutions on complex, dense graphs where classical approximation algorithms struggle.

5. Significance and Conclusion

Feasibility of Large-Scale VQE: The paper proves that VQE is a viable candidate for solving large-scale combinatorial problems on NISQ devices, provided that circuit decomposition techniques like LCC are used.
Hardware Efficiency: By reducing the required qubits to a constant number (5) regardless of problem size, LCC-VQE bypasses the primary hardware limitation of current quantum processors.
Noise Resilience: The method effectively turns the "noise problem" into a "circuit depth problem," showing that shallower, smaller circuits yield better results than deeper, larger ones on current hardware.
Future Directions: The authors suggest that while LCC-VQE shows promise, further research is needed to optimize the combination of LCC with other algorithms and to test these methods on other combinatorial optimization problems beyond Max-Cut.

In summary, this work demonstrates that Light Cone Cancellation is a powerful technique to make VQE practical for real-world, large-scale optimization problems by drastically reducing resource requirements and mitigating the detrimental effects of quantum noise.