# Lesson 13 — Learning the quantum computer vocabulary

## From a chemical state to a quantum register

We have described electronic states, selected a molecular model, and examined Hamiltonian representations. Before translating electrons into qubits, we need to understand what a quantum program actually manipulates. The next few ideas explain the Q# operations already present in this repository rather than asking us to treat circuit diagrams as unexplained symbols.

A quantum circuit is not a picture of electrons moving between atoms. It is a program acting on an abstract quantum register whose states have been assigned a meaning. The physical device implementing that register is a later hardware/error-correction question. Our six-active-electron nitrogen model does not automatically mean six qubits; an occupation encoding of six spatial orbitals has twelve spin modes before any symmetry reduction.

All circuit examples and arithmetic in this lesson are illustrative or read from source tests. No QDK import, compilation, simulation, measurement, or resource estimate was executed while preparing the course.

## A qubit has amplitudes, not two simultaneously readable classical values

A classical **bit** takes a value zero or one. A **qubit** is described by a normalized vector in a two-dimensional complex state space. Choose the computational basis

\[
|0\rangle=\begin{pmatrix}1\\0\end{pmatrix},\qquad
|1\rangle=\begin{pmatrix}0\\1\end{pmatrix}.
\]

A pure qubit state has the form

\[
|\psi\rangle=\alpha|0\rangle+\beta|1\rangle,
\qquad |\alpha|^2+|\beta|^2=1.
\]

The complex amplitudes \(\alpha,\beta\) play the same mathematical role as amplitudes in our determinant expansions, although the basis labels now refer to qubit values. Their squared magnitudes give probabilities of computational-basis measurement. They are not two classical answers that can both be read out.

For example, the illustrative state \(\tfrac{\sqrt3}{2}|0\rangle+\tfrac{i}{2}|1\rangle\), with \(i^2=-1\), gives outcome zero with probability three-quarters and outcome one with probability one-quarter. The imaginary factor does not make an imaginary probability. It carries phase information that can matter when amplitudes later interfere.

Multiplying the entire state by the same unit-magnitude factor \(e^{i\phi}\) gives an unobservable **global phase**. Multiplying only one component changes a **relative phase**, which can affect subsequent measurements after suitable operations. This distinction is central to phase-estimation circuits and to getting signs right in fermionic mappings.

## Gates are linear, reversible transformations

An ideal quantum **gate** is represented by a unitary matrix \(U\):

\[
U^{\dagger}U=I.
\]

The dagger means transpose plus complex conjugation. Unitarity preserves normalization, and the inverse operation is \(U^{\dagger}\), also called the **adjoint**. Measurement is different: it produces classical information and generally changes the state irreversibly from the perspective of the register alone.

The elementary **Pauli gates** are

\[
I=\begin{pmatrix}1&0\\0&1\end{pmatrix},\quad
X=\begin{pmatrix}0&1\\1&0\end{pmatrix},\quad
Y=\begin{pmatrix}0&-i\\i&0\end{pmatrix},\quad
Z=\begin{pmatrix}1&0\\0&-1\end{pmatrix}.
\]

`I` changes nothing. `X` exchanges zero and one. `Z` preserves computational-basis populations but changes the sign of the one component. `Y` both exchanges the basis values and adds phase: \(Y|0\rangle=i|1\rangle\) and \(Y|1\rangle=-i|0\rangle\). A minus sign in an amplitude is not a third classical measurement outcome.

The **Hadamard gate**, written `H` in circuit code, is

\[
H_{\mathrm{gate}}=\frac1{\sqrt2}
\begin{pmatrix}1&1\\1&-1\end{pmatrix}.
\]

It sends zero to the equal-plus superposition \(|+\rangle=(|0\rangle+|1\rangle)/\sqrt2\), and one to \(|-\rangle=(|0\rangle-|1\rangle)/\sqrt2\). The subscript reminds us that this `H` gate is not the molecular energy operator \(\hat H\). In general an energy matrix is not itself a unitary gate; an algorithm constructs suitable unitaries or embeddings from it.

