Understanding Phase Kickback in Quantum Computing

Consider a classical reversible CNOT gate with control bit c and target bit t. The output is (c, t ⊕ c). If c = 0, t is unchanged; if c = 1, t flips. At no point can t alter the state of c. The control bit is strictly immune to the target.

Now consider a general quantum controlled unitary gate, denoted as C–U, acting on a control qubit and a target register. The unitary operator U acts on the target if and only if the control qubit is |1⟩:

C-U |0⟩ |ψ⟩ = |0⟩ |ψ⟩
C-U |1⟩ |ψ⟩ = |1⟩ (U |ψ⟩)

What happens if the target state |u⟩ is an eigenstate of U with eigenvalue λ = e^iθ (so that U |u⟩ = e^iθ |u⟩)?

• If the control is |0⟩: C–U |0⟩ |u⟩ = |0⟩ |u⟩.
• If the control is |1⟩: C–U |1⟩ |u⟩ = |1⟩ (U |u⟩) = |1⟩ (e^iθ |u⟩) = e^iθ |1⟩ |u⟩.

Now, place the control qubit in an arbitrary superposition |φ⟩ = α |0⟩ + β |1⟩. By the linearity of quantum mechanics:

C-U [ (α |0⟩ + β |1⟩) ⊗ |u⟩ ] = α |0⟩ |u⟩ + β eiθ |1⟩ |u⟩
                              = [ (α |0⟩ + β eiθ |1⟩) ] ⊗ |u⟩

The cleanest and most famous physical illustration of phase kickback occurs with a Controlled-NOT (CNOT) gate. The target operator for a CNOT is the Pauli X gate (bit-flip):

X |0⟩ = |1⟩,    X |1⟩ = |0⟩

The eigenstates of X are the Hadamard basis states:

• State |+⟩ = ( |0⟩ + |1⟩ ) / √2 with eigenvalue +1 (X |+⟩ = +|+⟩).
• State |−⟩ = ( |0⟩ − |1⟩ ) / √2 with eigenvalue −1 (X |−⟩ = −|−⟩).

Let us set the control qubit to q₀ = |+⟩ and the target qubit to q₁ = |−⟩. We trace the two-qubit joint statevector through four explicit algebraic steps:

Step 1 — Formulate the Unentangled Tensor Input

|ψ0⟩ = |+⟩ ⊗ |−⟩ = [ (|0⟩ + |1⟩) / √2 ] ⊗ [ (|0⟩ − |1⟩) / √2 ]

Step 2 — Expand into the Computational Basis

|ψ0⟩ = (1/2) [ |00⟩ − |01⟩ + |10⟩ − |11⟩ ]

Step 3 — Apply the CNOT Gate (Control q₀, Target q₁)

The CNOT flips the target bit if and only if the control bit is 1. Thus, |00⟩ → |00⟩, |01⟩ → |01⟩, but |10⟩ → |11⟩ and |11⟩ → |10⟩:

|ψ1⟩ = (1/2) [ |00⟩ − |01⟩ + |11⟩ − |10⟩ ]

Step 4 — Regroup and Factorize the Output

|ψ1⟩ = (1/2) [ |0⟩(|0⟩ − |1⟩) − |1⟩(|0⟩ − |1⟩) ]
     = [ (|0⟩ − |1⟩) / √2 ] ⊗ [ (|0⟩ − |1⟩) / √2 ]
     = |−⟩ ⊗ |−⟩

Figure 1: Two-qubit CNOT Phase Kickback circuit. The control qubit q0 flips from |+⟩ to |−⟩ while target q1 remains invariant in |−⟩.

While CNOT illustrates phase kickback for an elementary bit-flip, quantum algorithms require evaluating general mathematical functions. In standard quantum oracle formulations, a black-box function f: {0, 1} → {0, 1} (or f: {0, 1}ⁿ → {0, 1}) is implemented as a unitary transformation U_f:

Uf |x⟩ |y⟩ = |x⟩ |y ⊕ f(x)⟩

Here, |x⟩ is the first qubit (the input/control register) and |y⟩ is the auxiliary target qubit. If we prepare the auxiliary target qubit in |−⟩ = ( |0⟩ − |1⟩ ) / √2, watch the action of U_f on any computational basis state |x⟩:

Uf |x⟩ |−⟩ = Uf |x⟩ [ (|0⟩ − |1⟩) / √2 ]
            = [ |x⟩ |0 ⊕ f(x)⟩ − |x⟩ |1 ⊕ f(x)⟩ ] / √2

• If f(x) = 0: [ |x⟩|0⟩ − |x⟩|1⟩ ] / √2 = (+1) |x⟩ |−⟩ = (−1)0 |x⟩ |−⟩
• If f(x) = 1: [ |x⟩|1⟩ − |x⟩|0⟩ ] / √2 = (−1) [ |x⟩|0⟩ − |x⟩|1⟩ ] / √2 = (−1)1 |x⟩ |−⟩

