qiskit-hardware

# Qiskit - Real Hardware & Pulse Control Moving from simulators to real hardware requires a shift in mindset. You are no longer working with perfect "ideal" qubits, but with superconducting circuits that suffer from decoherence, readout errors, and crosstalk. This guide covers how to get the most science out of noisy intermediate-scale quantum (NISQ) devices. ## When to Use - Executing quantum algorithms on real IBM Quantum backends. - Characterizing hardware noise (T1, T2 relaxation times). - Implementing Error Mitigation to improve result accuracy. - Using Qiskit Pulse to define custom microwave pulses (OpenPulse). - Optimizing circuits for specific hardware topologies (coupling maps). - Benchmarking quantum advantage in real-world conditions. ## Reference Documentation - **IBM Quantum Learning**: https://learning.quantum.ibm.com/ - **Qiskit Runtime Docs**: https://docs.quantum.ibm.com/run - **Qiskit Pulse Guide**: https://docs.quantum.ibm.com/build/pulse - **Search patterns**: `QiskitRuntimeService`, `Sampler`, `Estimator`, `transpile`, `InstructionScheduleMap` ## Core Principles ### 1. Qiskit Runtime (Primitives) The modern way to interact with hardware. Instead of sending raw circuits, you use Primitives: - **Sampler**: Returns quasi-probabilities (bitstrings). - **Estimator**: Returns expectation values of observables (e.g., energy). ### 2. Transpilation (Hardware Mapping) Physical backends only support a small set of "Basis Gates" (e.g., `rz`, `x`, `sx`, `ecr`). The Transpiler rewrites your abstract math into these specific instructions and maps virtual qubits to physical ones based on error rates. ### 3. Error Mitigation Unlike Error Correction (which requires thousands of qubits), Mitigation uses statistical tricks (like TREX or ZNE) to "clean" the results after execution. ## Quick Reference: Connecting to Hardware ### Installation ```bash pip install qiskit-ibm-runtime ``` ### Setup and Job Execution ```python from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler # 1. Initialize service (requires API key from quantum.ibm.com) # service = QiskitRuntimeService(channel="ibm_quantum", token="YOUR_TOKEN") service = QiskitRuntimeService() # Uses saved credentials # 2. Select backend backend = service.least_busy(operational=True, simulator=False) # 3. Run job using Primitives sampler = Sampler(backend=backend) job = sampler.run([my_circuit]) result = job.result() ``` ## Critical Rules ### ✅ DO - **Check Calibration Data** - Backends change daily. Always check `backend.properties()` for the latest error rates before choosing qubits. - **Use "Sessions"** - Wrap multiple related jobs in a `RuntimeSession` to minimize queue wait times. - **Set optimization_level** - Use level 3 for hardware to enable advanced routing and gate fusion. - **Apply Readout Mitigation** - Readout (measuring 0 as 1) is the largest error source. Use `resilience_level=1` in Primitives. - **Use Dynamical Decoupling (DD)** - Add pulses to "idling" qubits to prevent them from losing their state while waiting for other gates. ### ❌ DON'T - **Don't use execute()** - The old `qiskit.execute` is deprecated for hardware. Use `Sampler` and `Estimator`. - **Don't run deep circuits** - NISQ devices have limited coherence. If your circuit depth > 50-100, the result will likely be pure noise. - **Don't ignore the Coupling Map** - If you force a CNOT between two qubits that aren't physically connected, the transpiler will add many "SWAP" gates, increasing error. - **Don't use qasm_simulator for hardware prep** - Use `FakeBackend` objects (e.g., `FakeManilaV2`) which mimic real hardware noise for local debugging. ## Hardware-Aware Transpilation ### Mapping to physical qubits ```python from qiskit import transpile # Basis gates for a specific backend basis_gates = backend.operation_names coupling_map = backend.coupling_map # Optimized transpilation optimized_circ = transpile(my_circuit, backend=backend, optimization_level=3, initial_layout=[0, 2, 4]) # Manual qubit selection ``` ## Advanced Error Mitigation ### Resilience Levels in Estimator ```python from qiskit_ibm_runtime import EstimatorV2 as Estimator, EstimatorOptions options = EstimatorOptions() # resilience_level 0: No mitigation # resilience_level 1: Readout mitigation (TREX) # resilience_level 2: ZNE (Zero Noise Extrapolation) - expensive but accurate options.resilience_level = 1 estimator = Estimator(backend=backend, options=options) ``` ## Low-Level: Qiskit Pulse (OpenPulse) ### Defining custom microwave signals ```python from qiskit import pulse from qiskit.circuit import Parameter # Define a Gaussian pulse amp = Parameter('amp') with pulse.build(backend=backend, name='custom_pulse') as schedule: pulse.play(pulse.Gaussian(duration=160, amp=amp, sigma=40), pulse.drive_channel(0)) # Attach pulse to a gate my_circuit.add_calibration('my_gate', [0], schedule, params=[amp]) ``` ## Practical Workflows ### 1. Finding the "Best" Qubits on a Device ```python def get_best_qubits(backend, n_qubits): """Finds a linear chain of qubits with lowest error rates.""" props = backend.properties() # Logic to parse gate_error and readout_error from props # and find a connected subgraph with minimal noise. pass ``` ### 2. VQE on Hardware with Runtime ```python from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator def run_hardware_vqe(ansatz, hamiltonian, backend): with Session(backend=backend) as session: estimator = Estimator(session=session) # Standard optimization loop (using SciPy) # Each 'step' runs a job within the same session pass ``` ### 3. Measuring T1 Time (Relaxation) ```python def t1_experiment(qubit, delay_times): circuits = [] for t in delay_times: c = QuantumCircuit(qubit + 1) c.x(qubit) # Flip to |1> c.delay(t, qubit, unit='us') # Wait c.measure_all() circuits.append(c) # Execute on hardware and fit decay curve ``` ## Performance Optimization ### 1. Job Batching Submit multiple circuits in a single `run()` call to bypass repeated initialization overhead. ### 2. Transpiler Pass Manager Create custom stages for transpilation to control exactly how your circuit is modified. ```python from qiskit.transpiler import PassManager from qiskit.transpiler.passes import Unroller, BasicSwap # custom_pm = PassManager([Unroller(['u3', 'cx']), BasicSwap(coupling_map)]) ``` ## Common Pitfalls and Solutions ### Queue Wait Times Real hardware has high demand. ```python # ✅ Solution: # 1. Use the 'least_busy' helper. # 2. Check your IBM Quantum dashboard for reservation windows. # 3. Use Runtime Sessions to group your jobs. ``` ### "Depolarizing" Result Your histogram looks like a flat line (random noise). ```python # ✅ Solution: # 1. Reduce circuit depth. # 2. Use 'optimization_level=3'. # 3. Apply Error Mitigation (resilience_level=1+). # 4. Check if the backend is currently undergoing maintenance/calibration. ``` ### Frequency Collisions Two neighboring qubits have similar frequencies, leading to "Crosstalk". ```python # ✅ Solution: # Select qubits that are physically separated or have # significantly different frequencies in backend.properties(). ``` Qiskit Hardware is where quantum theory meets the harsh reality of physics. Mastering these tools allows you to push the boundaries of what is possible on today's noisy devices, paving the way for the fault-tolerant era.