All code claims verified with .venv (qiskit 2.5.1, qiskit-ibm-runtime 0.48.0, qiskit-aer 0.17.2).

Q1 — B. Sampler returns per-shot samples / bitstring counts from the circuit's classical registers. A describes the Estimator (Sampler PUBs never contain observables). C describes the deprecated V1 Sampler (quasi-distributions). D is Statevector / quantum_info, not a primitive.

Q2 — B. measure_all() auto-creates a classical register named meas, so the data lives at result[0].data.meas. Accessing .data.c raises AttributeError: 'DataBin' object has no attribute 'c' (verified). .c only exists when the circuit's creg is actually named c (e.g. QuantumCircuit(2, 2)).

Q3 — C. Sampler PUB shapes: (circuit,), (circuit, parameter_values), (circuit, parameter_values, shots) — shots is always the third element. For an unparameterized circuit use (circuit, None, shots). Observables (B) never appear in Sampler PUBs.

Q4 — B. Verified: run([(qc, None, 333)], shots=1000) gives num_shots == 333. Precedence: per-PUB shots > run(shots=) > options.default_shots > built-in default.

Q5 — B. One PubResult per PUB, in submission order, zero-indexed: qc_b → result[1]. With measure_all() the creg is meas. PrimitiveResult has no get_counts and no .data.

Q6 — A. num_shots = shots executed (512); num_bits = number of classical bits in the register (3). Verified pattern: BitArray(<shape=(), num_shots=512, num_bits=3>).

Q7 — C. get_bitstrings() returns the raw per-shot record — a list of strings whose length equals num_shots (verified: repeated entries like ['11', '11', '00', ...]). The dict of counts is get_counts(); integers come from get_int_counts().

Q8 — B. {'01': 10}, verified. Default join_data() concatenates registers in circuit order with the first register in the rightmost (least significant) position — little-endian. Register a always reads 1 and sits rightmost → '01'. Explicit name ordering follows the same rule (first-listed → rightmost), so res.join_data(['b', 'a']) gives {'10': 10} (verified).

Q9 — D. Verified: sampler.options.resilience_level = 1 raises ValidationError: Object has no attribute 'resilience_level'. Resilience/error mitigation (TREX, ZNE, PEC, resilience_level) is EstimatorV2-only. Sampler offers only error suppression: dynamical decoupling and twirling. A, B, C are all valid (verified).

Q10 — B. Valid literals are exactly 'XX', 'XpXm', 'XY4' (docs: Literal['XX', 'XpXm', 'XY4']; anything else raises ValidationError — verified with "YY").

Q11 — A. TwirlingOptions fields (verified by printing the options object): enable_gates, enable_measure, num_randomizations, shots_per_randomization, strategy. zne_factors and resilience_level are Estimator-side concepts; C invents names.

Q12 — B. Exam canon: Sampler circuits must contain measurements. (Fine print, verified: in qiskit 2.5.1 / runtime 0.48.0 a measurement-free circuit does not raise — it emits a UserWarning "…no output classical registers and so the result will be empty…" and returns an empty result. Either way you get no data; nothing is auto-measured and there is no observable.)

Q13 — B. QuantumCircuit(2, 2) creates the default classical register named c → result[0].data.c.get_counts() (verified). .data.meas would be an AttributeError here — the mirror image of Q2.

Q14 — A. service.job(job_id) (singular) retrieves one job by ID string — jobs live server-side and survive kernel restarts. service.jobs() (plural) takes filter kwargs, not an ID positional lookup. There is no SamplerV2.retrieve.

Q15 — A. Verified signature of QiskitRuntimeService.jobs: jobs(limit=10, skip=0, backend_name=None, pending=None, program_id=None, instance=None, job_tags=None, session_id=None, created_after=None, created_before=None, descending=True). pending=True filters to queued/running. B, C, D use nonexistent methods/kwargs.

Q16 — B. job.usage() returns QPU seconds consumed. job.metrics() returns a broader dict (timestamps, usage estimation, versions). No qpu_time attribute.

Q17 — C. P('11') = 588 / 1000 = 0.588. Probabilities are always count/shots from the actual data; the ideal 50/50 (B) is not what this run estimated — finite-shot noise (and possibly hardware noise) makes the empirical value the answer.