The repository’s [state-preparation utilities](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/utils/qsharp/src/StatePreparation.qs) use `X` to set occupied basis bits and `H` to prepare uniform superpositions. Their meaning is concrete matrix action, not a shorthand for solving a chemistry problem.

## Worked interference: a phase change becomes a different outcome

Follow this ideal one-qubit sequence without measuring between gates:

\[
|0\rangle\xrightarrow{H}
\frac{|0\rangle+|1\rangle}{\sqrt2}
\xrightarrow{Z}
\frac{|0\rangle-|1\rangle}{\sqrt2}
\xrightarrow{H}|1\rangle.
\]

Immediately after the `Z`, a computational-basis measurement would still look fifty-fifty. The final `H` combines amplitudes: contributions to zero cancel and contributions to one reinforce. That is **interference**. Without the `Z`, applying `H` twice returns zero instead.

A coherent superposition is therefore not merely a classical mixture of “zero half the time, one half the time.” A fifty-fifty mixture has lost the relative phase information. Applying `Z` does not change that mixture, and applying `H` still leaves a fifty-fifty computational-basis distribution. The coherent and mixed cases can have the same immediate measurement probabilities but different responses to subsequent gates.

An illustrative Q# program using the same gate syntax is:

```qsharp
operation InterferenceExample() : Result {
    use q = Qubit();
    H(q);
    Z(q);
    H(q);
    return MResetZ(q);
}
```

This is teaching code, not a function claimed to exist in the repository. `use` allocates a qubit, and `MResetZ` measures in the Z basis and resets the qubit to zero. In the ideal mathematical model its result is `One`. No run was performed here.

## Phase and rotation gates require explicit conventions

A phase gate such as \(S=\operatorname{diag}(1,i)\) changes relative phase without changing immediate Z-measurement probabilities. The commonly named \(T\) gate is \(\operatorname{diag}(1,e^{i\pi/4})\); this `T` is a gate name, not the kinetic-energy matrix from Lesson 5.

Use the standard rotation convention

\[
R_P(\theta)=e^{-i\theta P/2},
\]

where \(P\) is a Pauli matrix and \(\theta\) is an angle in radians. For example,

\[
R_z(\theta)=
\begin{pmatrix}e^{-i\theta/2}&0\\0&e^{i\theta/2}\end{pmatrix}.
\]

A phase operation \(\operatorname{diag}(1,e^{i\theta})\) differs from this by a global phase. That can be harmless for an isolated operation but not necessarily after making the operation controlled.

The chemistry repository uses Q# **`Exp`**, not a blind substitution of a coefficient into `Rz`. The [Pauli-exponential code](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/utils/qsharp/src/PauliExp.qs) calls:

```qsharp
Exp(paulis, -coeff, systems);
```

The [matrix-equivalence test](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/tests/test_circuit_mapper.py) checks the resulting term operation against \(e^{-i\,\mathrm{coeff}\,P}\). In the rotation convention above, that corresponds to \(R_P(2\,\mathrm{coeff})\), not \(R_P(\mathrm{coeff})\). The minus sign and factor of two are thus fixed by the concrete source/test contract, rather than guessed from a gate’s name. The external QDK standard library implements the primitive `Exp`; its internal compiler/runtime source was not reviewed here.

Gate order matters. If code applies operation one and then operation two, the state is multiplied by \(U_2U_1\). The repository’s sequential-composition helper follows precisely that chronological order. We will derive full Hamiltonian simulation formulas later; the immediate lesson is not to conflate an energy coefficient, an evolution angle, and a rotation-gate argument.

## Registers use tensor products

A **register** is an ordered collection of qubits. Two qubits have four computational-basis states, and \(q\) qubits have \(2^q\). The joint state space is a tensor product, meaning we combine all basis possibilities and multiply amplitudes for independent subsystems.

For the following derivation write kets in the displayed order \(|q_0q_1\rangle\). Then

\[
(a|0\rangle+b|1\rangle)\otimes(c|0\rangle+d|1\rangle)
=ac|00\rangle+ad|01\rangle+bc|10\rangle+bd|11\rangle.
\]

