Phase Kickback

Phase kickback is the coherent conversion of a target eigenvalue into a relative phase on a selector register. Nothing travels backward through the circuit: one joint unitary acts on both registers, the target returns on a common ray, and the selector branches retain the eigenvalue phases. Those phases become useful only when a later interference experiment makes their differences observable.

This page owns the reusable phase-transduction contract. It develops common-eigenstate kickback, the clean Boolean XOR-to-phase identity, modular-addition kickback with character states, compute–phase–uncompute, complementary readout, resource accounting, and phase-sensitive verification. It does not own any named algorithm’s promise, correctness proof, query advantage, or end-to-end cost.

Required background. Controlled Operations supplies projector-controlled branches, coherent-versus-classical control, branch-relative phase, the generic target-entanglement criterion, and the access assumptions needed before a controlled operator may be used.

Phase Kickback as Coherent Phase Transduction

Let a selector register have orthonormal basis $\{|x\rangle:x\in X\}$, and let $V_x$ be a unitary on a target register. The block-controlled operator is

$$W = \sum_{x\in X} |x\rangle\langle x|\otimes V_x.$$

For a selector state and normalized target

$$|\psi\rangle = \sum_x\alpha_x|x\rangle, \qquad \langle\eta|\eta\rangle=1,$$

suppose every populated branch sees the same target as an eigenstate:

$$V_x|\eta\rangle = e^{i\theta_x}|\eta\rangle \quad\text{whenever}\quad \alpha_x\ne0.$$

Linearity then gives

$$\begin{aligned} W|\psi\rangle|\eta\rangle &= \sum_x\alpha_x|x\rangle V_x|\eta\rangle\\ &= \left( \sum_x\alpha_xe^{i\theta_x}|x\rangle \right)|\eta\rangle. \end{aligned}$$

Thus the target returns exactly, while the selector undergoes the diagonal unitary

$$D_\theta = \sum_xe^{i\theta_x}|x\rangle\langle x|.$$

This algebra is the core of kickback, but it is not yet a complete scientific claim. One must still identify the phase convention, license the controlled access, account for target-state preparation and garbage, choose a phase-sensitive output test, and state what costs and conclusions the evidence supports. The Gates, Circuits, and Computation Models guide places that contract among its gate, measurement, transform, and computation-model owners.

The Ten-Field Kickback Record

Use this record before accepting a kickback diagram, converting an oracle, or reporting a numerical test. Every field needs a value; write N/A with a reason rather than leaving an access assumption or resource currency blank.

1. Kickback task and licensed claim — State the phase-transduction task and the strongest conclusion the evidence is meant to license.
2. Registers, dimensions, order, and basis — Name the selector, target, and work registers; fix their tensor order, dimensions, and basis-index convention.
3. Controlled operator or oracle and access model — Give the exact branch operator and say whether it is an explicit circuit, a controlled primitive, a query, or a physical interface.
4. Eigenstate or character ancilla and preparation — Specify and normalize the target state, prove the relevant eigenvalue relation, and debit its preparation.
5. Eigenvalue, phase sign, normalization, and inverse convention — Fix the exponential sign, branch phase, inverse action, and any modular reduction.
6. Branch map, garbage, factorization, and uncomputation — Show the full branch state, record every work register, and distinguish target return from mere factorization.
7. Interference, observable, measurement, and postprocessing — Name a phase-sensitive observable, its basis rotation, its outcome convention, and the classical interpretation.
8. Resource currencies, controls, synthesis, and connectivity — Separate queries, logical gates, controls, depth, width, preparation, routing, native operations, and physical time.
9. Verification data, tolerance, uncertainty, and reproducibility — Record the analytic reference, numerical representation, runtime, register order, tolerance, uncertainty, and stable recipe identity.
10. Conclusion, stopping point, and canonical handoff — State pass or fail, stop at the licensed boundary, and route algorithms, synthesis, or hardware claims to their owners.

The record prevents several common substitutions: target-return probability for phase verification, a query for one elementary gate, an uncontrolled eigenvalue phase for an observable relative phase, and one ideal identity for an algorithmic speedup.

Eigenstates, Selectors, and Relative Phase

The common-eigenstate condition is sufficient for exact target return. A slightly weaker condition is sufficient only for factorization. If there is one normalized state $|\xi\rangle$ such that

$$V_x|\eta\rangle = e^{i\theta_x}|\xi\rangle$$

on every populated branch, then

$$W|\psi\rangle|\eta\rangle = D_\theta|\psi\rangle|\xi\rangle.$$

The registers factor, but the target has changed from $|\eta\rangle$ to $|\xi\rangle$. Calling this target return would be inaccurate unless the two states lie on the same ray. If an identity branch is populated, that branch outputs $|\eta\rangle$, so factorization already fixes the common output ray to the input target ray.

For a generic target, tracing it out gives the selector state

$$\rho_D' = \sum_{x,x'} \alpha_x\alpha_{x'}^* \langle\eta|V_{x'}^\dagger V_x|\eta\rangle |x\rangle\langle x'|.$$

The matrix of target overlaps is a Gram matrix. Under exact kickback its entries are

$$\langle\eta|V_{x'}^\dagger V_x|\eta\rangle = e^{i(\theta_x-\theta_{x'})}.$$

