Qiskit

Overview

Qiskit is the world's most popular open-source quantum computing framework with 13M+ downloads. Build quantum circuits, optimize for hardware, execute on simulators or real quantum computers, and analyze results. Supports IBM Quantum (100+ qubit systems), IonQ, Amazon Braket, and other providers.

Key Features:

• 83x faster transpilation than competitors

• 29% fewer two-qubit gates in optimized circuits

• Backend-agnostic execution (local simulators or cloud hardware)

• Comprehensive algorithm libraries for optimization, chemistry, and ML

Quick Start

Installation

uv pip install qiskit uv pip install "qiskit[visualization]" matplotlib

First Circuit

from qiskit import QuantumCircuit from qiskit.primitives import StatevectorSampler

Create Bell state (entangled qubits)

qc = QuantumCircuit(2) qc.h(0) # Hadamard on qubit 0 qc.cx(0, 1) # CNOT from qubit 0 to 1 qc.measure_all() # Measure both qubits

Run locally

sampler = StatevectorSampler() result = sampler.run([qc], shots=1024).result() counts = result[0].data.meas.get_counts() print(counts) # {'00': ~512, '11': ~512}

Visualization

from qiskit.visualization import plot_histogram

qc.draw('mpl') # Circuit diagram plot_histogram(counts) # Results histogram

Core Capabilities

1. Setup and Installation

For detailed installation, authentication, and IBM Quantum account setup:

• See references/setup.md

Topics covered:

• Installation with uv

• Python environment setup

• IBM Quantum account and API token configuration

• Local vs. cloud execution

2. Building Quantum Circuits

For constructing quantum circuits with gates, measurements, and composition:

• See references/circuits.md

Topics covered:

• Creating circuits with QuantumCircuit

• Single-qubit gates (H, X, Y, Z, rotations, phase gates)

• Multi-qubit gates (CNOT, SWAP, Toffoli)

• Measurements and barriers

• Circuit composition and properties

• Parameterized circuits for variational algorithms

3. Primitives (Sampler and Estimator)

For executing quantum circuits and computing results:

• See references/primitives.md

Topics covered:

• Sampler: Get bitstring measurements and probability distributions

• Estimator: Compute expectation values of observables

• V2 interface (StatevectorSampler, StatevectorEstimator)

• IBM Quantum Runtime primitives for hardware

• Sessions and Batch modes

• Parameter binding

4. Transpilation and Optimization

For optimizing circuits and preparing for hardware execution:

• See references/transpilation.md

Topics covered:

• Why transpilation is necessary

• Optimization levels (0-3)

• Six transpilation stages (init, layout, routing, translation, optimization, scheduling)

• Advanced features (virtual permutation elision, gate cancellation)

• Common parameters (initial_layout, approximation_degree, seed)

• Best practices for efficient circuits

5. Visualization

For displaying circuits, results, and quantum states:

• See references/visualization.md

Topics covered:

• Circuit drawings (text, matplotlib, LaTeX)

• Result histograms

• Quantum state visualization (Bloch sphere, state city, QSphere)

• Backend topology and error maps

• Customization and styling

• Saving publication-quality figures

6. Hardware Backends

For running on simulators and real quantum computers:

• See references/backends.md

Topics covered:

• IBM Quantum backends and authentication

• Backend properties and status

• Running on real hardware with Runtime primitives

• Job management and queuing

• Session mode (iterative algorithms)

• Batch mode (parallel jobs)

• Local simulators (StatevectorSampler, Aer)

• Third-party providers (IonQ, Amazon Braket)

• Error mitigation strategies

7. Qiskit Patterns Workflow

For implementing the four-step quantum computing workflow:

• See references/patterns.md

Topics covered:

• Map: Translate problems to quantum circuits

• Optimize: Transpile for hardware

• Execute: Run with primitives

• Post-process: Extract and analyze results

• Complete VQE example

• Session vs. Batch execution

• Common workflow patterns

8. Quantum Algorithms and Applications

For implementing specific quantum algorithms:

• See references/algorithms.md

Topics covered:

• Optimization: VQE, QAOA, Grover's algorithm

• Chemistry: Molecular ground states, excited states, Hamiltonians

• Machine Learning: Quantum kernels, VQC, QNN

• Algorithm libraries: Qiskit Nature, Qiskit ML, Qiskit Optimization

• Physics simulations and benchmarking

Workflow Decision Guide

If you need to:

• Install Qiskit or set up IBM Quantum account → references/setup.md

• Build a new quantum circuit → references/circuits.md

• Understand gates and circuit operations → references/circuits.md

• Run circuits and get measurements → references/primitives.md

• Compute expectation values → references/primitives.md

• Optimize circuits for hardware → references/transpilation.md

• Visualize circuits or results → references/visualization.md

• Execute on IBM Quantum hardware → references/backends.md

• Connect to third-party providers → references/backends.md

• Implement end-to-end quantum workflow → references/patterns.md

• Build specific algorithm (VQE, QAOA, etc.) → references/algorithms.md

• Solve chemistry or optimization problems → references/algorithms.md

Best Practices

Development Workflow

Start with simulators: Test locally before using hardware

from qiskit.primitives import StatevectorSampler sampler = StatevectorSampler()

Always transpile: Optimize circuits before execution

from qiskit import transpile qc_optimized = transpile(qc, backend=backend, optimization_level=3)

Use appropriate primitives:

• Sampler for bitstrings (optimization algorithms)

• Estimator for expectation values (chemistry, physics)

Choose execution mode:

• Session: Iterative algorithms (VQE, QAOA)

• Batch: Independent parallel jobs

• Single job: One-off experiments

Performance Optimization

• Use optimization_level=3 for production

• Minimize two-qubit gates (major error source)

• Test with noisy simulators before hardware

• Save and reuse transpiled circuits

• Monitor convergence in variational algorithms

Hardware Execution

• Check backend status before submitting

• Use least_busy() for testing

• Save job IDs for later retrieval

• Apply error mitigation (resilience_level)

• Start with fewer shots, increase for final runs

Common Patterns

Pattern 1: Simple Circuit Execution

from qiskit import QuantumCircuit, transpile from qiskit.primitives import StatevectorSampler

qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) qc.measure_all()

sampler = StatevectorSampler() result = sampler.run([qc], shots=1024).result() counts = result[0].data.meas.get_counts()

Pattern 2: Hardware Execution with Transpilation

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler from qiskit import transpile

service = QiskitRuntimeService() backend = service.backend("ibm_brisbane")

qc_optimized = transpile(qc, backend=backend, optimization_level=3)

sampler = Sampler(backend) job = sampler.run([qc_optimized], shots=1024) result = job.result()

Pattern 3: Variational Algorithm (VQE)

from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator from scipy.optimize import minimize

with Session(backend=backend) as session: estimator = Estimator(session=session)

def cost_function(params):
    bound_qc = ansatz.assign_parameters(params)
    qc_isa = transpile(bound_qc, backend=backend)
    result = estimator.run([(qc_isa, hamiltonian)]).result()
    return result[0].data.evs

result = minimize(cost_function, initial_params, method='COBYLA')

Additional Resources

• Official Docs: https://quantum.ibm.com/docs

• Qiskit Textbook: https://qiskit.org/learn

• API Reference: https://docs.quantum.ibm.com/api/qiskit

• Patterns Guide: https://quantum.cloud.ibm.com/docs/en/guides/intro-to-patterns