All facts and outputs below verified with qiskit 2.5.1 (MPLBACKEND=Agg).

MCQ Answers

Q1 — B. With no arguments draw() uses output='text' and returns a TextDrawing object, which renders as ASCII art when printed/displayed. 'mpl' returns a matplotlib.figure.Figure (A); 'latex_source' returns the LaTeX string (C, verified: it starts with \documentclass...). It does not return None (D).

Q2 — A. reverse_bits is a pure display option of the drawer — it flips which wire is on top of the picture. The circuit object, its unitary, and the measured counts are completely unchanged. (Contrast with the method qc.reverse_bits(), which returns a new, genuinely reordered circuit.) B describes what would happen with the method, not the kwarg.

Q3 — C. For the text drawer, fold is the maximum width in characters before the diagram wraps into continuation rows (marked «); default 80. fold=-1 disables wrapping entirely, producing one arbitrarily wide row. It is not an error and does not reverse time.

Q4 — B. idle_wires=False only removes empty wires from the drawing. The circuit still owns all 5 qubits (qc.num_qubits == 5); nothing is deleted or "released". Verified: a 3-qubit circuit with an idle q_1 loses only the drawn wire, not the qubit.

Q5 — A. The diagram is H on q0 followed by CX(0→1) then measurement: a Bell pair (|00⟩+|11⟩)/√2. Ideal counts are only '00' and '11', roughly 50/50 with shot noise — {'00': 493, '11': 507} fits. B is the odd-parity signature (wrong), C is a uniform distribution (would need H on both qubits without the CX correlation), D would require a deterministic |11⟩ preparation.

Q6 — B. The solid dot ■ sits on the q_1 wire (control) and the boxed X on q_0 (target), so the control is qubit 1: qc.cx(1, 0). In cx(a, b) the FIRST argument is the control. A draws the mirror image; C would show two dots and no box (CZ is symmetric); D would show two separate X boxes with no connecting line.

Q7 — B. Left to right: two X marks joined vertically = SWAP(0,1); then two dots on q_1/q_2 = CZ(1,2); then dots on q_0 and q_1 with a boxed X on q_2 = CCX(0,1,2). Verified verbatim output for swap(0,1); cz(1,2); ccx(0,1,2). A starts with a CX (one dot + one box), C has the wrong middle gate, D has the wrong time order (time flows left → right).

Q8 — C. The circuit is H(0), CX(0→2), measure q0→c0 and q2→c2 (see the 0 2 under the ╩ symbols — those are clbit indices). q0 and q2 are perfectly correlated; q1 (and c1) stay 0. Count keys are read as c2 c1 c0 (little-endian, clbit 0 rightmost): either all zeros '000' or c2=1,c1=0,c0=1 → '101'. A forgets there are 3 classical bits; B and D put the '1's in the wrong positions.

Q9 — B. Verified: the x-tick labels are exactly ['00', '01', 'rest']. number_to_keep=N keeps the N most frequent outcomes as their own bars and aggregates all remaining outcomes into a single bar labeled rest — nothing is dropped (A) and it is not a styling option (D).

Q10 — B. Error-mitigated results and Sampler quasi-distributions can legitimately contain small negative quasi-probabilities; plot_distribution is built for probability-like data (bars ≈ sum to 1, negatives allowed), while plot_histogram presents count-derived bars. The other options are fabrications.

Q11 — C. h(0); cx(0,1) prepares a Bell state. plot_bloch_multivector draws each qubit's reduced (partial-traced) state; for a maximally entangled pair each reduced state is I/2, whose Bloch vector is (0, 0, 0). Verified: ⟨X⟩=⟨Y⟩=⟨Z⟩=0 on both qubits and purity 0.5. Zero-length arrows are the visual fingerprint of entanglement. A describes the state before the CX.

Q12 — B. On the qsphere each computational basis state is a blob whose size encodes its probability (amplitude magnitude) and whose color encodes its relative phase (phase color wheel). |0…0⟩ sits at the north pole, |1…1⟩ at the south, other states at latitudes by Hamming weight. A is the classic reversed-mapping trap.

Q13 — B. h sends |0⟩ → |+⟩ (+X); sdg then rotates −90° about Z, sending |+⟩ → |−i⟩, which lives on −Y. Verified: expectation values (⟨X⟩,⟨Y⟩,⟨Z⟩) = (0, −1, 0). (s instead of sdg would give +Y.)

Q14 — A. Verified exact output: \frac{\sqrt{2}}{2} |00\rangle+\frac{\sqrt{2}}{2} |11\rangle. Qiskit writes the amplitude as √2/2 (= 1/√2 ≈ 0.707). B has the wrong amplitude (1/2 is the probability), C is the wrong Bell state, D is missing normalization.

Q15 — B. Read the QASM line by line: x q[0] → qc.x(0); h q[1] → qc.h(1); cx q[1], q[0] — first operand is the control, so control=1, target=0 → qc.cx(1, 0); c = measure q; measures the whole register. Verified: loading this program gives exactly X(0), H(1), CX(1→0), measure, measure. A flips control/target; C and D swap which qubit gets X vs H.

Q16 — A. H on q0 then a CX chain 0→1, 1→2 is the standard GHZ construction: (|000⟩ + |111⟩)/√2. Verified via Statevector: amplitudes 0.7071 at indices 0 (000) and 7 (111), all others zero. D would require three H gates and no entanglers.

