All code facts verified with qiskit 2.5.1 / qiskit-ibm-runtime 0.48.0.

MCQ Answers

Q1 — B. The Estimator computes expectation values ⟨ψ|O|ψ⟩ of observables with respect to the state prepared by the circuit. Counts come from the Sampler (A), statevectors from Statevector/simulators (C); quasi-probabilities (D) were a V1 Sampler concept.

Q2 — C. Estimator circuits must NOT contain measurements — the observable defines the measurement basis. Verified locally: StatevectorEstimator raises QiskitError: 'Cannot apply instruction with classical bits: measure'.

Q3 — C. Estimator PUB ordering is (circuit, observables, parameter_values[, precision]). Compare Sampler: (circuit, parameter_values, shots) — observables slot in between circuit and parameters for the Estimator. A swaps obs/params, B puts the observable first, D describes no real API.

Q4 — B. SparsePauliOp (e.g. SparsePauliOp.from_list([("ZZ", 0.5), ("XI", 0.3)])) is the canonical observable type. Operator is a dense matrix, not the standard observable input; the others are unrelated.

Q5 — B. isa_obs = obs.apply_layout(isa_circuit.layout). It is a method on the observable that takes the transpiled circuit's layout, expanding the observable to the backend width and permuting Paulis onto the physical qubits. C has the call backwards; D is false — no automatic remapping happens.

Q6 — A. Verified error text: ValueError: The number of qubits of the circuit (5) does not match the number of qubits of the ()-th observable (2). No padding or NaN fallback exists.

Q7 — C. NumPy-style broadcasting: (3, 1) observables × (4,) parameter sets broadcast to (3, 4). Verified: result[0].data.evs.shape == (3, 4).

Q8 — A. Standard errors live next to the expectation values in the PUB result's data bin: result[0].data.evs and result[0].data.stds. metadata holds target_precision, shots, etc., not the stds array.

Q9 — B. Precision is the target standard error; shots scale ~1/precision². Verified locally on a fake backend: 0.1 → 100 shots, 0.05 → 400 shots, 0.01 → 10,000 shots. A is backwards (smaller precision = more shots); C is false — precision can be set per PUB, per run call, or via default_precision; D is false.

Q10 — B. Default is resilience level 1: minimal mitigation = measurement (readout) error mitigation via TREX (with measurement twirling). Level 0 is opt-in "raw", level 2 adds ZNE, and there is no level 3 for EstimatorV2 — setting 3 raises ValidationError (verified).

Q11 — C. Level 2 = everything in level 1 (TREX measurement mitigation) plus ZNE (and gate twirling). PEC is never enabled by a resilience level; DD is a separate suppression option at any level.

Q12 — B. Verified paths on runtime 0.48.0: est.options.resilience.zne_mitigation = True and est.options.resilience.zne.noise_factors = (1, 3, 5) (plus est.options.resilience.zne.extrapolator = "exponential"). The other paths don't exist.

Q13 — B. Valid extrapolators include "linear", "exponential", "polynomial_degree_k" (e.g. "polynomial_degree_2"), and "fallback". Verified: "exponential", "linear", "polynomial_degree_2" are accepted; an invalid name raises ValidationError.

Q14 — C. Runtime ZNE amplifies noise by digital gate folding — two-qubit gates are replaced with equivalent longer sequences (U → U U†U gives noise factor 3). Pulse amplitude/T1 manipulation is not how it works; random Paulis describe twirling. (The alternative amplifier is PEA: options.resilience.zne.amplifier = "pea".)

Q15 — A. options.resilience.measure_mitigation = True enables TREX directly; tuning lives under options.resilience.measure_noise_learning.* (verified). B enables measurement twirling (suppression-side ingredient), not the mitigation itself; C doesn't exist; D is dynamical decoupling.

Q16 — B. PEC returns an unbiased estimate but with sampling overhead scaling with γ², where γ grows exponentially with circuit depth. It must be enabled explicitly (options.resilience.pec_mitigation = True, cap via options.resilience.pec.max_overhead), is post-processing-based mitigation, and is an Estimator-only resilience option.

Q17 — B. Suppression = dynamical decoupling + Pauli twirling (act on the circuits during execution). Mitigation = TREX, ZNE, PEC (classical post-processing of expectation values).

Q18 — B. Suppression changes what is physically executed (inserted DD pulses, twirled gates) to reduce/reshape errors up front; mitigation processes the noisy outputs afterward (possibly using extra calibration/noise-amplified executions) to estimate the noise-free value. A is wrong — suppression isn't free (twirling needs randomizations) and the distinction isn't cost; C and D are false.

Q19 — B. DD inserts identity-equivalent pulse sequences on idle qubits to cancel coherent errors during gaps. On densely packed circuits it may not help and can even hurt due to imperfect pulses (per the IBM error-suppression guide).

