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])
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])
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())}")
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}")