qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/circuit/library/arithmetic/linear_pauli_rotations.py

@@ -0,0 +1,189 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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.
+
+
+"""Linearly-controlled X, Y or Z rotation."""
+
+from typing import Optional
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+from .functional_pauli_rotations import FunctionalPauliRotations
+
+
+class LinearPauliRotations(FunctionalPauliRotations):
+    r"""Linearly-controlled X, Y or Z rotation.
+
+    For a register of state qubits :math:`|x\rangle`, a target qubit :math:`|0\rangle` and the
+    basis ``'Y'`` this circuit acts as:
+
+    .. code-block:: text
+
+            q_0: ─────────────────────────■───────── ... ──────────────────────
+                                          │
+                                          .
+                                          │
+        q_(n-1): ─────────────────────────┼───────── ... ───────────■──────────
+                  ┌────────────┐  ┌───────┴───────┐       ┌─────────┴─────────┐
+            q_n: ─┤ RY(offset) ├──┤ RY(2^0 slope) ├  ...  ┤ RY(2^(n-1) slope) ├
+                  └────────────┘  └───────────────┘       └───────────────────┘
+
+    This can for example be used to approximate linear functions, with :math:`a =` ``slope``:math:`/2`
+    and :math:`b =` ``offset``:math:`/2` and the basis ``'Y'``:
+
+    .. math::
+
+        |x\rangle |0\rangle \mapsto \cos(ax + b)|x\rangle|0\rangle + \sin(ax + b)|x\rangle |1\rangle
+
+    Since for small arguments :math:`\sin(x) \approx x` this operator can be used to approximate
+    linear functions.
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: Optional[int] = None,
+        slope: float = 1,
+        offset: float = 0,
+        basis: str = "Y",
+        name: str = "LinRot",
+    ) -> None:
+        r"""Create a new linear rotation circuit.
+
+        Args:
+            num_state_qubits: The number of qubits representing the state :math:`|x\rangle`.
+            slope: The slope of the controlled rotation.
+            offset: The offset of the controlled rotation.
+            basis: The type of Pauli rotation ('X', 'Y', 'Z').
+            name: The name of the circuit object.
+        """
+        super().__init__(num_state_qubits=num_state_qubits, basis=basis, name=name)
+
+        # define internal parameters
+        self._slope = None
+        self._offset = None
+
+        # store parameters
+        self.slope = slope
+        self.offset = offset
+
+    @property
+    def slope(self) -> float:
+        """The multiplicative factor in the rotation angle of the controlled rotations.
+
+        The rotation angles are ``slope * 2^0``, ``slope * 2^1``, ... , ``slope * 2^(n-1)`` where
+        ``n`` is the number of state qubits.
+
+        Returns:
+            The rotation angle common in all controlled rotations.
+        """
+        return self._slope
+
+    @slope.setter
+    def slope(self, slope: float) -> None:
+        """Set the multiplicative factor of the rotation angles.
+
+        Args:
+            The slope of the rotation angles.
+        """
+        if self._slope is None or slope != self._slope:
+            self._invalidate()
+            self._slope = slope
+
+    @property
+    def offset(self) -> float:
+        """The angle of the single qubit offset rotation on the target qubit.
+
+        Before applying the controlled rotations, a single rotation of angle ``offset`` is
+        applied to the target qubit.
+
+        Returns:
+            The offset angle.
+        """
+        return self._offset
+
+    @offset.setter
+    def offset(self, offset: float) -> None:
+        """Set the angle for the offset rotation on the target qubit.
+
+        Args:
+            offset: The offset rotation angle.
+        """
+        if self._offset is None or offset != self._offset:
+            self._invalidate()
+            self._offset = offset
+
+    def _reset_registers(self, num_state_qubits: Optional[int]) -> None:
+        """Set the number of state qubits.
+
+        Note that this changes the underlying quantum register, if the number of state qubits
+        changes.
+
+        Args:
+            num_state_qubits: The new number of qubits.
+        """
+        self.qregs = []
+
+        if num_state_qubits:
+            # set new register of appropriate size
+            qr_state = QuantumRegister(num_state_qubits, name="state")
+            qr_target = QuantumRegister(1, name="target")
+            self.qregs = [qr_state, qr_target]
+
+    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
+        """Check if the current configuration is valid."""
+        valid = True
+
+        if self.num_state_qubits is None:
+            valid = False
+            if raise_on_failure:
+                raise AttributeError("The number of qubits has not been set.")
+
+        if self.num_qubits < self.num_state_qubits + 1:
+            valid = False
+            if raise_on_failure:
+                raise CircuitError(
+                    "Not enough qubits in the circuit, need at least "
+                    f"{self.num_state_qubits + 1}."
+                )
+
+        return valid
+
+    def _build(self):
+        """If not already built, build the circuit."""
+        if self._is_built:
+            return
+
+        super()._build()
+
+        circuit = QuantumCircuit(*self.qregs, name=self.name)
+
+        # build the circuit
+        qr_state = self.qubits[: self.num_state_qubits]
+        qr_target = self.qubits[self.num_state_qubits]
+
+        if self.basis == "x":
+            circuit.rx(self.offset, qr_target)
+        elif self.basis == "y":
+            circuit.ry(self.offset, qr_target)
+        else:  # 'Z':
+            circuit.rz(self.offset, qr_target)
+
+        for i, q_i in enumerate(qr_state):
+            if self.basis == "x":
+                circuit.crx(self.slope * pow(2, i), q_i, qr_target)
+            elif self.basis == "y":
+                circuit.cry(self.slope * pow(2, i), q_i, qr_target)
+            else:  # 'Z'
+                circuit.crz(self.slope * pow(2, i), q_i, qr_target)
+
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/multipliers/__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 multiplier circuit library."""
+
+from .hrs_cumulative_multiplier import HRSCumulativeMultiplier
+from .rg_qft_multiplier import RGQFTMultiplier
+from .multiplier import MultiplierGate

