``` python
def _run(qc, shots):
simulator = AerSimulator()
tqc = transpile(qc, simulator, optimization_level=3)
job = simulator.run(tqc, shots=shots)
result = job.result()
return dict(sorted(result.get_counts().items()))
```
Fedoriaka implements the *M**A**J* and *M**A**J*−1 gates
efficiently by incorporating the *A**N**D* and *A**N**D*−1
gates described in “Halving the cost of quantum addition” (Gidney).
Below is the implementation of said gates.
Screenshot 2026-04-09
224839.png
The *A**N**D*−1 implementation is particularly unique as it
uses classical measurement to skip practically every expensive operation
used in the *A**N**D* implementation. The phase is preserved by a *C**Z*
controlled on the result of the measurement.
### Testing *A**N**D* and *A**N**D*−1
``` python
qc = QuantumCircuit(3,3)
qc.h(2)
qc.t(2)
qc.x(0)
qc.x(1)
qc.compose(_AND(), qubits=[0,1,2], inplace=True)
qc.measure([0,1,2], [0,1,2])
assert _run(qc,8) == {'111': 8}, "AND gate does not work correctly"
qc = QuantumCircuit(3,3)
qc.h(2)
qc.t(2)
qc.x(0)
qc.compose(_AND(), qubits=[0,1,2], inplace=True)
qc.compose(_ANDdg(), qubits=[0,1,2], clbits=[0], inplace=True)
qc.measure([0,1,2],[0,1,2])
assert _run(qc,8) == {'001': 8}, "ANDdg fails to undo AND gate"
```
``` python
def _AdderBlock(constant_bit):
qc = QuantumCircuit(3)
if constant_bit:
qc.x(0)
qc.x(1)
qc.append(_AND(), [0,1,2])
if constant_bit:
qc.x(2)
return qc.to_gate(label='add_block')
def _AdderBlockUncompute_op(constant_bit):
qc = QuantumCircuit(3, 1)
if constant_bit:
qc.x(2)
qc.compose(_ANDdg(), qubits=[0,1,2], clbits=[0], inplace=True)
if constant_bit:
qc.x(0)
qc.cx(0,1)
return qc
```
Algorithmically generalized implementation, following the
fully-optimized Adder Design from the paper, shown below:
### Fedoriaka Adder Export
------------------------------------------------------------------------
### FedoriakaConstantAdder
``` python
def FedoriakaConstantAdder(
constant:int, size:int
)->QuantumCircuit:
```
*Implements |b\> -\> |(b + a) mod 2^N\> v* Where a is a fixed classical
constant Via the method outlined in: “New Circuit for Quantum Adder by
Constant” (Dmytro Fedoriaka)
Args: constant (int): Fixed classical value to add, where 0 \<= constant
\< 2^size a size (int): Number of qubits in the register b (0\|b\> -\> |c\>|(b + c*a) mod 2^N\>\* Where a is a fixed
classical constant and c is a quantum control bit Via the method for a
controlled-adder outlined in: “New Circuit for Quantum Adder by
Constant” (Dmytro Fedoriaka)
Args: constant (int): Fixed classical value to add, where 0 \<= constant
\< 2^size a size (int): Number of qubits in the register b (0\
