All answers verified by execution with Qiskit 2.5.1.

MCQ Answers

Q1 — B. Pauli strings are little-endian: the rightmost character acts on qubit 0. Pauli('IZ') = I on qubit 1, Z on qubit 0. This single convention decides several exam questions — always read Pauli strings right-to-left.

Q2 — C. Pauli('IZ').to_matrix() = np.kron(I, Z) (leftmost letter = highest qubit, first in the Kronecker product), giving diagonal [1, -1, 1, -1]. Option A ([1, 1, -1, -1]) is Pauli('ZI') = kron(Z, I) — the classic endianness distractor.

Q3 — B. .phase stores k where the prefix equals (−i)^k: ''→0, '-i'→1, '-'→2, 'i'→3. So '-i' → 1. Verified: Pauli('-iXY').phase == 1.

Q4 — C. A.compose(B) means "apply A first, then B" = matrix product B·A. Y·X = −iZ, so Pauli('X').compose(Pauli('Y')) prints -iZ. (X.dot(Y) = X·Y = iZ — compose and dot are opposite orders.)

Q5 — B. @ is dot: X·Z. Cyclic rule XY = iZ, YZ = iX, ZX = iY; reversing an adjacent pair flips the sign, so X·Z = −iY. Verified output: -iY.

Q6 — B. simplify() merges duplicate Pauli terms (1.0 + 1.0 → 2.0 for XX) and drops zero-coefficient terms (ZZ disappears). Result: SparsePauliOp(['XX'], coeffs=[2.+0.j]). Note the coefficient prints complex.

Q7 — C. ("ZX", [1, 4], 2.0) places Z on qubit 1 and X on qubit 4 (char i pairs with index i). Writing 5 qubits little-endian (q4 leftmost): q4=X, q3=I, q2=I, q1=Z, q0=I → 'XIIZI'. Verified output: SparsePauliOp(['XIIZI'], coeffs=[2.+0.j]).

Q8 — B. SparsePauliOp coefficients are always stored as complex128, whatever you pass in. Verified: op.coeffs.dtype → complex128, printed as [1.+0.j].

Q9 — C. Label '10' means q1 = 1, q0 = 0. The statevector index is the integer value of the bitstring: binary 10 = 2. Verified: data = [0, 0, 1, 0].

Q10 — B. qc.x(0) flips qubit 0, and bitstring keys are little-endian with qubit 0 rightmost, so the state is '01'. Output: {'01': 1.0}. Choosing '10' (option A) is the big-endian mistake.

Q11 — D. For (|00⟩ + |11⟩)/√2, each qubit individually is 50/50, so any single-qubit ⟨Z⟩ is 0. Verified: bell.expectation_value(SparsePauliOp(['ZI'])) → 0j (and 'IZ' → 0.0 too). Only correlated observables like ZZ or XX give ±1.

Q13 — C. S = diag(1, i). Option A is Z, B is T, D is H. Verified via Operator(qc_s).data → [[1, 0], [0, 1j]].

Q14 — A. T = diag(1, e^{iπ/4}); T² = diag(1, e^{iπ/2}) = diag(1, i) = S, exactly (verified with Operator == Operator, not just equiv). The ladder: T² = S, S² = Z, T⁴ = Z.

Q15 — D. HZH = X (H exchanges the X and Z axes of the Bloch sphere). Verified: Operator(hzh_circuit).data is exactly [[0, 1], [1, 0]] and equiv(Operator(Pauli('X'))) is True. Companion identity: HXH = Z.

Q16 — B. rz(π) = diag(−i, i) = −i·Z. That differs from Z by a global phase −i, so exact equality == is False but .equiv() (equality up to global phase) is True. Verified: a = False, b = True.

Q17 — C. Rule: two Pauli strings commute iff they anticommute on an even number of qubit positions. XX vs ZZ anticommute on 2 positions → commute (True). X vs Z anticommute (one position); XI vs ZI anticommute on qubit 1 (one position) → False. All verified with .commutes().

Q18 — C. Z|+⟩ = |−⟩ is a relative phase change — a genuinely different state (D is wrong), but Z is diagonal so computational-basis probabilities are untouched: both states give {'0': 0.5, '1': 0.5}. The change only shows up after a basis change (e.g., H maps |−⟩ → |1⟩).

Q19 — B. Tracing out either qubit of a Bell pair leaves [[0.5, 0], [0, 0.5]] = I/2, the maximally mixed state, with purity() ≈ 0.5. This is the hallmark of maximal entanglement: no pure single-qubit description exists. Verified with partial_trace(bell, [1]).

Q20 — A. Label '+0' is little-endian: qubit 1 = |+⟩, qubit 0 = |0⟩. Pauli('XI') puts X on qubit 1 (the |+⟩, X-eigenvalue +1) → 1.0; Pauli('IX') puts X on qubit 0 (the |0⟩, ⟨0|X|0⟩ = 0) → 0.0. Verified output: 1.0 0.0 (up to 1e-16).

Answer Key (quick grid)

Q	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
A	B	C	B	C	B	B	C	B	C	B	D	B	C	A	D	B	C	C	B	A

