Skip to content

Qiskit Quick Reference

Circuit Construction

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit import Parameter, ParameterVector
import numpy as np

# -- Circuit creation -----------------------------------------
qc = QuantumCircuit(4, 4)       # 4 qubits, 4 classical bits
qr = QuantumRegister(3, 'q')
cr = ClassicalRegister(3, 'c')
qc2 = QuantumCircuit(qr, cr)

# -- Gates ----------------------------------------------------
qc.h(0)             # Hadamard
qc.x(1)             # Pauli-X
qc.y(2)             # Pauli-Y
qc.z(3)             # Pauli-Z
qc.s(0)             # S gate
qc.sdg(0)           # S-dagger
qc.t(0)             # T gate
qc.tdg(0)           # T-dagger
qc.rx(0.5, 0)       # RX rotation
qc.ry(0.5, 0)       # RY rotation
qc.rz(0.5, 0)       # RZ rotation
qc.u(0.5, 0.5, 0.5, 0)  # general single-qubit U gate

# -- Two-qubit gates -------------------------------------------
qc.cx(0, 1)         # CNOT (control=0, target=1)
qc.cz(0, 1)         # CZ
qc.swap(0, 1)       # SWAP
qc.crx(0.5, 0, 1)  # controlled-RX
qc.cry(0.5, 0, 1)  # controlled-RY
qc.crz(0.5, 0, 1)  # controlled-RZ
qc.ecr(0, 1)        # ECR gate (IBM native)

# -- Measurement -----------------------------------------------
qc.measure(0, 0)    # measure qubit 0 into bit 0
qc.measure_all()    # measure all qubits

# -- Parameterized circuits -----------------------------------
theta = Parameter('theta')
phi = Parameter('phi')
params = ParameterVector('p', length=4)

qc_param = QuantumCircuit(2)
qc_param.rx(theta, 0)
qc_param.ry(phi, 1)
qc_param.cx(0, 1)

# Bind parameters
bound_circuit = qc_param.assign_parameters({theta: 0.5, phi: 1.2})

# -- State preparation -----------------------------------------
from qiskit.circuit.library import Initialize
state = [1/np.sqrt(2), 0, 0, 1/np.sqrt(2)]  # Bell state
qc.initialize(state, [0, 1])

Simulation

from qiskit_aer import AerSimulator
from qiskit import transpile

# Statevector simulator
sim_sv = AerSimulator(method='statevector')

# QASM simulator (shot-based)
sim_qasm = AerSimulator(method='automatic', shots=8192)

# Matrix product state (for large circuits)
sim_mps = AerSimulator(method='matrix_product_state')

# Run circuit
qc = QuantumCircuit(3)
qc.h(0); qc.cx(0, 1); qc.cx(1, 2)
qc.measure_all()

transpiled = transpile(qc, sim_qasm)
job = sim_qasm.run(transpiled, shots=4096)
result = job.result()
counts = result.get_counts()
print("GHZ state counts:", counts)

# Statevector (no measurement)
qc_sv = QuantumCircuit(3)
qc_sv.h(0); qc_sv.cx(0, 1); qc_sv.cx(1, 2)
qc_sv.save_statevector()
job_sv = sim_sv.run(transpile(qc_sv, sim_sv))
sv = job_sv.result().get_statevector()
print("State amplitudes:", sv.data[:8])

Transpilation and Optimization

from qiskit import transpile
from qiskit_ibm_runtime.fake_provider import FakeNairobi

backend = FakeNairobi()

# Transpile options
t = transpile(qc, backend=backend,
              optimization_level=3,   # 0=none, 1=light, 2=medium, 3=heavy
              seed_transpiler=42)     # for reproducibility

print(f"Original depth:   {qc.depth()}")
print(f"Transpiled depth: {t.depth()}")
print(f"Gate count: {dict(t.count_ops())}")

Qiskit Machine Learning

from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
from qiskit_machine_learning.algorithms import QSVC
from qiskit_machine_learning.kernels import FidelityQuantumKernel
from qiskit_aer import AerSimulator
from qiskit.primitives import Sampler

# Feature map and ansatz
n_features = 4
feature_map = ZZFeatureMap(feature_dimension=n_features, reps=2)
ansatz = RealAmplitudes(n_features, reps=3)

# Quantum kernel SVM
sampler = Sampler()
kernel = FidelityQuantumKernel(feature_map=feature_map)
qsvc = QSVC(quantum_kernel=kernel)

# Train and predict (sklearn-compatible interface)
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=100, n_features=4, random_state=42)
qsvc.fit(X[:80], y[:80])
acc = qsvc.score(X[80:], y[80:])
print(f"QSVC test accuracy: {acc:.3f}")