AI for Quantum Control and Calibration

AI for Quantum Control and Calibration

Abstract

Quantum computers require precise control: microsecond pulses must rotate qubits by exact angles, thousands of parameters must be calibrated daily, and drift must be compensated in real-time. Classical control methods struggle with this complexity. This document explores how machine learning—reinforcement learning for pulse optimization, Bayesian methods for calibration, and online learning for drift compensation—can dramatically improve quantum control.

1. The Quantum Control Stack

1.1 From Algorithm to Physics

┌─────────────────────────────────────────────────────────────────┐
│                    Quantum Control Stack                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  Level 4: Algorithm                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  Grover's Algorithm, VQE, etc.                           │   │
│  │  Abstract operations: H, CNOT, Rz(θ), etc.               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                           ↓                                      │
│  Level 3: Gate Decomposition                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  Map to native gate set: √X, Rz, CNOT                    │   │
│  │  Optimize gate count and depth                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                           ↓                                      │
│  Level 2: Pulse Schedule                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  Each gate → sequence of microwave/laser pulses          │   │
│  │  Timing, amplitude, phase for each pulse                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                           ↓                                      │
│  Level 1: Analog Waveforms                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  Continuous I(t), Q(t) quadrature signals                │   │
│  │  Shaped by AWG (Arbitrary Waveform Generator)            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                           ↓                                      │
│  Level 0: Physical Qubits                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │  Superconducting transmons, trapped ions, etc.           │   │
│  │  Hamiltonian evolution under applied fields              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

1.2 Why Control is Hard

Precision Requirements:

Target rotation:     π/2 (exactly 90°)
Allowed error:       < 0.1% (< 0.0009 radians)
Pulse duration:      ~20 ns
Required precision:  < 20 ps timing, < 0.01 dB amplitude

Parameter Count:

Per qubit:
- Qubit frequency: ω₀
- Anharmonicity: α
- T1, T2 relaxation times
- Drive amplitude calibration
- DRAG coefficient
- Readout frequency, amplitude, phase

Per qubit pair:
- Coupling strength: g
- Cross-resonance parameters
- ZZ crosstalk strength

Total for 100-qubit system: ~5000+ parameters

Drift:

Frequency drift:    ~10-100 kHz/hour
T1 variation:       ±20% daily
Optimal parameters: Change every few hours

2. Classical Control Methods

2.1 GRAPE (Gradient Ascent Pulse Engineering)

Principle: Optimize pulse shape using gradient descent on fidelity.

Algorithm:
1. Parameterize pulse: Ω(t) = Σᵢ aᵢ · Bᵢ(t)
2. Simulate evolution: U(T) = 𝒯 exp(-i ∫₀ᵀ H(t) dt)
3. Compute fidelity: F = |Tr(U_target† · U(T))|² / d²
4. Compute gradients: ∂F/∂aᵢ via backpropagation through simulation
5. Update: aᵢ ← aᵢ + η · ∂F/∂aᵢ
6. Repeat until convergence

Limitations:

• Requires accurate Hamiltonian model
• Computationally expensive (full simulation)
• Doesn't adapt to hardware drift
• Local optima problems

2.2 Randomized Benchmarking Calibration

Process:

1. Run random Clifford sequences of varying length
2. Measure average fidelity decay
3. Fit exponential to extract error per gate
4. Adjust pulse parameters to minimize error
5. Repeat

Limitations:

• Time-consuming (many circuits)
• Provides aggregate error, not parameter-specific
• Manual parameter adjustment

2.3 Rabi/Ramsey Experiments

For frequency calibration:

Ramsey experiment:
|0⟩ → X/2 → wait(τ) → X/2 → measure

Signal: P(|0⟩) = ½(1 + cos(Δω · τ))
Fit Δω to correct frequency

Limitations:

• Measures one parameter at a time
• Slow for many qubits
• Requires manual analysis

3. Reinforcement Learning for Pulse Optimization

3.1 Problem Formulation

Goal: Find pulse Ω(t) that maximizes gate fidelity.

RL Formulation:

State s_t:     Current pulse parameters + recent fidelity measurements
Action a_t:    Adjustment to pulse parameters
Reward r_t:    Measured gate fidelity (or proxy)
Episode:       One pulse optimization attempt

Policy π(a|s): Neural network mapping state to action distribution

