IBM C1000-179: Fundamentals of Quantum Computing Using Qiskit v2.X Developer

Pass mark: 47 / 68. All code outputs below were verified by execution on Qiskit 2.5.1 + qiskit-ibm-runtime 0.48.0 + qiskit-aer.

Answer Table

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

Section 1 — Create Quantum Circuits (Q1–Q12)

Q1 — B (3). Depth is the longest path of non-overlapping layers: layer 1 = h(0), layer 2 = cx(0,1), layer 3 = both measurements (they act on different qubits/clbits so they share a layer). Verified: prints 3.

Q2 — A. [HARD] measure_all() inserts its own barrier before the three measurements, in addition to the explicit qc.barrier() — so barrier: 2, not 1 (trap in B). C forgets barriers count as ops in count_ops(); D miscounts the two h gates. Verified output: OrderedDict({'measure': 3, 'h': 2, 'cx': 2, 'barrier': 2}).

Q3 — C. GHZ = Hadamard on one qubit, then a CX chain fanning the superposition out: h(0); cx(0,1); cx(1,2). A gives the uniform superposition over all 8 states (no entanglement structure), B has control/target reversed so the CXs act trivially on |0⟩ controls, and D's CZ gates do nothing to |0⟩/|+⟩ inputs' populations.

Q4 — D (5). width() = qubits + clbits = 3 + 2 = 5. A is num_qubits only; C doubles the qubits. Verified.

Q5 — B. [HARD] compose() is not in-place by default — it returns a new circuit, and here the return value is discarded. So qc1 still contains only the h. A is the trap for assuming in-place behavior (that needs qc1.compose(qc2, inplace=True) or qc1 = qc1.compose(qc2)); C additionally gets the order backwards. Verified: only the H wire prints.

Q6 — A. [HARD] List binding assigns values in the order of circuit.parameters, which is alphabetically sorted: [phi, theta]. So phi=0.5, theta=1.5, giving Rz(1.5) then Rx(0.5). B is the trap of assuming insertion order (rz first). Verified: Rz(1.5), Rx(0.5).

Q7 — C. Qiskit v2.x uses the with qc.if_test((creg, value)): context manager for classical feedforward. A/B use c_if, which was deprecated and removed in Qiskit 2.0 (classic outdated-API distractor); D is not a real signature.

Q8 — A. Optimization level 0 still runs layout, routing, and translation (an ISA circuit is always required), but performs essentially no optimization. Levels 1–3 add increasing optimization; 1 is the default.

Q9 — C. With basis rz/sx/x/ecr, H translates to Rz(π/2)·√X·Rz(π/2) with global phase π/4. Verified: {'rz': 2, 'sx': 1}, global_phase = π/4. A is wrong — translation is exactly what transpilation does; D confuses basis translation with connectivity routing.

Q10 — B. inverse() reverses the gate order and inverts each gate: (HS)⁻¹ = S†H† = Sdg then H. Verified: ['sdg', 'h']. A inverts gates without reversing order; C reverses order without daggering S.

Q11 — C (4). measure_all() adds a new 2-bit classical register named meas even though the circuit already has 2 clbits, giving 4 total. A is the trap (expecting reuse of the existing register — that requires measure_all(add_bits=False)). Verified: 4.

Q12 — D. [HARD] The clean pattern: convert the circuit to a gate (to_gate()), call .control(1) to get a 3-qubit controlled gate, and append to [0, 1, 2] (control first). A calls .control(1) but then supplies only 2 qubits for a 3-qubit operation — CircuitError. B: cx takes qubit indices, not circuits. C appends the uncontrolled 2-qubit gate onto 3 qubits — width mismatch error.

Section 2 — Perform Quantum Operations (Q13–Q23)

Q13 — B. [HARD] Little-endian Pauli strings: in Pauli('XZ') the rightmost character (Z) acts on qubit 0 and X acts on qubit 1. Z leaves |0⟩ alone; X flips qubit 1, giving |10⟩ (q1=1, q0=0). A is the big-endian trap (reading X as acting on qubit 0). Verified: {'10': 1.0}.