A magnitude below one suppresses selector coherence and signals correlation with the target. A unit-modulus entry with the wrong argument is instead a coherent phase error. Computational-basis probabilities and target-return probability alone can miss both distinctions.

For one control and one target unitary,

$$C_1(U) \left(a|0\rangle+b|1\rangle\right)|u\rangle = \left(a|0\rangle+be^{i\theta}|1\rangle\right)|u\rangle, \qquad U|u\rangle=e^{i\theta}|u\rangle.$$

Only phase differences among populated branches are observable. A common shift $\theta_x\mapsto\theta_x+\gamma$ changes the whole joint state by one global phase, but rephasing only one controlled branch changes $D_\theta$. In particular,

$$C_1(e^{i\gamma}U) = \left(P(\gamma)\otimes I\right)C_1(U), \qquad P(\gamma) = |0\rangle\langle0|+e^{i\gamma}|1\rangle\langle1|.$$

The phase of an isolated state vector remains ray redundancy, as explained by Rays and Global Phase. The controlled construction promotes a target-operator phase into a selector-relative phase; it does not make an independently observable global phase. Nor does the existence of the block matrix imply that an unknown channel automatically supplies coherent controlled access.

Boolean XOR Oracles and the Minus Ancilla

A clean Boolean XOR oracle has the exact interface

$$O_f|x\rangle|y\rangle = |x\rangle|y\mathbin{\oplus}f(x)\rangle, \qquad f(x)\in\{0,1\}.$$

The target operation on branch $x$ is $X^{f(x)}$. Define the two $X$ eigenstates

$$|\chi_s\rangle = \frac{|0\rangle+(-1)^s|1\rangle}{\sqrt2}, \qquad s\in\{0,1\},$$

so that

$$X|\chi_s\rangle = (-1)^s|\chi_s\rangle.$$

The oracle therefore acts as

$$O_f|x\rangle|\chi_s\rangle = (-1)^{s f(x)}|x\rangle|\chi_s\rangle.$$

For $s=1$, the target is

$$|\chi_1\rangle = |-\rangle = \frac{|0\rangle-|1\rangle}{\sqrt2},$$

and the data branch receives $(-1)^{f(x)}$. For $s=0$, the target is $|+\rangle$ and every branch eigenvalue is $+1$, so no phase is marked. In both cases the target returns exactly; the difference is entirely phase-sensitive.

For a data superposition $\sum_x\alpha_x|x\rangle$, one clean query gives

$$O_f \left( \sum_x\alpha_x|x\rangle \right)|-\rangle = \left( \sum_x\alpha_x(-1)^{f(x)}|x\rangle \right)|-\rangle.$$

This is not a readable list of all function values. The phase pattern must be followed by an interference operation chosen for the task. It also assumes that the declared oracle is clean: if an implementation leaves $x$-dependent workspace, the data register need not carry a pure phase pattern by itself.

Modular Addition and Character States

Boolean kickback is the two-level member of a more general character-state construction. Let an $m$-qubit target encode $M=2^m$ basis states in increasing integer order, and define modular translation by

$$T_a|y\rangle = |y+a\bmod M\rangle.$$

Using the positive-sign transform convention of the Quantum Fourier Transform owner, define the negative-exponent character

$$|\chi_k^-\rangle = \frac1{\sqrt M} \sum_{y=0}^{M-1} e^{-2\pi i k y/M}|y\rangle = F_M^\dagger|k\rangle.$$

Changing variables to $z=y+a\bmod M$ gives

$$\begin{aligned} T_a|\chi_k^-\rangle &= \frac1{\sqrt M} \sum_y e^{-2\pi i k y/M}|y+a\rangle\\ &= e^{+2\pi i k a/M} \frac1{\sqrt M} \sum_z e^{-2\pi i k z/M}|z\rangle\\ &= e^{+2\pi i k a/M}|\chi_k^-\rangle. \end{aligned}$$

Thus a coherent addition oracle

$$A_f = \sum_x|x\rangle\langle x|\otimes T_{f(x)}$$

obeys

$$A_f|x\rangle|\chi_k^-\rangle = e^{+2\pi i k f(x)/M}|x\rangle|\chi_k^-\rangle.$$

Both signs matter. Replacing $T_a$ by $T_{-a}$ conjugates the eigenvalue, and using $F_M|k\rangle$ instead of $F_M^\dagger|k\rangle$ also reverses the exponent. Reducing $ka$ modulo $M$ is safe only after the translation and Fourier conventions have been fixed.

The character state is a resource, not a free catalyst. If it is prepared from $|k\rangle$, its inverse-QFT gates, bit order, swaps, approximation, and synthesis errors belong in the ledger. Reuse is licensed only to the accuracy with which target return and coherent phase were actually verified.

Interference and Phase Readout

For one returned control phase, write

$$|\psi_\theta\rangle = \frac{|0\rangle+e^{i\theta}|1\rangle}{\sqrt2}.$$

Computational-basis measurement gives one half for each outcome, independently of $\theta$. It cannot distinguish correct kickback from a coherent phase bias. With

$$|+_Y\rangle = \frac{|0\rangle+i|1\rangle}{\sqrt2},$$

the complementary expectations are

