Lesson

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
 
# Style 1: bare integers (auto-creates registers named 'q' and 'c')
qc = QuantumCircuit(2, 2)
print(qc.num_qubits, qc.num_clbits)   # 2 2
print(qc.qregs)                       # [QuantumRegister(2, 'q')]
print(qc.cregs)                       # [ClassicalRegister(2, 'c')]
 
# Style 2: explicit registers (you pick the names)
qr = QuantumRegister(3, 'data')
cr = ClassicalRegister(3, 'out')
qc = QuantumCircuit(qr, cr)
 
# Style 3: qubits only, no clbits
qc = QuantumCircuit(4)

qc = QuantumCircuit(QuantumRegister(2, 'a'), QuantumRegister(3, 'b'))
print(qc.num_qubits)   # 5

from qiskit.circuit import AncillaRegister
qr  = QuantumRegister(2, 'q')
anc = AncillaRegister(1, 'anc')
cr  = ClassicalRegister(2, 'c')
qc  = QuantumCircuit(qr, anc, cr)
print(qc.num_qubits, qc.num_ancillas, qc.num_clbits)  # 3 1 2
print(qc.width())                                     # 5

import numpy as np
qc = QuantumCircuit(1)
qc.h(0)
qc.p(np.pi/4, 0)          # phase gate: diag(1, e^{i*lam})
qc.rx(np.pi/2, 0)         # rotation gates take (angle, qubit)
qc.u(np.pi/2, 0, np.pi, 0)  # u(theta, phi, lam, qubit)

from qiskit.quantum_info import Operator
# t;t == s          -> True
# sx;sx == x        -> True
# s;sdg == identity -> True
# u(pi/2, 0, pi) == h            -> True
# u(0, 0, lam) == p(lam)  (exact) -> True
# p(pi) == z (exact)              -> True
# rz(pi) equiv z (up to GLOBAL PHASE only; not exactly equal)
qz  = QuantumCircuit(1); qz.z(0)
qrz = QuantumCircuit(1); qrz.rz(np.pi, 0)
print(Operator(qrz).equiv(Operator(qz)))   # True
print(Operator(qrz) == Operator(qz))       # False  <- global phase differs!

qc = QuantumCircuit(3)
qc.x([0, 1, 2])            # also qc.h(range(3))
print(qc.count_ops())      # OrderedDict({'x': 3})

qc = QuantumCircuit(2)
qc.cx(0, 1)         # control=0, target=1
qc.cp(np.pi/2, 0, 1)  # controlled-phase: (angle, control, target)
qc.rzz(0.3, 0, 1)     # two-qubit rotations: (angle, q1, q2)
qc.ecr(0, 1)          # echoed cross-resonance: an IBM-hardware-native entangler

sw = QuantumCircuit(2); sw.swap(0, 1)
c3 = QuantumCircuit(2); c3.cx(0, 1); c3.cx(1, 0); c3.cx(0, 1)
print(Operator(sw).equiv(Operator(c3)))   # True

from qiskit.quantum_info import Statevector
qc = QuantumCircuit(2)
qc.x(0)
qc.iswap(0, 1)
print(Statevector(qc))
# Statevector([0.+0.j, 0.+0.j, 0.+1.j, 0.+0.j],
#             dims=(2, 2))          <- i|10>, i.e. amplitude i on qubit-1=1

qc = QuantumCircuit(4)
qc.ccx(0, 1, 2)          # Toffoli: controls 0,1 -> target 2
qc.cswap(0, 1, 2)        # Fredkin: control 0 swaps 1<->2
qc.mcx([0, 1, 2], 3)     # multi-controlled X: control LIST, then target
print(qc.count_ops())    # OrderedDict({'ccx': 1, 'cswap': 1, 'mcx': 1})

from qiskit.circuit.library import XGate
g = XGate().control(2)
print(g.name, g.num_qubits)   # ccx 3

qc = QuantumCircuit(2, 2)
qc.h(0)
qc.measure(0, 0)              # qubit 0 -> clbit 0
qc.measure([0, 1], [0, 1])    # broadcast form
qc.barrier()                  # visual/optimization fence
qc.reset(0)                   # forces qubit back to |0>

qc = QuantumCircuit(2)
qc.h(0); qc.cx(0, 1)
qc.measure_all()
print(qc.cregs)        # [ClassicalRegister(2, 'meas')]
print(qc.count_ops())  # OrderedDict({'measure': 2, 'h': 1, 'cx': 1, 'barrier': 1})

