qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/synthesis/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -0,0 +1,154 @@
+# 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 ripple-carry approach."""
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister, AncillaRegister
+
+
+def adder_ripple_c04(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
+    r"""A ripple-carry circuit to perform in-place addition on two qubit registers.
+
+    This circuit uses :math:`2n + O(1)` CCX gates and :math:`5n + O(1)` CX gates,
+    at a depth of :math:`2n + O(1)` [1]. The constant depends on the kind
+    of adder implemented.
+
+    As an example, a ripple-carry adder circuit that performs addition on two 3-qubit sized
+    registers with a carry-in bit (``kind="full"``) is as follows:
+
+    .. parsed-literal::
+
+                ┌──────┐                                     ┌──────┐
+         cin_0: ┤2     ├─────────────────────────────────────┤2     ├
+                │      │┌──────┐                     ┌──────┐│      │
+           a_0: ┤0     ├┤2     ├─────────────────────┤2     ├┤0     ├
+                │      ││      │┌──────┐     ┌──────┐│      ││      │
+           a_1: ┤  MAJ ├┤0     ├┤2     ├─────┤2     ├┤0     ├┤  UMA ├
+                │      ││      ││      │     │      ││      ││      │
+           a_2: ┤      ├┤  MAJ ├┤0     ├──■──┤0     ├┤  UMA ├┤      ├
+                │      ││      ││      │  │  │      ││      ││      │
+           b_0: ┤1     ├┤      ├┤  MAJ ├──┼──┤  UMA ├┤      ├┤1     ├
+                └──────┘│      ││      │  │  │      ││      │└──────┘
+           b_1: ────────┤1     ├┤      ├──┼──┤      ├┤1     ├────────
+                        └──────┘│      │  │  │      │└──────┘
+           b_2: ────────────────┤1     ├──┼──┤1     ├────────────────
+                                └──────┘┌─┴─┐└──────┘
+        cout_0: ────────────────────────┤ X ├────────────────────────
+                                        └───┘
+
+    Here *MAJ* and *UMA* 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.
+
+    Two different kinds of adders are supported. By setting the ``kind`` argument, you can also
+    choose a half-adder, which doesn't have a carry-in, and a fixed-sized-adder, which has neither
+    carry-in nor carry-out, and thus acts on fixed register sizes. Unlike the full-adder,
+    these circuits need one additional helper qubit.
+
+    The circuit diagram for the fixed-point adder (``kind="fixed"``) on 3-qubit sized inputs is
+
+    .. parsed-literal::
+
+                ┌──────┐┌──────┐                ┌──────┐┌──────┐
+           a_0: ┤0     ├┤2     ├────────────────┤2     ├┤0     ├
+                │      ││      │┌──────┐┌──────┐│      ││      │
+           a_1: ┤      ├┤0     ├┤2     ├┤2     ├┤0     ├┤      ├
+                │      ││      ││      ││      ││      ││      │
+           a_2: ┤      ├┤  MAJ ├┤0     ├┤0     ├┤  UMA ├┤      ├
+                │      ││      ││      ││      ││      ││      │
+           b_0: ┤1 MAJ ├┤      ├┤  MAJ ├┤  UMA ├┤      ├┤1 UMA ├
+                │      ││      ││      ││      ││      ││      │
+           b_1: ┤      ├┤1     ├┤      ├┤      ├┤1     ├┤      ├
+                │      │└──────┘│      ││      │└──────┘│      │
+           b_2: ┤      ├────────┤1     ├┤1     ├────────┤      ├
+                │      │        └──────┘└──────┘        │      │
+        help_0: ┤2     ├────────────────────────────────┤2     ├
+                └──────┘                                └──────┘
+
+    It has one less qubit than the full-adder since it doesn't have the carry-out, but uses
+    a helper qubit instead of the carry-in, so it only has one less qubit, not two.
+
+    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.
+        kind: The kind of adder, can be ``"full"`` for a full adder, ``"half"`` for a half
+            adder, or ``"fixed"`` for a fixed-sized adder. A full adder includes both carry-in
+            and carry-out, a half only carry-out, and a fixed-sized adder neither carry-in
+            nor carry-out.
+
+    Raises:
+        ValueError: If ``num_state_qubits`` is lower than 1.
+
+    **References:**
+
+    [1] Cuccaro et al., A new quantum ripple-carry addition circuit, 2004.
+    `arXiv:quant-ph/0410184 <https://arxiv.org/pdf/quant-ph/0410184.pdf>`_
+
+    [2] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+    if num_state_qubits < 1:
+        raise ValueError("The number of qubits must be at least 1.")
+
+    circuit = QuantumCircuit()
+
+    if kind == "full":
+        qr_c = QuantumRegister(1, name="cin")
+        circuit.add_register(qr_c)
+    else:
+        qr_c = AncillaRegister(1, name="help")
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    circuit.add_register(qr_a, qr_b)
+
+    if kind in ["full", "half"]:
+        qr_z = QuantumRegister(1, name="cout")
+        circuit.add_register(qr_z)
+
+    if kind != "full":
+        circuit.add_register(qr_c)
+
+    # build carry circuit for majority of 3 bits in-place
+    # corresponds to MAJ gate in [1]
+    qc_maj = QuantumCircuit(3, name="MAJ")
+    qc_maj.cx(0, 1)
+    qc_maj.cx(0, 2)
+    qc_maj.ccx(2, 1, 0)
+    maj_gate = qc_maj.to_gate()
+
+    # build circuit for reversing carry operation
+    # corresponds to UMA gate in [1]
+    qc_uma = QuantumCircuit(3, name="UMA")
+    qc_uma.ccx(2, 1, 0)
+    qc_uma.cx(0, 2)
+    qc_uma.cx(2, 1)
+    uma_gate = qc_uma.to_gate()
+
+    # build ripple-carry adder circuit
+    circuit.append(maj_gate, [qr_a[0], qr_b[0], qr_c[0]])
+
+    for i in range(num_state_qubits - 1):
+        circuit.append(maj_gate, [qr_a[i + 1], qr_b[i + 1], qr_a[i]])
+
+    if kind in ["full", "half"]:
+        circuit.cx(qr_a[-1], qr_z[0])
+
+    for i in reversed(range(num_state_qubits - 1)):
+        circuit.append(uma_gate, [qr_a[i + 1], qr_b[i + 1], qr_a[i]])
+
+    circuit.append(uma_gate, [qr_a[0], qr_b[0], qr_c[0]])
+
+    return circuit

qiskit/synthesis/arithmetic/adders/draper_qft_adder.py

@@ -0,0 +1,103 @@
+# 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.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.library.basis_change import QFTGate
+
+
+def adder_qft_d00(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
+    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 ``kind="fixed"``) or ordinary addition by adding a carry qubits (with
+    ``kind="half"``). The fixed adder uses :math:`(3n^2 - n)/2` :class:`.CPhaseGate` operators,
+    with an additional :math:`n` for the half adder.
+
+    As an example, a non-fixed_point QFT adder circuit that performs addition on two 2-qubit sized
+    registers is as follows:
+
+    .. parsed-literal::
+
+        a_0: ─────────■──────■────────■──────────────────────────────────
+                      │      │        │
+        a_1: ─────────┼──────┼────────┼────────■──────■──────────────────
+             ┌──────┐ │      │        │P(π/4)  │      │P(π/2) ┌─────────┐
+        b_0: ┤0     ├─┼──────┼────────■────────┼──────■───────┤0        ├
+             │      │ │      │P(π/2)           │P(π)          │         │
+        b_1: ┤1 Qft ├─┼──────■─────────────────■──────────────┤1 qft_dg ├
+             │      │ │P(π)                                   │         │
+       cout: ┤2     ├─■───────────────────────────────────────┤2        ├
+             └──────┘                                         └─────────┘
+
+    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.
+        kind: The kind of adder, can be ``"half"`` for a half adder or
+            ``"fixed"`` for a fixed-sized adder. A half adder contains a carry-out to represent
+            the most-significant bit, but the fixed-sized adder doesn't and hence performs
+            addition modulo ``2 ** num_state_qubits``.
+
+    **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>`_
+
+    """
+
+    if kind == "full":
+        raise ValueError("The DraperQFTAdder only supports 'half' and 'fixed' as ``kind``.")
+
+    if num_state_qubits < 1:
+        raise ValueError("The number of qubits must be at least 1.")
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    qr_list = [qr_a, qr_b]
+
+    if kind == "half":
+        qr_z = QuantumRegister(1, name="cout")
+        qr_list.append(qr_z)
+
+    # add registers
+    circuit = QuantumCircuit(*qr_list)
+
+    # define register containing the sum and number of qubits for QFT circuit
+    qr_sum = qr_b[:] if kind == "fixed" else qr_b[:] + qr_z[:]
+    num_sum = num_state_qubits if kind == "fixed" else num_state_qubits + 1
+
+    # build QFT adder circuit
+    qft = QFTGate(num_sum)
+    circuit.append(qft, qr_sum[:])
+
+    for j in range(num_state_qubits):
+        for k in range(num_sum - j):
+            lam = np.pi / (2**k)
+            # note: if we were able to remove the final swaps from the QFTGate, we could
+            # simply use qr_sum[(j + k)] here and avoid synthesizing two swap networks, which
+            # can be elided and cancelled by the compiler
+            circuit.cp(lam, qr_a[j], qr_sum[~(j + k)])
+
+    circuit.append(qft.inverse(), qr_sum[:])
+
+    return circuit

qiskit/synthesis/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -0,0 +1,161 @@
+# 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 __future__ import annotations
+from qiskit.circuit.bit import Bit
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister, AncillaRegister
+
+
+def adder_ripple_v95(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:
+    r"""The VBE ripple carry adder [1].
+
+    This method uses :math:`4n + O(1)` CCX gates and :math:`4n + 1` CX gates at a depth
+    of :math:`6n - 2` [2].
+
+    This circuit performs inplace addition of two equally-sized quantum registers.
+    As an example, a classical adder circuit that performs full addition (i.e. including
+    a carry-in bit) on two 2-qubit sized registers is as follows:
+
+    .. parsed-literal::
+
+                  ┌────────┐                       ┌───────────┐┌──────┐
+           cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
+                  │        │                       │           ││      │
+             a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
+                  │        │┌────────┐     ┌──────┐│           ││  Sum │
+             a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
+                  │        ││        │  │  │      ││           ││      │
+             b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
+                  │        ││        │┌─┴─┐│      ││           │└──────┘
+             b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
+                  │        ││        │└───┘│      ││           │
+          cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
+                  │        ││        │     │      ││           │
+        helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
+                  └────────┘└────────┘     └──────┘└───────────┘
+
+
+    Here *Carry* and *Sum* gates correspond to the gates introduced in [1].
+    *Carry_dg* correspond to the inverse of the *Carry* gate. 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.
+
+    Args:
+        num_state_qubits: The size of the register.
+        kind: The kind of adder, can be ``"full"`` for a full adder, ``"half"`` for a half
+            adder, or ``"fixed"`` for a fixed-sized adder. A full adder includes both carry-in
+            and carry-out, a half only carry-out, and a fixed-sized adder neither carry-in
+            nor carry-out.
+
+    Raises:
+        ValueError: If ``num_state_qubits`` is lower than 1.
+
+    **References:**
+
+    [1] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    [2] Cuccaro et al., A new quantum ripple-carry addition circuit, 2004.
+    `arXiv:quant-ph/0410184 <https://arxiv.org/pdf/quant-ph/0410184.pdf>`_
+
+    """
+    if num_state_qubits < 1:
+        raise ValueError("The number of qubits must be at least 1.")
+
+    # define the input registers
+    registers: list[QuantumRegister | list[Bit]] = []
+    if kind == "full":
+        qr_cin = QuantumRegister(1, name="cin")
+        registers.append(qr_cin)
+    else:
+        qr_cin = QuantumRegister(0)
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+
+    registers += [qr_a, qr_b]
+
+    if kind in ["half", "full"]:
+        qr_cout = QuantumRegister(1, name="cout")
+        registers.append(qr_cout)
+    else:
+        qr_cout = QuantumRegister(0)
+
+    if num_state_qubits > 1:
+        qr_help = AncillaRegister(num_state_qubits - 1, name="helper")
+        registers.append(qr_help)
+    else:
+        qr_help = AncillaRegister(0)
+
+    circuit = QuantumCircuit(*registers)
+
+    # the code is simplified a lot if we create a list of all carries and helpers
+    carries = qr_cin[:] + qr_help[:] + qr_cout[:]
+
+    # 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)
+    carry_gate = qc_carry.to_gate()
+    carry_gate_dg = carry_gate.inverse()
+
+    # corresponds to Sum gate in [1]
+    qc_sum = QuantumCircuit(3, name="Sum")
+    qc_sum.cx(1, 2)
+    qc_sum.cx(0, 2)
+    sum_gate = qc_sum.to_gate()
+
+    # handle all cases for the first qubits, depending on whether cin is available
+    i = 0
+    if kind == "half":
+        i += 1
+        circuit.ccx(qr_a[0], qr_b[0], carries[0])
+    elif kind == "fixed":
+        i += 1
+        if num_state_qubits == 1:
+            circuit.cx(qr_a[0], qr_b[0])
+        else:
+            circuit.ccx(qr_a[0], qr_b[0], carries[0])
+
+    for inp, out in zip(carries[:-1], carries[1:]):
+        circuit.append(carry_gate, [inp, qr_a[i], qr_b[i], out])
+        i += 1
+
+    if kind in ["full", "half"]:  # final CX (cancels for the 'fixed' case)
+        circuit.cx(qr_a[-1], qr_b[-1])
+
+    if len(carries) > 1:
+        circuit.append(sum_gate, [carries[-2], qr_a[-1], qr_b[-1]])
+
+    i -= 2
+    for j, (inp, out) in enumerate(zip(reversed(carries[:-1]), reversed(carries[1:]))):
+        if j == 0:
+            if kind == "fixed":
+                i += 1
+            else:
+                continue
+        circuit.append(carry_gate_dg, [inp, qr_a[i], qr_b[i], out])
+        circuit.append(sum_gate, [inp, qr_a[i], qr_b[i]])
+        i -= 1
+
+    if kind in ["half", "fixed"] and num_state_qubits > 1:
+        circuit.ccx(qr_a[0], qr_b[0], carries[0])
+        circuit.cx(qr_a[0], qr_b[0])
+
+    return circuit

qiskit/synthesis/arithmetic/multipliers/__init__.py

@@ -0,0 +1,16 @@
+# 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 multiplier_cumulative_h18
+from .rg_qft_multiplier import multiplier_qft_r17

qiskit/synthesis/arithmetic/multipliers/hrs_cumulative_multiplier.py

@@ -0,0 +1,102 @@
+# 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 __future__ import annotations
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+
+
+def multiplier_cumulative_h18(
+    num_state_qubits: int, num_result_qubits: int | None = None
+) -> QuantumCircuit:
+    r"""A multiplication circuit to store product of two input registers out-of-place.
+
+    The circuit uses the approach from Ref. [1]. As an example, a multiplier circuit that
+    performs a non-modular multiplication on two 3-qubit sized registers is:
+
+    .. plot::
+        :include-source:
+
+        from qiskit.synthesis.arithmetic import multiplier_cumulative_h18
+
+        num_state_qubits = 3
+        circuit = multiplier_cumulative_h18(num_state_qubits)
+        circuit.draw("mpl")
+
+    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.
+
+    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.
+
+    Raises:
+        ValueError: If ``num_result_qubits`` is given and not valid, meaning not
+            in ``[num_state_qubits, 2 * num_state_qubits]``.
+
+    **References:**
+
+    [1] Häner et al., Optimizing Quantum Circuits for Arithmetic, 2018.
+    `arXiv:1805.12445 <https://arxiv.org/pdf/1805.12445.pdf>`_
+
+    """
+    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})"
+        )
+
+    # define the registers
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    qr_out = QuantumRegister(num_result_qubits, name="out")
+
+    circuit = QuantumCircuit(qr_a, qr_b, qr_out)
+
+    # prepare adder as controlled gate
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.library.arithmetic import HalfAdderGate, ModularAdderGate
+
+    adder = HalfAdderGate(num_state_qubits)
+    controlled_adder = adder.control(annotated=True)
+
+    # build multiplication circuit
+    for i in range(num_state_qubits):
+        excess_qubits = max(0, num_state_qubits + i + 1 - num_result_qubits)
+        if excess_qubits == 0:
+            num_adder_qubits = num_state_qubits
+            this_controlled = controlled_adder
+        else:
+            num_adder_qubits = num_state_qubits - excess_qubits + 1
+            modular = ModularAdderGate(num_adder_qubits)
+            this_controlled = modular.control(annotated=True)
+
+        qr_list = (
+            [qr_a[i]]
+            + qr_b[:num_adder_qubits]
+            + qr_out[i : num_state_qubits + i + 1 - excess_qubits]
+        )
+        circuit.append(this_controlled, qr_list)
+
+    return circuit