qiskit/circuit/library/arithmetic/multipliers/hrs_cumulative_multiplier.py

@@ -0,0 +1,145 @@
+# 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 product of two qubit registers using classical multiplication approach."""
+
+from typing import Optional
+from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit
+
+from .multiplier import Multiplier
+
+
+class HRSCumulativeMultiplier(Multiplier):
+    r"""A multiplication circuit to store product of two input registers out-of-place.
+
+    Circuit uses the approach from [1]. As an example, a multiplier circuit that
+    performs a non-modular multiplication on two 3-qubit sized registers with
+    the default adder is as follows (where ``Adder`` denotes the
+    ``CDKMRippleCarryAdder``):
+
+    .. code-block:: text
+
+          a_0: ────■─────────────────────────
+                   │
+          a_1: ────┼─────────■───────────────
+                   │         │
+          a_2: ────┼─────────┼─────────■─────
+               ┌───┴────┐┌───┴────┐┌───┴────┐
+          b_0: ┤0       ├┤0       ├┤0       ├
+               │        ││        ││        │
+          b_1: ┤1       ├┤1       ├┤1       ├
+               │        ││        ││        │
+          b_2: ┤2       ├┤2       ├┤2       ├
+               │        ││        ││        │
+        out_0: ┤3       ├┤        ├┤        ├
+               │        ││        ││        │
+        out_1: ┤4       ├┤3       ├┤        ├
+               │  Adder ││  Adder ││  Adder │
+        out_2: ┤5       ├┤4       ├┤3       ├
+               │        ││        ││        │
+        out_3: ┤6       ├┤5       ├┤4       ├
+               │        ││        ││        │
+        out_4: ┤        ├┤6       ├┤5       ├
+               │        ││        ││        │
+        out_5: ┤        ├┤        ├┤6       ├
+               │        ││        ││        │
+        aux_0: ┤7       ├┤7       ├┤7       ├
+               └────────┘└────────┘└────────┘
+
+    Multiplication in this circuit is implemented in a classical approach by performing
+    a series of shifted additions using one of the input registers while the qubits
+    from the other input register act as control qubits for the adders.
+
+    .. seealso::
+
+        The :class:`.MultiplierGate` objects represents a multiplication, like this circuit class,
+        but allows the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this circuit
+        can be chosen via ``Multiplier=["cumulative_h18"]``.
+
+    **References:**
+
+    [1] Häner et al., Optimizing Quantum Circuits for Arithmetic, 2018.
+    `arXiv:1805.12445 <https://arxiv.org/pdf/1805.12445.pdf>`_
+
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        num_result_qubits: Optional[int] = None,
+        adder: Optional[QuantumCircuit] = None,
+        name: str = "HRSCumulativeMultiplier",
+    ) -> 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.
+            num_result_qubits: The number of result qubits to limit the output to.
+                If number of result qubits is :math:`n`, multiplication modulo :math:`2^n` is performed
+                to limit the output to the specified number of qubits. Default
+                value is ``2 * num_state_qubits`` to represent any possible
+                result from the multiplication of the two inputs.
+            adder: Half adder circuit to be used for performing multiplication. The
+                CDKMRippleCarryAdder is used as default if no adder is provided.
+            name: The name of the circuit object.
+        Raises:
+            NotImplementedError: If ``num_result_qubits`` is not default and a custom adder is provided.
+        """
+        super().__init__(num_state_qubits, num_result_qubits, name=name)
+
+        if self.num_result_qubits != 2 * num_state_qubits and adder is not None:
+            raise NotImplementedError("Only default adder is supported for modular multiplication.")
+
+        # define the registers
+        qr_a = QuantumRegister(num_state_qubits, name="a")
+        qr_b = QuantumRegister(num_state_qubits, name="b")
+        qr_out = QuantumRegister(self.num_result_qubits, name="out")
+        self.add_register(qr_a, qr_b, qr_out)
+
+        # prepare adder as controlled gate
+        if adder is None:
+            from qiskit.circuit.library.arithmetic.adders import CDKMRippleCarryAdder
+
+            adder = CDKMRippleCarryAdder(num_state_qubits, kind="half")
+
+        # get the number of helper qubits needed
+        num_helper_qubits = adder.num_ancillas
+
+        # add helper qubits if required
+        if num_helper_qubits > 0:
+            qr_h = AncillaRegister(num_helper_qubits, name="helper")  # helper/ancilla qubits
+            self.add_register(qr_h)
+
+        # build multiplication circuit
+        circuit = QuantumCircuit(*self.qregs, name=name)
+
+        for i in range(num_state_qubits):
+            excess_qubits = max(0, num_state_qubits + i + 1 - self.num_result_qubits)
+            if excess_qubits == 0:
+                num_adder_qubits = num_state_qubits
+                adder_for_current_step = adder
+            else:
+                num_adder_qubits = num_state_qubits - excess_qubits + 1
+                adder_for_current_step = CDKMRippleCarryAdder(num_adder_qubits, kind="fixed")
+            controlled_adder = adder_for_current_step.to_gate().control(1)
+            qr_list = (
+                [qr_a[i]]
+                + qr_b[:num_adder_qubits]
+                + qr_out[i : num_state_qubits + i + 1 - excess_qubits]
+            )
+            if num_helper_qubits > 0:
+                qr_list.extend(qr_h[:])
+            circuit.append(controlled_adder, qr_list)
+
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/multipliers/multiplier.py