Because (−1)⁰ = +1 and (−1)¹ = −1, both branches unify into an exact, compact identity for all inputs x ∈ {0, 1}:

Uf |x⟩ |−⟩ = (−1)f(x) |x⟩ |−⟩

What Happens When the First Qubit Is in Superposition?

Now prepare the first qubit in the equal superposition state |ψ_in⟩ = |+⟩ = ( |0⟩ + |1⟩ ) / √2. The composite input state entering the oracle is:

|ψ0⟩ = |+⟩ ⊗ |−⟩ = [ ( |0⟩ + |1⟩ ) / √2 ] ⊗ |−⟩ = (1/√2) |0⟩ |−⟩ + (1/√2) |1⟩ |−⟩

Applying the linear operator U_f evaluates each basis state simultaneously:

Uf |ψ0⟩ = (1/√2) Uf |0⟩ |−⟩ + (1/√2) Uf |1⟩ |−⟩
        = (1/√2) (−1)f(0) |0⟩ |−⟩ + (1/√2) (−1)f(1) |1⟩ |−⟩

Now, factor out the auxiliary target state |−⟩:

Uf |ψ0⟩ = [ (−1)f(0) |0⟩ + (−1)f(1) |1⟩ ] / √2  ⊗  |−⟩

Look closely at this output state:

1. The Target Qubit Is Invariant: The auxiliary qubit remains entirely in state |−⟩, unentangled with the first qubit, and carries no function data.
2. The First Qubit Acquires the Phase: The value of f(0) appears as a phase factor on the |0⟩ branch, and f(1) appears as a phase factor on the |1⟩ branch. The first qubit has directly acquired the (−1)^f(x) phase factor!
3. Information Transformation: The oracle did not write f(x) into an auxiliary bit register to be read classically. Instead, it encoded the function values directly into the relative quantum phase of the first qubit.

Figure 2: The canonical Phase Kickback Oracle circuit. Ancilla target q1 is prepared in |−⟩; after oracle evaluation, the (−1)^f(x) phase is acquired by input qubit q0 and decoded via Hadamard H.

Now that the first qubit holds the state [ (−1)^f(0) |0⟩ + (−1)^f(1) |1⟩ ] / √2, can we simply measure it in the standard computational basis?

No. In the standard Z-basis, the measurement probability for state |0⟩ is |(−1)^f(0) / √2|² = 1/2, and for |1⟩ is |(−1)^f(1) / √2|² = 1/2. Measuring immediately would yield a completely random coin toss, obliterating the phase information!

To observe the acquired phase, we factor out (−1)^f(0) as an unobservable global phase:

|ψ⟩ = (−1)f(0) [ |0⟩ + (−1)f(0) ⊕ f(1) |1⟩ ] / √2

Notice that the state of the first qubit depends strictly on whether f(0) = f(1) (Constant) or f(0) ≠ f(1) (Balanced):

By applying a final Hadamard gate H to the first qubit, constructive and destructive interference rotates the relative phase back into amplitude. If the function is constant, the amplitudes for |1⟩ destructively cancel to 0; if the function is balanced, the amplitudes for |0⟩ destructively cancel to 0. A single deterministic measurement extracts a global property of f(x) that classically requires two queries.

Phase kickback is not a one-off trick for the Deutsch algorithm. It is the core mathematical mechanism that connects almost all known quantum speedups:

The Python script below implements and verifies Phase Kickback using Qiskit 2.5+. First, it demonstrates the CNOT kickback by tracking exact statevectors; second, it implements the general oracle circuit and demonstrates how the (−1)^f(x) phase acquired by the first qubit enables deterministic function classification:

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.primitives import StatevectorSampler

# ----------------------------------------------------------------------
# 1. VERIFY CNOT PHASE KICKBACK VIA STATEVECTORS
# ----------------------------------------------------------------------
print("=" * 60)
print("1. CNOT PHASE KICKBACK: |+> (x) |->  --->  |-> (x) |->")
print("=" * 60)

# In Qiskit, qubit ordering in statevector notation is |q1 q0>
qc_cnot = QuantumCircuit(2)
qc_cnot.h(0)  # q0 (control) = |+>
qc_cnot.x(1)  # q1 (target)  = |1>
qc_cnot.h(1)  # q1 (target)  = |->

sv_before = Statevector(qc_cnot)
print("State BEFORE CNOT (|q1 q0> = |-> ⊗ |+>):")
print(sv_before.data.round(3))

# Apply CNOT: q0 controls q1
qc_cnot.cx(0, 1)

sv_after = Statevector(qc_cnot)
print("\nState AFTER CNOT (|q1 q0> = |-> ⊗ |->):")
print(sv_after.data.round(3))
print("Notice: Control qubit q0 acquired the -1 phase and flipped to |->!")

