Paper: paper-10-FULL.md · 68 questions · pass = 47/68 All code-output answers were verified by execution on Qiskit 2.5.1 with qiskit-ibm-runtime 0.48.0 and qiskit-aer. Questions marked [deep dive] get extended analysis — they are the 15 hardest on the paper.

Answer Key

Q	Ans	Q	Ans	Q	Ans	Q	Ans
1	B	18	C	35	C	52	A
2	C	19	B	36	D	53	D
3	D	20	A	37	A	54	B
4	A	21	D	38	B	55	A
5	B	22	B	39	C	56	C
6	C	23	B, C	40	D	57	D
7	A	24	A	41	A	58	B
8	D	25	C	42	B	59	A
9	B	26	B	43	C	60	C
10	C	27	D	44	A	61	B
11	D	28	A	45	D	62	D
12	A	29	C	46	B	63	C
13	B	30	B	47	C	64	A
14	C	31	D	48	A	65	B
15	B	32	C	49	A, C	66	C
16	D	33	A	50	B	67	D
17	A	34	B	51	C	68	A

Section 1 — Create Quantum Circuits (Q1–Q12)

Q1 — B (4). [deep dive] Barriers do not contribute to depth(). The longest gate path is h(0) → cx(0,1) → cx(1,2), which is 3 layers; both the explicit barrier() and the barrier that measure_all() inserts are ignored by the depth calculation, and the three measurements all fit in one additional parallel layer. Total: 3 + 1 = 4 (verified: prints 4). The trap answers count one or both barriers as layers (5, 6) or forget the measurement layer (3). Remember: depth() measures the critical path of operations; barriers only constrain scheduling, they are not operations with duration in this metric.

Q2 — C ({'h': 2, 'cx': 2} 4). [deep dive] The trap is assuming a.compose(b.inverse()) cancels. b is cx then h, so b.inverse() is h then cx (order reversed, each gate inverted; H and CX are their own inverses). Composing gives h, cx, h, cx — which is not the identity because a was h then cx, i.e. b.inverse() ≠ a.inverse(). Nothing cancels structurally, and compose performs no algebraic simplification anyway: even truly canceling gates would still appear in count_ops(). Verified output: {'h': 2, 'cx': 2} 4.

Q3 — D. [deep dive] h(0); cx(0,1) gives (|00⟩+|11⟩)/√2. x(1) flips qubit 1 (the left character in little-endian labels): |00⟩→|10⟩, |11⟩→|01⟩, producing the triplet (|01⟩+|10⟩)/√2. The final z(1) puts a −1 on every component where qubit 1 is |1⟩, i.e. on |10⟩, yielding (|01⟩−|10⟩)/√2 = |Ψ⁻⟩ (verified statevector: [0, +0.7071, −0.7071, 0]). Option B stops at the triplet |Ψ⁺⟩; option C produces |Φ⁻⟩ = (|00⟩−|11⟩)/√2.

Q4 — A (≈50/50). [deep dive] List binding follows the order of circuit.parameters, which is alphabetical by name, not gate-insertion order. Verified: qc.parameters is [phi, theta], so [π, π/2] binds phi=π, theta=π/2. The circuit is rx(π/2) then rz(π): rx(π/2) puts the qubit on the equator (50/50 in Z), and rz only changes phase, which Z-basis measurement cannot see. The bait answer B (100% '1') is what you get if you bind by insertion order (theta=π). Verified probabilities: {'0': 0.5, '1': 0.5}.

Q5 — B. Gates render left→right in application order with q_0 on top: H on q_0, then a CX with control dot on q_0 and ⊕ box on q_2, X box on q_1, and finally CZ drawn as two connected dots on q_1/q_2 (CZ is symmetric — no box). Option B is the character-exact draw('text') output (verified). Option A draws the CX backwards; C and D change the wiring.

Q6 — C. Classical feedforward in v2.x uses the if_test context manager, whose as else_ handle opens the else branch. c_if (option A) is the removed legacy API, and option B is ordinary Python that executes at build time, not at circuit runtime. The snippet in C builds successfully (verified: circuit contains one if_else operation).

Q7 — A. [deep dive] In compose(sub, qubits=[2, 0]) the list maps sub's qubit i to base's qubits[i]: sub-qubit 0 → base-qubit 2 and sub-qubit 1 → base-qubit 0. So H lands on qubit 2 and the CX has control 2, target 0 (verified: h [2], cx [2, 0]). Composing a smaller circuit into a larger one is explicitly allowed — option D is false; it is the reverse (bigger into smaller without a qubit map) that fails.