$$\langle X\rangle=\cos\theta, \qquad \langle Y\rangle=\sin\theta,$$

and therefore

$$p_{X+} = \frac{1+\cos\theta}{2}, \qquad p_{Y+} = \frac{1+\sin\theta}{2}.$$

An $X$-basis readout applies $H$ and then measures $Z$. With the $|+_Y\rangle$ convention above, a $Y$-basis readout applies $S^\dagger$, then $H$, then measures $Z$. These are incompatible settings and require separate ensembles. Measurement in Circuits owns the basis-rotation, outcome-record, estimator, and finite-shot framework; here those tools are specialized to the kickback phase.

A phase audit should combine complementary selector observables with a target or joint-state check. Correct $X/Y$ means can coexist with untested leakage outside a promised subspace, while target-return probability alone can miss a coherent phase offset. For finite shots, report the number of trials in each basis, the interval or uncertainty rule, and a prespecified acceptance tolerance.

Compute–Phase–Uncompute

A useful predicate is often implemented by a reversible evaluator rather than delivered as a clean phase oracle. Suppose

$$C_f |x\rangle|0^w\rangle|0\rangle = |x\rangle|g_x\rangle|f(x)\rangle,$$

where $|g_x\rangle$ is workspace. Applying $Z$ to the output bit gives

$$|x\rangle|g_x\rangle|f(x)\rangle \longmapsto (-1)^{f(x)} |x\rangle|g_x\rangle|f(x)\rangle.$$

Then the inverse evaluator restores the auxiliaries:

$$C_f^\dagger (I\otimes I\otimes Z) C_f |x\rangle|0^w\rangle|0\rangle = (-1)^{f(x)} |x\rangle|0^w\rangle|0\rangle.$$

