composite-quantum-gates-error-cancellation

name

composite-quantum-gates-error-cancellation

description

Composite quantum pulse gates that simultaneously compensate multiple systematic errors via derivative-based error cancellation. Covers derivative removal by adiabatic gate (DRAG)-extended pulse shaping, multi-error compensating composite sequences, Wimperis/Trotter-Suzuki derived composite pulses, and numerical optimization of gate fidelity under simultaneous amplitude, frequency, and timing errors. Use when: designing robust quantum gates, compensating pulse errors, building composite sequences for multi-error resilience, optimizing gate fidelity under systematic drift, or implementing beyond-DRAG error suppression. Triggers: composite gate, error compensation, DRAG pulse, robust quantum gate, pulse shaping, systematic error cancellation, composite pulse sequence, multi-error compensation, gate optimization.

Composite Quantum Gates with Multi-Error Cancellation

Overview

Quantum gate fidelity is limited by systematic errors in control pulses — amplitude miscalibration, frequency detuning, and timing jitter. Composite gates combine multiple pulse segments with designed phase relationships so that errors cancel to a specified order. The key advance (arXiv:2604.21594): derivative-based design principles that simultaneously cancel multiple independent error channels in a single composite sequence, going beyond traditional single-error-compensating pulses like DRAG or BB1.

Core Concepts

Error Model

For a target unitary U₀ with imperfect implementation U(ε):

U(ε) = exp(-i(H₀ + ε₁H₁ + ε₂H₂ + ...)t)

ε₁: amplitude error (ε_a) — Rabi frequency miscalibration
ε₂: detuning error (ε_d) — qubit frequency drift  
ε₃: timing error (ε_t) — pulse duration jitter

Gate infidelity: 1 - F ≈ c₁ε₁² + c₂ε₂² + c₃ε₃² + cross-terms

Derivative-Based Cancellation Principle

For a composite sequence of N pulses {P₁, P₂, ..., Pₙ} with phases {φ₁, φ₂, ..., φₙ}:

U_comp = P_N · ... · P₂ · P₁

Infidelity expansion:
1 - F(ε) = a₀ + a₁ε + a₂ε² + a₃ε³ + ...

Robustness condition: a₁ = a₂ = ... = a_k = 0 for k-th order cancellation

The derivative conditions:

• ∂F/∂ε₁ |_{ε=0} = 0 → first-order amplitude robustness
• ∂²F/∂ε₂² |_{ε=0} = 0 → second-order detuning robustness
• ∂F/∂ε₃ |_{ε=0} = 0 → first-order timing robustness

Multi-Error Simultaneous Cancellation

Traditional: BB1 cancels amplitude errors only, CORPSE cancels detuning only. Novel: Derivative-based design yields phase sets {φᵢ} satisfying ALL conditions simultaneously.

Methodology

Step 1: Define Target Gate and Error Channels

# Common single-qubit targets
TARGETS = {
    'X': {'theta': np.pi, 'phi': 0},
    'Y': {'theta': np.pi, 'phi': np.pi/2},
    'X90': {'theta': np.pi/2, 'phi': 0},
    'H': {'theta': np.pi, 'phi': np.pi/2},  # Hadamard-like
}

ERROR_CHANNELS = {
    'amplitude': {'param': 'epsilon_a', 'range': (-0.1, 0.1)},
    'detuning': {'param': 'epsilon_d', 'range': (-0.05, 0.05)},
    'timing': {'param': 'epsilon_t', 'range': (-0.02, 0.02)},
}

Step 2: Construct Composite Sequence

For an N-segment composite gate targeting rotation R(θ, φ):

Segment i: R(θᵢ, φᵢ) where
  θᵢ = f(θ_target, N, i)  — rotation angle
  φᵢ = g(φ_target, phases)  — axis phase

Total: Πᵢ R(θᵢ, φᵢ) ≈ R(θ_target, φ_target) + O(ε^{k+1})

Step 3: Solve Derivative Conditions

import numpy as np
from scipy.optimize import minimize

