Qiskit

When to Use

• You are building or optimizing quantum circuits with Qiskit for simulators or real hardware.
• You need IBM Quantum-style tooling for transpilation, execution, visualization, or algorithm libraries.
• You want guidance on moving from a simple circuit prototype to backend-aware execution.

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
Copy

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}
Copy

Visualization

from qiskit.visualization import plot_histogram

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

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

1. Start with simulators: Test locally before using hardware python from qiskit.primitives import StatevectorSampler sampler = StatevectorSampler()

2. Always transpile: Optimize circuits before execution python from qiskit import transpile qc_optimized = transpile(qc, backend=backend, optimization_level=3)

3. Use appropriate primitives:

4. Sampler for bitstrings (optimization algorithms)

5. Estimator for expectation values (chemistry, physics)

6. Choose execution mode:

7. Session: Iterative algorithms (VQE, QAOA)
8. Batch: Independent parallel jobs
9. 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()
Copy

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()
Copy

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')
Copy

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

Limitations

• Use this skill only when the task clearly matches the scope described above.
• Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
• Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.