The data phase survives because the inverse removes correlations, not the scalar multiplying each branch. On a superposition, omitting the inverse leaves data coherences weighted by garbage overlaps such as $\langle g_{x'}|g_x\rangle$. Orthogonal garbage can erase the very interference the phase was meant to produce.

Reversible Computation owns reversible embeddings, workspace accounting, and generic compute–copy–uncompute. The phase construction here has a different explicit ledger: one forward evaluator, one phase operation, and one inverse evaluator. It may be counted as one query only if the declared interface supplies the entire clean phase oracle as one query.

Access Models, Resources, and Verification

An algebraic block and an available primitive are different claims. A known, phase-fixed circuit can often be controlled gate by gate, carrying its ancillas and approximation error. A supplied controlled query licenses one use at the query layer but says nothing about internal logical gates. An uncontrolled channel oracle does not fix the branch phase needed to define a unique controlled operation. A physical interferometric construction may supply extra path or subspace structure, which must be named as an additional resource.

The Circuit Model owns generic register, composition, and cost syntax. A kickback ledger should keep at least these currencies separate:

• target or character-state preparation;
• base, inverse, and controlled queries;
• logical one- and two-qubit gates;
• additional controls and live ancillas;
• depth under a declared parallelism and connectivity model;
• routing and native-gate synthesis;
• repetitions and complementary-basis measurements;
• classical postprocessing and physical time.

Gate Decomposition owns compilation into a selected alphabet and topology. Calling one controlled modular shift “one gate” without such an interface is a category error.

For a desired branch phase $\theta_x$, define

$$\epsilon_x = \left\| V_x|\eta\rangle - e^{i\theta_x}|\eta\rangle \right\|.$$

Selector orthogonality gives the exact state-error identity

$$\left\| |\Psi_{\mathrm{actual}}\rangle - |\Psi_{\mathrm{ideal}}\rangle \right\|^2 = \sum_x|\alpha_x|^2\epsilon_x^2.$$

The corresponding ideal-state fidelity is

$$\left| \sum_x|\alpha_x|^2 e^{-i\theta_x} \langle\eta|V_x|\eta\rangle \right|^2.$$

These are state-specific metrics on the declared input, not an operator-norm or channel guarantee. A reproducible numerical claim must also fix the complex-number representation, basis and tensor order, construction order, runtime version, tolerance, and whether quoted uncertainty is numerical or statistical.

Canonical Uses and Ownership Boundaries

Phase kickback is a reusable seam between coherent access and interference, not a complete algorithm. The Algorithmic Primitives page owns that composition vocabulary and previews where the seam is used. Quantum Phase Estimation owns controlled powers, phase-gradient registers, inverse-QFT decoding, precision, aliasing, success guarantees, and coherent-time cost. Grover Search owns the marked-subspace reflection, two-reflection rotation, stopping rule, and optimal search-query bound.

Quantum Oracles owns oracle taxonomy, promise domains, separately licensed inverse, controlled, powered, and family access, capability-sensitive equivalences, and oracle-specific fair comparisons. This page owns the clean conversion identities and phase-sensitive audit after an XOR, modular-addition, or controlled-branch interface has been declared. Deutsch–Jozsa Algorithm owns its constant-versus-balanced promise, exact decision proof, and matched query comparison; Bernstein–Vazirani Algorithm owns its hidden linear-word promise, exact character decoding, and matched query theorem; Simon and Shor retain their own promises, correctness proofs, and complexity claims. Amplitude Amplification begins from a licensed good-subspace $\pi$ reflection and owns the generalized prepared-state rotation, schedule regimes, bounds, and access ledger.

For orientation, Quantum Information and Computation places coherent phase processing among computation, communication, sensing, simulation, and hardware; What Is Quantum Information? gives the operational introduction. The Quantum Information Roadmap supplies a learning sequence, while Math Needed for Quantum Information supplies the finite-dimensional linear-algebra and character-eigenstate crosswalk.

Worked Audit: A Three-Bit Boolean Phase Pattern

Take

$$s=101_2, \qquad f_s(x) = s\mathbin{\cdot}x\bmod2 = x_2\mathbin{\oplus}x_0.$$

The complete audit record is:

1. Kickback task and licensed claim — Starting from a clean XOR oracle for $f_s$, verify that a minus ancilla converts one query into a diagonal sign pattern and that Hadamard interference returns $101_2$. Passing licenses only this ideal identity and query-level readout, not the Bernstein–Vazirani promise theorem, speedup, or implementation cost.

2. Registers, dimensions, order, and basis — Use $D=q_2\otimes q_1\otimes q_0$ in ascending binary basis order from $000$ through $111$, followed by target qubit $a$. The integer is $x=4x_2+2x_1+x_0$, and the full system has four qubits.

3. Controlled operator or oracle and access model — One clean query obeys $O_{f_s}|x\rangle|y\rangle=|x\rangle|y\oplus f_s(x)\rangle$, with $O_{f_s}^\dagger=O_{f_s}$. Internal gates, depth, routing, and physical cost are not licensed.

4. Eigenstate or character ancilla and preparation — Prepare $|-\rangle=(|0\rangle-|1\rangle)/\sqrt2$ from $|0\rangle$ with $X$ then $H$, and verify $X|-\rangle=-|-\rangle$.

5. Eigenvalue, phase sign, normalization, and inverse convention — In the declared basis the phase vector is

   $$(+1,-1,+1,-1,-1,+1,-1,+1).$$

   The sign is $(-1)^{f_s(x)}$, every data amplitude has magnitude $1/\sqrt8$, and a second clean-oracle call removes the phase from the full data–target state.

6. Branch map, garbage, factorization, and uncomputation — The exact map is

   $$O_{f_s}|+\rangle^{\otimes3}|-\rangle = \frac1{\sqrt8} \sum_{x=0}^{7} (-1)^{s\cdot x}|x\rangle|-\rangle.$$

   The target returns and factors, and the declared oracle has no workspace.

7. Interference, observable, measurement, and postprocessing — Applying $H^{\otimes3}$ to $D$ gives $|101\rangle|-\rangle$, so data measurement returns $101_2$ with ideal probability one. With target $|+\rangle$, no phase appears and the same decode returns $000_2$.

8. Resource currencies, controls, synthesis, and connectivity — From $|000\rangle|0\rangle$, count four qubits, seven $H$ gates, one $X$, one abstract clean XOR query, three data measurements, no workspace, and no additional controls. Oracle synthesis and connectivity are N/A, not zero. The seven Hadamards are three data-preparation gates, one target-preparation gate, and three data-decoding gates.

9. Verification data, tolerance, uncertainty, and reproducibility — The exact sign vector and Walsh identity are the analytic references. Node.js v26.4.0 with V8 14.6.202.34-node.21 uses IEEE-754 binary64 amplitudes in the declared $q_2,q_1,q_0,a$ order. A dense check reports state-vector residual $0$, decoded $p(101)=0.9999999999999998$, all other decoded probability $0$, and passes a $2\times10^{-14}$ norm/state tolerance. Sampling uncertainty is N/A for this deterministic state-vector check.

10. Conclusion, stopping point, and canonical handoff — Pass: the clean oracle produces the exact phase pattern, target return, and interference decode. Stop before predicate synthesis, named-algorithm query claims, noise, or hardware performance.

The Walsh identity behind the decode is

$$H^{\otimes3} \left( \frac1{\sqrt8} \sum_x(-1)^{s\cdot x}|x\rangle \right) = |s\rangle.$$

The following source-embedded record is LF-normalized UTF-8 text including its final line feed. Its SHA-256 is AD31B5DF7F1A39B23DE0C3A7284B56F55560A21446AA456B38B3826B9AE06D25.

artifact=phase-kickback-boolean-s5-v1
runtime=Node.js v26.4.0
v8=14.6.202.34-node.21
precision=IEEE-754 binary64
tensor=q2,q1,q0,a
data_basis=000,001,010,011,100,101,110,111
function=f(x)=x2 xor x0
target=(|0>-|1>)/sqrt(2)
phase_vector=1,-1,1,-1,-1,1,-1,1
recipe=prepare H3 and minus; apply dense clean XOR permutation; decode H3
state_vector_residual=0
decoded_p_101=0.9999999999999998
decoded_other_probability=0
norm_state_tolerance=2e-14
uncertainty=N/A deterministic state-vector audit

Worked Audit: Modular-Addition Kickback

An uncontrolled translation of a character state changes only its global phase. To make the phase observable, include an explicit identity reference branch. Set

$$M=8, \qquad k=3, \qquad a=5,$$

and

$$T_5|y\rangle = |y+5\bmod8\rangle, \qquad |\chi_3^-\rangle = \frac1{\sqrt8} \sum_{y=0}^{7} e^{-2\pi i3y/8}|y\rangle.$$

The complete audit record is:

1. Kickback task and licensed claim — Verify that one identity-versus-shift controlled query returns the character target and places the shift eigenphase on the control. Passing licenses this ideal conversion and its $X/Y$ readout only.

2. Registers, dimensions, order, and basis — Use $C\otimes A$, with the one-qubit control first and $A=a_2\otimes a_1\otimes a_0$ second. Let $y=4a_2+2a_1+a_0$ and order target basis states as $0,1,\ldots,7$.

3. Controlled operator or oracle and access model — Declare

   $$C_1(T_5) = |0\rangle\langle0|\otimes I + |1\rangle\langle1|\otimes T_5.$$

   Count one controlled-shift query. Its inverse is $C_1(T_{-5})$; base-shift, synthesis, routing, and hardware costs are not licensed.

4. Eigenstate or character ancilla and preparation — The normalized target is $|\chi_3^-\rangle=F_8^\dagger|3\rangle$. This audit declares it as a supplied normalized input, so its preparation circuit and gate cost are N/A under the audited input contract, not zero. An end-to-end audit that instead prepares it from $|3\rangle=|011\rangle$ must debit two $X$ gates plus the exact inverse-QFT circuit.

5. Eigenvalue, phase sign, normalization, and inverse convention — The negative-exponent character and positive shift give

   $$e^{2\pi i k a/M} = e^{2\pi i(15)/8} = e^{7\pi i/4} = e^{-i\pi/4}.$$

   Translation by $-5$ conjugates this eigenvalue, and using $F_8|3\rangle$ reverses its sign.

6. Branch map, garbage, factorization, and uncomputation — The explicit controlled reference gives

   $$C_1(T_5)|+\rangle|\chi_3^-\rangle = \frac{|0\rangle+e^{-i\pi/4}|1\rangle}{\sqrt2} \otimes|\chi_3^-\rangle.$$

   The target returns exactly, no workspace is present, and no inverse call is needed merely to factor the target under this ideal interface.

7. Interference, observable, measurement, and postprocessing — Separate ensembles give

   $$p_{X+} = \frac{2+\sqrt2}{4} = 0.853553390593\ldots,$$

   and

   $$p_{Y+} = \frac{2-\sqrt2}{4} = 0.146446609407\ldots.$$

   Apply $H$ before $Z$ readout for $X$, and $S^\dagger$ then $H$ for $Y$. Do not combine the incompatible settings into one shot record.

8. Resource currencies, controls, synthesis, and connectivity — Count four qubits, one $H$ for control preparation, one control, and one abstract controlled-shift query. The $X$ setting uses one final $H$ and one control measurement; the $Y$ setting uses one final $S^\dagger$, one $H$, and one control measurement on a separate ensemble. Shot counts are N/A for this deterministic state-vector audit. Character preparation is a supplied input as declared in field 4; its circuit cost is N/A under that input contract. Base additions, logical synthesis, connectivity, native gates, and physical time are N/A because the query has no declared implementation or hardware model.

9. Verification data, tolerance, uncertainty, and reproducibility — The exact character vector, principal phase $-\pi/4$, and analytic probabilities above are the normative results. A deterministic Node.js v26.4.0 binary64 run used the declared $C\otimes A$ basis and a dense controlled-permutation matrix. It found rounded upper bounds $5\times10^{-16}$ for norm defect, $6\times10^{-16}$ for state-vector residual, $3\times10^{-16}$ for target-return infidelity, $5\times10^{-16}$ for control-purity defect, $5\times10^{-16}$ for wrapped phase error, and $5\times10^{-16}$ for each probability error. These recomputable diagnostics are evidence, not last-digit fixtures; acceptance requires every applicable absolute residual to be at most $2\times10^{-14}$. Shot uncertainty is N/A.

10. Conclusion, stopping point, and canonical handoff — Pass: the ideal controlled shift returns the target and produces the predicted relative phase, sign, and quadrature probabilities. Stop before QFT preparation cost, adder synthesis, phase-estimation precision, algorithmic speedup, noise, or hardware evidence.

The coherent reference branch is essential. Without it,

$$T_5|\chi_3^-\rangle = e^{-i\pi/4}|\chi_3^-\rangle$$

differs from the input by only a global phase, so the quoted control probabilities do not exist.

The dense construction and its non-normative, rounded diagnostics are recorded below. The local scrolling boundary keeps the raw record readable on narrow screens.

artifact=phase-kickback-modular-m8-k3-a5-v1
runtime=Node.js v26.4.0
precision=IEEE-754 binary64
tensor=control,a2,a1,a0
target_basis=0,1,2,3,4,5,6,7
character=exp(-2*pi*i*3*y/8)/sqrt(8)
character_preparation=supplied normalized input; circuit cost N/A by input contract
query=C1(T5); T5|y>=|y+5 mod 8>
construction=dense controlled permutation on plus tensor character
normative_phase=-pi/4
normative_p_X_plus=(2+sqrt(2))/4
normative_p_Y_plus=(2-sqrt(2))/4
observed_norm_defect<5e-16
observed_state_residual<6e-16
observed_target_return_infidelity<3e-16
observed_control_purity_defect<5e-16
observed_wrapped_phase_error<5e-16
observed_p_X_plus_error<5e-16
observed_p_Y_plus_error<5e-16
acceptance_absolute_error<=2e-14
uncertainty=N/A deterministic state-vector audit

Common Failure Modes

• Describing kickback as a backward signal. The joint unitary acts once in the ordinary circuit time order. “Kickback” names the algebraic phase appearing on selector amplitudes.
• Using a generic target as if it were an eigenstate. Distinct target branch vectors generally entangle with the selector. Verify the populated-support eigenstate or common-ray condition.
• Dropping a target-operator phase before adding a control. A phase that was global for an isolated target channel becomes relative between controlled branches.
• Using $|+\rangle$ for Boolean marking. It is the $+1$ eigenstate of $X$ and produces no $(-1)^{f(x)}$ phase. Use $|-\rangle$ and test the result through interference.
• Ignoring garbage. An $x$-dependent work state can suppress data coherence. Restore it with the inverse evaluator or retain it explicitly in the output contract.
• Losing a modular sign. The translation direction and Fourier exponent both determine the phase sign. Declare them before reducing $ka$ modulo $M$.
• Calling an uncontrolled eigenvalue phase observable kickback. Without a coherent reference branch, the eigenvalue is a global phase on the whole state.
• Verifying only computational-basis probabilities. A diagonal phase leaves those probabilities unchanged. Use complementary observables or inverse interference.
• Calling one query one elementary gate. Preparation, controls, synthesis, routing, inverse access, repetitions, and readout are different resource currencies.
• Inferring an algorithmic speedup. The identity supplies one interface inside an algorithm, not its promise theorem, fair comparator, or end-to-end cost.

Exercises

1. Derive the Exact Return Criterion

For $W=\sum_j|j\rangle\langle j|\otimes V_j$ and $|\psi\rangle=\sum_j\alpha_j|j\rangle$, prove exact returning kickback when $V_j|\eta\rangle=e^{i\theta_j}|\eta\rangle$ on the populated support. Distinguish this from the weaker common-output condition $V_j|\eta\rangle=e^{i\theta_j}|\xi\rangle$. Why does an occupied identity branch make the two conditions coincide up to a common phase?

Solution

Direct substitution gives

$$\begin{aligned} W|\psi\rangle|\eta\rangle &= \sum_j\alpha_j|j\rangle V_j|\eta\rangle\\ &= \sum_j\alpha_je^{i\theta_j}|j\rangle|\eta\rangle\\ &= D_\theta|\psi\rangle|\eta\rangle. \end{aligned}$$

The target is exactly the input ray. Under the weaker condition, the same calculation ends in $D_\theta|\psi\rangle|\xi\rangle$: the registers factor, but the target ray may have changed.

If an occupied branch has $V_{j_0}=I$, its output is $|\eta\rangle$. Common-output factorization also says that output equals $e^{i\theta_{j_0}}|\xi\rangle$, so $|\xi\rangle=e^{-i\theta_{j_0}}|\eta\rangle$. The common target is therefore the input ray, and its common phase can be absorbed into all selector phases.

2. Promote a Target Phase to a Branch Phase

Prove $C_1(e^{i\gamma}U)=(P(\gamma)\otimes I)C_1(U)$. If $U|u\rangle=e^{i\theta}|u\rangle$ and the control begins in $|+\rangle$, find $p_{X+}$. Explain why $U$ and $e^{i\gamma}U$ define the same isolated channel but different controlled operations.

Solution

Using $P_b=|b\rangle\langle b|$,

$$\begin{aligned} C_1(e^{i\gamma}U) &= P_0\otimes I+e^{i\gamma}P_1\otimes U\\ &= \left[ (P_0+e^{i\gamma}P_1)\otimes I \right] \left(P_0\otimes I+P_1\otimes U\right)\\ &= (P(\gamma)\otimes I)C_1(U). \end{aligned}$$

On $|+\rangle|u\rangle$, the active branch receives phase $e^{i(\theta+\gamma)}$, so

$$p_{X+} = \frac{1+\cos(\theta+\gamma)}{2}.$$

Conjugation by $U$ and by $e^{i\gamma}U$ gives the same isolated channel because the scalar cancels against its conjugate. After control, the scalar multiplies only one branch and becomes observable relative phase.

3. Choose the Boolean Ancilla

Apply a clean XOR oracle to $|x\rangle|+\rangle$ and to $|x\rangle|-\rangle$. Give a phase-sensitive test that rejects the wrong ancilla for a branch with $f(x)=1$.

Solution

Since $X|+\rangle=|+\rangle$,

$$O_f|x\rangle|+\rangle = |x\rangle|+\rangle$$

for both values of $f(x)$. Since $X|-\rangle=-|-\rangle$,

$$O_f|x\rangle|-\rangle = (-1)^{f(x)}|x\rangle|-\rangle.$$

To expose the difference, place a control or data label in an equal superposition of one $f=0$ branch and one $f=1$ branch. The minus ancilla produces relative phase $\pi$, so an $X$-basis interference measurement swaps the constructive and destructive outcomes. The plus ancilla produces relative phase zero. Measuring only the target in the computational basis would not distinguish the intended phase pattern.

4. Clean a Dirty Predicate

Suppose

$$C_f|x\rangle|0^w\rangle|0\rangle = |x\rangle|g_x\rangle|f(x)\rangle.$$

Show that applying $Z$ to the output and then $C_f^\dagger$ produces a clean sign-phase oracle. Count the abstract operations and explain the interference failure if the inverse is omitted.

Solution

The output bit is a $Z$ eigenstate, so

$$(I\otimes I\otimes Z) |x\rangle|g_x\rangle|f(x)\rangle = (-1)^{f(x)} |x\rangle|g_x\rangle|f(x)\rangle.$$

Applying $C_f^\dagger$ restores both auxiliary registers:

$$C_f^\dagger(I\otimes I\otimes Z)C_f |x\rangle|0^w\rangle|0\rangle = (-1)^{f(x)}|x\rangle|0^w\rangle|0\rangle.$$

The ledger contains one forward evaluator, one $Z$, and one inverse evaluator. Without the inverse, tracing out the workspace multiplies a data coherence between $x$ and $x'$ by $\langle g_{x'}|g_x\rangle$ together with any output-bit overlap. Orthogonal garbage can remove that coherence completely.

