Phase Kickback

You have already met, in the chapter on global vs relative phase, the rule that a phase on the whole state is invisible and a phase between components of a superposition is observable. That rule sounds mild. But combined with a controlled gate, it is the engine of quantum advantage.

Here is the setup, in one breath. A unitary U has an eigenstate |u\rangle — a state that U merely multiplies by a phase, U|u\rangle = e^{i\varphi}|u\rangle. In isolation, that phase e^{i\varphi} is global on |u\rangle: no measurement can detect it. But if you put a control qubit in |+\rangle = \tfrac{1}{\sqrt 2}(|0\rangle + |1\rangle) and fire a controlled-U with |u\rangle as the target, something subtle happens. The controlled gate applies U to the target on the |1\rangle branch of the control's superposition and leaves the target alone on the |0\rangle branch. The phase e^{i\varphi} gets attached only to one branch — so it stops being global and becomes a relative phase on the control. The control came in as |+\rangle; it leaves as \tfrac{1}{\sqrt 2}(|0\rangle + e^{i\varphi}|1\rangle). The target is unchanged.

That is phase kickback. One line of algebra, one sentence to state it, and the reason every quantum algorithm from Deutsch (1985) onward achieves a speedup. This chapter builds the full picture: the derivation, the worked examples, the mechanism it powers in Deutsch and Deutsch-Jozsa, and the preview of phase estimation and Shor that it sets up.

The setup — one eigenstate, one controlled gate

Start from the ingredients. You need a unitary U on a single target qubit, and you need to know one of its eigenstates.

An eigenstate of U is a state |u\rangle that U does not rotate — it only multiplies by a phase. Every unitary has eigenstates (a 2\times 2 unitary has two of them), and the phases e^{i\varphi_k} that go with the eigenstates are called the eigenvalues of U. Since U is unitary, the eigenvalues all have modulus 1 — they are points on the unit circle in the complex plane. For the Pauli-Z gate, the eigenstates are |0\rangle (eigenvalue +1) and |1\rangle (eigenvalue -1). For Pauli-X, they are |+\rangle (eigenvalue +1) and |-\rangle (eigenvalue -1). For a rotation R_z(\theta) about the z-axis, they are |0\rangle and |1\rangle again, with eigenvalues e^{-i\theta/2} and e^{+i\theta/2} respectively.

Why it is worth pausing on eigenstates: when a unitary meets one of its eigenstates, it does not rotate the Bloch sphere for that particular input — it only stamps a phase on it. That phase is the eigenvalue. Kickback is the trick of getting that phase out of the target (where it hides as a global phase) and onto the control (where a measurement can find it).

The controlled gate. Take a control qubit and a target qubit, and use the controlled-U recipe from the controlled-U gates chapter: apply U to the target when the control is |1\rangle; do nothing when the control is |0\rangle. On the four product states,

The input. Prepare the control in |+\rangle and the target in |u\rangle. The joint input state is

Two equal-amplitude branches on the control; the same eigenstate |u\rangle on the target for both branches. You are ready to kick the phase back.

The derivation — three lines of algebra

Apply controlled-U to |+\rangle|u\rangle and compute, term by term.

Line 1. Use the definition of controlled-U on each branch of the control's superposition:

Why: on the |0\rangle branch the gate does nothing, so the target |u\rangle stays put; on the |1\rangle branch the gate applies U to the target, turning |u\rangle into U|u\rangle. Linearity lets you treat the two branches independently and then add.

Line 2. Use the eigenvalue equation U|u\rangle = e^{i\varphi}|u\rangle to replace U|u\rangle with e^{i\varphi}|u\rangle:

Why: this step is where knowing that |u\rangle is an eigenstate pays off. If |u\rangle were not an eigenstate of U, U|u\rangle would be some other state entirely and you would not be able to factor |u\rangle back out. The eigenstate condition is what makes the kickback clean.

Line 3. The number e^{i\varphi} is a complex scalar. It commutes past the |1\rangle ket freely. And |u\rangle now appears on both branches, so it factors out of the whole expression:

Why the factoring is allowed: a scalar multiplier on one branch of a tensor product can be pulled out of the tensor product because c(|a\rangle|b\rangle) = (c|a\rangle)|b\rangle = |a\rangle(c|b\rangle) — scalars travel through the tensor symbol freely. Here c = e^{i\varphi} and the shared |u\rangle factors out onto the right.

