Arithmetic circuit library: Adders

qiskit/circuit/library/__init__.py

@@ -146,6 +146,9 @@
 .. autosummary::
    :toctree: ../stubs/
 
+   ClassicalAdder
+   QFTAdder
+   RippleCarryAdder
    WeightedAdder
 
 Comparators
@@ -354,8 +357,12 @@
     WeightedAdder,
     QuadraticForm,
     LinearAmplitudeFunction,
+    ClassicalAdder,
+    RippleCarryAdder,
+    QFTAdder,
     PiecewiseChebyshev,
 )
+
 from .n_local import (
     NLocal,
     TwoLocal,

qiskit/circuit/library/arithmetic/__init__.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2020.
+# (C) Copyright IBM 2021.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -21,4 +21,5 @@
 from .weighted_adder import WeightedAdder
 from .quadratic_form import QuadraticForm
 from .linear_amplitude_function import LinearAmplitudeFunction
+from .adders import ClassicalAdder, RippleCarryAdder, QFTAdder
 from .piecewise_chebyshev import PiecewiseChebyshev

qiskit/circuit/library/arithmetic/adders/__init__.py

@@ -0,0 +1,17 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""The adder circuit library."""
+
+from .ripple_carry_adder import RippleCarryAdder
+from .qft_adder import QFTAdder
+from .classical_adder import ClassicalAdder

qiskit/circuit/library/arithmetic/adders/adder.py

@@ -0,0 +1,58 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Compute the sum of two equally sized qubit registers."""
+
+from qiskit.circuit import QuantumCircuit
+
+
+class Adder(QuantumCircuit):
+    r"""Compute the sum of two equally sized qubit registers.
+
+    For two registers :math:`|a\rangle_n` and :math:|b\rangle_n` with :math:`n` qubits each, an
+    adder performs the following operation
+
+    .. math::
+
+        |a\rangle_n |b\rangle_n \mapsto |a\rangle_n |a + b\rangle_{n + 1}.
+
+    The quantum register :math:`|a\rangle_n` (and analogously :math:`|b\rangle_n`)
+
+    .. math::
+
+        |a\rangle_n = |a_0\rangle \otimes \cdots \otimes |a_{n - 1}\rangle,
+
+    for :math:`a_i \in \{0, 1\}`, is associated with the integer value
+
+    .. math::
+
+        a = 2^{0}a_{0} + 2^{1}a_{1} + \cdots + 2^{n - 1}a_{n - 1}.
+
+    """
+
+    def __init__(self, num_state_qubits: int, name: str = 'Adder') -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the registers.
+            name: The name of the circuit.
+        """
+        super().__init__(name=name)
+        self._num_state_qubits = num_state_qubits
+
+    @property
+    def num_state_qubits(self) -> int:
+        """The number of state qubits, i.e. the number of bits in each input register.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits

qiskit/circuit/library/arithmetic/adders/classical_adder.py

@@ -0,0 +1,118 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Compute the sum of two qubit registers using Classical Addition."""
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
+
+from .adder import Adder
+
+
+class ClassicalAdder(Adder):
+    r"""A circuit that uses Classical Addition to perform in-place addition on two qubit registers.
+
+    As an example, a classical adder circuit that performs addition on two 3-qubit sized
+    registers is as follows:
+
+    .. parsed-literal::
+
+                ┌────────┐                                                   ┌────────┐┌──────┐
+           a_0: ┤1       ├───────────────────────────────────────────────────┤1       ├┤1     ├
+                │        │┌────────┐                       ┌────────┐┌──────┐│        ││      │
+           a_1: ┤        ├┤1       ├───────────────────────┤1       ├┤1     ├┤        ├┤      ├
+                │        ││        │┌────────┐     ┌──────┐│        ││      ││        ││      │
+           a_2: ┤        ├┤        ├┤1       ├──■──┤1     ├┤        ├┤      ├┤        ├┤      ├
+                │        ││        ││        │  │  │      ││        ││      ││        ││      │
+           b_0: ┤2       ├┤        ├┤        ├──┼──┤      ├┤        ├┤      ├┤2       ├┤2     ├
+                │        ││        ││        │  │  │      ││        ││      ││        ││  Sum │
+           b_1: ┤  Carry ├┤2       ├┤        ├──┼──┤      ├┤2       ├┤2     ├┤  Carry ├┤      ├
+                │        ││        ││        │┌─┴─┐│      ││        ││  Sum ││        ││      │
+           b_2: ┤        ├┤  Carry ├┤2       ├┤ X ├┤2     ├┤  Carry ├┤      ├┤        ├┤      ├
+                │        ││        ││  Carry │└───┘│  Sum ││        ││      ││        ││      │
+        cout_0: ┤        ├┤        ├┤3       ├─────┤      ├┤        ├┤      ├┤        ├┤      ├
+                │        ││        ││        │     │      ││        ││      ││        ││      │
+         cin_0: ┤0       ├┤        ├┤        ├─────┤      ├┤        ├┤      ├┤0       ├┤0     ├
+                │        ││        ││        │     │      ││        ││      ││        │└──────┘
+         cin_1: ┤3       ├┤0       ├┤        ├─────┤      ├┤0       ├┤0     ├┤3       ├────────
+                └────────┘│        ││        │     │      ││        │└──────┘└────────┘
+         cin_2: ──────────┤3       ├┤0       ├─────┤0     ├┤3       ├──────────────────────────
+                          └────────┘└────────┘     └──────┘└────────┘
+
+
+    Here *Carry* and *Sum* gates correspond to the gates introduced in [1]. Note that
+    in this implementation the input register qubits are ordered as all qubits from
+    the first input register, followed by all qubits from the second input register.
+    This is different ordering as compared to Figure 2 in [1], which leads to a different
+    drawing of the circuit.
+
+    **References:**
+
+    [1] T. G. Draper, Addition on a Quantum Computer, 2000.
+    `arXiv:quant-ph/0008033 <https://arxiv.org/pdf/quant-ph/0008033.pdf>`_
+
+    """
+
+    def __init__(self,
+                 num_state_qubits: int,
+                 name: str = 'ClassicalAdder'
+                 ) -> None:
+        """
+        Args:
+            num_state_qubits: The size of the register.
+            name: The name of the circuit.
+
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        if num_state_qubits < 1:
+            raise ValueError('The number of qubits must be at least 1.')
+
+        super().__init__(num_state_qubits, name=name)
+
+        # define the registers
+        qr_a = QuantumRegister(num_state_qubits, name='a')
+        qr_b = QuantumRegister(num_state_qubits, name='b')
+        qr_cin = AncillaRegister(num_state_qubits, name='cin')
+        qr_cout = QuantumRegister(1, name='cout')
+
+        # initialize the registers
+        self.add_register(qr_a, qr_b, qr_cout, qr_cin)
+
+        # corresponds to Carry gate in [1]
+        qc_carry = QuantumCircuit(4, name='Carry')
+        qc_carry.ccx(1, 2, 3)
+        qc_carry.cx(1, 2)
+        qc_carry.ccx(0, 2, 3)
+        qc_instruction_carry = qc_carry.to_gate()
+
+        # corresponds to Sum gate in [1]
+        qc_sum = QuantumCircuit(3, name='Sum')
+        qc_sum.cx(1, 2)
+        qc_sum.cx(0, 2)
+        qc_instruction_sum = qc_sum.to_gate()
+
+        # Build a temporary subcircuit that adds a to b,
+        # storing the result in b
+
+        for j in range(num_state_qubits - 1):
+            self.append(qc_instruction_carry, [qr_cin[j], qr_a[j], qr_b[j], qr_cin[j+1]])
+
+        self.append(qc_instruction_carry, [qr_cin[num_state_qubits - 1],
+                                           qr_a[num_state_qubits - 1], qr_b[num_state_qubits - 1],
+                                           qr_cout])
+        self.cx(qr_a[num_state_qubits - 1], qr_b[num_state_qubits - 1])
+        self.append(qc_instruction_sum, [qr_cin[num_state_qubits - 1],
+                                         qr_a[num_state_qubits - 1], qr_b[num_state_qubits - 1]])
+
+        for j in reversed(range(num_state_qubits - 1)):
+            self.append(qc_instruction_carry.inverse(), [qr_cin[j], qr_a[j], qr_b[j], qr_cin[j+1]])
+            self.append(qc_instruction_sum, [qr_cin[j], qr_a[j], qr_b[j]])

qiskit/circuit/library/arithmetic/adders/qft_adder.py

@@ -0,0 +1,109 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Compute the sum of two qubit registers using QFT."""
+
+import numpy as np
+
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.library.basis_change import QFT
+
+from .adder import Adder
+
+
+class QFTAdder(Adder):
+    r"""A circuit that uses QFT to perform in-place addition on two qubit registers.
+
+    For registers with :math:`n` qubits, the QFT adder can perform addition modulo
+    :math:`2^n` (with `modular=True`) or ordinary addition by adding a carry qubits (with
+    `modular=False`).
+
+    As an example, a non-modular QFT adder circuit that performs addition on two 2-qubit sized
+    registers is as follows:
+
+    .. parsed-literal::
+
+         a_0:   ─────────■──────■────────────────────────■────────────────
+                         │      │                        │
+         a_1:   ─────────┼──────┼────────■──────■────────┼────────────────
+                ┌──────┐ │P(π)  │        │      │        │       ┌───────┐
+         b_0:   ┤0     ├─■──────┼────────┼──────┼────────┼───────┤0      ├
+                │      │        │P(π/2)  │P(π)  │        │       │       │
+         b_1:   ┤1 qft ├────────■────────■──────┼────────┼───────┤1 iqft ├
+                │      │                        │P(π/2)  │P(π/4) │       │
+        cout_0: ┤2     ├────────────────────────■────────■───────┤2      ├
+                └──────┘                                         └───────┘
+
+    **References:**
+
+    [1] T. G. Draper, Addition on a Quantum Computer, 2000.
+    `arXiv:quant-ph/0008033 <https://arxiv.org/pdf/quant-ph/0008033.pdf>`_
+
+    [2] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
+    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
+
+    [3] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+
+    def __init__(self,
+                 num_state_qubits: int,
+                 modular: bool = False,
+                 name: str = 'QFTAdder'
+                 ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits in either input register for
+                state :math:`|a\rangle` or :math:`|b\rangle`. The two input
+                registers must have the same number of qubits.
+            modular: Whether addition is modular with mod :math:`2^n`.
+                Additional qubit is attached in case of non-modular addition
+                to carry the most significant qubit of the sum.
+            name: The name of the circuit object.
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        if num_state_qubits < 1:
+            raise ValueError('The number of qubits must be at least 1.')
+
+        super().__init__(num_state_qubits, name=name)
+
+        qr_a = QuantumRegister(num_state_qubits, name='a')
+        qr_b = QuantumRegister(num_state_qubits, name='b')
+        qr_list = [qr_a, qr_b]
+
+        if not modular:
+            qr_z = QuantumRegister(1, name='cout')
+            qr_list.append(qr_z)
+
+        # add registers
+        self.add_register(*qr_list)
+
+        # define register containing the sum and number of qubits for QFT circuit
+        qr_sum = qr_b[:] if modular else qr_b[:] + qr_z[:]
+        num_qubits_qft = num_state_qubits if modular else num_state_qubits + 1
+
+        # build QFT adder circuit
+        self.append(QFT(num_qubits_qft, do_swaps=False).to_gate(), qr_sum[:])
+
+        for j in range(num_state_qubits):
+            for k in range(num_state_qubits - j):
+                lam = np.pi / (2 ** k)
+                self.cp(lam, qr_a[j], qr_b[j + k])
+
+        if not modular:
+            for j in range(num_state_qubits):
+                lam = np.pi / (2 ** (j + 1))
+                self.cp(lam, qr_a[num_state_qubits - j - 1], qr_z[0])
+
+        self.append(QFT(num_qubits_qft, do_swaps=False).inverse().to_gate(), qr_sum[:])