I have two states $|a\rangle = \frac{1}{\sqrt N}\sum_{i=0}^{N-1}|i\rangle|a_i\rangle$ and $|b\rangle = \frac{1}{\sqrt N}\sum_{j=0}^ {N-1} |j\rangle|b_j\rangle$, with $i,j,a_i,b_j \in \mathbb{N}$.

I want to add $|a\rangle$ and $|b\rangle$ such that the output I get from an adder circuit is $|c\rangle = \frac{1}{\sqrt N}\sum_{i=0}^{N-1}|i\rangle|a_i+b_i\rangle$. Is this circuit possible?

  • $\begingroup$ You can think about $a_i,b_i\in\{0,1\}$ will be better. And you can test some simple examples to see if the transformation is unitary, if so then it can be done, if not then it can't. $\endgroup$
    – narip
    Aug 29, 2022 at 10:17
  • $\begingroup$ Here is what I am thinking of. I can use $|i\rangle$ to control operations applied solely to $|b\rangle$. Each operation does not touch $|a\rangle$. Therefore, a circuit can be constructed? But this feels wrong due to entanglement with $|i\rangle$. So I guess I'm lost here. $\endgroup$
    – Paulske
    Aug 29, 2022 at 10:25
  • $\begingroup$ What should be the result for states $|a_1\rangle=|0\rangle|0\rangle, b_1=|0\rangle|0\rangle$ and $|a_2\rangle=|0\rangle|1\rangle, b_2=|0\rangle|1\rangle$? $\endgroup$ Aug 29, 2022 at 11:33
  • $\begingroup$ @NikitaNemkov $|c\rangle = \frac{1}{\sqrt 2} \left(|0\rangle|0\rangle + |1\rangle|0\rangle\right)$ with the entire result something of $|a\rangle|c\rangle$ up to ancilla qubits. ($a_1 = 0$, $b_1=0$, $a_1+b_1=0$, $a_2=1$, $b_2=1$, $a_2+b_2=2$.) $\endgroup$
    – Paulske
    Aug 29, 2022 at 11:54

1 Answer 1


This construction is impossible. At a high level, the problem is that any kind of "find a matching index within a superposition" functionality is a super power. It's just a matter of turning the specific kind of matching you're using here (two uniform superpositions match up their indices) into a super power that's known to be impossible.

I'll use the notation a_d[a_i] to refer to an index register a_i in uniform superposition and its entangled data register a_d. I'll write the hypothetical addition operation as c_d[c_i] = b_d[b_i] + a_d[a_i].

What I will is is start from an array a_d[a_i] where either all data values are 0 or there's a single data value that's 1. I'll show these two cases can be distinguished reliable, which is impossible, so the addition must have been a problem. I'll assume there are N possible indices and that N is a power of two.

Basically all I do is compute a series of intermediate values, and keep shifting and combining them to spread the 1 around if it's present:

z_d[z_i] = 0
a1_d[a1_i] = a_d[a_i] + z_d[z_i]
a1_i += 1 (mod N)
a2_d[a2_i] = a1_d[a1_i] + a_d[a_i]
a2_i += 3 (mod N)
a3_d[a3_i] = a2_d[a2_i] + a1_d[a1_i]
a3_i += 7 (mod N)
... etc ...

After $\log_2 N$ iterations, the last produced array is all 1s if there was a single 1 in a_d[a_i] and all 0s if there wasn't. Not only does this violate lower bounds on how fast quantum search can be, it also violates things like no cloning because it can widen an initially tiny angle difference between two states into outputs where the states have become perpendicular.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.