Q14 — A. simplify() merges duplicate Pauli terms: 1.0·XI + 2.0·XI = 3.0·XI, plus 1.0·ZZ. B is the unsimplified operator; C wrongly keeps only one coefficient; D flips the Pauli label. Verified: SparsePauliOp(['XI', 'ZZ'], coeffs=[3.+0.j, 1.+0.j]).

Q15 — B. [HARD] Label '01' means q1=0, q0=1. The statevector index is the little-endian integer value of the bitstring: binary 01 = 1, so index 1. A (index 2) is the big-endian trap. Verified: nonzero amplitude at index 1.

Q16 — C. H|0⟩ = |+⟩; Z flips the sign of the |1⟩ component, giving |−⟩ = (|0⟩ − |1⟩)/√2. Z does not change measurement probabilities in the computational basis but does change the state.

Q17 — B. HXH = Z (and HZH = X) — the Hadamard exchanges the X and Z bases. This identity pair appears constantly on the exam.

Q18 — C (0.5). Fidelity = |⟨+|0⟩|² = |1/√2|² = 0.5. B (0.25) squares twice; A confuses with orthogonal states. Verified: 0.4999....

Q19 — A (True). The circuit implements HZH = X, and equiv compares up to global phase, so it returns True. C is false — Operator.equiv accepts any operator-like input.

Q20 — D. (|00⟩ + |11⟩)/√2 is the Bell state Φ⁺ — it cannot be written as a tensor product. A is explicitly a product; B factors as |0⟩⊗|+⟩ (q1 fixed at 0); C factors as |+⟩⊗|−⟩ written out.

Q21 — B (0.0). |+⟩ is an eigenstate of X, not Z; measuring Z on |+⟩ gives ±1 with equal probability, so ⟨Z⟩ = 0. Verified: 0.0.

Q22 — A. x.tensor(z) puts the argument on the lower-numbered qubits: result label is 'XZ' (X on qubit 1, Z on qubit 0). B is the expand() result — the classic tensor/expand confusion. Verified: SparsePauliOp(['XZ'], ...).

Q23 — C. [HARD] rz(π) = diag(e^{−iπ/2}, e^{iπ/2}) = −iZ — a global phase away from Z, so alone they are indistinguishable. But controlling promotes global phase to relative phase: crz(π) ≠ cz (they differ by a controlled-phase). A is the trap of assuming phase never matters; B wrongly claims measurement statistics differ for the uncontrolled gates; D confuses π with 2π (and even rz(2π) = −I, not I).

Section 3 — Run Quantum Circuits (Q24–Q33)

Q24 — B. service.least_busy(operational=True, simulator=False) is the canonical v2.x call. A would return simulators; C and D invent APIs (D is the old IBMProvider style).

Q25 — A. V2 primitives on real backends require ISA circuits — circuits already transpiled to the backend's target (basis gates + connectivity). Non-ISA circuits are rejected with an error. B describes the removed server-side transpilation behavior of the V1 era.

Q26 — C. Iterative workloads where each job depends on the previous result are exactly what Session mode is for: a dedicated window with no re-queuing between jobs.

Q27 — B. Independent, no inter-job feedback, want parallel scheduling → Batch mode. Session (A) reserves the device unnecessarily; separate jobs (C) each wait in the queue.

Q28 — A. Passing a backend object as mode= runs each run() call as a standalone job — job mode. Session/batch modes require passing a Session/Batch object (or using their context managers).

Q29 — D. qiskit.primitives.StatevectorSampler is the local, ideal, account-free V2 sampler. A (qiskit.execute) was removed in Qiskit 1.0; B (BasicAer) is gone; C — Aer lives in qiskit_aer, not qiskit, and backend.run is not the primitives workflow.

Q30 — C. FakeManilaV2 is a 5-qubit fake backend in qiskit_ibm_runtime.fake_provider, running locally with a device-snapshot noise model. No account needed; nothing runs on real hardware.

Q31 — B. [HARD] Precedence for shots: per-PUB value > run(shots=...) > options.default_shots > server default. The PUB's 4096 wins. A inverts the precedence — the run-level value is only a fallback for PUBs that don't specify shots. Not an error (D); never summed (C).

Q32 — A. QiskitRuntimeService.save_account(channel=..., token=...) is the current API. B (IBMQ.save_account) is the long-removed qiskit-ibmq-provider API — a classic V1-era distractor.