3.2 Model-Free Pulse Optimization

class PulseOptimizationEnv:
    def __init__(self, target_gate, num_params=20):
        self.target = target_gate
        self.num_params = num_params
        self.pulse_params = np.zeros(num_params)

    def step(self, action):
        # Apply action (parameter adjustment)
        self.pulse_params += action

        # Execute on hardware and measure fidelity
        pulse = self.params_to_pulse(self.pulse_params)
        fidelity = self.execute_and_measure(pulse)

        reward = fidelity
        done = fidelity > 0.999  # Target achieved

        return self.get_state(), reward, done, {}

    def get_state(self):
        return np.concatenate([
            self.pulse_params,
            self.fidelity_history[-10:]  # Recent fidelity measurements
        ])

    def params_to_pulse(self, params):
        # Parameterized pulse shape
        # e.g., Gaussian + DRAG: Ω(t) = A·exp(-t²/2σ²) + β·dΩ/dt
        return generate_pulse(params)

    def execute_and_measure(self, pulse):
        # Run on actual hardware
        return hardware.run_gate_and_measure_fidelity(pulse)


class PPOPulseOptimizer:
    def __init__(self, env):
        self.env = env
        self.policy = nn.Sequential(
            nn.Linear(env.state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 128),
            nn.ReLU(),
            nn.Linear(128, env.action_dim * 2)  # Mean and std for each action
        )
        self.value = nn.Sequential(
            nn.Linear(env.state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 1)
        )

    def optimize(self, num_episodes=1000):
        for episode in range(num_episodes):
            state = self.env.reset()
            trajectory = []

            for step in range(100):
                # Sample action from policy
                action_dist = self.policy(state)
                action = action_dist.sample()

                # Take step
                next_state, reward, done, _ = self.env.step(action)
                trajectory.append((state, action, reward))

                if done:
                    break
                state = next_state

            # PPO update
            self.update_ppo(trajectory)

        return self.env.pulse_params

3.3 Key Results: Google's RL for Pulse Optimization

Experiment (2020):

• Single-qubit gates on superconducting qubits
• RL agent optimizes pulse amplitude, duration, DRAG coefficient
• Result: 20% reduction in gate error vs GRAPE

Why RL Works Better:
1. Model-free: Doesn't require Hamiltonian knowledge
2. Adaptive: Learns hardware-specific quirks
3. Exploration: Finds solutions GRAPE misses
4. Online: Can adapt to drift

3.4 Multi-Qubit Gate Optimization

class TwoQubitPulseEnv:
    def __init__(self, target_gate='CNOT'):
        self.target = target_gate

        # Two-qubit pulse has more parameters
        # Cross-resonance: drive qubit 1 at qubit 2's frequency
        self.params = {
            'cr_amplitude': 0.1,
            'cr_duration': 300,  # ns
            'cr_phase': 0,
            'echo_amplitude': 0.05,
            'rotary_amplitude': 0.02,
            # ... many more
        }

    def step(self, action):
        # Action modifies parameters
        self.params = apply_action(self.params, action)

        # Measure two-qubit gate fidelity
        fidelity = self.measure_cnot_fidelity()

        return self.get_state(), fidelity, fidelity > 0.995, {}

    def measure_cnot_fidelity(self):
        # Interleaved randomized benchmarking
        circuits = generate_irb_circuits('CNOT', depths=[1,2,4,8,16])
        results = [self.run_circuit(c) for c in circuits]
        return fit_irb_fidelity(results)

Result: RL achieves 99.5% CNOT fidelity vs 99.0% with manual tuning.

4. Bayesian Optimization for Calibration

4.1 The Calibration Problem

Given: ~5000 hardware parameters to calibrate
Goal:  Find parameter values that maximize overall performance
Constraint: Each evaluation (benchmark) takes ~1 minute

Naive grid search: 10^5000 evaluations (impossible)
Random search: Slow convergence
Bayesian optimization: Efficient sampling

4.2 Gaussian Process Optimization