Q8 — D. In standard teleportation (message on q0, Bell pair on q1–q2), after cx(0,1); h(0) and measuring both, the receiver applies X conditioned on q1's bit and Z conditioned on q0's bit. The X undoes the bit-flip correlation carried through the CX; the Z undoes the phase revealed by the H-then-measure on the message qubit. Each correction is independent, not joint (eliminating A and C).

Q9 — B ({'rz': 2, 'sx': 1}). The standard Euler decomposition of H in the {rz, sx, x} basis is rz(π/2)·sx·rz(π/2) — two RZs sandwiching one √X (verified). RZ gates are virtual (frame updates) on IBM hardware, which is exactly why this basis is chosen.

Q10 — C. Levels 0→3 add progressively heavier optimization (level 2 is the default in v2.x, and level 3 adds the most aggressive resynthesis, costing compile time). Level 0 still performs layout/routing when a backend/coupling map is given — it must, or the circuit could not run at all (A false). No optimization level touches error mitigation (D false).

Q11 — D (8). width() = total qubits + total clbits. AncillaRegister qubits are ordinary qubits for counting purposes: 3 + 2 qubits + 3 clbits = 8 (verified). Answer B counts only qubits; A only the main register.

Q12 — A (True). power(2) composes the circuit with itself, and S·S = Z exactly (S is the square root of Z), so the operators are equivalent (verified True). power works on any circuit, and no transpilation is needed to compare Operators.

Section 2 — Perform Quantum Operations (Q13–Q23)

Q13 — B. Pauli strings are little-endian: the rightmost character acts on qubit 0. In Pauli('XZ'), Z acts on qubit 0 and X on qubit 1. This is the single most classic trap on the exam.

Q14 — C. simplify() merges the duplicate XZ terms (1.0 + 1.0 = 2) and drops the zero-coefficient YY term, leaving SparsePauliOp(['XZ', 'II'], coeffs=[2.+0.j, 2.+0.j]) (verified exactly). Option B forgets to drop the zero term; D wrongly merges distinct Paulis.

Q15 — B. The label '01' means qubit 1 = |0⟩, qubit 0 = |1⟩, so the basis index is binary 01 = 1 and the amplitude sits at position 1: [0, 1, 0, 0] (verified). Option A (index 2) is the big-endian misread.

Q16 — D. H+CX makes (|00⟩+|11⟩)/√2, then x(1) flips the left bit of each label: {'01': 0.5, '10': 0.5} (verified). Option A forgets the X; answer keys with '00'/'11' misapply the flip to qubit 0.

Q17 — A. HZH = X is a fundamental conjugation identity (H swaps the X and Z axes of the Bloch sphere). Verified via Operator.equiv. The dual identity HXH = Z is equally exam-worthy.

Q18 — C (1.0 1.0 0.0). For |Φ⁺⟩ the qubits are perfectly correlated in both the Z and X bases, so ⟨ZZ⟩ = ⟨XX⟩ = +1, while each single qubit alone is maximally mixed, so ⟨ZI⟩ = 0 (verified). Any option with a nonzero single-qubit expectation contradicts entanglement.

Q19 — B (True False). [deep dive] RZ(π) = diag(e^{−iπ/2}, e^{iπ/2}) = −i·Z: it differs from Z by the global phase −i. Operator.equiv() compares up to global phase → True; == compares matrices element-wise → False (verified). This distinction — equivalence up to global phase vs exact equality — is exactly why transpilers may replace Z with RZ(π) freely, and why Operator(qrz) == Operator(zc) is the wrong test for physical equivalence. Remember rz(θ) = exp(−iθZ/2) has determinant 1 (SU(2)), while Z itself has determinant −1.

Q20 — A. from_sparse_list takes (pauli_chars, qubit_indices, coeff) tuples plus num_qubits, placing Z on qubit 2 → 'IZII' (verified). Option B's 'ZIII' puts Z on qubit 3 (little-endian!), C passes a nonexistent kwarg to from_list, and D is not a real Pauli signature.

Q21 — D (XZ ZX). [deep dive] a.tensor(b) returns a ⊗ b with a on the higher-indexed qubits — label 'XZ' (X on qubit 1, Z on qubit 0). a.expand(b) is the reverse ordering, b ⊗ a — label 'ZX' (verified: XZ ZX). Mnemonic: tensor keeps self first in the label (self becomes most significant); expand pushes self to the least-significant end. Combined with little-endian reading, this is a double-trap: in 'XZ' the Z is the qubit-0 operator.

Q22 — B (0.5). Fidelity between pure states is |⟨ψ|φ⟩|². ⟨+|0⟩ = 1/√2, so fidelity = 1/2 (verified 0.4999…). Option A (0.7071) is the overlap amplitude, not its square.