qc = QuantumCircuit(2, 2)        # already has creg 'c'
qc.h(0)
qc.measure_all()
print(qc.num_clbits, [r.name for r in qc.cregs])   # 4 ['c', 'meas']
# use qc.measure_all(add_bits=False) to reuse the existing clbits instead

qc = QuantumCircuit(3)
qc.h(0); qc.cx(0, 1)          # qubit 2 is idle
qc.measure_active()
print(qc.cregs)               # [ClassicalRegister(2, 'meas')]

from qiskit.primitives import StatevectorSampler
qc = QuantumCircuit(3, 3)
qc.x(0)
qc.x(2)
qc.measure(range(3), range(3))
sampler = StatevectorSampler(seed=1)
print(sampler.run([qc], shots=10).result()[0].data.c.get_counts())
# {'101': 10}     <- read as q2 q1 q0 = 1 0 1  (the number 5)

bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
print(Statevector(bell))
# Statevector([0.70710678+0.j, 0.        +0.j, 0.        +0.j,
#              0.70710678+0.j],
#             dims=(2, 2))

bellm = bell.copy()
bellm.measure_all()
sampler = StatevectorSampler(seed=42)
print(sampler.run([bellm], shots=1000).result()[0].data.meas.get_counts())
# {'11': 497, '00': 503}

g4 = QuantumCircuit(4)                       # chain: h, cx(0,1), cx(1,2), cx(2,3)
g4.h(0); g4.cx(0, 1); g4.cx(1, 2); g4.cx(2, 3)
print(g4.depth())                            # 4
 
g4b = QuantumCircuit(4)                      # tree/fan-out
g4b.h(0); g4b.cx(0, 1); g4b.cx(0, 2); g4b.cx(1, 3)
print(g4b.depth())                           # 3
print(Statevector(g4).equiv(Statevector(g4b)))   # True

a = QuantumCircuit(2); a.h(0)
b = QuantumCircuit(2); b.cx(0, 1)
c = a.compose(b)
print(c.count_ops())   # OrderedDict({'h': 1, 'cx': 1})
print(a.count_ops())   # OrderedDict({'h': 1})   <- a unchanged (use inplace=True to mutate)

a = QuantumCircuit(1); a.x(0)
b = QuantumCircuit(1); b.h(0)
c = a.compose(b, front=True)
print([ci.operation.name for ci in c.data])   # ['h', 'x']

bell = QuantumCircuit(2, name='bell')
bell.h(0); bell.cx(0, 1)
gate = bell.to_gate()
 
qc = QuantumCircuit(3)
qc.append(gate, [0, 2])
print(qc.count_ops())              # OrderedDict({'bell': 1})
print(qc.depth(), qc.size())       # 1 1   <- opaque gate counts as ONE op
print(qc.decompose().count_ops())  # OrderedDict({'h': 1, 'cx': 1})

x1 = QuantumCircuit(1); x1.x(0)
h1 = QuantumCircuit(1); h1.h(0)
t = x1.tensor(h1)          # ARGUMENT (h1) goes on the LOWER wires
print(t)
#      ┌───┐
# q_0: ┤ H ├
#      ├───┤
# q_1: ┤ X ├
#      └───┘
print(Statevector(t).probabilities_dict())   # {'10': 0.5, '11': 0.5}  (q1 fixed at 1)

qc = QuantumCircuit(1)
qc.s(0); qc.t(0)
inv = qc.inverse()
print([ci.operation.name for ci in inv.data])   # ['tdg', 'sdg']  <- reversed AND daggered

qc = QuantumCircuit(1)
qc.t(0)
p = qc.power(2)                          # wraps the repeated circuit as a sub-gate
print(p.decompose().count_ops())         # OrderedDict({'t': 2})

qc = QuantumCircuit(1)
alias = qc
cp = qc.copy()
qc.h(0)
print(alias.size(), cp.size())   # 1 0
# qc.copy_empty_like() keeps registers but drops all instructions (size 0)

bell = QuantumCircuit(2, name='bell')
bell.h(0); bell.cx(0, 1)
 
g = bell.to_gate()          # Gate: must be UNITARY (no measure/reset)
i = bell.to_instruction()   # Instruction: may contain measure/reset
 
cbell = g.control(1)
print(cbell.name, cbell.num_qubits)   # cbell 3   <- control qubit is FIRST when appended

qc = QuantumCircuit(2, 2)
qc.h(0); qc.cx(0, 1); qc.measure([0, 1], [0, 1])
print(qc.depth())       # 3   (h -> cx -> measures in parallel)
print(qc.size())        # 4   (h + cx + 2 measures)
print(qc.width())       # 4   (2 qubits + 2 clbits)
print(qc.count_ops())   # OrderedDict({'measure': 2, 'h': 1, 'cx': 1})