Q33 — D. [HARD] FakeManila's basis is rz/sx/x/cx (an older snapshot — not ecr), so H → 2×rz + 1×sx and the CX stays a cx. B is the trap for assuming all IBM backends use ecr. A would mean no translation happened; C uses the u basis of even older devices. Verified: OrderedDict({'rz': 2, 'sx': 1, 'cx': 1}).

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

Q34 — C. Sampler PUBs require circuits with classical output (measurements); a measurement-free circuit is an error. A describes Estimator-like implicit behavior that Sampler does not have; D confuses Sampler with a statevector simulator.

Q35 — B. measure_all() creates a register named meas, so counts live at result[0].data.meas.get_counts(). A (data.c) applies only to the default register created by QuantumCircuit(n, m); C is the V1-style API; D (quasi_dists) is the removed V1 Sampler output.

Q36 — A. [HARD] The DataBin attribute is named after the classical register, here result → result[0].data.result. With x(0), qubit 0 reads 1, so little-endian counts are {'01': 100}. B is the big-endian trap; D is the wrong-creg-attribute trap (data.c only exists for a register actually named c). Verified.

Q37 — C. BitArray.num_shots is 100 and num_bits is 2 (one bit per clbit). A reverses them. Verified: 100 2.

Q38 — D. The PUB (qc, [np.pi]) binds t=π at runtime; Ry(π)|0⟩ = |1⟩, so all 100 shots give '1'. C is false — PUB parameter binding is the standard v2 pattern, no pre-binding needed. Verified: {'1': 100}.

Q39 — A. sampler.options.default_shots = 2048. B and D invent attributes; C is the V1-style nested execution.shots path (the v2 option is top-level default_shots).

Q40 — B. Dynamical decoupling has its own options group: options.dynamical_decoupling.enable = True plus sequence_type = "XY4". A wrongly files DD under resilience; D confuses DD with twirling.

Q41 — D. [HARD] SamplerV2 options (verified by introspection): default_shots, dynamical_decoupling, execution, twirling, environment, simulator, experimental — no resilience_level. Resilience levels (TREX/ZNE/PEC) are expectation-value mitigation and exist only on EstimatorV2. This is a heavily tested Sampler/Estimator asymmetry.

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

Q42 — B. Estimator computes ⟨ψ|O|ψ⟩; the observable defines the measurement basis, so the circuit must not contain measurements. A is the exact opposite trap (that rule belongs to Sampler).

Q43 — C. [HARD] After transpilation the logical qubits sit on physical qubits, so the observable must be remapped: observable.apply_layout(isa_circuit.layout). A omits apply_layout — the single most classic Estimator mistake (fails or silently measures the wrong qubits); B passes the backend instead of the layout; D — pass managers run on circuits, not operators.

Q44 — A (1.0). For the Bell state, measurements of Z⊗Z are perfectly correlated: ⟨ZZ⟩ = 1. (⟨ZI⟩ and ⟨IZ⟩ are 0 individually.) Verified: 0.9999999999999998.

Q45 — B (−1.0). Ry(π)|0⟩ = |1⟩ and ⟨1|Z|1⟩ = −1. Verified: -1.0.

Q46 — D. Level 1 (default) = measurement/readout error mitigation (TREX); level 2 adds zero-noise extrapolation. PEC (B) is not part of level 2 in the current options model; DD (A) is suppression, configured separately.

Q47 — A. ZNE lives under options.resilience: zne_mitigation = True, zne.noise_factors, zne.extrapolator. The others invent flat or string-valued option paths.

Q48 — A, C. Dynamical decoupling and Pauli twirling act on the circuit before/during execution (suppression). ZNE and PEC are classical post-processing of results (mitigation). This suppression-vs-mitigation split is a staple exam distinction.

Q49 — C. One PUB may carry an array of observables; the result broadcasts to evs = [⟨ZZ⟩, ⟨ZI⟩, ⟨XX⟩] = [1. 0. 1.] (Bell state: ZZ and XX correlated, single-qubit Z zero). D is false — arrays of observables are a core PUB feature. Verified: [1. 0. 1.].

Section 6 — Visualize (Q50–Q57)

