Part II. Mathematical Core

Unitary Operations and Reversibility

One short equation — $U^{†} U = I$ — decides whether a matrix is allowed to be a quantum gate, and it buys something classical computing spent decades throwing away: every legal gate can be run backwards.

Listen to this chapter

Reversibility falls out of norm preservation for free: any operation that keeps every state valid automatically has an inverse, so everything that cannot be undone — measurement, reset, deletion — lives outside the gate model by definition.

By the end you will be able to certify a candidate gate with one matrix product, say exactly what its inverse is, and explain why a classical subroutine often needs ancilla registers and uncomputation before it can appear inside a quantum circuit.

Core concepts: unitarity, conjugate transpose, reversibility, inner-product preservation.

Notice that the loop closes exactly. Because U preserves length, U† undoes it with no information lost, no ancilla, and no approximation — a property measurement can never offer.

Unitarity in one line

A unitary operation preserves the length of every state vector, and it preserves the inner product between any two of them. Valid states stay valid, and distinguishability relationships survive closed-system evolution intact.

The whole doctrine fits in one equation:

U^{†} U = I

Here $U^{†}$ is the conjugate transpose of $U$ and $I$ is the identity. When the equation holds, the inverse exists and is handed to you:

U^{- 1} = U^{†}

That is the entire reason quantum gates are reversible. Undoing a gate never requires a search or a checkpoint — only the adjoint of the matrix you already used.

What preservation guarantees

Computing $U^{†} U$ and getting the identity certifies norm preservation for every input state, not just the one you tested. Unitarity also preserves overlaps:

⟨ U a ∣ U b ⟩ = ⟨ a ∣ b ⟩

The consequence is profound: a closed-system gate can never merge two distinct states into one. If it could, the inner product between them would change from zero to one, and the equation above forbids it. Measurement and noise can destroy that kind of information — which is precisely why they are modeled as different processes, outside the unitary framework.

Worked example: two candidates, one verdict each

Is Pauli X a legal gate?

X = (0110)

Its entries are real, so $X^{†} = X^{T} = X$ , and:

X^{†} X = X X = (1001) = I

Certified. X is unitary and its own inverse — applying it twice returns the original state, which you can verify on any input you like.

Now a non-unitary candidate:

A = (1000)

This maps $∣1 ⟩$ to the zero vector, destroying normalization, and it maps both $∣0 ⟩$ and $∣1 ⟩$ onto the same ray — information is gone. A is a projection, a useful operation in its place, but it can never appear as a closed-system gate.

Where the intuition fails

The first trap is assuming every useful mathematical operation can be a gate. Projection, deletion, reset, and most nontrivial classical functions are useful and none of them is unitary. Each needs measurement, environment interaction, a reset procedure, or a reversible embedding before it fits in a circuit.

The second trap is checking a candidate on one favorite input. A matrix can preserve the norm of $∣0 ⟩$ while mangling superpositions. The unitarity product checks all inputs at once — that is why you compute it instead of spot-testing.

The engineering view

Unitarity works like a type constraint on quantum operations. A function that is trivial in ordinary code — compare-and-overwrite, say — may be illegal as a direct gate, and implementing it in a circuit typically requires reversible logic, ancilla registers, and a final uncomputation pass to clean the ancillas up.

This has teeth for resource estimates. When a paper treats a complex classical subroutine as a free unitary oracle, the cost has not vanished; it is hiding in the reversible implementation. Ask for it.

Keep the boundary straight: measurement, reset, noise, and discarding information are legitimate parts of a full computation, but they are not unitary gates. A serious circuit description says which layer each operation belongs to, instead of hiding every physical effect inside one box.

What this buys you in diligence

When you assess a quantum software or algorithm claim, sort the operations: which are unitary, which are measurements, which are resets, and which are classical pre- or post-processing wearing a quantum costume? A credible architecture separates the layers cleanly. A weak claim blurs them — usually because the blurring is what makes the numbers look good.

Exercise

Certify a candidate gate. Pick any $2 \times 2$ matrix — try $(1011)$ if you want a surprise — and put it through the full test.

Submit: the complete product $U^{†} U$ , entry by entry, and your verdict on whether the matrix can be a closed-system quantum gate.
Check: state whether the operation is reversible, and if it is, write its inverse. If it is not, exhibit one input whose norm it fails to preserve.
Repair: if you tested only one input vector or skipped the conjugate transpose, redo Chapter 10 (Inner Products, Orthogonality, and Projection) before continuing.

Check your understanding

Answer without notes: given a candidate matrix, how do you decide whether it preserves valid quantum states, and what does the answer buy you?

A passing answer computes the adjoint product, compares it with the identity, and concludes both norm preservation and the existence of an inverse — without testing individual states one by one.

Oral defense: starting only from $U^{†} U = I$ , prove that a unitary preserves inner products between arbitrary states.

If you get stuck

If the conjugate transpose or the product itself is shaky, repair with Chapter 10 (Inner Products, Orthogonality, and Projection). If the gate semantics are the problem, revisit Chapter 11 (Matrices as Gates). Unitarity is where those two threads meet.