A gate acting on one subsystem is extended by the identity on the other. For example, \(X\otimes I\) in this displayed order flips the first listed qubit and leaves the second alone. A tensor-product matrix has a block structure; \(X\otimes I\) has identity blocks off diagonal and zero blocks on the diagonal. It is not the elementwise product of two matrices.

Actual software interfaces may print tensor factors in a different order. We will track that explicitly rather than silently switching which end of a bitstring means qubit zero.

## CNOT creates correlations coherently

The **controlled-NOT**, written `CNOT` in Q# and often `cx` in OpenQASM, has a control qubit and a target qubit. On basis states,

\[
\operatorname{CNOT}|a,b\rangle=|a,b\mathbin{\oplus}a\rangle,
\]

where \(\oplus\) is exclusive-or, addition modulo two. The target flips when the control is one; the control is not measured. Linearity extends this action to a superposition.

The repository’s [binary-encoding utilities](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/utils/qsharp/src/BinaryEncoding.qs) explicitly apply `CNOT(qs[control], qs[target])`, as well as X, SWAP, and double-controlled X operations, to manipulate encoded occupation information. These are coherent register transformations, not conditional statements based on reading a hidden classical value.

Starting from zero-zero, apply `H` to the first qubit and CNOT from first to second:

\[
|00\rangle\longrightarrow
\frac{|00\rangle+|10\rangle}{\sqrt2}
\longrightarrow
|\Phi^+\rangle=\frac{|00\rangle+|11\rangle}{\sqrt2}.
\]

This is a **Bell state**. It is entangled: it cannot be written as a tensor product of two pure one-qubit states. If the product formula above had nonzero `00` and `11` amplitudes but zero `01` and `10`, its factors would have to be both nonzero and zero in incompatible ways. The joint information cannot be assigned to two independent state vectors.

Each individual Z measurement is random, but the joint outcomes are equal: `00` or `11` ideally. A classical mixture of those same two outcomes reproduces that Z correlation, so that measurement alone does not establish quantum coherence. Measuring both qubits in X instead distinguishes them: the Bell state retains equal-outcome correlation, whereas that classical mixture gives all four X-basis combinations equally often.

Entanglement does not enable faster-than-light communication. A local measurement result remains random, and local statistics cannot reveal another party’s freely chosen action without the appropriate shared comparison. Correlation is not controllable signaling.

CNOT also does not clone an arbitrary unknown qubit. On \(|+\rangle|0\rangle\) it makes the Bell state, not \(|+\rangle|+\rangle\). Known computational-basis information can be copied reversibly, but arbitrary unknown amplitudes cannot be copied by that same operation.

## Controlled-U makes phase observable between branches

A general controlled operation is

\[
\operatorname{C}U=
|0\rangle\langle0|\otimes I+
|1\rangle\langle1|\otimes U.
\]

On a control superposition it coherently combines a branch that does nothing and a branch that applies \(U\):

\[
|+\rangle|\psi\rangle\longrightarrow
\frac{|0\rangle|\psi\rangle+|1\rangle U|\psi\rangle}{\sqrt2}.
\]

If \(U\) is replaced by \(e^{i\phi}U\), the one branch now gains a relative phase. A phase that was global for an isolated system operation becomes observable through control interference. This is why a scalar Hamiltonian energy offset cannot be dropped casually in a controlled evolution without accounting for its phase or restoring it consistently in interpretation.

The [controlled Pauli-exponential source](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/utils/qsharp/src/ControlledPauliExp.qs) uses

```qsharp
Controlled Exp([control], (paulis, -coeff, systems));
```

The [controlled matrix test](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/tests/test_controlled_circuit_mapper.py) compares to the block-diagonal controlled-U formula above. This directly checks both which branch acts and the sign convention. We are not yet deriving phase-estimation bit extraction; we are learning the coherent controlled operation it will require.

## Adjoint, controls, and ordinary classical code are different capabilities

Q# uses an `operation` for routines that can act on qubits, and a `function` for classical computation/construction. `Qubit[]` is an array of qubit handles. `Result[]` is an array of classical measurement results. `Unit` is a return type meaning no classical value is returned; it is not a unit of energy.

