Adding Binaries in Quantum Algorithm

Quick and dirty implementation of binary addition algorithm using qubits. The implementation uses Qiskit to build quantum circuits for binary addition with carry propagation.

The Circuit

The core idea is to implement a full adder using quantum gates. For each bit position, we need to compute the sum and carry. The sum of two bits with a carry-in can be computed using CNOT gates, while the carry-out uses Toffoli (CCX) gates:

def make_sum(qc, q1, q2, cin, out, cout):
    qc.cx(q1, out)
    qc.cx(q2, out)
    qc.cx(cin, out)
    qc.ccx(q1, q2, cout)
    qc.ccx(q1, cin, cout)
    qc.ccx(q2, cin, cout)

The full adder circuit chains these operations for each bit. The first bit uses a dedicated carry-in register, while subsequent bits take the carry from the previous stage:

from qiskit import *

def add(a, b, plot=0):
    n = len(a)
    q1 = QuantumRegister(n, "q1")
    q2 = QuantumRegister(n, "q2")
    cin = QuantumRegister(1, "cin")
    out = QuantumRegister(n, "out")
    cout = QuantumRegister(n, "cout")
    classic_bits = ClassicalRegister(n+1, "classical")
    qc = QuantumCircuit(q1, q2, cin, out, cout,
                        classic_bits)

    # Set input qubits
    for i, j in enumerate(a[::-1]):
        if int(j) == 1:
            qc.x(q1[i])
    for i, j in enumerate(b[::-1]):
        if int(j) == 1:
            qc.x(q2[i])

    # Chain full adders
    for i in range(n):
        if i == 0:
            make_sum(qc, q1[0], q2[0], cin,
                     out[0], cout[0])
        else:
            make_sum(qc, q1[i], q2[i], cout[i-1],
                     out[i], cout[i])

    # Measure
    for i in range(n):
        qc.measure(out[i], classic_bits[i])
    qc.measure(cout[-1], classic_bits[-1])
    return qc

Running the circuit on Qiskit's QASM simulator gives deterministic results for binary addition, demonstrating how classical arithmetic operations translate naturally into reversible quantum circuits.