class BayesianCalibrator:
    def __init__(self, param_bounds):
        self.bounds = param_bounds
        self.gp = GaussianProcessRegressor(
            kernel=Matern(nu=2.5),
            alpha=1e-6,
            normalize_y=True
        )
        self.X = []  # Evaluated parameters
        self.y = []  # Observed performance

    def suggest_next(self):
        """Suggest next parameters to evaluate using acquisition function."""
        if len(self.X) < 10:
            # Initial random sampling
            return self.random_sample()

        # Fit GP to observed data
        self.gp.fit(np.array(self.X), np.array(self.y))

        # Optimize acquisition function
        best_x = None
        best_acq = -np.inf

        for _ in range(1000):
            x = self.random_sample()
            acq = self.expected_improvement(x)
            if acq > best_acq:
                best_acq = acq
                best_x = x

        return best_x

    def expected_improvement(self, x):
        """Expected Improvement acquisition function."""
        mu, sigma = self.gp.predict([x], return_std=True)

        best_y = max(self.y)
        z = (mu - best_y) / sigma

        ei = sigma * (z * norm.cdf(z) + norm.pdf(z))
        return ei

    def update(self, x, performance):
        """Record evaluation result."""
        self.X.append(x)
        self.y.append(performance)

    def calibrate(self, num_iterations=100):
        """Run calibration loop."""
        for i in range(num_iterations):
            # Get next params to try
            params = self.suggest_next()

            # Apply to hardware and measure
            apply_params_to_hardware(params)
            performance = run_benchmark()

            # Update model
            self.update(params, performance)

            print(f"Iteration {i}: performance = {performance:.4f}")

        # Return best found parameters
        best_idx = np.argmax(self.y)
        return self.X[best_idx]

4.3 Hierarchical Calibration

Insight: Parameters have different sensitivity and timescales.

class HierarchicalCalibrator:
    def __init__(self):
        # Group parameters by sensitivity/timescale
        self.param_groups = {
            'critical': ['qubit_frequencies', 'pi_amplitudes'],
            'important': ['drag_coefficients', 'readout_params'],
            'fine_tune': ['cross_resonance_details', 'crosstalk_compensation']
        }

        self.calibrators = {
            group: BayesianCalibrator(get_bounds(params))
            for group, params in self.param_groups.items()
        }

    def calibrate_all(self):
        """Hierarchical calibration: coarse to fine."""

        # First: critical parameters (frequency, amplitude)
        print("Calibrating critical parameters...")
        critical_params = self.calibrators['critical'].calibrate(50)
        apply_params(critical_params)

        # Second: important parameters (DRAG, readout)
        print("Calibrating important parameters...")
        important_params = self.calibrators['important'].calibrate(30)
        apply_params(important_params)

        # Third: fine-tuning
        print("Fine-tuning...")
        fine_params = self.calibrators['fine_tune'].calibrate(20)
        apply_params(fine_params)

        return {**critical_params, **important_params, **fine_params}

4.4 IBM's Automated Calibration Pipeline

Production System:
1. Daily recalibration of all qubits
2. Continuous monitoring for drift
3. Triggered recalibration when performance drops
4. ML-based anomaly detection for hardware issues

Result: 5× reduction in calibration time vs manual methods.

5. Drift Compensation with Online Learning

5.1 The Drift Problem

Cause              | Timescale       | Effect
-------------------|-----------------|------------------
Temperature        | Minutes-hours   | Frequency shift
TLS (two-level)    | Seconds-minutes | Random fluctuations
Aging              | Days-weeks      | Gradual degradation
Cosmic rays        | Instantaneous   | Sudden changes

Challenge: Optimal parameters change faster than we can recalibrate.

5.2 Kalman Filter for Parameter Tracking

class ParameterTracker:
    def __init__(self, num_params, process_noise=0.01, measurement_noise=0.1):
        self.num_params = num_params

        # State: current parameter estimates
        self.x = np.zeros(num_params)

        # Covariance
        self.P = np.eye(num_params)

        # Noise models
        self.Q = process_noise * np.eye(num_params)  # Process noise
        self.R = measurement_noise * np.eye(num_params)  # Measurement noise

    def predict(self, dt):
        """Predict next state (parameters drift slowly)."""
        # Simple random walk model
        self.P = self.P + self.Q * dt
        return self.x

    def update(self, measurement):
        """Update estimate based on new measurement."""
        # Kalman gain
        S = self.P + self.R
        K = self.P @ np.linalg.inv(S)

        # Update state
        innovation = measurement - self.x
        self.x = self.x + K @ innovation

        # Update covariance
        self.P = (np.eye(self.num_params) - K) @ self.P

        return self.x

    def get_current_params(self):
        """Get current best estimate of parameters."""
        return self.x