5. Reverse a Character Convention

For $M=8$, $k=1$, and $a=3$, derive the eigenvalues of $T_3$ on $F_8^\dagger|1\rangle$ and on $F_8|1\rangle$. For a controlled shift, calculate $p_{X+}$ in each convention and show how the $Y$ expectation changes.

Solution

The negative-exponent character is $F_8^\dagger|1\rangle$, so the positive translation has eigenvalue

$$\lambda_- = e^{+2\pi i(1)(3)/8} = e^{+3\pi i/4}.$$

The positive-exponent character $F_8|1\rangle$ has the conjugate eigenvalue

$$\lambda_+ = e^{-2\pi i(1)(3)/8} = e^{-3\pi i/4}.$$

In both cases $\cos(\pm3\pi/4)=-1/\sqrt2$, hence

$$p_{X+} = \frac{1+\cos(\pm3\pi/4)}2 = \frac{2-\sqrt2}{4}.$$

The quadrature is sign-sensitive:

$$\langle Y\rangle_- = \sin(3\pi/4) = \frac1{\sqrt2}, \qquad \langle Y\rangle_+ = \sin(-3\pi/4) = -\frac1{\sqrt2}.$$

Thus $X$ alone cannot distinguish the two Fourier conventions, while a separate $Y$-basis ensemble can.

