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
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:
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
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.
1---2name: qiskit3description: "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."4license: Apache-2.0 license5metadata:6 source: https://skillmd.com/skills/antigravity/qiskit7 skill-author: K-Dense Inc.8risk: unknown9source: community10---1112# Qiskit1314## When to Use15- You are building or optimizing quantum circuits with Qiskit for simulators or real hardware.16- You need IBM Quantum-style tooling for transpilation, execution, visualization, or algorithm libraries.17- You want guidance on moving from a simple circuit prototype to backend-aware execution.1819## Overview2021Qiskit 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.2223**Key Features:**24- 83x faster transpilation than competitors25- 29% fewer two-qubit gates in optimized circuits26- Backend-agnostic execution (local simulators or cloud hardware)27- Comprehensive algorithm libraries for optimization, chemistry, and ML2829## Quick Start3031### Installation3233```bash34uv pip install qiskit35uv pip install "qiskit[visualization]" matplotlib36```3738### First Circuit3940```python41from qiskit import QuantumCircuit42from qiskit.primitives import StatevectorSampler4344# Create Bell state (entangled qubits)45qc = QuantumCircuit(2)46qc.h(0) # Hadamard on qubit 047qc.cx(0, 1) # CNOT from qubit 0 to 148qc.measure_all() # Measure both qubits4950# Run locally51sampler = StatevectorSampler()52result = sampler.run([qc], shots=1024).result()53counts = result[0].data.meas.get_counts()54print(counts) # {'00': ~512, '11': ~512}55```5657### Visualization5859```python60from qiskit.visualization import plot_histogram6162qc.draw('mpl') # Circuit diagram63plot_histogram(counts) # Results histogram64```6566## Core Capabilities6768### 1. Setup and Installation69For detailed installation, authentication, and IBM Quantum account setup:70- **See `references/setup.md`**7172Topics covered:73- Installation with uv74- Python environment setup75- IBM Quantum account and API token configuration76- Local vs. cloud execution7778### 2. Building Quantum Circuits79For constructing quantum circuits with gates, measurements, and composition:80- **See `references/circuits.md`**8182Topics covered:83- Creating circuits with QuantumCircuit84- Single-qubit gates (H, X, Y, Z, rotations, phase gates)85- Multi-qubit gates (CNOT, SWAP, Toffoli)86- Measurements and barriers87- Circuit composition and properties88- Parameterized circuits for variational algorithms8990### 3. Primitives (Sampler and Estimator)91For executing quantum circuits and computing results:92- **See `references/primitives.md`**9394Topics covered:95- **Sampler**: Get bitstring measurements and probability distributions96- **Estimator**: Compute expectation values of observables97- V2 interface (StatevectorSampler, StatevectorEstimator)98- IBM Quantum Runtime primitives for hardware99- Sessions and Batch modes100- Parameter binding101102### 4. Transpilation and Optimization103For optimizing circuits and preparing for hardware execution:104- **See `references/transpilation.md`**105106Topics covered:107- Why transpilation is necessary108- Optimization levels (0-3)109- Six transpilation stages (init, layout, routing, translation, optimization, scheduling)110- Advanced features (virtual permutation elision, gate cancellation)111- Common parameters (initial_layout, approximation_degree, seed)112- Best practices for efficient circuits113114### 5. Visualization115For displaying circuits, results, and quantum states:116- **See `references/visualization.md`**117118Topics covered:119- Circuit drawings (text, matplotlib, LaTeX)120- Result histograms121- Quantum state visualization (Bloch sphere, state city, QSphere)122- Backend topology and error maps123- Customization and styling124- Saving publication-quality figures125126### 6. Hardware Backends127For running on simulators and real quantum computers:128- **See `references/backends.md`**129130Topics covered:131- IBM Quantum backends and authentication132- Backend properties and status133- Running on real hardware with Runtime primitives134- Job management and queuing135- Session mode (iterative algorithms)136- Batch mode (parallel jobs)137- Local simulators (StatevectorSampler, Aer)138- Third-party providers (IonQ, Amazon Braket)139- Error mitigation strategies140141### 7. Qiskit Patterns Workflow142For implementing the four-step quantum computing workflow:143- **See `references/patterns.md`**144145Topics covered:146- **Map**: Translate problems to quantum circuits147- **Optimize**: Transpile for hardware148- **Execute**: Run with primitives149- **Post-process**: Extract and analyze results150- Complete VQE example151- Session vs. Batch execution152- Common workflow patterns153154### 8. Quantum Algorithms and Applications155For implementing specific quantum algorithms:156- **See `references/algorithms.md`**157158Topics covered:159- **Optimization**: VQE, QAOA, Grover's algorithm160- **Chemistry**: Molecular ground states, excited states, Hamiltonians161- **Machine Learning**: Quantum kernels, VQC, QNN162- **Algorithm libraries**: Qiskit Nature, Qiskit ML, Qiskit Optimization163- Physics simulations and benchmarking164165## Workflow Decision Guide166167**If you need to:**168169- Install Qiskit or set up IBM Quantum account → `references/setup.md`170- Build a new quantum circuit → `references/circuits.md`171- Understand gates and circuit operations → `references/circuits.md`172- Run circuits and get measurements → `references/primitives.md`173- Compute expectation values → `references/primitives.md`174- Optimize circuits for hardware → `references/transpilation.md`175- Visualize circuits or results → `references/visualization.md`176- Execute on IBM Quantum hardware → `references/backends.md`177- Connect to third-party providers → `references/backends.md`178- Implement end-to-end quantum workflow → `references/patterns.md`179- Build specific algorithm (VQE, QAOA, etc.) → `references/algorithms.md`180- Solve chemistry or optimization problems → `references/algorithms.md`181182## Best Practices183184### Development Workflow1851861. **Start with simulators**: Test locally before using hardware187 ```python188 from qiskit.primitives import StatevectorSampler189 sampler = StatevectorSampler()190 ```1911922. **Always transpile**: Optimize circuits before execution193 ```python194 from qiskit import transpile195 qc_optimized = transpile(qc, backend=backend, optimization_level=3)196 ```1971983. **Use appropriate primitives**:199 - Sampler for bitstrings (optimization algorithms)200 - Estimator for expectation values (chemistry, physics)2012024. **Choose execution mode**:203 - Session: Iterative algorithms (VQE, QAOA)204 - Batch: Independent parallel jobs205 - Single job: One-off experiments206207### Performance Optimization208209- Use optimization_level=3 for production210- Minimize two-qubit gates (major error source)211- Test with noisy simulators before hardware212- Save and reuse transpiled circuits213- Monitor convergence in variational algorithms214215### Hardware Execution216217- Check backend status before submitting218- Use least_busy() for testing219- Save job IDs for later retrieval220- Apply error mitigation (resilience_level)221- Start with fewer shots, increase for final runs222223## Common Patterns224225### Pattern 1: Simple Circuit Execution226227```python228from qiskit import QuantumCircuit, transpile229from qiskit.primitives import StatevectorSampler230231qc = QuantumCircuit(2)232qc.h(0)233qc.cx(0, 1)234qc.measure_all()235236sampler = StatevectorSampler()237result = sampler.run([qc], shots=1024).result()238counts = result[0].data.meas.get_counts()239```240241### Pattern 2: Hardware Execution with Transpilation242243```python244from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler245from qiskit import transpile246247service = QiskitRuntimeService()248backend = service.backend("ibm_brisbane")249250qc_optimized = transpile(qc, backend=backend, optimization_level=3)251252sampler = Sampler(backend)253job = sampler.run([qc_optimized], shots=1024)254result = job.result()255```256257### Pattern 3: Variational Algorithm (VQE)258259```python260from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator261from scipy.optimize import minimize262263with Session(backend=backend) as session:264 estimator = Estimator(session=session)265266 def cost_function(params):267 bound_qc = ansatz.assign_parameters(params)268 qc_isa = transpile(bound_qc, backend=backend)269 result = estimator.run([(qc_isa, hamiltonian)]).result()270 return result[0].data.evs271272 result = minimize(cost_function, initial_params, method='COBYLA')273```274275## Additional Resources276277- **Official Docs**: https://quantum.ibm.com/docs278- **Qiskit Textbook**: https://qiskit.org/learn279- **API Reference**: https://docs.quantum.ibm.com/api/qiskit280- **Patterns Guide**: https://quantum.cloud.ibm.com/docs/en/guides/intro-to-patterns281282## Limitations283- Use this skill only when the task clearly matches the scope described above.284- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.285- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.