class DriftCompensatingController:
    def __init__(self, hardware):
        self.hardware = hardware
        self.tracker = ParameterTracker(num_params=100)
        self.last_calibration = time.time()

    def execute_circuit(self, circuit):
        # Get current parameter estimates
        current_params = self.tracker.predict(time.time() - self.last_calibration)

        # Apply to hardware
        self.hardware.set_params(current_params)

        # Execute
        result = self.hardware.run(circuit)

        # Use result to update parameter estimates (if possible)
        if self.can_extract_param_info(result):
            measured_params = self.extract_params(result)
            self.tracker.update(measured_params)

        return result

5.3 Neural Drift Predictor

Idea: Learn drift patterns to predict future parameters.

class DriftPredictor(nn.Module):
    def __init__(self, num_params, history_len=100):
        super().__init__()

        self.lstm = nn.LSTM(
            input_size=num_params + 5,  # params + metadata (temp, time, etc.)
            hidden_size=128,
            num_layers=2,
            batch_first=True
        )

        self.output = nn.Linear(128, num_params)

    def forward(self, param_history, metadata):
        # param_history: batch × time × num_params
        # metadata: batch × time × 5 (temperature, time_of_day, etc.)

        x = torch.cat([param_history, metadata], dim=-1)
        lstm_out, _ = self.lstm(x)

        # Predict next parameter values
        prediction = self.output(lstm_out[:, -1, :])
        return prediction


class PredictiveDriftCompensation:
    def __init__(self, hardware):
        self.hardware = hardware
        self.predictor = DriftPredictor(num_params=100)
        self.history = []

    def compensate(self):
        """Preemptively adjust parameters based on predicted drift."""
        if len(self.history) < 100:
            return  # Not enough data

        # Predict where parameters will be in 10 minutes
        future_params = self.predictor(
            param_history=torch.tensor(self.history[-100:]),
            metadata=self.get_metadata()
        )

        # Preemptively adjust
        compensation = self.current_params - future_params
        self.hardware.set_params(self.current_params + compensation)

5.4 Results

6. Crosstalk Mitigation

6.1 The Crosstalk Problem

Ideal:    Gate on qubit A has no effect on qubit B
Reality:  Gate on qubit A causes small rotation on qubit B

Sources:
- Direct coupling (always-on ZZ interaction)
- Drive crosstalk (microwave leakage)
- Readout crosstalk (resonator coupling)
- Flux crosstalk (shared flux lines)

Impact:

For 100 qubits with 99.9% single-qubit fidelity:
Without crosstalk: (0.999)^100 ≈ 90% total fidelity
With 0.1% crosstalk per pair: (0.999)^100 × (0.999)^(100×50) ≈ 0.5% total fidelity

6.2 Crosstalk Matrix Learning

class CrosstalkModel(nn.Module):
    def __init__(self, num_qubits):
        super().__init__()

        # Graph neural network on qubit connectivity
        self.gnn = GCNConv(in_channels=10, out_channels=32)

        # Predict crosstalk matrix elements
        self.predictor = nn.Sequential(
            nn.Linear(64, 64),  # 32 features for each of 2 qubits
            nn.ReLU(),
            nn.Linear(64, 4)   # ZZ, ZX, XZ, XX coupling strengths
        )

    def forward(self, qubit_features, edge_index, qubit_pair):
        # qubit_features: per-qubit info (frequency, T1, T2, etc.)
        # edge_index: connectivity graph
        # qubit_pair: (i, j) pair to predict crosstalk for

        # GNN embedding
        embeddings = self.gnn(qubit_features, edge_index)

        # Concatenate pair embeddings
        i, j = qubit_pair
        pair_embedding = torch.cat([embeddings[i], embeddings[j]])

        # Predict crosstalk
        crosstalk = self.predictor(pair_embedding)
        return crosstalk