Result — the phase-kickback formula.

Stare at this for twenty seconds. Three things have happened, and none of them looks like what you'd expect.

1. The target is unchanged. The control fired a U at it, but because |u\rangle is an eigenstate of U, the target came through untouched. (The factor e^{i\varphi} multiplied it, but a global phase on a lone state is invisible.)
2. The control's state has changed — from |+\rangle = \tfrac{1}{\sqrt 2}(|0\rangle + |1\rangle) to \tfrac{1}{\sqrt 2}(|0\rangle + e^{i\varphi}|1\rangle), a state with a non-trivial relative phase \varphi between its amplitudes. Different Bloch point. Different measurement probabilities in the X-basis. A different state, in every physical sense.
3. The two qubits are not entangled — the output is a product state, (\text{something on control})\otimes|u\rangle. Kickback is a non-entangling way of extracting phase information, which is the whole reason it is useful: the control ends up in a pure single-qubit state you can measure cleanly.

The phrase "phase kickback" is named after this move: the phase that U would have stamped on the target, as a global phase, has been kicked back onto the control as a relative phase. The verb is from the physicist's habit of imagining the information travelling backwards through the controlled gate — from the target where U physically acts, to the control that is "only watching."

A more careful look — why the phase wants to move

The kickback feels counter-intuitive on first encounter because classically, the control in a conditional operation is the sender and the target is the receiver. "If the condition is true, modify the target." So information flows control → target. Why, then, does the phase flow target → control?

Two reasons, which are really one reason seen from two angles.

The linearity angle. Quantum mechanics is linear. When the control is in a superposition, the controlled-U applies two different things to the target-control pair simultaneously — one thing on the |0\rangle branch, another on the |1\rangle branch. If the target is the same on both branches before the gate (|u\rangle) and the same on both branches after the gate (still |u\rangle, because it is an eigenstate), then the only difference between the branches is whatever factor the gate introduced. That factor is e^{i\varphi}, and it lives on the |1\rangle branch. The phase has nowhere to go except as a relative factor on the control's two amplitudes.

The global-to-relative angle. You saw in the global vs relative phase chapter that a phase on a whole state is invisible, but a phase on one branch of a superposition is observable. In isolation, U|u\rangle = e^{i\varphi}|u\rangle means |u\rangle and e^{i\varphi}|u\rangle are the same physical state — the phase is global and vanishes from every measurement. But inside the controlled gate, the |1\rangle branch of the control "holds" the phase-multiplied version of the target, and the |0\rangle branch holds the untouched version. Those are two branches of a joint superposition, with a relative factor e^{i\varphi} between them. A global phase on a subsystem, once that subsystem is one branch of a bigger superposition, becomes a relative phase of the bigger state.

The worked examples

Kickback inside Deutsch's algorithm

The first time kickback was used deliberately was in Deutsch's algorithm (1985), though the word "kickback" was not used and Deutsch described the move in a different language. You already know the algorithm from its own chapter; here you will see why the ingredient list is the kickback recipe.

Deutsch's problem: given a function f: \{0,1\} \to \{0,1\}, promised to be either constant (f(0) = f(1)) or balanced (f(0) \ne f(1)), decide which with one oracle query. The oracle is implemented as the two-qubit unitary

where \oplus is XOR. This is the standard reversible encoding of any classical function — the oracle writes f(x) into the target's value, while keeping the input.

The algorithm sets the input register to |x\rangle (a superposition over both inputs, after a Hadamard) and the target register to |-\rangle = \tfrac{1}{\sqrt 2}(|0\rangle - |1\rangle). Now watch what U_f does to |x\rangle|-\rangle for each choice of x:

Case f(x) = 0. The target is |-\rangle, and y \oplus 0 = y, so the oracle does nothing:

Case f(x) = 1. The target is |-\rangle = \tfrac{1}{\sqrt 2}(|0\rangle - |1\rangle), and y \oplus 1 flips |0\rangle \leftrightarrow |1\rangle. Apply the flip inside the |-\rangle:

So U_f\,|x\rangle|-\rangle = -|x\rangle|-\rangle.

Putting both cases together:

The target came out unchanged (it is an eigenstate of the oracle), and the eigenvalue (-1)^{f(x)} landed on the input register as a phase. This is exactly phase kickback: |-\rangle is an eigenstate of the XOR-flip operation with eigenvalue \pm 1, and controlled on the input |x\rangle, the eigenvalue (-1)^{f(x)} is kicked back onto |x\rangle.

The rest of Deutsch's algorithm — Hadamard the input, measure — is the machinery that reads out the kicked-back phase. The kickback itself is the line above. Once you see that, every quantum algorithm that uses an oracle takes on a consistent shape: put the target in |-\rangle (or another eigenstate), apply the oracle, and the oracle's output lands as a phase on the input register, which interference can then decode.

What kickback is good for — three classes of algorithm

Kickback is not a curiosity; it is the primitive on which most quantum advantages are built. Three broad classes of algorithm depend on it.

Oracle-decision algorithms. Deutsch's algorithm, Deutsch-Jozsa, Bernstein-Vazirani, and Simon's algorithm all use the same |-\rangle-target-eigenstate trick. The oracle U_f kicks back the phase (-1)^{f(x)} onto the input register; subsequent Hadamards turn that pattern of \pm 1's into a distinguishable measurement outcome. Without kickback, the (-1)^{f(x)} would be trapped in the target's invisible global phase and nothing could be inferred.

Phase estimation. Given a unitary U and an eigenstate |u\rangle with eigenvalue e^{2\pi i \theta}, quantum phase estimation estimates \theta to n-bit precision using n control qubits and O(2^n) applications of U. The circuit shape: prepare the n controls in |+\rangle^{\otimes n} and the target in |u\rangle; apply controlled-U^{2^k} with the k-th control; do an inverse QFT on the controls; measure. Each controlled-U^{2^k} kicks e^{2\pi i \theta \cdot 2^k} onto its control — a specific pattern of kickbacks that the inverse QFT decodes into the binary digits of \theta.

Grover's algorithm. Grover's amplitude-amplification search uses kickback for a different purpose. The oracle for Grover marks the solution by flipping its sign: |\text{good}\rangle \to -|\text{good}\rangle, other states untouched. Phrased another way, the marked state picks up eigenvalue -1 from the oracle, and an unmarked state picks up eigenvalue +1 — the oracle's action is diagonal in the computational basis, and every basis state is an eigenstate. The "-1 on the good state" is exactly the kicked-back phase that reflection operations later amplify into probability.

Shor's factoring algorithm. Shor's algorithm reduces integer factoring to order-finding, and order-finding is a phase-estimation call on the modular-multiplication operator U_a: |x\rangle \to |ax \bmod N\rangle. The eigenvalues of U_a encode the order r (the smallest integer with a^r \equiv 1 \pmod N) in their phases, and phase estimation — which is a tower of kickbacks followed by an inverse QFT — reads out r. From r a classical step produces a factor of N. The speedup from exponential (classical) to polynomial (quantum) lives entirely in the phase-estimation-and-therefore-kickback step.

Common confusions

• "Phase kickback only works when the target is |-\rangle." Only for Deutsch-style problems where the oracle acts as |x\rangle|y\rangle \to |x\rangle|y \oplus f(x)\rangle, and |-\rangle happens to be the eigenstate with eigenvalue (-1)^{f(x)} of that oracle's target action. The general phase-kickback principle works with any eigenstate of any unitary U: the eigenvalue e^{i\varphi} lands on the control, whatever \varphi and U are. |-\rangle is just the specific eigenstate that gives a \pm 1 phase for Boolean-function oracles.

• "The target changes during kickback." It does not. If |u\rangle is an eigenstate of U with eigenvalue e^{i\varphi}, then U|u\rangle = e^{i\varphi}|u\rangle, which is the same physical state as |u\rangle (global phase is invisible). The target exits the gate in the same state it entered. Only if the target is not an eigenstate does it actually change — and in that case the kickback "smears out" across the eigenbasis and the control gets entangled with the target rather than coming out clean.

• "Kickback only works for controlled unitaries." Kickback is specifically a feature of controlled operations. The word "controlled" is what makes the phase attach to only one branch of the control's superposition. Without the control — i.e. applying U directly, unconditionally, to |u\rangle — the phase e^{i\varphi} stays global on |u\rangle and you cannot observe it. The control + superposition combination is what turns global into relative.