Q20 — C. Verified by attribute inspection on runtime 0.48.0: EstimatorV2 options have default_precision, default_shots, resilience_level, and resilience.*; SamplerV2 options have default_shots but no default_precision and no resilience. Both share dynamical_decoupling and twirling (suppression applies to both primitives).

Lab Solutions

Run with /home/kartikey_purohit/development/ibm-qiskit/.venv/bin/python.

Lab 1 — Bell-state observable safari

Predictions for (|00⟩ + |11⟩)/√2: ⟨ZZ⟩ = 1, ⟨XX⟩ = 1, ⟨YY⟩ = −1, ⟨ZI⟩ = 0, ⟨IZ⟩ = 0, ⟨XY⟩ = 0.

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
 
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
 
labels = ["ZZ", "XX", "YY", "ZI", "IZ", "XY"]
obs = [SparsePauliOp(l) for l in labels]
 
result = StatevectorEstimator().run([(qc, obs)]).result()
print(dict(zip(labels, result[0].data.evs.round(6))))
# {'ZZ': 1.0, 'XX': 1.0, 'YY': -1.0, 'ZI': 0.0, 'IZ': 0.0, 'XY': 0.0}
print(result[0].data.evs.shape)   # (6,)
print(result[0].data.stds)        # all 0.0 — exact statevector simulation

Why: the Bell state is a +1 eigenstate of ZZ and XX and a −1 eigenstate of YY (ZZ·XX = −YY on the stabilizer group). Single-qubit Z's average to 0 because each qubit alone is maximally mixed. Bonus: evs.shape == (6,) (list of 6 observables broadcast against no parameters), and stds is all zeros for the exact simulator.

Lab 2 — Broadcasting grid

Predicted shape: (3, 4). Predicted matrix (rows Z, X, Y; columns θ = 0, π/2, π, 3π/2):

Z: [ 1,  0, -1,  0]      <Z> = cos(theta)
X: [ 0,  1,  0, -1]      <X> = sin(theta)
Y: [ 0,  0,  0,  0]      RY keeps the state in the X-Z plane, so <Y> = 0

import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
 
theta = Parameter("theta")
pqc = QuantumCircuit(1)
pqc.ry(theta, 0)
 
params = [[0.0], [np.pi/2], [np.pi], [3*np.pi/2]]                       # shape (4, 1)
obs = [[SparsePauliOp("Z")], [SparsePauliOp("X")], [SparsePauliOp("Y")]]  # shape (3, 1)
 
result = StatevectorEstimator().run([(pqc, obs, params)]).result()
print(result[0].data.evs.shape)          # (3, 4)
print(np.round(result[0].data.evs, 3))
# [[ 1.  0. -1. -0.]
#  [ 0.  1.  0. -1.]
#  [ 0.  0.  0.  0.]]

Flat-list variant: observables shape (3,) vs parameter sets shape (4,) are not broadcast-compatible (3 vs 4), so the PUB is rejected with a broadcasting error — you need the (3, 1) column shape to get the outer-product grid. (Shapes (n,) and (n,) would pair element-wise instead.)

Lab 3 — The apply_layout gauntlet + precision economics

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit_ibm_runtime import EstimatorV2 as Estimator
 
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
obs = SparsePauliOp("ZZ")
 
backend = FakeManilaV2()
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_circuit = pm.run(qc)                 # 5 qubits now
est = Estimator(mode=backend)
 
# (a) untranspiled observable -> ValueError (verified):
# "The number of qubits of the circuit (5) does not match the number of
#  qubits of the ()-th observable (2)."
try:
    est.run([(isa_circuit, obs)]).result()
except ValueError as e:
    print(type(e).__name__, e)
 
# (b) fix with apply_layout
isa_obs = obs.apply_layout(isa_circuit.layout)   # becomes 5-qubit 'IIIZZ'-style op
result = est.run([(isa_circuit, isa_obs)]).result()
print(result[0].data.evs)   # ~0.85-0.92 (verified run gave ~0.88) — noise pulls it below 1.0
 
# (c) precision -> shots (shots = 1/precision**2, verified)
for p in (0.1, 0.05, 0.01):
    r = est.run([(isa_circuit, isa_obs)], precision=p).result()
    print(p, "->", r[0].metadata["shots"], "shots")
# 0.1  -> 100 shots
# 0.05 -> 400 shots
# 0.01 -> 10000 shots

Predictions explained:

(a) The exception is a ValueError about mismatched qubit counts — this is the apply_layout exam trap.
(b) The fake backend has realistic noise, so ⟨ZZ⟩ lands noticeably below the ideal 1.0 (about 0.88 in the verified run; exact value varies with seed/noise model).
(c) shots = 1/precision² exactly: 100, 400, 10,000. This is why asking for 10× better precision costs 100× the shots — the core precision-vs-shots relation to remember.