@@ -0,0 +1,192 @@
+# 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 product of two equally sized qubit registers."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumCircuit, Gate
+from qiskit.utils.deprecation import deprecate_func
+
+
+class Multiplier(QuantumCircuit):
+    r"""Compute the product of two equally sized qubit registers into a new register.
+
+    For two input registers :math:`|a\rangle_n`, :math:`|b\rangle_n` with :math:`n` qubits each
+    and an output register with :math:`2n` qubits, a multiplier performs the following operation
+
+    .. math::
+
+        |a\rangle_n |b\rangle_n |0\rangle_{t} \mapsto |a\rangle_n |b\rangle_n |a \cdot b\rangle_t
+
+    where :math:`t` is the number of bits used to represent the result. To completely store the result
+    of the multiplication without overflow we need :math:`t = 2n` bits.
+
+    The quantum register :math:`|a\rangle_n` (analogously :math:`|b\rangle_n` and
+    output register)
+
+    .. 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}.
+
+    """
+
+    @deprecate_func(
+        since="1.3",
+        additional_msg=(
+            "Use the MultiplierGate provided in qiskit.circuit.library.arithmetic instead. "
+            "For different multiplier implementations, see "
+            "https://docs.quantum.ibm.com/api/qiskit/synthesis.",
+        ),
+        pending=True,
+    )
+    def __init__(
+        self,
+        num_state_qubits: int,
+        num_result_qubits: int | None = None,
+        name: str = "Multiplier",
+    ) -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the input registers.
+            num_result_qubits: The number of result qubits to limit the output to.
+                Default value is ``2 * num_state_qubits`` to represent any possible
+                result from the multiplication of the two inputs.
+            name: The name of the circuit.
+        Raises:
+            ValueError: If ``num_state_qubits`` is smaller than 1.
+            ValueError: If ``num_result_qubits`` is smaller than ``num_state_qubits``.
+            ValueError: If ``num_result_qubits`` is larger than ``2 * num_state_qubits``.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("The number of qubits must be at least 1.")
+
+        if num_result_qubits is None:
+            num_result_qubits = 2 * num_state_qubits
+
+        if num_result_qubits < num_state_qubits:
+            raise ValueError(
+                "Number of result qubits is smaller than number of input state qubits."
+            )
+        if num_result_qubits > 2 * num_state_qubits:
+            raise ValueError(
+                "Number of result qubits is larger than twice the number of input state qubits."
+            )
+
+        super().__init__(name=name)
+        self._num_state_qubits = num_state_qubits
+        self._num_result_qubits = num_result_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
+
+    @property
+    def num_result_qubits(self) -> int:
+        """The number of result qubits to limit the output to.
+
+        Returns:
+            The number of result qubits.
+        """
+        return self._num_result_qubits
+
+
+class MultiplierGate(Gate):
+    r"""Compute the product of two equally sized qubit registers into a new register.
+
+    For two input registers :math:`|a\rangle_n`, :math:`|b\rangle_n` with :math:`n` qubits each
+    and an output register with :math:`2n` qubits, a multiplier performs the following operation
+
+    .. math::
+
+        |a\rangle_n |b\rangle_n |0\rangle_{t} \mapsto |a\rangle_n |b\rangle_n |a \cdot b\rangle_t
+
+    where :math:`t` is the number of bits used to represent the result. To completely store the result
+    of the multiplication without overflow we need :math:`t = 2n` bits.
+
+    The quantum register :math:`|a\rangle_n` (analogously :math:`|b\rangle_n` and
+    output register)
+
+    .. 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,
+        num_result_qubits: int | None = None,
+        label: str | None = None,
+    ) -> None:
+        """
+        Args:
+            num_state_qubits: The number of qubits in each of the input registers.
+            num_result_qubits: The number of result qubits to limit the output to.
+                Default value is ``2 * num_state_qubits`` to represent any possible
+                result from the multiplication of the two inputs.
+            name: The name of the circuit.
+        Raises:
+            ValueError: If ``num_state_qubits`` is smaller than 1.
+            ValueError: If ``num_result_qubits`` is smaller than ``num_state_qubits``.
+            ValueError: If ``num_result_qubits`` is larger than ``2 * num_state_qubits``.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("The number of state qubits must be at least 1.")
+
+        if num_result_qubits is None:
+            num_result_qubits = 2 * num_state_qubits
+        elif num_result_qubits < num_state_qubits or num_result_qubits > 2 * num_state_qubits:
+            raise ValueError(
+                f"num_result_qubits ({num_result_qubits}) must be in between num_state_qubits "
+                f"({num_state_qubits}) and 2 * num_state_qubits ({2 * num_state_qubits})"
+            )
+
+        super().__init__("Multiplier", 2 * num_state_qubits + num_result_qubits, [], label=label)
+
+        self._num_state_qubits = num_state_qubits
+        self._num_result_qubits = num_result_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
+
+    @property
+    def num_result_qubits(self) -> int:
+        """The number of result qubits to limit the output to.
+
+        Returns:
+            The number of result qubits.
+        """
+        return self._num_result_qubits

