full code upload

Author: FilipeChagasDev

README.md

@@ -1,2 +1,43 @@
-# quantum-arithmetic
-Public repository of research codes on quantum arithmetic algorithms
+# Register-by-Constant QFT Addition Algorithm - by Filipe Chagas Ferraz
+
+
+## Presentation
+
+This is a quantum algorithm I created that can be considered a simplified version of Draper's adder. This algorithm is described as a unitary operator $U_+(c)$ such that $U_+(c)|a\rangle \mapsto | a + c \pmod{2^N}\rangle$, where $|a\rangle$ is the initial state of the $N$-qubit register. This state can be defined for natural number as:
+
+$$|a\rangle = |a_N,...,a_2,a_1\rangle, \quad a = \sum_{j=1}^N a_j 2^{j-1}$$
+
+This state can also be defined for (signed) integer numbers using the two's complement notation.
+
+The operator $U_+(c)$ is defined as $U_+(c) = U_\text{QFT}^\dagger \times U_{\phi(+)}(c) \times U_\text{QFT}$, where $U_{\phi(+)}(c) = \text{diag}[1, \omega^{c}, \omega^{2c}, \omega^{3c},...,\omega^{(2^N-1)c}]$. This operator can be implemented as the following quantum circuit:
+
+![reg-by-const QFT adder](img/QAdder.png)
+
+## Organization
+
+This repository is organized as follows:
+
+* The file **qiskit_quantum_fourier_transform.py** contains a function that gives the QFT gate. As the filename says, this function uses Qiskit.
+* The file **qiskit_reg_by_const_qft_adder.py** has functions that gives Qiskit gates of the operators $U_+(c)$ and $U_{\phi(+)}(c)$.
+* The file **qiskit_reg_by_const_qft_adder_test.ipynb** is a Jupyter notebook made for test the functions in *qiskit_reg_by_const_qft_adder.py*. This notebook contains the results of some tests.
+
+* The file **numeric_systems.py** has functions that convert natural numbers and integers into sequences of bits. These functions are used for testing.
+
+* The file **test_tools.py** contains functions that are used for testing.
+
+## Citation
+
+This algorithm is described in detail in the paper *"Quantum Algorithm based on Quantum Fourier Transform for Register-by-Constant Addition"* (https://doi.org/10.48550/arXiv.2207.05309). If you use this algorithm in your research, please cite it as follows:
+
+```
+@misc{ferraz_22,
+  doi = {10.48550/ARXIV.2207.05309},
+  url = {https://arxiv.org/abs/2207.05309},
+  author = {Ferraz, Filipe Chagas},
+  keywords = {Quantum Physics (quant-ph), FOS: Physical sciences, FOS: Physical sciences},
+  title = {Quantum Algorithm based on Quantum Fourier Transform for Register-by-Constant Addition},
+  publisher = {arXiv},
+  year = {2022},
+  copyright = {Creative Commons Attribution 4.0 International}
+}
+```

img/QAdder.png

@@ -0,0 +1,68 @@
+#By Filipe Chagas
+#Mar 2022
+
+from typing import *
+
+def natural_to_binary(x: int, n: int) -> List[bool]:
+    """Returns x in the binary system.
+
+    :param x: Natural (including zero) to convert.
+    :type x: int
+    :param n: Number of bits.
+    :type n: int
+    :return: List of bits. Each bit is a bool. Most significant bit last.
+    :rtype: List[bool]
+    """
+    assert n > 0
+    assert x >= 0
+    assert x < 2**n
+    return [bool((x//2**i)%2) for i in range(n)]
+
+def binary_to_natural(x: List[bool]) -> int:
+    """Returns x as a natural number (including zero).
+
+    :param x: List of bits. Most significant bit last.
+    :type x: List[bool]
+    :return: Natural number (including zero).
+    :rtype: int
+    """
+    n = len(x)
+    return sum([(2**i)*int(x[i]) for i in range(n)])
+
+def two_complement(x: List[bool]) -> List[bool]:
+    """Returns the 2's complement for x.
+
+    :param x: List of bits. Most significant bit last.
+    :type x: List[bool]
+    :return: 2's complement of x. List of bits. Most significant bit last.
+    :rtype: List[bool]
+    """
+    n = len(x)
+    one_complement = [not x_i for x_i in x]
+    return natural_to_binary(binary_to_natural(one_complement) + 1, n)
+
+def integer_to_binary(x: int, n: int) -> List[bool]:
+    """Returns x in the binary system using 2's complement notation.
+
+    :param x: Integer value to convert.
+    :type x: int
+    :param n: Number of bits.
+    :type n: int
+    :return: List of bits. Less significant bit fist. Sign bit last.
+    :rtype: List[bool]
+    """
+    assert n > 0
+    assert x < 2**(n-1)
+    assert x >= -2**(n-1)
+    return natural_to_binary(x, n) if x >= 0 else two_complement(natural_to_binary(-x, n))
+
+def binary_to_integer(x: List[bool]) -> int:
+    """Returns x as an integer number.
+
+    :param x: List of bits. Less significant bit fist. Sign bit last.
+    :type x: List[bool]
+    :return: Integer number.
+    :rtype: int
+    """
+    n = len(x)
+    return binary_to_natural(x) if x[n-1] == False else -binary_to_natural(two_complement(x))

numeric_systems.py

@@ -0,0 +1,33 @@
+#By Filipe Chagas
+#2022
+
+import qiskit
+from math import *
+
+def qft(n: int) -> qiskit.circuit.Gate:
+    """Returns a QFT gate for n qubits.
+
+    :param n: Number of target qubits.
+    :type n: int
+    :return: QFT gate.
+    :rtype: qiskit.circuit.Gate
+    """
+    def rotations(my_circuit: qiskit.circuit.Gate, m: int):
+        if m == 0:
+            return my_circuit
+        else:
+            my_circuit.h(m-1) #Add a Haddamard gate to the most significant qubit
+        
+            for i in range(m-1):
+                my_circuit.crz(pi/(2**(m-1-i)), i, m-1)
+
+            rotations(my_circuit, m-1) 
+    
+    my_circuit = qiskit.QuantumCircuit(n, name='QFT')
+    
+    rotations(my_circuit, n)
+
+    for m in range(n//2):
+        my_circuit.swap(m, n-m-1)
+
+    return my_circuit.to_gate()

qiskit_quantum_fourier_transform.py

@@ -0,0 +1,58 @@
+#By Filipe Chagas
+#2022
+
+import qiskit
+from math import *
+from qiskit_quantum_fourier_transform import qft
+from numeric_systems import *
+
+def reg_by_const_fourier_basis_adder(n: int, c: int) -> qiskit.circuit.Gate:
+    """
+    Register-by-constant addition gate in Fourier basis.
+    Get a gate to perform an addition of a constant $c$ to an integer register in Fourier basis.
+    No ancillary qubits needed.
+    
+    [see https://doi.org/10.48550/arXiv.2207.05309]
+
+    :param n: Number of target qubits.
+    :type n: int
+    :param c: Constant to add.
+    :type c: int
+    :return: $U_{\phi(+)}(c)$ gate.
+    :rtype: qiskit.circuit.Gate
+    """
+    assert n > 0
+
+    my_circuit = qiskit.QuantumCircuit(n, name=f'$U_{{\\phi(+)}}({c})$')
+
+    for i in range(n):
+        theta = c * (pi / (2**(n-i-1)))
+        my_circuit.rz(theta, i)
+
+    return my_circuit.to_gate()
+
+def reg_by_const_qft_adder(n: int, c: int) -> qiskit.circuit.Gate:
+    """
+    Register-by-constant QFT addition gate.
+    Get a gate to perform an addition of a constant $c$ to a integer register.
+    No ancillary qubits needed.
+
+    [see https://doi.org/10.48550/arXiv.2207.05309]
+
+    :param n: Number of target qubits.
+    :type n: int
+    :param c: Constant to add.
+    :type c: int
+    :return: $U_{+}(c)$ gate.
+    :rtype: qiskit.circuit.Gate
+    """
+    assert n > 0
+
+    my_circuit = qiskit.QuantumCircuit(n, name=f'$U_{{+}}({c})$')
+
+    my_qft = qft(n)
+    my_circuit.append(my_qft, list(range(n)))
+    my_circuit.append(reg_by_const_fourier_basis_adder(n, c), list(range(n)))
+    my_circuit.append(my_qft.inverse(), list(range(n)))
+
+    return my_circuit.to_gate()

qiskit_reg_by_const_qft_adder.py

@@ -0,0 +1,126 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import qiskit\n",
+    "from qiskit_reg_by_const_qft_adder import reg_by_const_qft_adder\n",
+    "from numeric_systems import *\n",
+    "from typing import *\n",
+    "from test_tools import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "a=-4, c=-4, result=-8\n",
+      "a=-4, c=-3, result=-7\n",
+      "a=-4, c=-2, result=-6\n",
+      "a=-4, c=-1, result=-5\n",
+      "a=-4, c=0, result=-4\n",
+      "a=-4, c=1, result=-3\n",
+      "a=-4, c=2, result=-2\n",
+      "a=-3, c=-4, result=-7\n",
+      "a=-3, c=-3, result=-6\n",
+      "a=-3, c=-2, result=-5\n",
+      "a=-3, c=-1, result=-4\n",
+      "a=-3, c=0, result=-3\n",
+      "a=-3, c=1, result=-2\n",
+      "a=-3, c=2, result=-1\n",
+      "a=-2, c=-4, result=-6\n",
+      "a=-2, c=-3, result=-5\n",
+      "a=-2, c=-2, result=-4\n",
+      "a=-2, c=-1, result=-3\n",
+      "a=-2, c=0, result=-2\n",
+      "a=-2, c=1, result=-1\n",
+      "a=-2, c=2, result=0\n",
+      "a=-1, c=-4, result=-5\n",
+      "a=-1, c=-3, result=-4\n",
+      "a=-1, c=-2, result=-3\n",
+      "a=-1, c=-1, result=-2\n",
+      "a=-1, c=0, result=-1\n",
+      "a=-1, c=1, result=0\n",
+      "a=-1, c=2, result=1\n",
+      "a=0, c=-4, result=-4\n",
+      "a=0, c=-3, result=-3\n",
+      "a=0, c=-2, result=-2\n",
+      "a=0, c=-1, result=-1\n",
+      "a=0, c=0, result=0\n",
+      "a=0, c=1, result=1\n",
+      "a=0, c=2, result=2\n",
+      "a=1, c=-4, result=-3\n",
+      "a=1, c=-3, result=-2\n",
+      "a=1, c=-2, result=-1\n",
+      "a=1, c=-1, result=0\n",
+      "a=1, c=0, result=1\n",
+      "a=1, c=1, result=2\n",
+      "a=1, c=2, result=3\n",
+      "a=2, c=-4, result=-2\n",
+      "a=2, c=-3, result=-1\n",
+      "a=2, c=-2, result=0\n",
+      "a=2, c=-1, result=1\n",
+      "a=2, c=0, result=2\n",
+      "a=2, c=1, result=3\n",
+      "a=2, c=2, result=4\n"
+     ]
+    }
+   ],
+   "source": [
+    "for a in range(-4, 3):\n",
+    "    for c in range(-4, 3):\n",
+    "        #Create the quantum circuit\n",
+    "        my_circuit = qiskit.QuantumCircuit(4)\n",
+    "\n",
+    "        #Initialize register with $a$\n",
+    "        a_binary = integer_to_binary(a, 4)\n",
+    "        for i in range(4):\n",
+    "            if a_binary[i] == True:\n",
+    "                my_circuit.x(i)\n",
+    "\n",
+    "        #Create gate\n",
+    "        g = reg_by_const_qft_adder(4, c)\n",
+    "\n",
+    "        #Append gate to the circuit\n",
+    "        my_circuit.append(g, list(range(4)))\n",
+    "\n",
+    "        #Append measurements\n",
+    "        my_circuit.measure_all()\n",
+    "\n",
+    "        #Simulation\n",
+    "        result_binary = one_shot_simulation(my_circuit)\n",
+    "        result_integer = binary_to_integer(result_binary)\n",
+    "        print(f'a={a}, c={c}, result={result_integer}')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

qiskit_reg_by_const_qft_adder_test.ipynb

@@ -0,0 +1,42 @@
+# By Filipe Chagas
+# 2022
+
+import qiskit
+from numeric_systems import *
+from typing import *
+
+def result_string_to_list(result: str) -> List[bool]:
+    """Convert a string result to a list of bits.
+
+    :param result: String result from Qiskit.
+    :type result: str
+    :return: List of bits. Most significant bit last.
+    :rtype: List[bool]
+    """
+    return [(True if c == '1' else False) for c in result[::-1]]
+
+def extract_register_from_result(result: List[bool], register: List[int]) -> List[bool]:
+    """Extract a register from a list of bits.
+
+    :param result: List of bits from Qiskit result. Most significant bit last.
+    :type result: List[bool]
+    :param register: List of register's qubits indexes. Most significant bit last.
+    :type register: List[int]
+    :return: List of bits. Most significant bit last.
+    :rtype: List[bool]
+    """
+    return [result[i] for i in register]
+
+def one_shot_simulation(circuit: qiskit.QuantumCircuit) -> List[bool]:
+    """Do a one-shot simulation with Qiskit and return it's result as a list of bits.
+
+    :param circuit: Qiskit quantum circuit.
+    :type circuit: qiskit.QuantumCircuit
+    :return: List of bits. Most significant bit last.
+    :rtype: List[bool]
+    """
+    backend = qiskit.BasicAer.get_backend('qasm_simulator')
+    job = qiskit.execute(circuit, backend, shots=1)
+    counts = job.result().get_counts()
+    result_string = list(counts.keys())[0]
+    return result_string_to_list(result_string)