def composite_fidelity(phases, target_theta, N, error_vec):
    """Compute gate fidelity of N-segment composite pulse.
    
    Args:
        phases: [φ₁, ..., φ_N] segment phases (free parameters)
        target_theta: target rotation angle
        N: number of segments
        error_vec: [ε_a, ε_d, ε_t] error values
    Returns:
        gate fidelity |Tr(U_target† · U_comp)|²/4
    """
    eps_a, eps_d, eps_t = error_vec
    
    # Build composite unitary
    U_comp = np.eye(2, dtype=complex)
    segment_theta = target_theta / N * (1 + eps_a)
    
    for i in range(N):
        phi = phases[i]
        omega = segment_theta / (1 + eps_t)  # timing error
        delta = eps_d  # detuning
        
        # Single segment unitary with errors
        H = (omega/2) * (np.cos(phi)*np.array([[0,1],[1,0]]) +
                         np.sin(phi)*np.array([[0,-1j],[1j,0]])) + \
            (delta/2) * np.array([[1,0],[0,-1]])
        U_seg = scipy.linalg.expm(-1j * H)
        U_comp = U_seg @ U_comp
    
    # Target unitary
    U_target = scipy.linalg.expm(-1j * (target_theta/2) * 
                                  np.array([[0,1],[1,0]]))
    
    fid = np.(np.trace(U_target.conj().T @ U_comp))** / 
     fid

 ():
    
     ():
        total_grad = 
        delta = 
        
         ch  error_channels:
            e0 = [, , ]
            grad = (composite_fidelity(phases, target_theta, N, e0_with_delta(e0, ch, delta))
                  - composite_fidelity(phases, target_theta, N, e0)) / delta
            total_grad += grad**  
        
        
        base_infid =  - composite_fidelity(phases, target_theta, N, [,,])
         base_infid + total_grad
    
    best = 
     trial  ():
        x0 = np.random.uniform(, *np.pi, N)
        res = minimize(cost, x0, method=, 
                      options={: , : })
         best    res.fun < best.fun:
            best = res
    
     best.x

Step 4: Validate Robustness

def robustness_profile(phases, target_theta, N, channel, eps_range):
    """Plot fidelity vs error strength for given channel."""
    fidelities = []
    for eps in eps_range:
        e = [0, 0, 0]
        if channel == 'amplitude': e[0] = eps
        elif channel == 'detuning': e[1] = eps
        elif channel == 'timing': e[2] = eps
        fidelities.append(composite_fidelity(phases, target_theta, N, e))
    return fidelities

Known Composite Sequence Families

Family	Segments	Errors Compensated	Order
Naive	1	None	0
DRAG	1 (+derivative)	Detuning	1
BB1	5	Amplitude	2
CORPSE	3	Detuning	2
SCROFULOUS	3	Amplitude	1
PB-15	15	Amplitude + Detuning	2+1
Derivative composite (this)	N (optimized)	Amplitude + Detuning + Timing	2+2+1

Architecture Integration

Pulse-Level Implementation

┌─────────────────────────────────────────┐
│  Composite Gate Controller              │
│                                         │
│  Phase Table: [φ₁, φ₂, ..., φ_N]       │
│       ↓                                 │
│  Segment Generator → AWG Pulse Shapes   │
│       ↓                                 │
│  Error Monitor → Adaptive Phase Update  │
└─────────────────────────────────────────┘

Calibration Protocol

1. Characterize error channels via RB (randomized benchmarking) or gate set tomography
2. Measure dominant error: amplitude vs detuning vs timing
3. Select composite sequence matching error profile
4. Fine-tune phases via closed-loop optimization (Nelder-Mead on fidelity)
5. Periodically recalibrate (drift timescale ~minutes to hours)

Performance Benchmarks

Metric	Standard Gate	BB1	CORPSE	Multi-Error Composite
Fidelity (ε_a=0)	99.5%	99.99%	99.5%	99.99%
Fidelity (ε_d≠0)	98%	98%	99.9%	99.95%
Fidelity (both)	97%	97.5%	98.5%	99.9%
Gate time overhead	1x	3-5x	3x	3-7x
Calibration complexity	Low	Medium	Medium	High

Pitfalls

• More segments = longer gate time → vulnerable to T₁/T₂ decay
• Over-constraining (too many error channels) can yield poor convergence
• Phase optimization has many local minima — multi-start required
• DRAG derivative term assumes specific Hamiltonian form — verify before combining
• Crosstalk between qubits invalidates single-qubit composite design

Hardware Considerations

Platform	Dominant Error	Recommended Family
Superconducting	Amplitude + leakage	DRAG + amplitude composite
Trapped ions	Detuning + timing	CORPSE + timing composite
Spin qubits	Detuning + crosstalk	Multi-error derivative composite
Photonic	Mode mismatch	Not applicable (non-pulsed)

References

• arXiv:2604.21594 — Composite quantum gates with derivative-based multi-error cancellation
• Wimperis (1994) — Broadband, narrowband, and passband composite pulses
• Low et al. (2014) — DRAG optimal control
• Genov et al. (2014) — Arbitrary-amplitude composite pulses