An operation declared `is Adj + Ctl` exposes adjoint and controlled variants. `Adjoint op` requests its inverse; `Controlled op` requests a coherent controlled version. The [composition helpers](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/utils/qsharp/src/CircuitComposition.qs) build these callable forms and adapt a control-register operation to a single-control-qubit signature. The declared callable capability matters: not every source helper exposes every modifier just because some gates in its body are unitary.

Ordinary irreversible assignments cannot simply be promoted into coherent computation. A reversible implementation of a classical function typically preserves its input and writes an answer into another register, for example \(|x\rangle|y\rangle\mapsto|x\rangle|y\oplus f(x)\rangle\). Overwriting many distinguishable inputs with the same value would not have a unitary inverse.

Classical assignments and loops are still useful around quantum operations. In Q# source, constructing an array of measurement results or looping over known coefficient parameters is classical control. It does not place the Python/Q# integer variables themselves into quantum superposition. A branch on a measured `Result` is **classical feedback**, different from `Controlled op` acting on an unmeasured qubit.

## Ancillas must be prepared, used, and cleaned up

An **ancilla** is an auxiliary qubit used for a computation rather than directly representing the target electronic occupation. A circuit may have an occupation register, a control/readout qubit, address registers, and scratch/work ancillas. They all cost space while alive, but their roles differ.

A work register often becomes entangled with the system while computing an intermediate value. Simply ignoring it does not restore a clean system state; it can destroy interference when viewed only on the system. **Uncomputation** coherently reverses the work after its result has been used, returning the scratch register to its known initial state when the algorithm’s assumptions hold.

Q#’s `within { ... } apply { ... }` pattern performs the setup, the body, then the adjoint of the setup. The repository’s `MakeSharedAncillaOp` uses this pattern to prepare and restore trailing shared ancillas. The enclosed operation must respect the intended ancilla contract; an arbitrary destructive operation is not magically repaired by running the preparation backward.

The binary-encoding helpers also accept pools of initially zero ancillas and document which are restored before return. Reusing a cleaned ancilla can reduce peak width even though the algorithm performed many work operations. Measurement-based cleanup is another implementation strategy, but it can change which adjoint/control capabilities a routine exposes. We will treat detailed state-preparation tradeoffs later rather than assuming every helper is one generic unitary black box.

## Measurement returns samples, not the whole amplitude vector

A computational-basis measurement of one qubit returns zero or one with the corresponding squared-amplitude probabilities. Measuring a general Pauli observable returns an eigenvalue sign, conventionally represented by `Zero` for +1 and `One` for −1. Measuring in X or Y means asking a different observable, often implemented through a basis change and a computational measurement.

Measurement generally changes the joint state. For the Bell example, observing zero on one qubit conditions the partner to zero in that measurement basis. Repeating that measurement immediately on the same state is not another independent sample of the original preparation. A **shot** normally means reprepare the intended initial state, execute the circuit, and obtain a fresh set of outcomes.

The repository’s [`MeasureInBasis`](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/utils/qsharp/src/MeasurementBasis.qs) calls `MResetX`, `MResetY`, or `MResetZ` for the chosen basis and resets qubits. For a Pauli-I position it performs `Reset` but appends no measurement result. Thus the returned result-array length can be smaller than the register width. It is a destructive readout/cleanup operation, not a state-preserving observation of all amplitudes. `MakeMeasurementCircuit` checks that the basis array matches the declared register size before preparation and readout.

Repeated shots estimate probabilities and expectation values statistically. An ideal Bell experiment does not guarantee exactly fifty `00` and fifty `11` results in one hundred shots. Finite-sample uncertainty remains even with noiseless gates. Noise and qubit loss introduce additional issues that are not the same as this ordinary sampling uncertainty.

## Indexing conventions must be attached to the data

The written ket order in our two-qubit derivations was \(|q_0q_1\rangle\). The repository’s standardized executor bitstrings instead place the first returned bit at the **right-hand end** after conversion. The [result-processing code](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/algorithms/circuit_executor/qdk.py) reverses the raw result array while making its string.