class CrosstalkCompensator:
    def __init__(self, num_qubits):
        self.model = CrosstalkModel(num_qubits)
        self.crosstalk_matrix = np.zeros((num_qubits, num_qubits, 4))

    def learn_crosstalk(self, hardware):
        """Measure and learn crosstalk matrix."""
        data = []

        for i in range(num_qubits):
            for j in range(num_qubits):
                if i != j:
                    # Measure crosstalk i→j
                    crosstalk = hardware.measure_crosstalk(i, j)
                    data.append((i, j, crosstalk))

        # Train model
        self.train_model(data)

        # Populate matrix
        for i, j, _ in data:
            self.crosstalk_matrix[i, j] = self.model.predict(i, j)

    def compensate_circuit(self, circuit):
        """Add compensation pulses to cancel predicted crosstalk."""
        compensated = circuit.copy()

        for gate in circuit.gates:
            if gate.is_single_qubit():
                qubit = gate.qubit

                # Find qubits affected by crosstalk
                for other in range(num_qubits):
                    if other != qubit:
                        crosstalk = self.crosstalk_matrix[qubit, other]

                        # Add compensating rotation
                        if np.abs(crosstalk).max() > threshold:
                            compensation = -crosstalk  # Negate crosstalk
                            compensated.add_gate(
                                VirtualZGate(other, compensation[0])
                            )

        return compensated

6.3 Real-Time Crosstalk Prediction

class RealtimeCrosstalkPredictor:
    def __init__(self, hardware):
        self.hardware = hardware
        self.model = CrosstalkLSTM()
        self.history = []

    def predict_crosstalk(self, upcoming_gate):
        """Predict crosstalk from upcoming gate in real-time."""
        state = {
            'gate': upcoming_gate,
            'recent_gates': self.history[-10:],
            'qubit_states': self.hardware.get_qubit_states()
        }

        predicted_crosstalk = self.model(state)
        return predicted_crosstalk

    def generate_compensation(self, crosstalk):
        """Generate compensation pulses."""
        return -crosstalk  # Simple negation; could be more sophisticated

7. Hardware-in-the-Loop Learning

7.1 The Simulation-Reality Gap

Problem:
- RL agents trained in simulation
- Real hardware differs from simulation
- Agent fails on real hardware

Solution: Hardware-in-the-loop training

7.2 Direct Hardware Training

class HardwareInLoopTrainer:
    def __init__(self, hardware, agent):
        self.hardware = hardware
        self.agent = agent

    def train(self, num_episodes=1000):
        for episode in range(num_episodes):
            state = self.get_hardware_state()

            for step in range(100):
                # Agent chooses action
                action = self.agent.act(state)

                # Apply to real hardware
                self.hardware.apply_control(action)

                # Measure result on real hardware
                fidelity = self.hardware.measure_fidelity()

                # Update agent
                reward = fidelity
                next_state = self.get_hardware_state()
                self.agent.update(state, action, reward, next_state)

                state = next_state

            # Reset hardware periodically
            if episode % 10 == 0:
                self.hardware.reset()

7.3 Sim-to-Real Transfer

class SimToRealTransfer:
    def __init__(self, simulator, hardware):
        self.sim = simulator
        self.hardware = hardware
        self.agent = PPOAgent()

    def train(self):
        # Phase 1: Pre-train in simulation (fast)
        print("Phase 1: Simulation pre-training...")
        for _ in range(10000):
            self.train_step_sim()

        # Phase 2: Fine-tune on hardware (slow but accurate)
        print("Phase 2: Hardware fine-tuning...")
        for _ in range(100):
            self.train_step_hardware()

        # Phase 3: Continuous adaptation
        print("Phase 3: Continuous adaptation...")
        while True:
            self.train_step_hardware()
            time.sleep(60)  # Train periodically

    def train_step_sim(self):
        """Fast training in simulation."""
        # Add domain randomization for robustness
        noise_level = np.random.uniform(0.001, 0.01)
        self.sim.set_noise(noise_level)

        state = self.sim.reset()
        action = self.agent.act(state)
        next_state, reward = self.sim.step(action)
        self.agent.update(state, action, reward, next_state)

    def train_step_hardware(self):
        """Slow but accurate training on real hardware."""
        state = self.hardware.get_state()
        action = self.agent.act(state)

        self.hardware.apply(action)
        fidelity = self.hardware.measure()

        self.agent.update(state, action, fidelity, self.hardware.get_state())

8. Integration with Your Existing Work

8.1 Your IBM Quantum Runner

From your ibm_quantum_runner.py:

class IBMQuantumConnection:
    # Service management