Lab Solutions

Lab A — The H sandwich (HZH = X, HXH = Z)

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator, Pauli
 
def sandwich(mid):
    qc = QuantumCircuit(1)
    qc.h(0); getattr(qc, mid)(0); qc.h(0)
    return Operator(qc)
 
print(sandwich('z') == Operator(Pauli('X')))        # True  — HZH is EXACTLY X
print(sandwich('z').equiv(Operator(Pauli('X'))))    # True
print(sandwich('x') == Operator(Pauli('Z')))        # True  — HXH is EXACTLY Z
print(np.round(sandwich('z').data.real))            # [[0. 1.] [1. 0.]]
 
# Bonus: HYH = -Y (exactly)
print(sandwich('y') == Operator(Pauli('-Y')))       # True
print(sandwich('y').equiv(Operator(Pauli('Y'))))    # True (!)  equiv ignores the -1

Prediction check: both == and equiv are True here — HZH equals X with no leftover global phase (H and Z are real matrices). The bonus is the subtle bit: HYH = −Y exactly, yet equiv(Y) is also True because −1 is a global phase. Verified: all six booleans print as commented.

Lab B — Bell autopsy

from qiskit import QuantumCircuit
from qiskit.quantum_info import (Statevector, SparsePauliOp, partial_trace,
                                 state_fidelity, DensityMatrix)
 
qc = QuantumCircuit(2)
qc.h(0); qc.cx(0, 1)
bell = Statevector.from_instruction(qc)
 
for label in ['ZZ', 'XX', 'ZI', 'IZ']:
    print(label, bell.expectation_value(SparsePauliOp([label])))
# ZZ (1+0j)   XX (1+0j)   ZI 0j   IZ 0j        (≈, up to 1e-16)
 
rho0 = partial_trace(bell, [1])        # trace OUT qubit 1, keep qubit 0
print(rho0.data.real)                  # [[0.5 0. ] [0.  0.5]]  = I/2
print(rho0.purity())                   # ~0.5  (maximally mixed; pure would be 1.0)
print(state_fidelity(rho0, DensityMatrix.from_label('0')))   # ~0.5

Verified outputs: ⟨ZZ⟩ = ⟨XX⟩ ≈ 1, both single-qubit ⟨Z⟩ = 0, reduced state exactly diag(0.5, 0.5), purity ≈ 0.5, fidelity with |0⟩ = 0.5. Interpretation: each qubit alone carries zero information (Bloch vector length 0 → center of the sphere in plot_bloch_multivector); all the structure lives in the ZZ/XX correlations. That is what "entangled" means operationally.

Lab C — Phase detective

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator, Pauli, Statevector
 
# 1) rz(pi) vs Z, rx(pi) vs X
qrz = QuantumCircuit(1); qrz.rz(np.pi, 0)
qrx = QuantumCircuit(1); qrx.rx(np.pi, 0)
print(Operator(qrz) == Operator(Pauli('Z')), Operator(qrz).equiv(Operator(Pauli('Z'))))
# False True    — rz(pi) = diag(-i, i) = -i·Z
print(Operator(qrx) == Operator(Pauli('X')), Operator(qrx).equiv(Operator(Pauli('X'))))
# False True    — rx(pi) = [[0,-i],[-i,0]] = -i·X
 
# 2) S|+> is |i> = label 'r'; probabilities unchanged
plus = Statevector.from_label('+')
qs = QuantumCircuit(1); qs.s(0)
after_s = plus.evolve(qs)
print(after_s.probabilities_dict())                       # {'0': 0.5, '1': 0.5}
print(after_s.equiv(Statevector.from_label('r')))         # True
 
# 3) basis change reveals (some) phases
def h_after(gate):
    qc = QuantumCircuit(1); getattr(qc, gate)(0); qc.h(0)
    return plus.evolve(qc).probabilities_dict()
 
print(h_after('z'))   # {'1': 1.0}            — deterministic!
print(h_after('s'))   # {'0': 0.5, '1': 0.5}  — STILL 50/50
print(h_after('t'))   # {'0': 0.854, '1': 0.146}

Verified outputs as commented. Explanations:

rz(π)/rx(π): rotation gates are exp(−iθP/2), so at θ = π they equal −i·P — same physics as the Pauli (global phase −i), hence equiv True, == False.
Z then H → certain '1': Z sends |+⟩ (+X axis) to |−⟩ (−X axis); H reads the X axis into the Z basis, so |−⟩ → |1⟩ deterministically. The "invisible" relative phase was one basis change away from being a definite bit.
S then H → still 50/50: S rotates |+⟩ a quarter turn to the Y axis (|i⟩ = 'r'). The Y axis is equidistant from ±X, so an X-basis readout (H + measure) is still random. You would need an Sdg before H (a Y-basis measurement) to see it deterministically.
T then H → cos²(π/8) ≈ 0.854 / 0.146: T is a 45° Z-rotation, leaving the state closer to +X than −X — exactly (1 + cos 45°)/2 = 0.8536 for outcome '0'.