Q18 — B. ⟨Z⟩ = (n₀ − n₁)/shots = (300 − 700)/1000 = −0.4. Eigenvalue +1 for |0⟩, −1 for |1⟩. A flips the sign; C/D are probabilities, not an expectation value.

Q19 — B. Error ∝ 1/√shots, so halving the error needs 4× shots: 1000 → 4000. (Verified empirically in the lesson: ~0.16 deviation at 100 shots vs ~0.01 at 10 000.)

Q20 — A. PrimitiveResult is an iterable of PubResults (one per PUB), with job-level result.metadata (e.g. {'version': 2}) and per-PUB result[0].metadata (e.g. {'shots': 1024, 'circuit_metadata': {}}) — all verified. Data (bitstrings/counts) lives in .data, never in .metadata.

Lab Solutions

Lab 1 — The register detective

Verified output (your high/h(1) numbers will vary ~500/500):

res.data has attributes low and high — one per classical register, named after the registers. res.data.c raises AttributeError: no register named c exists (that name only appears when you use the QuantumCircuit(n, m) shortcut).
res.data.low.get_counts() → {'1': 1000} (qubit 0 has an X, always 1). res.data.high.get_counts() → roughly {'0': ~500, '1': ~500} (qubit 1 is in |+⟩).
res.join_data().get_counts() → keys '01' and '11', each ~500. Default order = circuit creg order with the first register (low) in the rightmost bit — so the always-1 bit is the RIGHT character, and only the left character varies.
res.join_data(['high', 'low']) puts high rightmost instead → keys '10' and '11'. (Same rule: first-listed name → least significant bits.)

# verified solution code
print(res.data.low.get_counts())                  # {'1': 1000}
print(res.data.high.get_counts())                 # {'0': ~500, '1': ~500}
print(res.join_data().get_counts())               # {'01': ~500, '11': ~500}
print(res.join_data(['high', 'low']).get_counts())# {'10': ~500, '11': ~500}

Lab 2 — Estimator impersonation

Verified with 8192 shots:

Only '00' and '11' appear (ideal Bell state), each with probability ≈ 0.5 (probs = {k: v/shots for k, v in counts.items()}).

⟨Z⊗Z⟩ via parity = exactly +1.0 on a noiseless simulator: every observed bitstring ('00', '11') has even parity, so every shot contributes +1.

shots = sum(counts.values())
zz = sum(v * (1 if b.count('1') % 2 == 0 else -1) for b, v in counts.items()) / shots
# 1.0  (verified)

⟨Z₀⟩ ≈ 0 (verified: −0.0024 at 8192 shots — pure shot noise, magnitude ~1/√8192 ≈ 0.011):
```
z0 = sum(v * (1 if b[-1] == '0' else -1) for b, v in counts.items()) / shots
```
Each qubit of a Bell pair is individually maximally mixed → ⟨Z⟩ = 0, even though the pair is perfectly correlated (⟨ZZ⟩ = 1). Remember: qubit 0 = rightmost character, hence b[-1].

Cross-check:

from qiskit.quantum_info import Statevector, SparsePauliOp
bell_nomeas = QuantumCircuit(2); bell_nomeas.h(0); bell_nomeas.cx(0, 1)
Statevector(bell_nomeas).expectation_value(SparsePauliOp('ZZ'))   # (1+0j)

Matches the counts-based estimate — this is exactly what EstimatorV2 automates.

Lab 3 — Shots precedence ladder

Verified output:

PUB	`num_shots`	Decided by
`job1` pub 0 `(qc,)`	512	`run(shots=512)` — no PUB shots, run-level beats `default_shots`
`job1` pub 1 `(qc, None, 128)`	128	per-PUB shots — most specific, always wins
`job2` pub 0 `(qc,)`	4096	`options.default_shots` — nothing more specific given

print(job1.result()[0].data.meas.num_shots)   # 512
print(job1.result()[1].data.meas.num_shots)   # 128
print(job2.result()[0].data.meas.num_shots)   # 4096

Ladder to memorize: PUB shots > run(shots=) > options.default_shots > built-in default (4096 for runtime SamplerV2, 1024 for StatevectorSampler).

Note observed while verifying (post-exam-content trivia): runtime 0.48.0 emits a DeprecationWarning when a single job mixes different shot counts across PUBs — real-world code should split them into separate jobs (or a Batch), but the PUB shape and precedence rules above are unchanged and are what the exam tests.