# ----------------------------------------------------------------------
# 2. VERIFY (-1)^f(x) ORACLE PHASE KICKBACK
# ----------------------------------------------------------------------
print("\n" + "=" * 60)
print("2. ORACLE PHASE KICKBACK: ENCODING (-1)^f(x) INTO FIRST QUBIT")
print("=" * 60)

def build_oracle(f_type: str) -> QuantumCircuit:
    """Constructs the unitary oracle U_f: |x>|y> -> |x>|y ^ f(x)>."""
    oracle = QuantumCircuit(2, name=f_type)
    if f_type == "constant_0":
        pass                  # f(x) = 0 (Identity)
    elif f_type == "constant_1":
        oracle.x(1)           # f(x) = 1 (Unconditional flip on target)
    elif f_type == "balanced_identity":
        oracle.cx(0, 1)       # f(x) = x (CNOT)
    elif f_type == "balanced_not":
        oracle.x(0)
        oracle.cx(0, 1)       # f(x) = NOT x
        oracle.x(0)
    return oracle

def run_kickback_experiment(f_type: str):
    qc = QuantumCircuit(2, 1)
    
    # State preparation: q0 (input) in |+>, q1 (auxiliary) in |->
    qc.h(0)
    qc.x(1)
    qc.h(1)
    qc.barrier()
    
    # Oracle: applies (-1)^f(x) directly to q0
    oracle = build_oracle(f_type)
    qc.compose(oracle, inplace=True)
    qc.barrier()
    
    # Interference: decode relative phase on first qubit via H
    qc.h(0)
    qc.measure(0, 0)
    
    sampler = StatevectorSampler()
    res = sampler.run([qc], shots=100).result()
    counts = res[0].data.c.get_counts()
    decision = "CONSTANT" if "0" in counts and counts["0"] == 100 else "BALANCED"
    return counts, decision

oracles = ["constant_0", "constant_1", "balanced_identity", "balanced_not"]
print(f"{'Oracle Function':<22} | {'Measurement (q0)':<18} | {'Verdict':<10}")
print("-" * 56)
for name in oracles:
    counts, verdict = run_kickback_experiment(name)
    print(f"{name:<22} | {str(counts):<18} | {verdict:<10}")

Terminal Execution Output:

============================================================
1. CNOT PHASE KICKBACK: |+> (x) |->  --->  |-> (x) |->
============================================================
State BEFORE CNOT (|q1 q0> = |-> ⊗ |+>):
[ 0.5+0.j  0.5+0.j -0.5+0.j -0.5+0.j]

State AFTER CNOT (|q1 q0> = |-> ⊗ |->):
[ 0.5+0.j -0.5+0.j -0.5+0.j  0.5+0.j]
Notice: Control qubit q0 acquired the -1 phase and flipped to |->!

============================================================
2. ORACLE PHASE KICKBACK: ENCODING (-1)^f(x) INTO FIRST QUBIT
============================================================
Oracle Function        | Measurement (q0)   | Verdict   
--------------------------------------------------------
constant_0             | {'0': 100}         | CONSTANT  
constant_1             | {'0': 100}         | CONSTANT  
balanced_identity      | {'1': 100}         | BALANCED  
balanced_not           | {'1': 100}         | BALANCED  

Malcolm Low is an Associate Professor at the Singapore Institute of Technology, writing on quantum computing, programming, and applied computing from Singapore.

Website: malcolmlow.com  ·  Singapore

What is phase kickback in quantum computing?

Phase kickback is a quantum phenomenon where a controlled unitary operation applied to a target qubit in an eigenstate leaves the target qubit unchanged while transferring the eigenvalue phase factor directly back onto the control qubit.

Why does the first qubit acquire a (-1)^f(x) phase factor in quantum oracles?

In a standard oracle U_f |x⟩ |y⟩ = |x⟩ |y ⊕ f(x)⟩, preparing the auxiliary target qubit in |−⟩ = ( |0⟩ − |1⟩ ) / √2 causes U_f to evaluate as [ |x⟩ |0 ⊕ f(x)⟩ − |x⟩ |1 ⊕ f(x)⟩ ] / √2. When f(x)=0, this equals (+1)|x⟩ |−⟩; when f(x)=1, it equals (−1)|x⟩ |−⟩. Factoring out the invariant |−⟩ leaves the first qubit multiplied by (−1)^f(x).

Why can’t we measure the (-1)^f(x) phase directly?

In quantum mechanics, measurement in the computational Z-basis measures state probabilities proportional to |α|² and |β|². Because |(−1)^f(x)|² = 1, the sign disappears upon immediate measurement. Applying a Hadamard gate rotates the phase difference into amplitude interference, making the phase deterministically readable.

How does phase kickback differ from quantum entanglement?

In phase kickback, the joint state remains completely separable before and after the controlled operation (|ψ⟩ = |−⟩ ⊗ |−⟩). No entanglement is created because the target qubit is an eigenstate of the gate operator. In contrast, entanglement occurs when a controlled gate couples non-eigenstates into an inseparable statevector.