Q23 — B and C. [deep dive] Single-qubit X and Z anticommute (A ✗), as do X and Y (D ✗). But XX and ZZ commute: on each factor there is one anticommutation, and (−1)·(−1) = +1 across the tensor product — verified numerically. This "even number of anticommuting positions" rule is how stabilizer pairs like XX, ZZ coexist. RZ(θ) = exp(−iθZ/2) is a function of Z, and every operator commutes with functions of itself, so Z and rz(0.7) commute (verified). Two-qubit Paulis built from anticommuting singles commuting pairwise is a favorite "sounds wrong but is right" exam item.

Section 3 — Run Quantum Circuits (Q24–Q33)

Q24 — A. service.least_busy(operational=True, simulator=False) returns the online real device with the fewest pending jobs. The other calls are invented APIs — least_busy is a method of the service, filtered by keyword arguments.

Q25 — C. V2 primitives on IBM hardware reject non-ISA circuits: the circuit must already be expressed in the backend's basis gates and satisfy its connectivity. There is no server-side auto-transpilation in the v2 workflow — transpile locally with generate_preset_pass_manager first.

Q26 — B. Iterative, feedback-dependent workloads are exactly what Session mode exists for: within the session window, successive jobs skip re-queuing. Batch (A) is for independent jobs; a bare for loop in job mode (C) re-queues on every iteration.

Q27 — D. 500 independent circuits with no inter-job feedback are the textbook Batch case: jobs are scheduled together, can run back-to-back or in parallel, and there is no state shared between them. Session would reserve the device unnecessarily.

Q28 — A. Passing a backend object as mode= runs the primitive in job mode: SamplerV2(mode=backend) then sampler.run([isa_circuit]) (note the list of PUBs). backend.run and execute are removed v1-era APIs.

Q29 — C. An ideal GHZ measurement yields only '000' and '111', each around 50% with shot noise (497/503 is plausible). Option B has no superposition; A and D contain outcomes with zero ideal amplitude.

Q30 — B (2048 1024). [deep dive] Shots resolve in priority order: PUB-level > run-level > option default. The first PUB explicitly carries shots=2048 in its third slot, overriding the run's shots=1024; the second PUB has no PUB-level value, so it inherits 1024 (verified: 2048 1024). This per-PUB override is a deliberate V2 design feature — different PUBs in one job can use different shot budgets — and it appears on the real exam in both Sampler and Estimator (precision) forms.

Q31 — D. Fake backends snapshot a real device's coupling map, basis gates, and noise calibration data, and run locally on Aer. They let you exercise the full transpile→ISA→primitive workflow (including realistic noise) without queue time or cost. They never contact the real device (A false).

Q32 — C. pm.run(qc) returns a new transpiled circuit; it does not mutate qc. The code then submits the original qc, which still contains h and has no layout, so the runtime rejects it as non-ISA. Classic "transpiled but submitted the wrong variable" integration bug.

Q33 — A. Since mid-2025 the platform channel is "ibm_quantum_platform"; save_account(channel=..., token=..., set_as_default=True) persists credentials for later no-argument QiskitRuntimeService() construction. "ibm_quantum" (B) is the retired channel name, and IBMQ (D) was removed with qiskit-ibmq-provider.

Section 4 — Use the Sampler Primitive (Q34–Q41)

Q34 — B. QuantumCircuit(2, 2) creates a default classical register named c, so the samples live at result[0].data.c. The meas field only exists when measure_all() created its own register named meas. Verified: .data.meas raises AttributeError; .data.c.get_counts() gives {'01': 1024}.

Q35 — C ({'10': 100}). x(1) sets qubit 1, and in little-endian bitstrings qubit 1 is the left character of a 2-bit string: '10' (verified). Option A is the big-endian misread.

Q36 — D. Verified behavior: StatevectorSampler emits the warning "One of your circuits has no output classical registers and so the result will be empty..." and returns an empty DataBin(). It does not implicitly measure (A) and does not hard-error (B) — a subtle but tested distinction from the Estimator, which does raise on measured circuits.

Q37 — A ({'1': 200}). RY(π)|0⟩ = |1⟩ exactly, so every shot reads 1 (verified). PUB parameter values may be lists/arrays — a dict is not required (D false).

Q38 — B. Idle-qubit decoherence is addressed by dynamical decoupling, an error suppression technique: pulse sequences (XX, XpXm, XY4) inserted into idle windows. resilience_level (A) doesn't exist on Sampler, and more shots (D) do nothing against coherent idling errors.

