Title: CertiQ — C1000-179 / 6 · Use the estimator primitive

Question: You ran an EstimatorV2 job and stored result = job.result(). Which expression returns the estimated expectation value(s) for the first PUB?
from qiskit_ibm_runtime import EstimatorV2
# job = estimator.run([(isa_circuit, isa_observable)])
result = job.result()
value = ...  # which expression?
A.result[0].data.evs
B.result[0].data.stds
C.result[0].data.meas.get_counts()
D.result[0].quasi_dists
Answer: Correct: A
An EstimatorV2 PubResult carries a DataBin whose evs field holds the estimated expectation value(s) for that PUB (with the shape of the broadcasted observable/parameter arrays); stds holds the accompanying standard errors. result[0] selects the first PUB's result.
References
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q010 · mcq · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: The circuit prepares a Bell state. Using an exact estimator, what is the expectation value of the observable O = 0.5*ZZ + 0.5*XX?
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)
obs = SparsePauliOp(["ZZ", "XX"], coeffs=[0.5, 0.5])
print(StatevectorEstimator().run([(qc, obs)]).result()[0].data.evs)
A.0.5
B.0.0
C.1.0
D.2.0
Answer: Correct: C
The expectation value of a weighted sum of Paulis is the same weighted sum of the individual expectation values. On the Bell state (|00>+|11>)/sqrt(2) both correlators are +1: <ZZ> = 1 and <XX> = 1. So <O> = 0.5*(1) + 0.5*(1) = 1.0.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
Meta: s6-q011 · predict-output · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: You have an ISA circuit isa and a layout-aligned observable iobs, and est = EstimatorV2(mode=backend). Which call correctly submits this single estimation task?
from qiskit_ibm_runtime import EstimatorV2
est = EstimatorV2(mode=backend)
# isa: transpiled circuit, iobs: observable after apply_layout
job = ...  # which call?
A.job = est.run((isa, iobs))
B.job = est.run([(isa, iobs)])
C.job = est.run([isa, iobs])
D.job = est.run(isa, iobs)
Answer: Correct: B
EstimatorV2.run() takes a list of PUBs; each PUB is a tuple whose first two elements are the circuit and its observable(s). The single task must therefore be wrapped as [(isa, iobs)] — a list containing one (circuit, observable) tuple.
References
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
- quantum.cloud.ibm.com/docs/guides/estimator-options
Meta: s6-q012 · mcq · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: This code transpiles a 2-qubit circuit for a 5-qubit backend and then tries to estimate <ZZ>, but estimator.run(...).result() raises ValueError: The number of qubits of the circuit (5) does not match the number of qubits of the ()-th observable (2). What is the correct fix?
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import EstimatorV2
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
obs = SparsePauliOp("ZZ")
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa = pm.run(qc)
est = EstimatorV2(mode=backend)
job = est.run([(isa, obs)])   # <-- raises when result() is fetched
A.Build the observable for the ISA circuit with iobs = obs.apply_layout(isa.layout) and pass iobs.
B.Add qc.measure_all() before transpiling so the circuit and observable match.
C.Pass the backend to run: est.run([(isa, obs)], backend=backend).
D.Replace the SparsePauliOp with the plain string "ZZ".
Answer: Correct: A
Transpilation maps the 2 logical qubits onto physical qubits of the 5-qubit device, so the ISA circuit spans 5 qubits. The observable must be expanded to those same 5 qubits with obs.apply_layout(isa.layout), which pads/permutes it to match the circuit's final layout. Then the PUB is well-formed and the estimator runs.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q013 · spot-bug · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Which assignment to estimator.options.resilience_level is accepted by EstimatorV2 without raising a validation error?
from qiskit_ibm_runtime import EstimatorV2
estimator = EstimatorV2(mode=backend)
estimator.options.resilience_level = ...  # which value?
A.3
B.5
C.-1
D.2
Answer: Correct: D
The Estimator resilience_level is defined only for the values 0, 1, and 2 (0 = no mitigation, 1 = readout/TREX, 2 = adds ZNE and gate twirling). Higher levels mean more accuracy at more cost. 2 is the maximum, so it validates; any value outside 0..2 raises a pydantic ValidationError.
References
- quantum.cloud.ibm.com/docs/guides/error-mitigation-and-suppression-techniques
- quantum.cloud.ibm.com/docs/guides/runtime-options-overview
Meta: s6-q014 · mcq · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: The circuit applies X to qubit 0 only. Using an exact estimator with the two observables SparsePauliOp('ZI') and SparsePauliOp('IZ'), what is the returned [<ZI>, <IZ>]?
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
qc = QuantumCircuit(2)
qc.x(0)
obs = [SparsePauliOp("ZI"), SparsePauliOp("IZ")]
print(StatevectorEstimator().run([(qc, obs)]).result()[0].data.evs)
A.[-1.0, 1.0]
B.[1.0, -1.0]
C.[1.0, 1.0]
D.[-1.0, -1.0]
Answer: Correct: B
Pauli-string labels are little-endian: the right-most character acts on qubit 0 and the left-most on the highest-indexed qubit. Only qubit 0 is flipped to |1>. In 'ZI' the Z is on qubit 1 (still |0>, eigenvalue +1); in 'IZ' the Z is on qubit 0 (|1>, eigenvalue -1). So [<ZI>, <IZ>] = [+1, -1].
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
Meta: s6-q015 · predict-output · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: You want a single EstimatorV2 job to target a tighter accuracy on its expectation value. Which call is valid?
from qiskit_ibm_runtime import EstimatorV2
est = EstimatorV2(mode=backend)
# isa: ISA circuit, iobs: layout-aligned observable
job = ...  # which call?
A.est.run([(isa, iobs)], shots=8000)
B.est.run([(isa, iobs)], resilience_level=2)
C.est.run([(isa, iobs)], precision=0.01)
D.est.run([(isa, iobs)], shots=8000, precision=0.01)
Answer: Correct: C
The Estimator's accuracy knob is precision — the target standard error of the estimate. It is the only run-time keyword EstimatorV2.run() accepts (besides the PUB list), overriding default_precision for that job. A smaller precision value means a more accurate (and more expensive) estimate.
References
- quantum.cloud.ibm.com/docs/guides/estimator-options
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q016 · mcq · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: The Estimator precision is the target standard error of an expectation value. If you tighten precision from 0.02 to 0.01 (halve it), approximately how does the number of shots the estimator must collect change?
A.It increases by about 2x.
B.It increases by about 4x.
C.It increases by about 16x.
D.It is unchanged — precision does not affect the number of shots.
Answer: Correct: B
The standard error of a Monte-Carlo estimate falls as 1/sqrt(N), so to reach a target standard error (precision) you need N ~ 1/precision^2 shots. Halving precision (0.02 -> 0.01) therefore multiplies the required shots by (0.02/0.01)^2 = 4. Empirically, the spread of the estimate scales linearly with precision, confirming the inverse-square shot cost.
References
- quantum.cloud.ibm.com/docs/guides/estimator-options
Meta: s6-q017 · mcq · Difficulty 3/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: In a variational algorithm you need the expectation value <O> of a SparsePauliOp observable for the state your circuit prepares, to use as a cost function. Which Runtime primitive is designed for this, and what does it return?
A.SamplerV2 — it returns the expectation value(s) directly in result[0].data.evs.
B.SamplerV2 — it returns quasi-probability distributions that already equal the expectation value.
C.EstimatorV2 — it returns the expectation value(s) directly in result[0].data.evs.
D.EstimatorV2 — but you must add measure_all() and average the bitstrings yourself.
Answer: Correct: C
The Estimator primitive is purpose-built to estimate expectation values of observables. You give it (circuit, observable) PUBs and it performs the necessary basis changes and averaging internally, returning the expectation values in data.evs (with standard errors in data.stds).
References
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
- quantum.cloud.ibm.com/docs/guides/get-started-with-primitives
Meta: s6-q018 · mcq · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Select all of the following that are error MITIGATION techniques for the Estimator — methods that post-process results from an ensemble of circuits to reduce bias in expectation values (as opposed to error suppression, which prevents errors before/during execution).
A.Dynamical decoupling
B.Probabilistic error cancellation (PEC)
C.Twirled Readout Error eXtinction (TREX)
D.Raising the transpiler optimization_level
E.Zero-noise extrapolation (ZNE)
Answer: Correct: B, C, E
Error mitigation runs an ensemble of related circuits and post-processes their outputs to reduce bias in expectation values. TREX mitigates readout error, ZNE amplifies noise then extrapolates to the zero-noise limit, and PEC expresses the ideal result as a quasi-probabilistic combination of noisy circuits (unbiased, but with sampling overhead). All three are mitigation.
References
- quantum.cloud.ibm.com/docs/guides/error-mitigation-and-suppression-techniques
- quantum.cloud.ibm.com/docs/guides/estimator-noise-management
Meta: s6-q019 · multi · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: You are researching your own error-mitigation method and want EstimatorV2 to return raw, unmitigated expectation values (turning off all built-in error mitigation and suppression). Which setting does this?
A.estimator.options.resilience_level = 2
B.estimator.options.resilience_level = 1
C.estimator.options.resilience.zne_mitigation = True
D.estimator.options.resilience_level = 0
Answer: Correct: D
Resilience level 0 means 'no mitigation' — it turns off the built-in error mitigation and suppression so the Estimator returns raw expectation values. This is the documented way to disable everything when you plan to apply your own mitigation.
References
- quantum.cloud.ibm.com/docs/guides/estimator-options
- quantum.cloud.ibm.com/docs/guides/estimator-noise-management
Meta: s6-q020 · mcq · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: How does zero-noise extrapolation (ZNE) produce a mitigated expectation value?
A.It runs the circuit at several amplified noise levels, then extrapolates the results back to the zero-noise limit.
B.It learns the readout-error transfer matrix from calibration circuits and inverts it.
C.It inserts pulse sequences on idle qubits to cancel decoherence during execution.
D.It expresses the ideal circuit as a quasi-probability combination of noisy circuits and samples from it.
Answer: Correct: A
ZNE has two stages: noise amplification (running the circuit at several increased noise rates, e.g. by digital gate folding) and extrapolation (fitting those noisy expectation values and extrapolating to the zero-noise limit). It often improves results but is not guaranteed to be unbiased.
References
- quantum.cloud.ibm.com/docs/guides/error-mitigation-and-suppression-techniques
Meta: s6-q021 · mcq · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: The circuit prepares |+>. Using an exact estimator with the observable SparsePauliOp.from_list([('X', 3.0)]), what expectation value is returned?
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
qc = QuantumCircuit(1)
qc.h(0)
obs = SparsePauliOp.from_list([("X", 3.0)])
print(StatevectorEstimator().run([(qc, obs)]).result()[0].data.evs)
A.1.0
B.0.0
C.-3.0
D.3.0
Answer: Correct: D
H|0> = |+> is the +1 eigenstate of X, so <X> = 1. The coefficient of the Pauli term scales the expectation value linearly, so <3*X> = 3 * 1 = 3.0.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
Meta: s6-q022 · predict-output · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: A parameterized circuit applies RY(theta) to |0>, and the PUB binds theta to the three values [0, pi/2, pi] against the observable Z. What array of expectation values is returned?
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")
qc = QuantumCircuit(1)
qc.ry(theta, 0)
obs = SparsePauliOp("Z")
values = [[0.0], [np.pi/2], [np.pi]]
print(StatevectorEstimator().run([(qc, obs, values)]).result()[0].data.evs)
A.[1.0, 0.0, -1.0]
B.[0.0, 1.0, 0.0]
C.[1.0, -1.0, 1.0]
D.[-1.0, 0.0, 1.0]
Answer: Correct: A
RY(theta)|0> = cos(theta/2)|0> + sin(theta/2)|1>, whose Z expectation is <Z> = cos(theta). Binding theta to [0, pi/2, pi] gives [cos 0, cos(pi/2), cos(pi)] = [1, 0, -1]. The three parameter rows broadcast to a length-3 array of expectation values.
References
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q023 · predict-output · Difficulty 3/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Which call successfully constructs a two-qubit SparsePauliOp observable without raising an error?
A.SparsePauliOp.from_list([("ZZ", 1.0), ("X", 0.5)])
B.SparsePauliOp.from_list([("ZZ", 1.0), ("XX", 0.5)])
C.SparsePauliOp(["ZZ", "XYZ"])
D.SparsePauliOp("ZZ", "XX")
Answer: Correct: B
All Pauli terms in one SparsePauliOp must act on the same number of qubits. from_list([('ZZ', 1.0), ('XX', 0.5)]) uses two consistent 2-qubit labels with their coefficients, producing 1.0*ZZ + 0.5*XX.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
Meta: s6-q024 · mcq · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: This code estimates a correlator on a 3-qubit GHZ state but raises ValueError: The number of qubits of the circuit (3) does not match the number of qubits of the ()-th observable (2). What is the correct fix?
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
ghz = QuantumCircuit(3)
ghz.h(0)
ghz.cx(0, 1)
ghz.cx(1, 2)
obs = SparsePauliOp("ZZ")   # <-- intended to correlate all three qubits
print(StatevectorEstimator().run([(ghz, obs)]).result()[0].data.evs)
A.Transpile the circuit with a preset pass manager before running.
B.Add ghz.measure_all() before passing the circuit to the estimator.
C.Use an observable whose label spans all three qubits, e.g. SparsePauliOp("IZZ") or "ZZZ".
D.Pass num_qubits=3 to estimator.run(...).
Answer: Correct: C
An observable must act on exactly as many qubits as the circuit. The circuit has 3 qubits but 'ZZ' is a 2-qubit operator. Writing a 3-character label (e.g. 'IZZ' to correlate qubits 0 and 1, or 'ZZZ' for all three) makes the observable span all 3 qubits and the PUB becomes valid.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q025 · spot-bug · Difficulty 3/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: You want to explicitly turn on zero-noise extrapolation for an EstimatorV2 job by setting an individual option (not by choosing a resilience level). Which line does this?
A.estimator.options.dynamical_decoupling.enable = True
B.estimator.options.resilience.zne_mitigation = True
C.estimator.options.resilience_level = 1
D.estimator.run([(isa, obs)], zne=True)
Answer: Correct: B
ZNE is controlled by the resilience sub-option zne_mitigation. Setting estimator.options.resilience.zne_mitigation = True enables zero-noise extrapolation directly; you can then tune resilience.zne.noise_factors and resilience.zne.extrapolator.
References
- quantum.cloud.ibm.com/docs/guides/error-mitigation-and-suppression-techniques
- quantum.cloud.ibm.com/docs/guides/estimator-options
Meta: s6-q026 · mcq · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Qubit 0 is rotated by RY(pi/3) (qubit 1 stays |0>). Using an exact estimator with SparsePauliOp(['IZ', 'ZI'], coeffs=[1.0, 1.0]) (i.e. Z on qubit 0 plus Z on qubit 1), what expectation value is returned?
import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
qc = QuantumCircuit(2)
qc.ry(np.pi/3, 0)
obs = SparsePauliOp(["IZ", "ZI"], coeffs=[1.0, 1.0])
print(StatevectorEstimator().run([(qc, obs)]).result()[0].data.evs)
A.0.5
B.1.0
C.2.0
D.1.5
Answer: Correct: D
Expectation is linear over the terms: <Z_q0 + Z_q1> = <Z_q0> + <Z_q1>. Qubit 0 is in RY(pi/3)|0>, so <Z_q0> = cos(pi/3) = 0.5; qubit 1 is |0>, so <Z_q1> = 1. The sum is 0.5 + 1 = 1.5.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
Meta: s6-q027 · predict-output · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Select all TRUE statements about the EstimatorV2 resilience_level option.
A.Level 0 applies no error mitigation.
B.Level 1 is the default and applies readout-error mitigation (TREX).
C.Higher resilience levels reduce total runtime because fewer circuits are executed.
D.Level 2 additionally applies zero-noise extrapolation (on top of level 1).
E.The maximum supported resilience_level is 5.
Answer: Correct: A, B, D
The resilience level is a coarse cost/accuracy dial: level 0 = no mitigation, level 1 (the default) = readout-error mitigation via TREX, and level 2 = level 1 plus zero-noise extrapolation and gate twirling. Higher levels give more accurate (less biased) results at greater cost.
References
- quantum.cloud.ibm.com/docs/guides/estimator-noise-management
- quantum.cloud.ibm.com/docs/guides/error-mitigation-and-suppression-techniques
Meta: s6-q028 · multi · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: You construct EstimatorV2(mode=backend) and never touch resilience_level. On real hardware, which error mitigation is applied by default?
A.None — the default resilience level is 0 (raw, unmitigated results).
B.Readout-error mitigation (TREX), because the default resilience level is 1.
C.Zero-noise extrapolation, because the default resilience level is 2.
D.Every available technique, because the default enables maximum resilience.
Answer: Correct: B
The default resilience_level for the Estimator is 1, which applies minimal-cost mitigation: readout-error mitigation via Twirled Readout Error eXtinction (TREX). You get some mitigation for free unless you explicitly lower the level to 0.
References
- quantum.cloud.ibm.com/docs/guides/estimator-noise-management
Meta: s6-q029 · mcq · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: A single PUB pairs one Bell-state circuit with a Python list of three separate observables. What is the shape of result[0].data.evs?
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
obs = [SparsePauliOp("ZZ"), SparsePauliOp("XX"), SparsePauliOp("YY")]
print(StatevectorEstimator().run([(bell, obs)]).result()[0].data.evs.shape)
A.() (a single scalar)
B.(1,)
C.(3,)
D.(3, 2)
Answer: Correct: C
Each SparsePauliOp counts as one element, and a Python list of three of them has shape (3,). The Estimator returns one expectation value per observable, following that shape, so evs is a length-3 array.
References
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q030 · predict-output · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: This snippet raises ValidationError on the last line. What is the problem and fix?
from qiskit_ibm_runtime import EstimatorV2
estimator = EstimatorV2(mode=backend)
estimator.options.default_precision = 0   # <-- raises ValidationError
A.default_precision must be a positive number (it is a target standard error, e.g. 0.01); 0 is invalid.
B.default_precision must be an integer number of shots, so 0 should be 1000.
C.There is no default_precision option; you must set default_shots instead.
D.Precision cannot be set on options; it can only be passed to run().
Answer: Correct: A
default_precision is the target standard error for expectation values, so it must be a strictly positive real number. Zero (an impossible target with finite shots) fails validation; a positive value such as 0.01 is accepted.
References
- quantum.cloud.ibm.com/docs/guides/estimator-options
Meta: s6-q031 · spot-bug · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: How do probabilistic error cancellation (PEC) and zero-noise extrapolation (ZNE) differ in the guarantee they give for the mitigated expectation value?
A.ZNE returns an unbiased estimate, while PEC is biased but always cheaper.
B.Both return provably unbiased estimates at the same sampling cost.
C.PEC suppresses errors before execution, while ZNE post-processes the results afterward.
D.PEC returns an unbiased estimate but generally incurs greater sampling overhead, whereas ZNE is cheaper but not guaranteed to be unbiased.
Answer: Correct: D
PEC represents the ideal result as a quasi-probability combination of noisy circuits, yielding an unbiased estimate, but the sampling overhead grows (quadratically in the quasi-probability norm, which scales exponentially with depth). ZNE amplifies noise and extrapolates to zero; it is cheaper but 'not guaranteed to produce an unbiased result.'
References
- quantum.cloud.ibm.com/docs/guides/error-mitigation-and-suppression-techniques
Meta: s6-q032 · mcq · Difficulty 3/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: You align a 2-qubit observable to physical qubits with an explicit index list. What label does SparsePauliOp('ZZ').apply_layout([2, 0], num_qubits=4) produce?
from qiskit.quantum_info import SparsePauliOp
obs = SparsePauliOp("ZZ").apply_layout([2, 0], num_qubits=4)
print(obs.paulis[0])
A.IZIZ
B.ZIZI
C.ZZII
D.IIZZ
Answer: Correct: A
apply_layout([2, 0], num_qubits=4) places the observable's logical qubit 0 on physical qubit 2 and logical qubit 1 on physical qubit 0, padding to 4 qubits. In little-endian labels (right-most char = qubit 0), Z sits at positions 2 and 0, giving 'IZIZ'.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q033 · predict-output · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: On a deep circuit run on real hardware, you raise the Estimator resilience_level from 0 to 2. What is the expected effect?
A.Jobs finish faster, because mitigation lets the estimator use fewer shots.
B.No change in runtime; resilience level only selects which physical qubits are used.
C.More accurate (less biased) expectation values, at the cost of longer runtime and more QPU usage.
D.The circuit is automatically simplified to fewer gates before execution.
Answer: Correct: C
Higher resilience levels build more resilience against errors by running and post-processing larger ensembles of circuits (e.g. ZNE's noise-amplified copies at level 2). This yields more accurate, less biased expectation values but takes longer and consumes more QPU time — a cost/accuracy trade-off.
References
- quantum.cloud.ibm.com/docs/guides/estimator-noise-management
Meta: s6-q034 · mcq · Difficulty 3/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: What single-term Pauli label does SparsePauliOp.from_sparse_list([('Z', [0], 1.0)], num_qubits=3) produce?
from qiskit.quantum_info import SparsePauliOp
op = SparsePauliOp.from_sparse_list([("Z", [0], 1.0)], num_qubits=3)
print(op.paulis[0])
A.ZII
B.IZI
C.ZZZ
D.IIZ
Answer: Correct: D
from_sparse_list places the operator 'Z' on qubit index 0 of a 3-qubit register. Labels are little-endian: qubit 0 is the right-most character. So the Z lands on the right-most position, giving 'IIZ'.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
Meta: s6-q035 · predict-output · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: After transpiling a circuit to a backend, why must you call observable.apply_layout(isa_circuit.layout) before building the Estimator PUB?
A.To convert the observable from a dense matrix into the Pauli basis.
B.To expand and permute the observable onto the circuit's physical qubits so it spans the same qubits as the ISA circuit.
C.To turn on error mitigation for that observable.
D.To attach measurement instructions so the observable can be sampled.
Answer: Correct: B
Transpilation maps logical qubits onto (and pads out to) the device's physical qubits, so the ISA circuit spans the backend's qubits in a possibly permuted order. apply_layout rewrites the observable with that same layout, so it acts on the correct physical qubits and has the same width as the ISA circuit; otherwise the PUB is invalid.
References
- quantum.cloud.ibm.com/docs/guides/specify-observables-pauli
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q036 · mcq · Difficulty 1/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Using the default StatevectorEstimator (which computes exact expectation values), what does result[0].data.stds contain for a single-observable PUB?
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import StatevectorEstimator
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
data = StatevectorEstimator().run([(bell, SparsePauliOp("ZZ"))]).result()[0].data
print(data.stds)
A.0.0 — an exact calculation has no sampling uncertainty.
B.The same value as evs (the expectation value).
C.1.0 — the maximum possible standard deviation.
D.It is undefined; StatevectorEstimator has no stds field.
Answer: Correct: A
The stds field reports the standard error of the estimate. StatevectorEstimator computes the expectation value exactly from the statevector (default precision 0, no shot sampling), so there is no statistical uncertainty and stds is 0.0.
References
- quantum.cloud.ibm.com/docs/guides/primitive-input-output
Meta: s6-q037 · predict-output · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Select all TRUE statements about the EstimatorV2 precision parameter.
A.It specifies the target standard error of the estimated expectation value.
B.A larger precision value requests a more accurate result.
C.Reaching a smaller precision generally requires more shots (roughly as 1/precision^2).
D.It is supplied to run() under the keyword name shots.
E.If no precision is set in the PUB or in run(), the estimator falls back to the options (e.g. default_precision).
Answer: Correct: A, C, E
precision is the target standard error of the expectation value. Because the standard error falls as 1/sqrt(shots), reaching a smaller precision needs roughly 1/precision^2 shots. It can be given per-PUB or as the precision keyword of run(); if omitted everywhere, the estimator uses the options value (default_precision, or shots/twirling settings).
References
- quantum.cloud.ibm.com/docs/guides/estimator-options
Meta: s6-q038 · multi · Difficulty 3/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.

Question: Your circuit leaves some qubits idle for long stretches, and you want to suppress decoherence on them during execution. Which EstimatorV2 option should you enable?
A.estimator.options.resilience.zne_mitigation = True
B.estimator.options.resilience.measure_mitigation = True
C.estimator.options.dynamical_decoupling.enable = True
D.estimator.options.resilience_level = 1
Answer: Correct: C
Dynamical decoupling inserts pulse sequences on idle qubits to approximately cancel decoherence while they wait — exactly the situation described. It is an error-suppression technique enabled via options.dynamical_decoupling.enable = True.
References
- quantum.cloud.ibm.com/docs/guides/error-mitigation-and-suppression-techniques
- quantum.cloud.ibm.com/docs/guides/configure-error-suppression
Meta: s6-q039 · mcq · Difficulty 2/3
AI-generated, execution-verified — CertiQ. Unofficial: not affiliated with, endorsed by, or sponsored by IBM.