Bundled upstream support
Supporting files are included at skill-relative paths. See UPSTREAM-NOTICE.md for their pinned sources, licenses, hashes, and import changes.
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/iradoweck/qiskit7 skill-author: K-Dense Inc.8risk: critical9source: community10date_added: "2026-03-06"11---1213## Bundled upstream support1415Supporting files are included at skill-relative paths. See [UPSTREAM-NOTICE.md](UPSTREAM-NOTICE.md) for their pinned sources, licenses, hashes, and import changes.1617# Qiskit1819## When to Use20- You are building or optimizing quantum circuits with Qiskit for simulators or real hardware.21- You need IBM Quantum-style tooling for transpilation, execution, visualization, or algorithm libraries.22- You want guidance on moving from a simple circuit prototype to backend-aware execution.2324## Overview2526Qiskit 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.2728**Key Features:**29- 83x faster transpilation than competitors30- 29% fewer two-qubit gates in optimized circuits31- Backend-agnostic execution (local simulators or cloud hardware)32- Comprehensive algorithm libraries for optimization, chemistry, and ML3334## Quick Start3536### Installation3738```bash39uv pip install qiskit40uv pip install "qiskit[visualization]" matplotlib41```4243### First Circuit4445```python46from qiskit import QuantumCircuit47from qiskit.primitives import StatevectorSampler4849# Create Bell state (entangled qubits)50qc = QuantumCircuit(2)51qc.h(0) # Hadamard on qubit 052qc.cx(0, 1) # CNOT from qubit 0 to 153qc.measure_all() # Measure both qubits5455# Run locally56sampler = StatevectorSampler()57result = sampler.run([qc], shots=1024).result()58counts = result[0].data.meas.get_counts()59print(counts) # {'00': ~512, '11': ~512}60```6162### Visualization6364```python65from qiskit.visualization import plot_histogram6667qc.draw('mpl') # Circuit diagram68plot_histogram(counts) # Results histogram69```7071## Core Capabilities7273### 1. Setup and Installation74For detailed installation, authentication, and IBM Quantum account setup:75- **See `references/setup.md`**7677Topics covered:78- Installation with uv79- Python environment setup80- IBM Quantum account and API token configuration81- Local vs. cloud execution8283### 2. Building Quantum Circuits84For constructing quantum circuits with gates, measurements, and composition:85- **See `references/circuits.md`**8687Topics covered:88- Creating circuits with QuantumCircuit89- Single-qubit gates (H, X, Y, Z, rotations, phase gates)90- Multi-qubit gates (CNOT, SWAP, Toffoli)91- Measurements and barriers92- Circuit composition and properties93- Parameterized circuits for variational algorithms9495### 3. Primitives (Sampler and Estimator)96For executing quantum circuits and computing results:97- **See `references/primitives.md`**9899Topics covered:100- **Sampler**: Get bitstring measurements and probability distributions101- **Estimator**: Compute expectation values of observables102- V2 interface (StatevectorSampler, StatevectorEstimator)103- IBM Quantum Runtime primitives for hardware104- Sessions and Batch modes105- Parameter binding106107### 4. Transpilation and Optimization108For optimizing circuits and preparing for hardware execution:109- **See `references/transpilation.md`**110111Topics covered:112- Why transpilation is necessary113- Optimization levels (0-3)114- Six transpilation stages (init, layout, routing, translation, optimization, scheduling)115- Advanced features (virtual permutation elision, gate cancellation)116- Common parameters (initial_layout, approximation_degree, seed)117- Best practices for efficient circuits118119### 5. Visualization120For displaying circuits, results, and quantum states:121- **See `references/visualization.md`**122123Topics covered:124- Circuit drawings (text, matplotlib, LaTeX)125- Result histograms126- Quantum state visualization (Bloch sphere, state city, QSphere)127- Backend topology and error maps128- Customization and styling129- Saving publication-quality figures130131### 6. Hardware Backends132For running on simulators and real quantum computers:133- **See `references/backends.md`**134135Topics covered:136- IBM Quantum backends and authentication137- Backend properties and status138- Running on real hardware with Runtime primitives139- Job management and queuing140- Session mode (iterative algorithms)141- Batch mode (parallel jobs)142- Local simulators (StatevectorSampler, Aer)143- Third-party providers (IonQ, Amazon Braket)144- Error mitigation strategies145146### 7. Qiskit Patterns Workflow147For implementing the four-step quantum computing workflow:148- **See `references/patterns.md`**149150Topics covered:151- **Map**: Translate problems to quantum circuits152- **Optimize**: Transpile for hardware153- **Execute**: Run with primitives154- **Post-process**: Extract and analyze results155- Complete VQE example156- Session vs. Batch execution157- Common workflow patterns158159### 8. Quantum Algorithms and Applications160For implementing specific quantum algorithms:161- **See `references/algorithms.md`**162163Topics covered:164- **Optimization**: VQE, QAOA, Grover's algorithm165- **Chemistry**: Molecular ground states, excited states, Hamiltonians166- **Machine Learning**: Quantum kernels, VQC, QNN167- **Algorithm libraries**: Qiskit Nature, Qiskit ML, Qiskit Optimization168- Physics simulations and benchmarking169170## Workflow Decision Guide171172**If you need to:**173174- Install Qiskit or set up IBM Quantum account → `references/setup.md`175- Build a new quantum circuit → `references/circuits.md`176- Understand gates and circuit operations → `references/circuits.md`177- Run circuits and get measurements → `references/primitives.md`178- Compute expectation values → `references/primitives.md`179- Optimize circuits for hardware → `references/transpilation.md`180- Visualize circuits or results → `references/visualization.md`181- Execute on IBM Quantum hardware → `references/backends.md`182- Connect to third-party providers → `references/backends.md`183- Implement end-to-end quantum workflow → `references/patterns.md`184- Build specific algorithm (VQE, QAOA, etc.) → `references/algorithms.md`185- Solve chemistry or optimization problems → `references/algorithms.md`186187## Best Practices188189### Development Workflow1901911. **Start with simulators**: Test locally before using hardware192 ```python193 from qiskit.primitives import StatevectorSampler194 sampler = StatevectorSampler()195 ```1961972. **Always transpile**: Optimize circuits before execution198 ```python199 from qiskit import transpile200 qc_optimized = transpile(qc, backend=backend, optimization_level=3)201 ```2022033. **Use appropriate primitives**:204 - Sampler for bitstrings (optimization algorithms)205 - Estimator for expectation values (chemistry, physics)2062074. **Choose execution mode**:208 - Session: Iterative algorithms (VQE, QAOA)209 - Batch: Independent parallel jobs210 - Single job: One-off experiments211212### Performance Optimization213214- Use optimization_level=3 for production215- Minimize two-qubit gates (major error source)216- Test with noisy simulators before hardware217- Save and reuse transpiled circuits218- Monitor convergence in variational algorithms219220### Hardware Execution221222- Check backend status before submitting223- Use least_busy() for testing224- Save job IDs for later retrieval225- Apply error mitigation (resilience_level)226- Start with fewer shots, increase for final runs227228## Common Patterns229230### Pattern 1: Simple Circuit Execution231232```python233from qiskit import QuantumCircuit, transpile234from qiskit.primitives import StatevectorSampler235236qc = QuantumCircuit(2)237qc.h(0)238qc.cx(0, 1)239qc.measure_all()240241sampler = StatevectorSampler()242result = sampler.run([qc], shots=1024).result()243counts = result[0].data.meas.get_counts()244```245246### Pattern 2: Hardware Execution with Transpilation247248```python249from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler250from qiskit import transpile251252service = QiskitRuntimeService()253backend = service.backend("ibm_brisbane")254255qc_optimized = transpile(qc, backend=backend, optimization_level=3)256257sampler = Sampler(backend)258job = sampler.run([qc_optimized], shots=1024)259result = job.result()260```261262### Pattern 3: Variational Algorithm (VQE)263264```python265from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator266from scipy.optimize import minimize267268with Session(backend=backend) as session:269 estimator = Estimator(session=session)270271 def cost_function(params):272 bound_qc = ansatz.assign_parameters(params)273 qc_isa = transpile(bound_qc, backend=backend)274 result = estimator.run([(qc_isa, hamiltonian)]).result()275 return result[0].data.evs276277 result = minimize(cost_function, initial_params, method='COBYLA')278```279280## Additional Resources281282- **Official Docs**: https://quantum.ibm.com/docs283- **Qiskit Textbook**: https://qiskit.org/learn284- **API Reference**: https://docs.quantum.ibm.com/api/qiskit285- **Patterns Guide**: https://quantum.cloud.ibm.com/docs/en/guides/intro-to-patterns286287## Limitations288- Use this skill only when the task clearly matches the scope described above.289- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.290- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.