6. Diagnose a Non-Eigenstate Target

Apply controlled-$Z$ to

$$|+\rangle_C \left( \cos\alpha|0\rangle + \sin\alpha|1\rangle \right)_T.$$

Derive the selector overlap and reduced-control purity. Evaluate the purity at $\alpha=\pi/8$ and interpret the result.

Solution

Let

$$|\eta\rangle = \cos\alpha|0\rangle + \sin\alpha|1\rangle.$$

The two control branches carry $|\eta\rangle$ and $Z|\eta\rangle$, whose overlap is

$$z = \langle\eta|Z|\eta\rangle = \cos^2\alpha-\sin^2\alpha = \cos2\alpha.$$

Tracing out the target gives

$$\rho_C = \frac12 \begin{pmatrix} 1 & z\\ z & 1 \end{pmatrix}, \qquad \operatorname{Tr}\rho_C^2 = \frac{1+z^2}{2} = \frac{1+\cos^2(2\alpha)}2.$$

At $\alpha=\pi/8$, $z=1/\sqrt2$ and the purity is $3/4$. Because it is below one, the output is entangled: the target has not returned to a common ray, and no single pure control phase describes the result.

7. Audit a Resource Overclaim

A report calls one controlled modular shift “one gate” and omits phase-state preparation, inverse access, synthesis, routing, repetitions, and readout. Rewrite the claim as a currency-separated ledger and state what the kickback algebra actually licenses.