• "Phase kickback violates the definition of a controlled gate." The rule "controlled-U applies U only when the control is |1\rangle" is still satisfied exactly. What happens is that applying U to an eigenstate produces a phase-multiplied version of the same eigenstate. That phase-multiplied output then factors out of the superposition onto the control. The gate is not violating its rule — it is enforcing the rule, and the rule combined with the eigenstate condition produces the kickback.

• "If the target is in a superposition, kickback still gives a clean control output." Only if that superposition happens to be an eigenstate of U. If the target is a general superposition |\psi\rangle = \sum_k c_k |u_k\rangle over different eigenstates |u_k\rangle with different eigenvalues e^{i\varphi_k}, each eigenvalue kicks back with a different phase on a different branch, and the control becomes entangled with the target. A clean, factorable kickback requires the target to be a single eigenstate (or, for phase-estimation purposes, a known linear combination of eigenstates whose phases you want to extract simultaneously).

• "Phase kickback is a pedagogical analogy, not a computational mechanism." It is the computational mechanism. Every line of Shor's algorithm's speedup over classical factoring lives in the kickback step of phase estimation. A classical computer cannot do the kickback trick because it has no notion of a phase on a branch of a superposition — the branches do not exist classically. That this specific quantum-mechanical move (global phase becoming relative phase through a controlled gate) is what classical algorithms cannot simulate efficiently is, in a real sense, the source of quantum advantage for these problems.

Going deeper

The spectral-decomposition derivation

Any unitary U acting on a finite-dimensional Hilbert space has a spectral decomposition — a representation as a sum of projectors onto its eigenstates, weighted by eigenvalues:

where the |u_k\rangle are an orthonormal eigenbasis and e^{i\varphi_k} are the corresponding eigenvalues (all of modulus 1, since U is unitary).

Now take a general target state and expand it in this basis: |\psi\rangle = \sum_k c_k |u_k\rangle, where c_k = \langle u_k|\psi\rangle. Apply the controlled-U to |+\rangle|\psi\rangle:

Regroup:

This is an entangled state between the control and the target — unless only one c_k is non-zero (i.e. |\psi\rangle is a single eigenstate), the control qubit is in a different "kicked" state for each eigencomponent of the target, and you cannot factor the two qubits apart. The kickback has happened, but it has happened to every eigenvalue simultaneously and is now correlated with which eigenstate the target lives in.

This is not a bug — it is the feature that powers quantum phase estimation. If the target is a single eigenstate, you extract that one eigenvalue cleanly. If the target is a superposition of eigenstates, you extract a superposition of eigenvalues, and a measurement of the control register reveals one of them probabilistically (with probability |c_k|^2). Either way, the kickback has transferred the eigenvalue information from the target's (invisible) phase into the control's (measurable) state.

Multiple controls — the phase-estimation tower

Scale up. Take n control qubits, each initialised to |+\rangle, and a single target in an eigenstate |u\rangle of U with eigenvalue e^{2\pi i \theta}. For each control k \in \{0, 1, \ldots, n-1\}, apply controlled-U^{2^k} with the k-th control as control and the single target as target.

The key identity: if U|u\rangle = e^{2\pi i \theta}|u\rangle, then U^{2^k}|u\rangle = e^{2\pi i \theta \cdot 2^k}|u\rangle. So the k-th controlled gate kicks back a phase e^{2\pi i \theta \cdot 2^k} onto the k-th control. After all n controlled gates:

The control register now holds a specific phase pattern — e^{2\pi i \theta}, e^{4\pi i \theta}, e^{8\pi i \theta}, \ldots — which, after an inverse quantum Fourier transform, collapses to a measurement outcome that reads out the binary digits of \theta. The tower of controlled-U^{2^k} gates, each kicking back its own power of the eigenvalue, is the core structural fact of the phase-estimation algorithm.

Why kickback is the quantum-advantage mechanism

