⚛️ quantum physics

Pulse-level control for quantum resource preparation

This paper introduces a pulse-level control technique for transmon-qubit systems that directly optimizes quantum correlations to achieve minimal-time preparation of maximally entangled states (such as Bell, GHZ, and W states), thereby mitigating decoherence and reducing control complexity to enhance algorithmic performance.

Original authors: K. De La Ossa Doria, T. Merlo Vergara, D. Goyeneche

Published 2026-02-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: K. De La Ossa Doria, T. Merlo Vergara, D. Goyeneche

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

The Big Idea: Cooking with a Master Chef vs. Following a Recipe

Imagine you want to bake a perfect chocolate cake.

The Old Way (Standard Quantum Computing):
Most quantum computers today work like a strict recipe book. You have to follow a specific list of steps (gates): "Add flour," "Mix for 30 seconds," "Add eggs." Even if you know a faster way to mix the batter, the machine forces you to follow the standard steps one by one. This takes time, and while you are waiting, the cake might start to dry out or burn (this is called decoherence). Also, if the recipe is too complex, you might get confused and make a mistake (this is called the barren plateau problem).

The New Way (This Paper's Approach):
The authors of this paper say, "Why follow the recipe step-by-step? Let's just control the oven and the mixer directly."

Instead of telling the computer to perform a series of pre-defined "gates" (like a recipe), they send a custom-designed electromagnetic pulse (a specific pattern of microwave energy) directly to the machine. It's like a master chef who doesn't follow a recipe but instead feels the batter, adjusts the heat instantly, and knows exactly how long to mix to get the perfect texture.

The Problem: Time is the Enemy

In the quantum world, time is the enemy. Quantum states are like delicate soap bubbles. If you try to build a complex structure (like a Bell state or a GHZ state) using too many small steps, the bubble pops before you finish. The goal of this research is to build these structures as fast as possible to keep the bubble intact.

The Solution: Targeting the "Vibe" Instead of the "Shape"

Usually, scientists try to force the computer to look exactly like a specific target shape (e.g., "Make it look exactly like a Bell state").

The authors changed the strategy. Instead of asking, "Does it look like the target?" they asked, "Does it have the right quantum connection?"

The Analogy: Imagine you want two people to be best friends.
- Old Way: You force them to stand in specific poses and say specific phrases until they look like a photo of "Best Friends."
- New Way: You just make sure they are having a deep, meaningful conversation. If the connection (entanglement) is strong, it doesn't matter exactly what they look like or what words they use.

By focusing on the quality of the connection (entanglement) rather than the exact shape of the state, they found much faster ways to get the job done.

The Experiments: Building Quantum "Friendships"

The team tested this on a simulated superconducting quantum computer (like the ones IBM uses). They tried to create three famous types of quantum "friendships":

The Bell State (Two Qubits): Two particles that are perfectly linked.
- Result: They used a custom microwave pulse to link them in 1,379 time units.
- Comparison: The standard "recipe" way took 2,912 time units. They cut the time almost in half!
The GHZ State (Three Qubits): A group of three where if one changes, all change instantly.
- Result: They did it in 3,750 time units.
- Comparison: The standard way took 5,315 time units.
The W State (Three Qubits): A group where the connection is shared equally, so if one leaves, the others are still connected.
- Result: They did it in 6,132 time units.
- Comparison: The standard way took 8,224 time units.

Why This is a Big Deal

1. Speed Saves the Day
Because their method is so much faster, the quantum "soap bubbles" don't have time to pop. This means the computer can do more useful work before the information is lost to the environment.

2. Less Confusion (The "Barren Plateau" Fix)
In complex quantum algorithms, if you give the computer too many options (too much "expressivity"), it gets lost and can't learn how to improve. It's like trying to find a needle in a haystack the size of a galaxy.
By using these direct pulses, the authors naturally limit the options. They force the computer to stay on a narrow, efficient path. This makes the learning process much easier and more stable.

3. Real-World Ready
They didn't just use perfect math; they simulated a real, messy machine (IBM's "Sherbrooke" processor) that has imperfections. Even with those imperfections, their "direct pulse" method worked better and faster than the standard "gate" method.

The Takeaway

This paper suggests that the future of quantum computing might not be about building better "Lego blocks" (gates) to stack together. Instead, it's about learning to conduct the orchestra directly with a baton (pulses). By skipping the middleman and controlling the energy directly, we can build quantum resources faster, more reliably, and with less chance of the whole thing falling apart.

1. Problem Statement

The paper addresses the critical challenge of decoherence and control imperfections in near-term quantum hardware (specifically superconducting transmon qubits). Traditional quantum algorithms rely on gate-based paradigms, where complex operations are decomposed into sequences of discrete quantum gates (e.g., Hadamard, CNOT).

Limitations of Gate-Based Approaches:
- Decoherence: Long sequences of gates increase the time required for state preparation, exposing the system to environmental noise and errors.
- Expressivity vs. Trainability: Highly expressive variational quantum circuits (VQCs) often suffer from the "barren plateau" phenomenon, where cost-function gradients vanish exponentially with system size, making optimization impossible.
- Sub-optimality: Compiling logical gates into native hardware pulses often introduces unnecessary overhead and does not directly target the desired physical resource (entanglement).

The authors propose shifting from gate synthesis to pulse-level control, where the objective is to directly optimize electromagnetic pulse sequences to generate specific quantum resources (entanglement) rather than reproducing a specific target state via a fixed circuit.

