Chapter 7 — Key Takeaways (Qiskit Architecture)

Where things live, which question you are asking, and the line that must never be missing.

The package map

Date old code by its imports: Aqua/Ignis → pre-2021. from qiskit import Aer or execute → pre-1.0.

The circuit model

qc.data is a list of CircuitInstruction — operation + qubits + clbits. Bits are objects, not indices; qc.find_bit(q).index converts. Composite gates carry their own definitions and expand during transpilation, not construction.

The transpiler works on a DAG. Depth is the longest path through the graph, not a count:

4 operations, depth 3 -- the two measures share a layer (neither depends on the other)

Aer is several simulators

Measured on a GHZ chain (Clifford):

A 1000-qubit entangled state, exact, in four seconds. The flip side: anything simulable that easily cannot give a quantum advantage. T gates break it — hence T-count as the fault-tolerant currency (Ch. 23).

★ The two primitives

If you would summarize the result as a single real number → Estimator. As "the answer is 01101" → Sampler.

Measured impact at 20 qubits: ~1000× fewer shots. At 30 qubits: ~10⁶×.

Why: estimating a mean never requires resolving the whole distribution. $\mathrm{Var}(C)$ depends on the cost function's range, not the outcome count.

Pubs:

sampler.run([(circuit,)])
estimator.run([(circuit, observable)])
estimator.run([(circuit, observable, parameter_values)])     # bind at submission

Precision, not shots

result = estimator.run([(qc, H)], precision=0.01).result()[0]
value, error = float(result.data.evs), float(result.data.stds)

stds matches the requested precision exactly. Values differ between runs — an Estimator value is a sample, not a constant. For bit-reproducibility use StatevectorEstimator, which is exact.

⚠️ precision is statistical only. Requesting $10^{-4}$ on noisy hardware returns a confident $10^{-4}$ error bar on a number that may be 0.2 from the truth. Match precision to systematic error (Ch. 5 §5.9 step 5).

★★ The layout trap

isa = pm.run(qc)
observable = observable.apply_layout(isa.layout)      # ← NEVER OMIT THIS

Measured, circuit on physical qubits [60, 61]:

  reference (exact)                     +2.0000
  observable laid out correctly         +1.8135    ratio 0.907  ← noise
  observable placed on qubits 0,1       +0.8838    ratio 0.442  ← SILENTLY WRONG

Why every check misses it: the optimizer converges (it minimizes whatever you give it); error bars are correct (they are statistical); runs agree (wrong answers are stable); simulator matches hardware (same wrong observable in both).

The two checks that work — both step outside the failing pipeline:

1. Compare to an exact reference on the untranspiled circuit (StatevectorEstimator). Free. Ratio near 1 = noise; near 0.5 or near 0 = structural.
2. Print the layout and the observable's support.

A check that shares a code path with the bug cannot find it.

Best defense: make it unrepresentable. Return the transpiled circuit and laid-out observable as one object. Encode rules in types, not comments.

Transpile once, bind many

isa = pm.run(ansatz)                              # ONCE -- parameters still free
laid_out = observable.apply_layout(isa.layout)    # ONCE
for values in optimizer_suggestions():
    estimator.run([(isa, laid_out, values)], precision=1e-2)

Roughly linear in $N$ — the transpilation cost is paid once instead of $N$ times.

Sessions

Without a session, a 200-iteration VQE queues 200 times. Sessions are metered while open, so keep classical work fast or outside, and batch what the optimizer allows.

Common pitfalls

• Passing a measured circuit to an Estimator, or an unmeasured one to a Sampler.
• Forgetting apply_layout — the chapter's headline failure.
• Reading stds as a total uncertainty.
• Re-transpiling inside an optimizer loop.
• Using the Sampler for a quantity that is a single number.
• Opening a session to run one circuit.

Project piece added this chapter

vqelab/backends.py v1 — get_estimator, get_sampler, prepare, reference_value, check_against_reference, and a frozen Prepared dataclass.

prepare() returns the transpiled circuit and its laid-out observable as one object, so the trap is designed out. reference_value() computes the exact noiseless answer, and check_against_reference() turns the silent failure into a loud one — with an error message that names the likely cause rather than the symptom.