Here is the paragraph-length version of a claim that quantum information researchers have argued for years. Classical computers can simulate superposition (by tracking amplitudes as a list of complex numbers) and can simulate unitary operations (by matrix multiplication). What they cannot do efficiently — what takes exponential time on a classical computer for generic large quantum states — is track the interference patterns that emerge when different branches of a superposition carry different phases and are then recombined. Phase kickback produces exactly such a pattern: it places a phase on a specific branch of a control's superposition, phases that differ from one controlled gate to the next, and the interference between those phased branches (after Hadamards or QFTs) is what decodes the computation. The speedup in Shor's, Grover's, and Simon's algorithms is directly traceable to the fact that a polynomial number of kickbacks produces a phase pattern whose interference, classically, would require an exponentially large calculation to simulate.

This is why the "quantum computer tries every answer at once" slogan is misleading. What a quantum computer actually does is: kick phases onto controls via controlled-unitaries, recombine those phases through interference, and measure the result. "Trying every answer" would only be parallel brute force (no speedup for most problems); kickback-and-interference is a fundamentally different mechanism and the real source of advantage.

The Elitzur-Vaidman bomb test — kickback in disguise

A curiosity to show the reach of the idea. In 1993, Elitzur and Vaidman proposed an "interaction-free measurement": a scheme that determines whether a bomb is live (would detonate if a photon hit it) or dud (would not) without the photon ever hitting the bomb. The scheme uses a Mach-Zehnder interferometer — a device that splits a photon into two paths and recombines them — with the bomb placed in one arm.

Translated into quantum-computing language: the photon's "which-path" state is a qubit in |+\rangle; the bomb acts as an oracle on one path, mapping the photon into an orthogonal "detonated" state (the analogue of picking up a phase) if the bomb is live. If the bomb is live, the kickback makes the interferometer's output register the phase kick — with some non-zero probability the photon emerges in the "wrong" port, a port that would be impossible without the phase. If the bomb is dud, no kickback, and the photon always goes to the "right" port. Observing a "wrong"-port detection proves the bomb is live and proves the photon did not hit it.

The setup is really a single-qubit phase-kickback circuit dressed up in beam-splitter language. It is the same mathematics and the same physics — a phase that, on a single branch of a superposition, becomes observable through interference — and it won Elitzur and Vaidman an Antonelli prize in 1993 and a place in every introductory quantum foundations course.

The Indian context — this is everyone's trick

Phase kickback is a universal piece of quantum machinery; it does not belong to any one country or group. But the Indian quantum-computing community has worked with it extensively — the National Quantum Mission supports groups at TIFR, IISc Bangalore, and the IITs developing phase-estimation-based algorithms for quantum chemistry and finance. When the mission's target of building a 1000-qubit quantum computer is met, the first "useful" algorithms it runs will almost certainly be phase-estimation circuits — which is to say, kickback towers.

Where this leads next

• Deutsch-Jozsa — the n-qubit generalisation of Deutsch, the first algorithm to show an exponential quantum-classical query separation, built entirely on phase kickback.
• Quantum Phase Estimation — the tower of kickbacks that estimates eigenvalues of unitaries; the workhorse subroutine of modern quantum algorithms.
• Shor's Algorithm — order-finding via phase estimation, and factoring via order-finding. The speedup lives in the kickback.
• Grover's Algorithm — the -1 oracle eigenvalue on marked states, kicked back and amplified by reflection.
• Controlled-U Gates — the gate family that makes kickback possible.
• Global vs Relative Phase — the prerequisite rule that a global phase on a branch of a superposition is a relative phase of the whole.

References

1. Wikipedia, Phase kickback (within Quantum phase estimation) — the standard encyclopaedic treatment, with circuit diagrams.
2. John Preskill, Lecture Notes on Quantum Computation, Ch. 6 (quantum algorithms) — theory.caltech.edu/~preskill/ph229.
3. Nielsen and Chuang, Quantum Computation and Quantum Information, §1.4 (the first quantum algorithms, including Deutsch's kickback) — Cambridge University Press.
4. Cleve, Ekert, Macchiavello, Mosca, Quantum algorithms revisited (1998) — a unified treatment of Deutsch, Deutsch-Jozsa, Simon, and Shor through the phase-kickback lens. arXiv:quant-ph/9708016.
5. Qiskit Textbook, Phase kickback — runnable examples in Qiskit, with controlled-T and controlled-phase kickback.
6. Wikipedia, Quantum phase estimation algorithm — the tower-of-kickbacks construction that Shor uses.