Solution

A defensible ledger keeps the currencies separate:

• query cost: one declared controlled-shift query for the demonstrated forward map; inverse access is a separate capability and is N/A until specified;
• logical gates and depth: N/A until a base-shift circuit, control construction, and synthesis tolerance are supplied;
• ancillas: the control and character register are counted, while implementation workspace is N/A until a circuit is given;
• preparation: the basis gates for $|k\rangle$ and the chosen exact or approximate inverse QFT are charged explicitly;
• measurement: $X$ and $Y$ settings, repetitions, estimator, and acceptance rule are separate costs;
• connectivity, native gates, and physical time: N/A without a target architecture, routing, calibration model, and schedule.

The algebra licenses one ideal query-level phase conversion under the declared access model. It does not turn that query into an elementary gate and, by itself, establishes neither an end-to-end cost nor a speedup.

8. Complete a Ten-Field Modular Record

Use a $|+\rangle$ control, $M=16$, $k=5$, $a=7$, the negative-exponent character, and one declared $C_1(T_7)$ query. Complete the page’s full record, derive the reduced phase, and give the separate $X$- and $Y$-basis probabilities.

Solution

1. Kickback task and licensed claim — Verify exact character-target return and promotion of the $T_7$ eigenvalue to the reference control. Passing licenses the ideal phase conversion and quadrature readout, not an implementation or speedup.