class QuantumRAGCircuits:
    # Circuit builders for Grover's, walks, entanglement

class QuantumExecutor:
    # Run on simulator or real hardware

8.2 Proposed Control Enhancements

# Enhanced version of your ibm_quantum_runner.py

class ControlOptimizedQuantumRunner:
    def __init__(self, base_runner):
        self.runner = base_runner
        self.pulse_optimizer = PPOPulseOptimizer()
        self.calibrator = BayesianCalibrator()
        self.drift_tracker = ParameterTracker()

    def optimize_circuit_pulses(self, circuit):
        """Optimize pulse-level implementation of circuit."""
        # Convert gates to pulses
        pulse_schedule = circuit.to_pulse_schedule()

        # Optimize each gate's pulses
        for gate in pulse_schedule.gates:
            optimized_pulse = self.pulse_optimizer.optimize(gate)
            pulse_schedule.replace(gate, optimized_pulse)

        return pulse_schedule

    def execute_with_drift_compensation(self, circuit):
        """Execute with real-time drift compensation."""
        # Get predicted current parameters
        current_params = self.drift_tracker.predict(dt=time.time() - self.last_run)

        # Compensate circuit
        compensated = self.compensate_for_drift(circuit, current_params)

        # Execute
        result = self.runner.execute(compensated)

        # Update drift model
        measured_params = self.extract_params_from_result(result)
        self.drift_tracker.update(measured_params)

        return result

    def run_grover_optimized(self, oracle):
        """Your Grover's algorithm with optimized control."""
        # Build circuit
        circuit = self.runner.build_grover_circuit(oracle)

        # Optimize pulses
        optimized_circuit = self.optimize_circuit_pulses(circuit)

        # Execute with drift compensation
        result = self.execute_with_drift_compensation(optimized_circuit)

        return result

8.3 Using Your Validation Data

From your VALIDATION_RESULTS.md:

Noise impact: 1% gate error → 60% performance loss
Hardware safe for up to 5 qubits (coherence margins)

Training Data Collection:

def collect_control_training_data(your_runner, num_runs=1000):
    """Collect data for training control ML models."""
    data = []

    for _ in range(num_runs):
        # Vary control parameters
        params = sample_control_params()
        your_runner.set_params(params)

        # Run your Grover benchmark
        result = your_runner.run_grover_test()

        data.append({
            'params': params,
            'fidelity': result.fidelity,
            'success_prob': result.success_probability,
            'metadata': result.metadata
        })

    return data

9. Summary

9.1 Key Takeaways

9.2 Production Deployment

9.3 Open Research Questions

1. Scalability: How does RL pulse optimization scale to 1000+ qubits?
2. Transfer learning: Can control policies transfer between devices?
3. Interpretability: Can we understand what ML controllers learn?
4. Certification: How do we verify ML controllers are safe?
5. Real-time: Can we do RL updates in microseconds?

References

1. Niu, M. Y., et al. (2019). "Universal quantum control through deep reinforcement learning." npj Quantum Information, 5(1), 33.

2. Baum, Y., et al. (2021). "Experimental deep reinforcement learning for error-robust gate-set design on a superconducting quantum computer." PRX Quantum, 2(4), 040324.

3. Wittler, N., et al. (2021). "Integrated tool set for control, calibration, and characterization of quantum devices applied to superconducting qubits." Physical Review Applied, 15(3), 034080.

4. Kelly, J., et al. (2018). "Physical qubit calibration on a directed acyclic graph." arXiv:1803.03226.

5. Klimov, P. V., et al. (2020). "Fluctuations of energy-relaxation times in superconducting qubits." Physical Review Letters, 121(9), 090502.

6. Werninghaus, M., et al. (2021). "Leakage reduction in fast superconducting qubit gates via optimal control." npj Quantum Information, 7(1), 14.

7. Rol, M. A., et al. (2019). "Fast, high-fidelity conditional-phase gate exploiting leakage interference in weakly anharmonic superconducting qubits." Physical Review Letters, 123(12), 120502.

8. Arute, F., et al. (2019). "Quantum supremacy using a programmable superconducting processor." Nature, 574(7779), 505-510. (Supplementary: calibration methods)

Document: 03_ai_quantum_control.md
Part of: AI-Quantum Symbiosis Research Series
Location: Documents/Learning/ai_quantum_symbiosis/