qiskit/circuit/library/arithmetic/multipliers/rg_qft_multiplier.py

@@ -0,0 +1,108 @@
+# 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 product of two qubit registers using QFT."""
+
+from typing import Optional
+import numpy as np
+
+from qiskit.circuit import QuantumRegister, QuantumCircuit
+from qiskit.circuit.library.standard_gates import PhaseGate
+from qiskit.circuit.library.basis_change import QFT
+
+from .multiplier import Multiplier
+
+
+class RGQFTMultiplier(Multiplier):
+    r"""A QFT multiplication circuit to store product of two input registers out-of-place.
+
+    Multiplication in this circuit is implemented using the procedure of Fig. 3 in [1], where
+    weighted sum rotations are implemented as given in Fig. 5 in [1]. QFT is used on the output
+    register and is followed by rotations controlled by input registers. The rotations
+    transform the state into the product of two input registers in QFT base, which is
+    reverted from QFT base using inverse QFT.
+    As an example, a circuit that performs a modular QFT multiplication on two 2-qubit
+    sized input registers with an output register of 2 qubits, is as follows:
+
+    .. code-block:: text
+
+          a_0: ────────────────────────────────────────■───────■──────■──────■────────────────
+                                                       │       │      │      │
+          a_1: ─────────■───────■───────■───────■──────┼───────┼──────┼──────┼────────────────
+                        │       │       │       │      │       │      │      │
+          b_0: ─────────┼───────┼───────■───────■──────┼───────┼──────■──────■────────────────
+                        │       │       │       │      │       │      │      │
+          b_1: ─────────■───────■───────┼───────┼──────■───────■──────┼──────┼────────────────
+               ┌──────┐ │P(4π)  │       │P(2π)  │      │P(2π)  │      │P(π)  │       ┌───────┐
+        out_0: ┤0     ├─■───────┼───────■───────┼──────■───────┼──────■──────┼───────┤0      ├
+               │  qft │         │P(2π)          │P(π)          │P(π)         │P(π/2) │  iqft │
+        out_1: ┤1     ├─────────■───────────────■──────────────■─────────────■───────┤1      ├
+               └──────┘                                                              └───────┘
+
+    .. seealso::
+
+        The :class:`.MultiplierGate` objects represents a multiplication, like this circuit class,
+        but allows the compiler to select the optimal decomposition based on the context.
+        Specific implementations can be set via the :class:`.HLSConfig`, e.g. this circuit
+        can be chosen via ``Multiplier=["qft_r17"]``.
+
+    **References:**
+
+    [1] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
+    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
+
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        num_result_qubits: Optional[int] = None,
+        name: str = "RGQFTMultiplier",
+    ) -> 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.
+            num_result_qubits: The number of result qubits to limit the output to.
+                If number of result qubits is :math:`n`, multiplication modulo :math:`2^n` is performed
+                to limit the output to the specified number of qubits. Default
+                value is ``2 * num_state_qubits`` to represent any possible
+                result from the multiplication of the two inputs.
+            name: The name of the circuit object.
+
+        """
+        super().__init__(num_state_qubits, num_result_qubits, name=name)
+
+        # define the registers
+        qr_a = QuantumRegister(num_state_qubits, name="a")
+        qr_b = QuantumRegister(num_state_qubits, name="b")
+        qr_out = QuantumRegister(self.num_result_qubits, name="out")
+        self.add_register(qr_a, qr_b, qr_out)
+
+        # build multiplication circuit
+        circuit = QuantumCircuit(*self.qregs, name=name)
+
+        circuit.append(QFT(self.num_result_qubits, do_swaps=False).to_gate(), qr_out[:])
+
+        for j in range(1, num_state_qubits + 1):
+            for i in range(1, num_state_qubits + 1):
+                for k in range(1, self.num_result_qubits + 1):
+                    lam = (2 * np.pi) / (2 ** (i + j + k - 2 * num_state_qubits))
+                    circuit.append(
+                        PhaseGate(lam).control(2),
+                        [qr_a[num_state_qubits - j], qr_b[num_state_qubits - i], qr_out[k - 1]],
+                    )
+
+        circuit.append(QFT(self.num_result_qubits, do_swaps=False).inverse().to_gate(), qr_out[:])
+
+        self.append(circuit.to_gate(), self.qubits)