Q39 — C. Verified: setting sampler.options.resilience_level = 1 raises a ValidationError ("Object has no attribute 'resilience_level'"). Resilience levels configure Estimator error mitigation; SamplerV2 offers twirling, dynamical decoupling, and shot options only.

Q40 — D ({'01': 50}). [deep dive] join_data() concatenates the classical registers in the order they were added, with earlier registers in the less-significant (rightmost) position — the same convention Qiskit uses when a circuit has multiple cregs. Register first holds 1 (X on qubit 0), second holds 0, so the joined string reads second first = '01' (verified). Option A is the "registers concatenate left-to-right as added" misconception. If you ever doubt the order, check result[0].data.first.get_counts() per register instead.

Q41 — A ((100, 2, 100)). num_shots is the shot count (100), num_bits the register width (2), and get_bitstrings() returns one string per shot — length 100, not the number of distinct outcomes (verified). Option B confuses bitstrings with the counts dictionary.

Section 5 — Use the Estimator Primitive (Q42–Q49)

Q42 — B ([1. 1. 0.]). Same physics as Q18, now through the Estimator API: an observables list inside one PUB returns an evs array with one entry per observable — ⟨ZZ⟩=1, ⟨XX⟩=1, ⟨ZI⟩=0 (verified).

Q43 — C. Verified: the run fails with QiskitError: 'Cannot apply instruction with classical bits: measure'. Estimator circuits must be measurement-free — the observable itself defines the measurement basis; this is the mirror image of the Sampler's must-have-measurements rule.

Q44 — A. [deep dive] The end-to-end order matters at every step: (1) transpile to ISA with a backend-aware pass manager; (2) map the observable with observable.apply_layout(isa.layout) — the layout comes from the transpiled circuit; (3) run the Estimator with the ISA circuit and the mapped observable; (4) read .data.evs. Option B skips apply_layout, so the ZZ would act on physical qubits 0–1 regardless of where the logical qubits were placed — silently wrong answers on hardware. Option C calls apply_layout(bell.layout) — the untranspiled circuit's layout is None. Option D inverts the call: apply_layout is a method of the observable, not the circuit. This is the single most integration-heavy pattern on the exam; know it cold.

Q45 — D. [deep dive] PUB broadcasting follows NumPy rules: observables shaped (2, 1) broadcast against 3 parameter sets shaped (3,) to give evs.shape == (2, 3) (verified). Row 0 is ⟨Z⟩ over the rx sweep: cos(0)=1, cos(π/2)=0, cos(π)=−1. Row 1 is ⟨X⟩, which is identically 0 for any rx(θ)|0⟩ since the state stays in the Y–Z plane (verified output [[1. 0. -1.], [0. 0. 0.]]). Option C is wrong because shapes need only be broadcast-compatible, not identical — the (2,1)-vs-(3,) pairing is the canonical "outer product" sweep pattern.

Q46 — B. Runtime Estimator defaults to resilience level 1 = measurement-error mitigation (TREX); level 2 adds ZNE; level 0 disables everything. PEC is never on by default — it must be explicitly enabled and is exponentially expensive.

Q47 — C. [deep dive] ZNE is configured through the nested resilience options: resilience.zne_mitigation = True, then resilience.zne.noise_factors = (1, 3, 5) and resilience.zne.extrapolator = "exponential" (verified accepted by EstimatorV2 0.48.0). There is no resilience level 3 (B), no top-level options.zne dict (A), and ZNE has nothing to do with dynamical decoupling sequences (D). Conceptual anchor: noise factors scale the noise (1 = raw), measurements are taken at each factor, and the extrapolator fits back to the zero-noise limit — a post-processing mitigation, not suppression.

Q48 — A (0.5). ⟨Z⟩ after rx(θ) on |0⟩ is cos θ; cos(π/3) = 0.5 (verified 0.5000…). Option B is cos(π/6) — the wrong angle.

Q49 — A and C. Suppression acts before/during execution: dynamical decoupling (pulse insertion) and Pauli twirling (randomized compiling). Mitigation is classical post-processing of noisy results: ZNE and PEC. The suppression/mitigation split is a stated exam objective.

Section 6 — Visualization (Q50–Q57)

Q50 — B. The diagram shows H then Z on q_0 (left→right), control dot on q_0 with target ⊕ on q_1, then measurements to clbits 0 and 1. Verified as the exact draw('text') output of option B. Option A swaps H/Z order; option D reverses the CX direction.

Q51 — C. reverse_bits=True flips the wire order so the highest-index qubit is drawn on top — the big-endian textbook convention. It only changes the drawing, not the circuit. The other options are invented arguments.