2. Methodology

The authors developed a resource-oriented pulse optimization framework for transmon-qubit systems.

System Model:
- Hardware: Simulated using the IBM Quantum "Fake Sherbrooke" backend (a 127-qubit Eagle family chip).
- Hamiltonian: The system is modeled using time-dependent Hamiltonians ( $H(t) = H_{sys} + \sum \mu_i(t)H_i$ $H (t) = H_{sy s} + \sum μ_{i} (t) H_{i}$ ).
  - Single Qubit: Modeled as a weakly anharmonic oscillator.
  - Multi-Qubit: Includes nearest-neighbor coupling ( $J$ ) and cross-resonance interactions.
- Levels: Simulations were performed in both two-level (ideal qubit) and three-level (realistic transmon with leakage to the $|2\rangle$ state) models.
Optimization Strategy:
- Direct Resource Targeting: Instead of targeting a specific state vector (e.g., $|GHZ\rangle$ $∣ G H Z ⟩$ ), the cost functions target entanglement measures:
  - 2-Qubit: Maximization of Negativity (for Bell states).
  - 3-Qubit (GHZ class): Maximization of the 3-tangle ( $\tau_3$ ).
  - 3-Qubit (W class): Minimization of the cost function $\sum_{i<j} (C_{ij} - 2/3)^2$ , where $C_{ij}$ is the concurrence of bipartite reductions.
- Pulse Parameterization:
  - Pulses are defined by amplitude, duration, and phase.
  - Two pulse shapes were tested: Square pulses (piecewise constant) and Gaussian Square pulses (smoother edges to reduce high-frequency leakage).
- Algorithm: The Differential Evolution algorithm (a global search method) was used to optimize pulse parameters, avoiding local minima.
Simulation Tools:
- Qiskit Dynamics with the differentiable integrator jax.odeint for efficient time-evolution of time-dependent Hamiltonians.
- Bures Metric: Used in post-processing to verify that the numerically obtained states are locally unitary (LU) equivalent to ideal target states.

3. Key Contributions

Resource-Oriented Control: Demonstrated that optimizing directly for entanglement measures yields shorter, more efficient protocols than compiling standard gate circuits.
Reduced Expressivity as an Advantage: Showed that restricting the control space to only what is necessary for a specific resource reduces the "effective expressivity" of the circuit. This mitigates barren plateaus and simplifies the optimization landscape for variational algorithms.
Robustness to Leakage: Successfully generated high-fidelity entangled states even when simulating the third energy level of transmon qubits, proving the method's viability for realistic hardware where leakage is a major error source.
Benchmarking: Provided a direct comparison between optimized pulse sequences and transpiled gate-based circuits on the IBM Sherbrooke architecture.

4. Key Results

The study successfully prepared maximally entangled states for 2 and 3 qubits with significantly reduced execution times compared to gate-based implementations.

Two-Qubit System (Bell State):
- Metric: Negativity $N(\rho) \approx 0.499$ (Maximal).
- Pulse Duration: 1,379.0 dt (using Gaussian Square pulses).
- Gate Comparison: The equivalent gate-based circuit (Hadamard + CNOT) required 2,912 dt.
- Result: The pulse approach reduced time by ~53%.
Three-Qubit System (GHZ Class):
- Metric: 3-tangle $\tau_3 \approx 0.999$ .
- Pulse Duration: 3,750.0 dt (Gaussian Square).
- Gate Comparison: Equivalent gate circuit required 5,315 dt.
- Result: Time reduction of ~30%.
Three-Qubit System (W Class):
- Metric: Squared Concurrences $C^2 \approx 0.44$ (Target $4/9 \approx 0.444$ ).
- Pulse Duration: 6,132.0 dt (Gaussian Square).
- Gate Comparison: Equivalent gate circuit required 8,224 dt.
- Result: Time reduction of ~25%.
- Validation: The Bures distance between the optimized state and the ideal W state was $1.3 \times 10^{-5}$ , confirming high fidelity.
Table IV Summary:

State Gate Scheme Time (dt) Pulse Scheme Time (dt) Reduction

Bell 2,912 1,379 ~53%

GHZ 5,315 3,750 ~30%

W 8,224 6,132 ~25%

State	Gate Scheme Time (dt)	Pulse Scheme Time (dt)	Reduction
Bell	2,912	1,379	~53%
GHZ	5,315	3,750	~30%
W	8,224	6,132	~25%

5. Significance and Implications

Decoherence Mitigation: By significantly reducing the total evolution time required to generate entanglement, this approach minimizes the window for decoherence and noise accumulation, which is crucial for NISQ (Noisy Intermediate-Scale Quantum) devices.
Variational Algorithm Improvement: The paper argues that pulse-level variational algorithms (replacing parameterized gates with parameterized pulses) offer a physically motivated way to constrain the search space. This restriction prevents barren plateaus, making the training of quantum neural networks more stable and efficient.
Hardware Efficiency: The method leverages the native physics of the transmon system (cross-resonance interactions) directly, bypassing the overhead of decomposing operations into a standard gate set (like ECR, $R_z$ , $SX$).
Future Outlook: The framework is scalable and can be extended to larger systems, different hardware architectures, and more complex resource measures. It paves the way for experimental realization of resource-driven quantum state preparation.

In conclusion, the paper establishes that pulse-level optimization targeting quantum resources is a superior strategy to traditional gate compilation for generating entanglement, offering faster execution, higher robustness against leakage, and improved trainability for variational algorithms.