qiskit/synthesis/arithmetic/multipliers/rg_qft_multiplier.py

@@ -0,0 +1,99 @@
+# 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 __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.library.standard_gates import PhaseGate
+from qiskit.circuit.library.basis_change import QFTGate
+
+
+def multiplier_qft_r17(
+    num_state_qubits: int, num_result_qubits: int | None = None
+) -> QuantumCircuit:
+    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.
+    For example, on 3 state qubits, a full multiplier is given by:
+
+    .. plot::
+        :include-source:
+
+        from qiskit.synthesis.arithmetic import multiplier_qft_r17
+
+        num_state_qubits = 3
+        circuit = multiplier_qft_r17(num_state_qubits)
+        circuit.draw("mpl")
+
+    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.
+
+    Raises:
+        ValueError: If ``num_result_qubits`` is given and not valid, meaning not
+            in ``[num_state_qubits, 2 * num_state_qubits]``.
+
+    **References:**
+
+    [1] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
+    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
+
+    """
+    # define the registers
+    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})"
+        )
+
+    qr_a = QuantumRegister(num_state_qubits, name="a")
+    qr_b = QuantumRegister(num_state_qubits, name="b")
+    qr_out = QuantumRegister(num_result_qubits, name="out")
+
+    # build multiplication circuit
+    circuit = QuantumCircuit(qr_a, qr_b, qr_out)
+    qft = QFTGate(num_result_qubits)
+
+    circuit.append(qft, 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, num_result_qubits + 1):
+                lam = (2 * np.pi) / (2 ** (i + j + k - 2 * num_state_qubits))
+
+                # note: if we can synthesize the QFT without swaps, we can implement this circuit
+                # more efficiently and just apply phase gate on qr_out[(k - 1)] instead
+                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.inverse(), qr_out[:])
+
+    return circuit

qiskit/synthesis/clifford/__init__.py

@@ -0,0 +1,19 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2023.
+#
+# 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.
+
+"""Module containing clifford circuit synthesis."""
+
+from .clifford_decompose_full import synth_clifford_full
+from .clifford_decompose_ag import synth_clifford_ag
+from .clifford_decompose_bm import synth_clifford_bm
+from .clifford_decompose_greedy import synth_clifford_greedy
+from .clifford_decompose_layers import synth_clifford_layers, synth_clifford_depth_lnn