2. Registers, dimensions, order, and basis — Use $C\otimes A$, with one control first and $A=a_3\otimes a_2\otimes a_1\otimes a_0$ second. Let $y=8a_3+4a_2+2a_1+a_0$ and order target states as $0,1,\ldots,15$.

3. Controlled operator or oracle and access model — Declare $C_1(T_7)=|0\rangle\langle0|\otimes I+|1\rangle\langle1|\otimes T_7$ as one controlled-shift query. Its inverse is $C_1(T_{-7})$; base shifts, synthesis, routing, and hardware cost are N/A.

4. Eigenstate or character ancilla and preparation — Prepare the normalized $|\chi_5^-\rangle=F_{16}^\dagger|5\rangle$ from $|0000\rangle$: apply $X$ to $a_2$ and $a_0$ to obtain $|5\rangle=|0101\rangle$, then apply the exact four-qubit inverse QFT with its declared natural-output bit order. The state is therefore prepared, not supplied.

5. Eigenvalue, phase sign, normalization, and inverse convention — The negative-exponent character and positive translation give

   $$\theta = \frac{2\pi(5)(7)}{16} = \frac{35\pi}{8} = \frac{3\pi}{8} \pmod{2\pi}.$$

   Thus $\lambda=e^{+3\pi i/8}$. Reversing the translation or Fourier sign conjugates it.

6. Branch map, garbage, factorization, and uncomputation — The controlled query maps

   $$|+\rangle|\chi_5^-\rangle \longmapsto \frac{|0\rangle+e^{3\pi i/8}|1\rangle}{\sqrt2} \otimes|\chi_5^-\rangle.$$

   The target returns, no workspace or garbage is present, and no inverse call is needed for factorization in this ideal interface.

7. Interference, observable, measurement, and postprocessing — On separate ensembles,

   $$p_{X+} = \frac{1+\cos(3\pi/8)}2 = \frac{2+\sqrt{2-\sqrt2}}4 = 0.691341716183\ldots,$$ $$p_{Y+} = \frac{1+\sin(3\pi/8)}2 = \frac{2+\sqrt{2+\sqrt2}}4 = 0.961939766256\ldots.$$

   Use $H$ then $Z$ measurement for $X$, and $S^\dagger$ then $H$ then $Z$ measurement for $Y$.

8. Resource currencies, controls, synthesis, and connectivity — Count five qubits and no additional ancilla. Character preparation costs two $X$ gates, four $H$ gates, six controlled inverse-phase rotations, and two SWAPs; control preparation adds one $H$. The transduction uses one control and one abstract controlled-shift query. The $X$ setting adds one $H$ and one control measurement, while the separate $Y$ setting adds one $S^\dagger$, one $H$, and one control measurement. Shot counts are N/A for the deterministic calculation. Base-shift implementation, query synthesis, connectivity, native gates, and physical time are N/A because no decomposition or hardware model is declared.

9. Verification data, tolerance, uncertainty, and reproducibility — The exact state, phase, and radicals above are the reference data. A reproducible check evaluates $35\bmod16=3$, both radicals, normalization, target return, and the two control expectations in the stated basis. Require absolute error at most $2\times10^{-14}$ for each deterministic quantity; sampling uncertainty is N/A.

10. Conclusion, stopping point, and canonical handoff — Pass: the ideal query returns the character state and produces phase $3\pi/8$ with the stated complementary probabilities. Stop before shift or QFT synthesis, phase-estimation precision, algorithmic advantage, noise, or hardware claims.

References

• E. Bernstein and U. Vazirani, “Quantum Complexity Theory”, SIAM Journal on Computing 26(5), 1411–1473 (1997).
• R. Cleve, A. Ekert, C. Macchiavello, and M. Mosca, “Quantum Algorithms Revisited”, Proceedings of the Royal Society A 454, 339–354 (1998).
• D. Deutsch, “Quantum Theory, the Church–Turing Principle and the Universal Quantum Computer”, Proceedings of the Royal Society A 400, 97–117 (1985).
• D. Deutsch and R. Jozsa, “Rapid Solution of Problems by Quantum Computation”, Proceedings of the Royal Society A 439, 553–558 (1992).
• T. G. Draper, “Addition on a Quantum Computer”, arXiv:quant-ph/0008033 (2000).
• L. K. Grover, “A Fast Quantum Mechanical Algorithm for Database Search”, in Proceedings of the 28th Annual ACM Symposium on Theory of Computing, 212–219 (1996).
• A. Yu. Kitaev, “Quantum Measurements and the Abelian Stabilizer Problem”, arXiv:quant-ph/9511026 (1995).
• N. D. Mermin, Quantum Computer Science: An Introduction, Cambridge University Press (2007).
• M. A. Nielsen and I. L. Chuang, Quantum Computation and Quantum Information, 10th anniversary edition, Cambridge University Press (2010).
• A. Ruiz-Perez and J. C. Garcia-Escartin, “Quantum Arithmetic with the Quantum Fourier Transform”, Quantum Information Processing 16, 152 (2017).
• P. W. Shor, “Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer”, SIAM Journal on Computing 26(5), 1484–1509 (1997).
• V. Vedral, A. Barenco, and A. Ekert, “Quantum Networks for Elementary Arithmetic Operations”, Physical Review A 54, 147–153 (1996).