The [executor test](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/tests/test_circuit_executor_qdk.py) makes this concrete: X on qubit zero of a two-qubit register gives raw results `One, Zero`, but the standardized count key is `"01"`. The same physical register assignment can therefore be written `|10⟩` in a q0-first explanatory ket and `"01"` in the result format. That is ordering, not a physical disagreement.

A little-endian integer convention assigns significance \(2^j\) to bit/qubit \(j\). A big-endian displayed ordering gives the leftmost listed bit the greatest significance. The [dense-preparation tests](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/tests/test_state_preparation_dense.py) explicitly handle Q# state-dump ordering, where the first allocated qubit is the most significant bit of the dense dump index. The [Python preparation builder](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/algorithms/state_preparation/dense_pure_state.py) uses a reversed `rowMap` to bridge its determinant-derived amplitude indexing to the Q# preparation.

Do not declare “QDK is always big endian” or “everything is little endian.” The interface matters: a state dump, an array of qubit handles, a Pauli label, and an executor count key can use different display/index conventions. Keep the conversion explicit, especially when not every qubit is measured.

## A concrete Circuit and execution handoff

The [executor tests](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/tests/test_circuit_executor_qdk.py) contain the following Bell-circuit structure in OpenQASM. The adapted example below shows the actual QDK Chemistry data/algorithm contract but was not executed:

```python
from qdk_chemistry.algorithms import create
from qdk_chemistry.data import Circuit

bell = Circuit(qasm="""
OPENQASM 3.0;
include "stdgates.inc";
qubit[2] q;
bit[2] c;
h q[0];
cx q[0], q[1];
c[0] = measure q[0];
c[1] = measure q[1];
""", num_qubits=2)
executor = create("circuit_executor", "qdk_sparse_state_simulator", seed=42)
results = executor.run(bell, shots=100)
counts = results.bitstring_counts
```

The ideal possible outcomes are `00` and `11`; no actual counts are being reported. The circuit explicitly measures, so the executor has classical results to return. A preparation-only operation returning `Unit` is not automatically a sampling program returning bitstrings.

[`CircuitExecutorData`](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/data/circuit_executor_data.py) contains count data, `total_shots`, executor identity, and optional execution metadata. Loss-affected outcomes, when an applicable noise model produces them, are separated into `loss_bitstrings` using `L`. Clean counts alone then need not sum to total shots. Full execution/noise policy is a later chapter; here the key distinction is between a prepared state, a returned classical sample, and metadata describing how it was produced.

## Circuit representations are descriptions at different stages

[`Circuit`](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/data/circuit.py) can hold OpenQASM text, QIR, a Q# circuit representation, or Q# factory data together with a composable operation. **OpenQASM** is a language for quantum programs. **QIR**, quantum intermediate representation, is a lower-level compiler interchange representation. **Q#** is the programming language used for many repository circuit routines. Changing formats is not itself execution on hardware.

A Q# factory stores a program and classical parameters from which a representation can be compiled when needed. `qsharp_op` is the callable used for composition; by itself it is not one of the constructor’s sufficient stored representations. The constructor requires QASM, QIR, a Q# circuit representation, or factory data. Conversion availability is also not universal: some QIR-to-QASM/Qiskit paths need the optional Qiskit integration.

The public data object resists ordinary attribute reassignment, but `get_qir()` can internally cache compiled QIR derived from its factory. This is a compiler-artifact cache, not a cached quantum state. Supplying several representations also does not independently prove they mean the same program; keep them tied to a consistent producer.

The known `num_qubits` field records the width of the register on which the supplied operation acts. **Internally allocated scratch qubits are not included in that declaration.** A compiler/resource estimate can therefore report a different peak width. `CircuitMetadata.num_phase_gradient_ancillas` describes special reusable trailing ancillas; it requires a declared width and cannot exceed that width. Their detailed preparation comes later, but even now we can see why one integer is not a complete physical-resource report.

## QDK Chemistry composes routines; the external QDK supplies the language runtime

