# How to make a half adder for x number of qubits with min. cost?

How to make a half adder for N inputs and getting the output on another x+1 output. Where x is numbers of qubit and N=2^x. please take a example of a circuit(x must be greater then 4 or 5 for example purpose ) for more understanding . Here is the example for 2 qubit half adder.

Qiskit includes an adder in the circuit library. Here is a quick introduction to it.

Let's say you wan to add two numbers, one of them is three-bit-long, the other one two-bit-long numbers. You will need a 5 qubit adder. That's the first parameter to qiskit.circuit.library.WeightedAdder. The second parameter is the weight of each of these qubits. Because the fist value is composed by $$q_0 \times 2^0 + q_1 \times 2^1 + q_2 \times 2^2$$, each of the weights is $$2^0$$, $$2^1$$, and $$2^2$$. The same applies to the second two-bit summand.

from qiskit.circuit.library.arithmetic import WeightedAdder
circuit = WeightedAdder(5, [1, 2, 4, 1, 2])


This creates a circuit, partially printed here:

circuit.draw()

  state_0: ──■────■────■──────────■────■──────────■────■─────────■────────»
│    │    │          │    │          │    │         │        »
state_1: ──┼────┼────┼──────────┼────┼──────────┼────┼─────────┼────────»
│    │    │          │    │          │    │         │        »
state_2: ──┼────┼────┼──────────┼────┼──────────┼────┼─────────┼────────»
│    │    │          │    │          │    │         │        »
state_3: ──┼────┼────┼──────────┼────┼──────────┼────┼─────────┼────────»
│    │    │          │    │          │    │         │        »
state_4: ──┼────┼────┼──────────┼────┼──────────┼────┼─────────┼────────»
│  ┌─┴─┐  │   ┌───┐  │    │          │    │         │        »
sum_0: ──■──┤ X ├──┼───┤ X ├──┼────┼──────────┼────┼─────────┼────────»
│  └───┘  │   └───┘┌─┴─┐  │   ┌───┐  │    │         │        »
sum_1: ──┼─────────■────────┤ X ├──┼───┤ X ├──┼────┼─────────┼────────»
│         │        └─┬─┘  │   └───┘┌─┴─┐  │  ┌───┐  │   ┌───┐»
sum_2: ──┼─────────┼──────────┼────■────────┤ X ├──┼──┤ X ├──■───┤ X ├»
│         │          │    │        └─┬─┘┌─┴─┐└───┘  │   └───┘»
sum_3: ──┼─────────┼──────────┼────┼──────────┼──┤ X ├───────┼────────»
┌─┴─┐       │          │    │          │  └─┬─┘       │        »
carry_0: ┤ X ├───────■──────────■────┼──────────┼────┼─────────┼────────»
└───┘     ┌─┴──┐            │          │    │         │        »
carry_1: ──────────┤0   ├────────────■──────────■────┼─────────■────────»
│    │          ┌─┴──┐            │       ┌─┴──┐     »
carry_2: ──────────┤  X ├──────────┤0   ├────────────■───────┤0   ├─────»
│    │          │  X │                    │  X │     »
control_0: ──────────┤1   ├──────────┤1   ├────────────────────┤1   ├─────»
└────┘          └────┘                    └────┘     »


Let's now measure the quantum registers sum and carry to extract the result of the computation:

from qiskit import ClassicalRegister

sum_result = ClassicalRegister(4, name='sum_result')
carry_result = ClassicalRegister(3, name='carry_result')
q_sum = circuit.qregs[1]
q_carry = circuit.qregs[2]

circuit.measure(q_sum, sum_result)
circuit.measure(q_carry, carry_result)


And now, let's create value summands. For example, $$4$$ (three-bit length) and $$2$$ (two-bit length)

from qiskit import QuantumCircuit

value1 = QuantumCircuit(3, name='value1')
value2 = QuantumCircuit(2, name='value2')

# bin(4) == 0b100
value1.x(2)

# bin(2) == 0b10
value2.x(1)


The inputs should be appended to the front of the adder circuit, like this:

circuit.compose(value1.to_gate(), qubits=[0, 1 ,2], front=True, inplace=True)
circuit.compose(value2.to_gate(), qubits=[3, 4], front=True, inplace=True)

circuit.draw()

                ┌─────────┐                                                    »
state_0: ┤0        ├──■────■────■──────────■────■──────────■────■───────»
│         │  │    │    │          │    │          │    │       »
state_1: ┤1 value1 ├──┼────┼────┼──────────┼────┼──────────┼────┼───────»
│         │  │    │    │          │    │          │    │       »
state_2: ┤2        ├──┼────┼────┼──────────┼────┼──────────┼────┼───────»
├─────────┤  │    │    │          │    │          │    │       »
state_3: ┤0        ├──┼────┼────┼──────────┼────┼──────────┼────┼───────»
│  value2 │  │    │    │          │    │          │    │       »
state_4: ┤1        ├──┼────┼────┼──────────┼────┼──────────┼────┼───────»
└─────────┘  │  ┌─┴─┐  │   ┌───┐  │    │          │    │       »
sum_0: ─────────────■──┤ X ├──┼───┤ X ├──┼────┼──────────┼────┼───────»
│  └───┘  │   └───┘┌─┴─┐  │   ┌───┐  │    │       »
sum_1: ─────────────┼─────────■────────┤ X ├──┼───┤ X ├──┼────┼───────»
│         │        └─┬─┘  │   └───┘┌─┴─┐  │  ┌───┐»
sum_2: ─────────────┼─────────┼──────────┼────■────────┤ X ├──┼──┤ X ├»
│         │          │    │        └─┬─┘┌─┴─┐└───┘»
sum_3: ─────────────┼─────────┼──────────┼────┼──────────┼──┤ X ├─────»
┌─┴─┐       │          │    │          │  └─┬─┘     »
carry_0: ───────────┤ X ├───────■──────────■────┼──────────┼────┼───────»
└───┘     ┌─┴──┐            │          │    │       »
carry_1: ─────────────────────┤0   ├────────────■──────────■────┼───────»
│    │          ┌─┴──┐            │       »
carry_2: ─────────────────────┤  X ├──────────┤0   ├────────────■───────»
│    │          │  X │                    »
control_0: ─────────────────────┤1   ├──────────┤1   ├────────────────────»
└────┘          └────┘                    »
sum_result: 4/═══════════════════════════════════════════════════════════════»
»
carry_result: 3/═══════════════════════════════════════════════════════════════»
»


Finally, it is time to run the circuit and see how it works:

from qiskit import BasicAer, execute
backend = BasicAer.get_backend('qasm_simulator')

result = execute(circuit, backend).result()

result.get_counts()

{'000 0110': 1024}


The result is $$4+2 = 6$$ (int('0110', base=2)).