Q17 — B. The program prepares a Bell pair then flips q1: state (|01⟩ + |10⟩)/√2 (verified: \frac{\sqrt{2}}{2} |01\rangle+\frac{\sqrt{2}}{2} |10\rangle). Measuring gives odd-parity strings '01' and '10', ~500 each. A is the un-flipped Bell result; C forgets the superposition; D mixes parities.

Q18 — A. q0 is measured in superposition → c0 is 0 or 1 with ~50% each. The if (c[0]) block applies X to q1 exactly when c0=1, so q1's later measurement always matches: c1 = c0. Outcomes are '00' and '11' only. Verified that this program loads into a Qiskit circuit with an If-0 conditional block (and note: OpenQASM 3 does have block-structured if — that is one of its headline features over QASM 2, so D is false).

Q19 — C. qasm3.dump(circuit, file_like) writes to an open file object (returns None); it does not accept a path string, so A fails. dumps takes only the circuit and returns a string — B passes a bogus second argument. load is the importer (D). Verified: dump into a StringIO produces text identical to dumps.

Q20 — B. QASM 3 adds real classical control flow (block if/else, for, while), input parameters (imported by Qiskit as Parameter objects — verified), and typed classical declarations. A is QASM 2 syntax. C exists in both. D (measure q -> c; / c = measure q; on whole registers) also exists in both. Verified: exporting a circuit with an if_test via qasm2.dumps raises QASM2ExportError ("OpenQASM 2 only supports register-equality conditions"), while qasm3.dumps emits if (c[0]) { x q[1]; }.

Lab Solutions

Lab 1 — Hand-written QASM3, verified with `Operator`

A correct hand-written program (gate order h, cx, cx, z — the Z on any qubit of the GHZ state flips the sign of the |111⟩ branch):

OPENQASM 3.0;
include "stdgates.inc";
qubit[3] q;
h q[0];
cx q[0], q[1];
cx q[1], q[2];
z q[0];

from qiskit import QuantumCircuit, qasm3
from qiskit.quantum_info import Operator, Statevector
 
loaded = qasm3.loads(program)          # program = the string above
ref = QuantumCircuit(3)
ref.h(0); ref.cx(0, 1); ref.cx(1, 2); ref.z(0)
 
Operator(loaded).equiv(Operator(ref))  # -> True   (verified)
Statevector(loaded).draw('latex_source')

Verified ket output (your prediction should match up to global phase):

\frac{\sqrt{2}}{2} |000\rangle- \frac{\sqrt{2}}{2} |111\rangle

Bonus: qasm3.dumps(loaded) returns a normalized program (declarations reordered — bit/qubit declarations first, canonical spacing), not your byte-for-byte original text. Round-tripping preserves the circuit, not the source formatting.

Lab 2 — Predict the ASCII art

Verified draw('text') output (default, reverse_bits=False):

     ┌───┐               ┌─┐
q_0: ┤ H ├─■────────X────┤M├
     └───┘ │        │    └╥┘
q_1: ──────┼────────┼─────╫─
           │P(π/2)  │ ┌─┐ ║
q_2: ──────■────────X─┤M├─╫─
                      └╥┘ ║
c: 2/══════════════════╩══╩═
                       0  1

And with reverse_bits=True (q_2 on top; same circuit, same clbit indices):

                      ┌─┐
q_2: ──────■────────X─┤M├───
           │        │ └╥┘
q_1: ──────┼────────┼──╫────
     ┌───┐ │P(π/2)  │  ║ ┌─┐
q_0: ┤ H ├─■────────X──╫─┤M├
     └───┘             ║ └╥┘
c: 2/══════════════════╩══╩═
                       0  1

Both blocks are verbatim drawer output. Things students usually miss:

cp is drawn as two control dots with the label P(π/2) beside the wire — a controlled-phase is symmetric, so there is no boxed target.
swap(0, 2) draws X…X with the vertical line passing through the untouched q_1 wire (┼).
measure(2, 0) fires before measure(0, 1) in the drawing order, and the numbers under the classical wire are the clbit indices: q_2 → c0, q_0 → c1.
reverse_bits=True flips only the vertical wire order; the clbit assignments (0, 1) do not move.

Lab 3 — Bloch detective

Predictions vs verified expectation values (⟨X⟩, ⟨Y⟩, ⟨Z⟩ per qubit):

Circuit	Qubit	Bloch vector	Reading
A: `h(0); sdg(0); x(1)`	q0	(0, −1, 0)	h →
A	q1	(0, 0, −1)	x →
B: `h(0); cx(0, 1)`	q0	(0, 0, 0)	entangled → zero-length arrow
B	q1	(0, 0, 0)	entangled → zero-length arrow

Verification code:

from qiskit.quantum_info import Statevector, Pauli
sv = Statevector.from_instruction(A)
[[float(sv.expectation_value(Pauli(p), [q]).real) for p in 'XYZ'] for q in (0, 1)]
# A -> [[0.0, -1.0, 0.0], [0.0, 0.0, -1.0]]     (verified)
# B -> [[0.0,  0.0, 0.0], [0.0, 0.0,  0.0]]     (verified)

Takeaway: a product state shows full-length arrows on definite axes; a maximally entangled pair shows two arrows collapsed to the sphere centers. plot_bloch_multivector is a separability diagnostic, not a picture of the joint state — for that, use plot_state_qsphere (Bell state: two equal-size blobs at |00⟩ and |11⟩, same color since their relative phase is 0).