The repository contains Q# source for state preparation, Pauli exponentials, controlled operations, measurement wrappers, and composition. It imports primitive gates and operations such as `PreparePureStateD`, `Exp`, and measurement/reset helpers from the external QDK standard library. Python’s [`QSHARP_UTILS` context helper](https://github.com/microsoft/qdk-chemistry/blob/97a3ff4f/python/src/qdk_chemistry/utils/qsharp/__init__.py) loads those chemistry utilities through a shared `qdk.Context`, created lazily. An isolated context can also be created when explicitly needed.

Operations composed together need compatible context ownership. A **target profile** limits which program capabilities the compiler accepts; it is not a complete choice of physical qubit technology or error-correcting code. The helper’s default profile is `Adaptive_RIF`; the Base-profile path loads only its supported subset of chemistry sources. None of those contexts was instantiated for this preparation.

`BeginEstimateCaching` in some repeated Q# wrappers is a resource-estimation facility. It helps the estimator handle repeated identical subroutines; it does not mean a physical device can apply an expensive unitary once and reuse the resulting unknown state for free. Repetition still belongs in the logical workload.

## Simulation, sampling, and resource counting are different computations

A **state-vector simulator** represents a quantum state on a classical computer and updates its amplitudes. A generic \(q\)-qubit vector has \(2^q\) complex amplitudes. As an illustrative storage model, complex128 amplitudes alone require sixteen GiB at thirty qubits. That is not a measurement of QDK’s implementation memory and excludes overhead.

Sparse-state simulation can exploit a state with few nonzero computational-basis amplitudes, but gates can rapidly grow that support. Special **Clifford** circuits—whose gates map Pauli operators to Pauli operators under conjugation—admit other efficient classical descriptions. H, S, and CNOT are examples; arbitrary rotations are not automatically in that class. The full-state executor exposes `type` choices `cpu`, `gpu`, and `clifford`, but a selectable value does not prove a corresponding device exists or that an arbitrary circuit is suitable for the Clifford backend.

The registered default executor is `qdk_sparse_state_simulator`; `qdk_full_state_simulator` uses the external QDK QIR simulation path. Both return measurement data through the executor interface. Their implementations are classical validation/execution backends, not evidence that a quantum device solved the molecule.

A physical quantum state is also not a cheap readable database of all \(2^q\) amplitudes. Reading it produces samples; learning a generic state requires many suitably chosen repeated preparations and measurements. Generic state preparation itself can be expensive. Useful quantum algorithms exploit problem structure and extract a chosen observable or phase, rather than compute every determinant energy and read all answers in parallel.

Resource counting asks yet another question: how many operations and qubits a program requires under a chosen compilation/cost model. `Circuit.estimate()` delegates supported Q# factory or QASM representations to external QDK estimation. `get_qre_application()` adapts available representations to the alternative `qdk.qre` interface. These are alternatives, not mandatory consecutive stages, and neither is a new chemistry calculation or a physical execution.

## Count the right things before discussing hardware

**Gate count** counts operations in a specified gate set. **Depth** counts sequential layers under a specified parallel scheduling/connectivity model. **Width** is the number of simultaneously live qubits. A circuit with many operations can reuse a small clean ancilla, while a short-depth implementation may use more concurrent work qubits. These are distinct tradeoffs.

A high-level `Exp` or rotation is not necessarily one cheap physical gate. It can decompose into many simpler operations, and synthesizing arbitrary rotations to a chosen precision changes later resource counts. Fault tolerance then encodes logical qubits and implements those operations with physical qubits and error-correction cycles. We defer those hardware/QEC models rather than invent a fixed number of physical qubits per chemical electron.

For a simple occupation-basis initializer of our six-active-electron, six-spatial-orbital model, one would allocate twelve occupation qubits and apply X to the six occupied spin-mode positions. That follows the repository’s single-reference preparation loop. It explains why six X operations do not imply only six system qubits, and why the eight inactive electrons are not another eight occupation qubits in that reduced model. Later state-preparation methods may require additional ancillas or different structure.

We now have the vocabulary to read a coherent circuit without mistaking amplitudes for probabilities, controls for measurements, or metadata widths for physical machines. The next lesson assigns electron occupations and fermionic signs to these registers by translating the Hamiltonian into Pauli and Majorana-based qubit representations.