Q50 — B. Top wire is q_0; the H sits on q_0 and the CX control dot is on q_0 with target ⊕ on q_1, and measurement M on q_0 goes to clbit 0. That is exactly h(0); cx(0,1); measure([0,1],[0,1]). A/C reverse control and target; D crosses the measurement wiring (clbit labels under the diagram would read 1 0). Diagram verified against draw('text').

Q51 — D. reverse_bits=True is display-only: it draws the highest-index qubit on top (big-endian-style display) without touching the circuit object. B is the trap — nothing is renumbered or mutated.

Q52 — A. Ideal Bell counts: only 00 and 11, each ≈0.5. C (01/10) is the Ψ-Bell-state/big-endian confusion distractor.

Q53 — C. Each qubit of a maximally entangled state is locally the maximally mixed state, so its Bloch vector has zero length — both vectors sit at the sphere centers. Any answer with definite directions (A/B/D) describes product states.

Q54 — B. On the Q-sphere, blob size encodes probability amplitude and blob color encodes phase. A reverses the encodings.

Q55 — D. (|0⟩ − i|1⟩)/√2 = |−i⟩, the −Y axis state. (+Y is (|0⟩ + i|1⟩)/√2; ±X are the ± superpositions without i.)

Q56 — A. number_to_keep=2 keeps the 2 most frequent outcomes as individual bars and lumps everything else into a single "rest" bar — it never drops data (B) or errors (C).

Q57 — B. Verified output: \frac{\sqrt{2}}{2} |0\rangle+\frac{\sqrt{2}}{2} |1\rangle. Qiskit prints amplitudes (√2/2), not probabilities (C's 1/2); D is the |−⟩ state; A — the drawer expands into the computational basis, it does not emit |+\rangle.

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

Q58 — C. Re-instantiate the service and call service.job("abc123") (singular). B (service.jobs) is the filtering API that takes keyword filters and returns a list; A and D invent class methods.

Q59 — A. run() is asynchronous and returns a job handle immediately; job.result() simply blocks until completion — no manual polling required (C), and results persist after sessions close (D).

Q60 — B. The PrimitiveResult contains one PubResult per PUB → len(result) is 2; result[1] is the X circuit, giving {'1': 10}. D's '01' pads to two bits, but the circuit has only one clbit. Verified: 2 {'1': 10}.

Q61 — C (0.2). ⟨Z⟩ = (n₀ − n₁)/shots = (600 − 400)/1000 = 0.2. A flips the sign convention (Z eigenvalue +1 belongs to |0⟩); B and D are the raw probabilities.

Q62 — A. 512/1000 = 0.512 and 488/1000 = 0.488 — plain normalization. Verified.

Q63 — D. Execution details such as the actual shot count are in the per-PUB result[0].metadata (with job-level info in result.metadata). DataBin (B) holds measurement data, not execution metadata.

Q64 — B (100). Error ∝ 1/√shots, so a 10× error reduction needs 10² = 100× the shots.

Section 8 — Operate with OpenQASM (Q65–Q68)

Q65 — C. [HARD] Verified verbatim output: OQ3 uses include "stdgates.inc";, bit[2] c; qubit[2] q;, and the OQ3 measurement assignment form c[0] = measure q[0];. A mixes in OQ2 syntax (qreg/creg, qelib1.inc); B uses the OQ2 arrow form measure q -> c inside an OQ3 header; D declares OPENQASM 2.0 with OQ3 declarations. The include-file and measure-direction pairings are the tested details.

Q66 — B. x q[0] sets q0=1; h q[1] superposes q1; cx q[1],q[0] flips q0 when q1=1. Branches: q1=0 → 01; q1=1 → q0 flips to 0 → 10. Little-endian bitstrings are q1q0. Verified counts ≈ 50/50 on '01'/'10'. A is the "Bell state so it must be 00/11" reflex without tracing the X.

Q67 — A, D. OpenQASM 3 adds input parameters and typed classical data with general classical control flow. Quantum registers (B) and standard-gate includes (C) exist in both versions.

Q68 — A. qasm3.loads(string) parses a string; qasm3.load(file) (B) takes a file path/stream — the s-suffix convention mirrors json.loads/json.load. C and D are not real APIs.

15 hardest questions (deeper distractor analysis above): Q2, Q5, Q6, Q11, Q12, Q13, Q15, Q23, Q31, Q33, Q36, Q41, Q43, Q57, Q65.