Secondo la domanda collegata, la soluzione più semplice è solo quella di **far eseguire al processore classico tali operazioni, se possibile** . Naturalmente, ciò potrebbe non essere possibile, quindi vogliamo creare un *sommatore* .

Esistono due tipi di sommatore a bit singolo: il *mezzo sommatore* e il *sommatore completo* . Il semisommatore prende gli ingressi e B ed emette il 'somma' (XOR) S = A ⊕ B e 'riporto' (AND) C = A ⋅ B . Un sommatore ha anche il 'carry in' C i n ingresso e il 'effettuare' uscita C o u t , sostituendo C . Ciò restituisce S = A ⊕ B ⊕ C i nA$A$B$B$S=A⊕B$S=A\oplus B$C=A⋅B$C=A\cdot B$Cin${C}_{in}$Cout${C}_{out}$C$C$S=A⊕B⊕Cin$S=A\oplus B\oplus {C}_{in}$e .Cout=Cin⋅(A+B)+A⋅B${C}_{out}={C}_{in}\cdot (A+B)+A\cdot B$

## Versione quantistica del mezzo sommatore

Guardando il gate CNOT sul registro qubit controlla il registro B : CNOT A → B | 0 ⟩ A | 0 ⟩ BA$A$B$B$ che dà subito all'uscita delBregistro comeA⊕B=S. Tuttavia, dobbiamo ancora calcolare il carry e lo stato delregistroBè cambiato, quindi dobbiamo anche eseguire l'operazione AND. Questo può essere fatto usando il gate Toffoli a 3 qubit (controllato-CNOT / CCNOT). Questo può essere fatto usando i registriAeBcome registri di controllo e inizializzando il terzo registro(C)nello stato| 0⟩

CNOTA→B|0⟩A|0⟩BCNOTA→B|0⟩A|1⟩BCNOTA→B|1⟩A|0⟩BCNOTA→B|1⟩A|1⟩B=|0⟩A|0⟩B=|0⟩A|1⟩B=|1⟩A|1⟩B=|1⟩A|0⟩B,$$\begin{array}{rl}{\text{CNOT}}_{A\to B}{|0\u27e9}_{A}{|0\u27e9}_{B}& ={|0\u27e9}_{A}{|0\u27e9}_{B}\\ {\text{CNOT}}_{A\to B}{|0\u27e9}_{A}{|1\u27e9}_{B}& ={|0\u27e9}_{A}{|1\u27e9}_{B}\\ {\text{CNOT}}_{A\to B}{|1\u27e9}_{A}{|0\u27e9}_{B}& ={|1\u27e9}_{A}{|1\u27e9}_{B}\\ {\text{CNOT}}_{A\to B}{|1\u27e9}_{A}{|1\u27e9}_{B}& ={|1\u27e9}_{A}{|0\u27e9}_{B},\end{array}$$

B$B$A⊕B=S$A\oplus B=S$B$B$A$A$B$B$(C)$\left(C\right)$|0⟩$|0\u27e9$, Dando l'uscita del terzo registro come

. L'implementazione di Toffoli sui registri

A e

B che controllano il registro

C seguito da CNOT con

A che controlla

B fornisce l'output del registro

B come somma e l'output del registro

C come carry. Uno schema circuitale quantistico del mezzo-sommatore è mostrato nella figura 1.

A⋅B=C$A\cdot B=C$A$A$B$B$C$C$A$A$B$B$B$B$C$C$

Figura 1: Schema circuitale di un mezzo sommatore, composto da Toffoli seguito da CNOT. Bit di ingresso sono e B , dando la somma S con carry out C .A$A$B$B$S$S$C$C$

## Versione quantistica del sommatore completo

Mostrato in figura 2, un modo semplice di fare questo per singoli bit è usando registri qubit, qui etichettati A , B , C i n e 1 , dove 1 inizia a stato | 0 ⟩ , quindi lo stato iniziale è | A ⟩ | B ⟩ | C i n ⟩ | 0 ⟩ :4$4$A$A$B$B$Cin${C}_{in}$1$1$1$1$|0⟩$|0\u27e9$|A⟩|B⟩|Cin⟩|0⟩$|A\u27e9|B\u27e9|{C}_{in}\u27e9|0\u27e9$

- Applicare Toffoli usando e B per controllare 1 : | A ⟩ | B ⟩ | C i n ⟩ | A ⋅ B ⟩A$A$B$B$1$1$|A⟩|B⟩|Cin⟩|A⋅B⟩$|A\u27e9|B\u27e9|{C}_{in}\u27e9|A\cdot B\u27e9$
- CNOT con controlla B : | A ⟩ | A ⊕ B ⟩ | C i n ⟩ | A ⋅ B ⟩A$A$B$B$|A⟩|A⊕B⟩|Cin⟩|A⋅B⟩$|A\u27e9|A\oplus B\u27e9|{C}_{in}\u27e9|A\cdot B\u27e9$
- Toffoli with B$B$ and Cin${C}_{in}$ controlling 1$1$: |A⟩|A⊕B⟩|Cin⟩|A⋅B⊕(A⊕B)⋅Cin=Cout⟩$|A\u27e9|A\oplus B\u27e9|{C}_{in}\u27e9|A\cdot B\oplus (A\oplus B)\cdot {C}_{in}={C}_{out}\u27e9$
- CNOT with B$B$ controlling Cin${C}_{in}$: |A⟩|A⊕B⟩|A⊕B⊕Cin=S⟩|Cout⟩$|A\u27e9|A\oplus B\u27e9|A\oplus B\oplus {C}_{in}=S\u27e9|{C}_{out}\u27e9$

A$A$B$B$A$A$B$B$

|ψout⟩=|A⟩|B⟩|S⟩|Cout⟩$$|{\psi}_{out}\u27e9=|A\u27e9|B\u27e9|S\u27e9|{C}_{out}\u27e9$$

This gives the output of register Cin${C}_{in}$ as the sum and the output of register 2$2$ as carry out.

Figure 2: Circuit diagram of a full adder. Input bits are A$A$ and B$B$ along with a carry in Cin${C}_{in}$, giving the sum S$S$ with carry out Cout${C}_{out}$.

## Quantum version of the ripple carry adder

A simple extension of the full adder is a ripple carry adder, named as it 'ripples' the carry out to become the carry in of the next adder in a series of adders, allowing for arbitrarily-sized (if slow) sums. A quantum version of such an adder can be found e.g. here

## Actual implementation of a half-adder

For many systems, implementing a Toffoli gate is far from as simple as implementing a single qubit (or even two qubit) gate. This answer gives a way of decomposing Toffoli into multiple smaller gates. However, in real systems, such as IBMQX, there can also be issues on which qubits can be used as targets. As such, a real life implementation on IBMQX2 looks like this:

Figure 3: Implementation of a half-adder on IBMQX2. In addition to decomposing the Toffoli gate into multiple smaller gates, additional gates are required as not all qubit registers can be used as targets. Registers q[0] and q[1] are added to get the sum in q[1] and the carry in q[2]. In this case, the result q[2]q[1] should be 10. Running this on the processor gave the correct result with a probability of 42.8% (although it was still the most likely outcome).