Q52 — A. Each panel of plot_bloch_multivector shows the reduced single-qubit state. For a Bell state each reduced state is I/2 (maximally mixed), whose Bloch vector has length zero — arrows collapse to the center. Zero-length per-qubit vectors are the visual fingerprint of entanglement.

Q53 — D. On the qsphere, blob size encodes the basis state's probability and blob color encodes its relative phase; position on the sphere encodes the basis state (Hamming weight = latitude). Arrows/lengths (B) describe the Bloch sphere, not the qsphere.

Q54 — B. x(2) sets qubit 2, the leftmost character of a 3-bit little-endian string: a single bar at '100' (verified counts {'100': 100}). Option A is the endianness trap.

Q55 — A. plot_histogram accepts a list of counts dicts plus a legend list of labels, drawing grouped bars (verified call succeeds). There is no labels=/overlay= API, and summing dicts (B) is a TypeError.

Q56 — C. (|0⟩ − i|1⟩)/√2 = |−i⟩, the −Y eigenstate. The Bloch axis map to memorize: |0⟩/|1⟩ = ±Z, |±⟩ = ±X, |±i⟩ = ±Y; the amplitude of |1⟩ (here −i) picks the Y-axis sign.

Section 7 — Retrieve and Analyze Results (Q58–Q64)

Q58 — B. Runtime jobs persist server-side: reconstruct the service, call service.job(job_id), then .result(). Nothing depends on the original Python session (D false); retrieval is a service method, not a primitive classmethod (A false).

Q59 — A (0.2). ⟨Z⟩ = (n₀ − n₁)/shots = (600 − 400)/1000 = 0.2. Option B is the raw probability of '0', not the expectation value.

Q60 — C. Standard error scales as 1/√shots, so halving the error needs 4× the shots. This inverse-square-root law is also why chasing one more decimal digit costs 100× the QPU time.

Q61 — B. A PrimitiveResult contains one PubResult per submitted PUB in submission order: len(result) is 3 and the second PUB is result[1] (zero-indexed). PUBs are never merged or deduplicated.

Q62 — D. job.usage() reports consumed QPU seconds — the billable quantity — and job.metrics() adds timestamps and execution spans. Job status objects (A) carry no timing, and result metadata (B) has no wall-clock field.

Q63 — C (0.6). ⟨ZZ⟩ assigns +1 to even-parity strings ('00', '11') and −1 to odd-parity ('01', '10'): (400+400−100−100)/1000 = 0.6. Option A forgets the odd-parity subtraction.

Q64 — A. Ideal GHZ output has support only on '000' and '111'; the small extra bars are gate and readout errors populating classically impossible outcomes. SWAP insertion (D) changes qubit mapping, which the layout bookkeeping undoes — it does not add spurious outcomes by itself.

Section 8 — Operate with OpenQASM (Q65–Q68)

Q65 — B. Verified: qasm3.dumps emits OPENQASM 3.0;, include "stdgates.inc";, then bit[2] c; / qubit[2] q; declarations and per-bit measurement assignments c[0] = measure q[0];. Options A/D use QASM 2's qreg/creg/measure -> forms; C capitalizes gates and drops the include.

Q66 — C. [deep dive] Trace it: x q[0] sets q0=1; h q[1] puts q1 in superposition; cx q[1],q[0] uses q1 as control (first argument) and q0 as target. Branch q1=0: q0 stays 1 → string '01' (q1 q0). Branch q1=1: q0 flips to 0 → '10'. Result: {'01': ~50%, '10': ~50%} (verified: {'01': 507, '10': 493}). Wrong answer A comes from misreading the control as q0 or assuming a Bell state on |00⟩; the pre-existing X breaks that symmetry. QASM argument order — cx control,target — plus little-endian output is a compound trap.

Q67 — D. OpenQASM 3 adds typed classical data, input parameters, and real-time classical control flow (if, while, for) — the features that make dynamic circuits expressible. include, cx, and classical registers all already existed in QASM 2.

Q68 — A. qasm3.load(path) reads a file; qasm3.loads(string) parses a program string (mnemonic: the trailing s = string, as in json.load/loads). Passing a filename to loads (B) tries to parse the literal text "teleport.qasm" as QASM. dump/dumps go the other direction.

Scoring: 47+ = pass. 15 deep-dive questions: Q1, Q2, Q3, Q4, Q7, Q19, Q21, Q23, Q30, Q36 (see its explanation), Q40, Q44, Q45, Q47, Q66. If you missed more than two of {Q13, Q15, Q35, Q54, Q66}, drill little-endian ordering again before exam day.