qc = QuantumCircuit(3)
qc.h(0); qc.cx(0, 1); qc.h(2)
print(qc.depth(), qc.size())   # 2 3   <- h(2) runs in parallel with layer 1

qc = QuantumCircuit(2)
qc.h(0); qc.barrier(); qc.x(1)
print(qc.depth(), qc.size(), len(qc.data))  # 2 2 3
print(qc.count_ops())                       # OrderedDict({'h': 1, 'barrier': 1, 'x': 1})
# without the barrier: depth would be 1 (h and x in parallel)

"""Lab 1: Depth Detective. Predict BEFORE running:
depth, size, width, count_ops of each circuit."""
from qiskit import QuantumCircuit
 
# --- Circuit A ---
qa = QuantumCircuit(3)
qa.h(0)
qa.h(1)
qa.cx(0, 1)
qa.x(2)
qa.cx(1, 2)
print("A depth:", qa.depth())
print("A size: ", qa.size())
print("A width:", qa.width())
print("A ops:  ", dict(qa.count_ops()))
 
# --- Circuit B: same gates, plus a barrier ---
qb = QuantumCircuit(3)
qb.h(0)
qb.h(1)
qb.barrier()
qb.cx(0, 1)
qb.x(2)
qb.cx(1, 2)
print("B depth:", qb.depth())
print("B size: ", qb.size())
print("B ops:  ", dict(qb.count_ops()))
 
# --- Circuit C: B with measure_all ---
qc = qb.copy()
qc.measure_all()
print("C width:", qc.width())
print("C clbit registers:", [r.name for r in qc.cregs])
print("C depth:", qc.depth())

"""Lab 2: The Little-Endian Vault. Predict every printed bitstring BEFORE running."""
from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
 
sampler = StatevectorSampler(seed=2026)
 
# Step 1: write the number 6 (binary 110) into a 3-qubit register.
vault = QuantumCircuit(3, 3)
vault.x(1)
vault.x(2)
vault.measure(range(3), range(3))
counts = sampler.run([vault], shots=100).result()[0].data.c.get_counts()
print("Step 1 counts:", counts)
 
# Step 2: same circuit but swap qubits 0 and 2 before measuring.
vault2 = QuantumCircuit(3, 3)
vault2.x(1)
vault2.x(2)
vault2.swap(0, 2)
vault2.measure(range(3), range(3))
counts2 = sampler.run([vault2], shots=100).result()[0].data.c.get_counts()
print("Step 2 counts:", counts2)
 
# Step 3: measure qubits in REVERSED clbit order (q0->c2, q1->c1, q2->c0).
vault3 = QuantumCircuit(3, 3)
vault3.x(1)
vault3.x(2)
vault3.measure([0, 1, 2], [2, 1, 0])
counts3 = sampler.run([vault3], shots=100).result()[0].data.c.get_counts()
print("Step 3 counts:", counts3)

"""Lab 3: The Bell Gate Factory. Predict outputs BEFORE running."""
from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler
 
# Step 1: package a Bell pair as a reusable Gate.
bell = QuantumCircuit(2, name="bell")
bell.h(0)
bell.cx(0, 1)
bell_gate = bell.to_gate()
print("Step 1:", bell_gate.name, "| qubits:", bell_gate.num_qubits)
 
# Step 2: append it to a 3-qubit circuit on qubits [1, 2], then extend to GHZ.
qc = QuantumCircuit(3)
qc.append(bell_gate, [1, 2])
qc.cx(1, 0)
print("Step 2 ops:", dict(qc.count_ops()))
print("Step 2 depth:", qc.depth())
print("Step 2 decomposed ops:", dict(qc.decompose().count_ops()))
 
# Step 3: measure and sample. What two bitstrings appear?
qc.measure_all()
sampler = StatevectorSampler(seed=99)
counts = sampler.run([qc], shots=2000).result()[0].data.meas.get_counts()
print("Step 3 counts:", counts)
 
# Step 4: a CONTROLLED bell gate, control stays |0>. What comes out?
cbell = bell_gate.control(1)
print("Step 4 gate:", cbell.name, "| qubits:", cbell.num_qubits)
qc4 = QuantumCircuit(3)
qc4.append(cbell, [0, 1, 2])   # qubit 0 is the control
qc4.measure_all()
counts4 = sampler.run([qc4], shots=1000).result()[0].data.meas.get_counts()
print("Step 4 counts:", counts4)