qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__cp39-abi3-win32.whl

{qiskit-1.3.0.dist-info → qiskit-1.3.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: bdist_wheel (0.44.0)
 Root-Is-Purelib: false
 Tag: cp39-abi3-win32
 

{qiskit-1.3.0.dist-info → qiskit-1.3.0b1.dist-info}/entry_points.txt

@@ -1,20 +1,4 @@
 [qiskit.synthesis]
-FullAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisC04
-FullAdder.ripple_c04 = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisC04
-FullAdder.ripple_v95 = qiskit.transpiler.passes.synthesis.hls_plugins:FullAdderSynthesisV95
-HalfAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisDefault
-HalfAdder.qft_d00 = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisD00
-HalfAdder.ripple_c04 = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisC04
-HalfAdder.ripple_v95 = qiskit.transpiler.passes.synthesis.hls_plugins:HalfAdderSynthesisV95
-ModularAdder.default = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisDefault
-ModularAdder.qft_d00 = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisD00
-ModularAdder.ripple_c04 = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisC04
-ModularAdder.ripple_v95 = qiskit.transpiler.passes.synthesis.hls_plugins:ModularAdderSynthesisV95
-Multiplier.cumulative_h18 = qiskit.transpiler.passes.synthesis.hls_plugins:MultiplierSynthesisH18
-Multiplier.default = qiskit.transpiler.passes.synthesis.hls_plugins:MultiplierSynthesisR17
-Multiplier.qft_r17 = qiskit.transpiler.passes.synthesis.hls_plugins:MultiplierSynthesisR17
-PauliEvolution.default = qiskit.transpiler.passes.synthesis.hls_plugins:PauliEvolutionSynthesisDefault
-PauliEvolution.rustiq = qiskit.transpiler.passes.synthesis.hls_plugins:PauliEvolutionSynthesisRustiq
 clifford.ag = qiskit.transpiler.passes.synthesis.hls_plugins:AGSynthesisClifford
 clifford.bm = qiskit.transpiler.passes.synthesis.hls_plugins:BMSynthesisClifford
 clifford.default = qiskit.transpiler.passes.synthesis.hls_plugins:DefaultSynthesisClifford
@@ -24,9 +8,6 @@ clifford.lnn = qiskit.transpiler.passes.synthesis.hls_plugins:LayerLnnSynthesisC
 linear_function.default = qiskit.transpiler.passes.synthesis.hls_plugins:DefaultSynthesisLinearFunction
 linear_function.kms = qiskit.transpiler.passes.synthesis.hls_plugins:KMSSynthesisLinearFunction
 linear_function.pmh = qiskit.transpiler.passes.synthesis.hls_plugins:PMHSynthesisLinearFunction
-mcmt.default = qiskit.transpiler.passes.synthesis.hls_plugins:MCMTSynthesisDefault
-mcmt.noaux = qiskit.transpiler.passes.synthesis.hls_plugins:MCMTSynthesisNoAux
-mcmt.vchain = qiskit.transpiler.passes.synthesis.hls_plugins:MCMTSynthesisVChain
 mcx.1_clean_b95 = qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesis1CleanB95
 mcx.default = qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisDefault
 mcx.gray_code = qiskit.transpiler.passes.synthesis.hls_plugins:MCXSynthesisGrayCode

qiskit/circuit/library/data_preparation/_zz_feature_map.py

@@ -1,150 +0,0 @@
-# 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.
-
-"""Second-order Pauli-Z expansion circuit."""
-
-from typing import Callable, List, Union, Optional, Dict, Tuple
-import numpy as np
-from qiskit.utils.deprecation import deprecate_func
-from .pauli_feature_map import PauliFeatureMap
-
-
-class ZZFeatureMap(PauliFeatureMap):
-    r"""Second-order Pauli-Z evolution circuit.
-
-    For 3 qubits and 1 repetition and linear entanglement the circuit is represented by:
-
-    .. code-block:: text
-
-        ┌───┐┌────────────────┐
-        ┤ H ├┤ P(2.0*φ(x[0])) ├──■───────────────────────────■───────────────────────────────────
-        ├───┤├────────────────┤┌─┴─┐┌─────────────────────┐┌─┴─┐
-        ┤ H ├┤ P(2.0*φ(x[1])) ├┤ X ├┤ P(2.0*φ(x[0],x[1])) ├┤ X ├──■───────────────────────────■──
-        ├───┤├────────────────┤└───┘└─────────────────────┘└───┘┌─┴─┐┌─────────────────────┐┌─┴─┐
-        ┤ H ├┤ P(2.0*φ(x[2])) ├─────────────────────────────────┤ X ├┤ P(2.0*φ(x[1],x[2])) ├┤ X ├
-        └───┘└────────────────┘                                 └───┘└─────────────────────┘└───┘
-
-    where :math:`\varphi` is a classical non-linear function, which defaults to :math:`\varphi(x) = x`
-    if and :math:`\varphi(x,y) = (\pi - x)(\pi - y)`.
-
-    Examples:
-
-    .. code-block::
-
-         from qiskit.circuit.library import ZZFeatureMap
-         prep = ZZFeatureMap(2, reps=1)
-         print(prep.decompose())
-
-    .. code-block:: text
-
-              ┌───┐┌─────────────┐
-         q_0: ┤ H ├┤ P(2.0*x[0]) ├──■──────────────────────────────────────■──
-              ├───┤├─────────────┤┌─┴─┐┌────────────────────────────────┐┌─┴─┐
-         q_1: ┤ H ├┤ P(2.0*x[1]) ├┤ X ├┤ P(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
-              └───┘└─────────────┘└───┘└────────────────────────────────┘└───┘
-
-    .. code-block::
-
-         from qiskit.circuit.library import EfficientSU2
-         classifier = ZZFeatureMap(3).compose(EfficientSU2(3))
-         classifier.num_parameters
-
-    .. code-block:: text
-
-         27
-
-    .. code-block::
-
-         classifier.parameters  # 'x' for the data preparation, 'θ' for the SU2 parameters
-
-    .. code-block:: text
-
-         ParameterView([
-             ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
-             ParameterVectorElement(x[2]), ParameterVectorElement(θ[0]),
-             ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]),
-             ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]),
-             ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]),
-             ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]),
-             ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]),
-             ParameterVectorElement(θ[11]), ParameterVectorElement(θ[12]),
-             ParameterVectorElement(θ[13]), ParameterVectorElement(θ[14]),
-             ParameterVectorElement(θ[15]), ParameterVectorElement(θ[16]),
-             ParameterVectorElement(θ[17]), ParameterVectorElement(θ[18]),
-             ParameterVectorElement(θ[19]), ParameterVectorElement(θ[20]),
-             ParameterVectorElement(θ[21]), ParameterVectorElement(θ[22]),
-             ParameterVectorElement(θ[23])
-         ])
-
-    .. code-block::
-
-         classifier.count_ops()
-
-    .. code-block:: text
-
-        OrderedDict([('ZZFeatureMap', 1), ('EfficientSU2', 1)])
-
-    """
-
-    @deprecate_func(
-        since="1.3",
-        additional_msg=(
-            "Use the z_feature_map function as a replacement. Note that this will no longer "
-            "return a BlueprintCircuit, but just a plain QuantumCircuit."
-        ),
-        pending=True,
-    )
-    def __init__(
-        self,
-        feature_dimension: int,
-        reps: int = 2,
-        entanglement: Union[
-            str,
-            Dict[int, List[Tuple[int]]],
-            Callable[[int], Union[str, Dict[int, List[Tuple[int]]]]],
-        ] = "full",
-        data_map_func: Optional[Callable[[np.ndarray], float]] = None,
-        parameter_prefix: str = "x",
-        insert_barriers: bool = False,
-        name: str = "ZZFeatureMap",
-    ) -> None:
-        """Create a new second-order Pauli-Z expansion.
-
-        Args:
-            feature_dimension: Number of features.
-            reps: The number of repeated circuits, has a min. value of 1.
-            entanglement: Specifies the entanglement structure. Refer to
-                :class:`~qiskit.circuit.library.PauliFeatureMap` for detail.
-            data_map_func: A mapping function for data x.
-            parameter_prefix: The prefix used if default parameters are generated.
-            insert_barriers: If True, barriers are inserted in between the evolution instructions
-                and hadamard layers.
-
-        Raises:
-            ValueError: If the feature dimension is smaller than 2.
-        """
-        if feature_dimension < 2:
-            raise ValueError(
-                "The ZZFeatureMap contains 2-local interactions and cannot be "
-                f"defined for less than 2 qubits. You provided {feature_dimension}."
-            )
-
-        super().__init__(
-            feature_dimension=feature_dimension,
-            reps=reps,
-            entanglement=entanglement,
-            paulis=["Z", "ZZ"],
-            data_map_func=data_map_func,
-            parameter_prefix=parameter_prefix,
-            insert_barriers=insert_barriers,
-            name=name,
-        )

qiskit/circuit/twirling.py

@@ -1,145 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2024
-#
-# 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 twirling module."""
-
-from __future__ import annotations
-import typing
-
-from qiskit._accelerate.twirling import twirl_circuit as twirl_rs
-from qiskit.circuit.quantumcircuit import QuantumCircuit, _copy_metadata
-from qiskit.circuit.gate import Gate
-from qiskit.circuit.library.standard_gates import CXGate, ECRGate, CZGate, iSwapGate
-from qiskit.exceptions import QiskitError
-
-if typing.TYPE_CHECKING:
-    from qiskit.transpiler.target import Target
-
-
-NAME_TO_CLASS = {
-    "cx": CXGate._standard_gate,
-    "ecr": ECRGate._standard_gate,
-    "cz": CZGate._standard_gate,
-    "iswap": iSwapGate._standard_gate,
-}
-
-
-def pauli_twirl_2q_gates(
-    circuit: QuantumCircuit,
-    twirling_gate: None | str | Gate | list[str] | list[Gate] = None,
-    seed: int | None = None,
-    num_twirls: int | None = None,
-    target: Target | None = None,
-) -> QuantumCircuit | list[QuantumCircuit]:
-    """Create copies of a given circuit with Pauli twirling applied around specified two qubit
-    gates.
-
-    If you're running this function with the intent to twirl a circuit to run on hardware this
-    may not be the most efficient way to perform twirling. Especially if the hardware vendor
-    has implemented the :mod:`.primitives` execution interface with :class:`.SamplerV2` and
-    :class:`.EstimatorV2` this most likely is not the best way to apply twirling to your
-    circuit and you'll want to refer to the implementation of :class:`.SamplerV2` and/or
-    :class:`.EstimatorV2` for the specified hardware vendor.
-
-    If the intent of this function is to be run after :func:`.transpile` or
-    :meth:`.PassManager.run` the optional ``target`` argument can be used
-    so that the inserted 1 qubit Pauli gates are synthesized to be
-    compatible with the given :class:`.Target` so the output circuit(s) are
-    still compatible.
-
-    Args:
-        circuit: The circuit to twirl
-        twirling_gate: The gate to twirl, defaults to `None` which means twirl all default gates:
-            :class:`.CXGate`, :class:`.CZGate`, :class:`.ECRGate`, and :class:`.iSwapGate`.
-            If supplied it can either be a single gate or a list of gates either as either a gate
-            object or its string name. Currently only the names `"cx"`, `"cz"`, `"ecr"`,  and
-            `"iswap"` are supported. If a gate object is provided outside the default gates it must
-            have a matrix defined from its :class:`~.Gate.to_matrix` method for the gate to potentially
-            be twirled. If a valid twirling configuration can't be computed that particular gate will
-            be silently ignored and not twirled.
-        seed: An integer seed for the random number generator used internally by this function.
-            If specified this must be between 0 and 18,446,744,073,709,551,615.
-        num_twirls: The number of twirling circuits to build. This defaults to ``None`` and will return
-            a single circuit. If it is an integer a list of circuits with `num_twirls` circuits
-            will be returned.
-        target: If specified an :class:`.Target` instance to use for running single qubit decomposition
-            as part of the Pauli twirling to optimize and map the pauli gates added to the circuit
-            to the specified target.
-
-    Returns:
-        A copy of the given circuit with Pauli twirling applied to each
-        instance of the specified twirling gate.
-    """
-    custom_gates = None
-    if isinstance(twirling_gate, str):
-        gate = NAME_TO_CLASS.get(twirling_gate, None)
-        if gate is None:
-            raise QiskitError(f"The specified gate name {twirling_gate} is not supported")
-        twirling_std_gate = [gate]
-    elif isinstance(twirling_gate, list):
-        custom_gates = []
-        twirling_std_gate = []
-        for gate in twirling_gate:
-            if isinstance(gate, str):
-                gate = NAME_TO_CLASS.get(gate, None)
-                if gate is None:
-                    raise QiskitError(f"The specified gate name {twirling_gate} is not supported")
-                twirling_std_gate.append(gate)
-            else:
-                twirling_gate = getattr(gate, "_standard_gate", None)
-
-                if twirling_gate is None:
-                    custom_gates.append(gate)
-                else:
-                    if twirling_gate in NAME_TO_CLASS.values():
-                        twirling_std_gate.append(twirling_gate)
-                    else:
-                        custom_gates.append(gate)
-        if not custom_gates:
-            custom_gates = None
-        if not twirling_std_gate:
-            twirling_std_gate = None
-    elif twirling_gate is not None:
-        std_gate = getattr(twirling_gate, "_standard_gate", None)
-        if std_gate is None:
-            twirling_std_gate = None
-            custom_gates = [twirling_gate]
-        else:
-            if std_gate in NAME_TO_CLASS.values():
-                twirling_std_gate = [std_gate]
-            else:
-                twirling_std_gate = None
-                custom_gates = [twirling_gate]
-    else:
-        twirling_std_gate = twirling_gate
-    out_twirls = num_twirls
-    if out_twirls is None:
-        out_twirls = 1
-    new_data = twirl_rs(
-        circuit._data,
-        twirling_std_gate,
-        custom_gates,
-        seed,
-        out_twirls,
-        target,
-    )
-    if num_twirls is not None:
-        out_list = []
-        for circ in new_data:
-            new_circ = QuantumCircuit._from_circuit_data(circ)
-            _copy_metadata(circuit, new_circ, "alike")
-            out_list.append(new_circ)
-        return out_list
-    else:
-        out_circ = QuantumCircuit._from_circuit_data(new_data[0])
-        _copy_metadata(circuit, out_circ, "alike")
-        return out_circ

qiskit/synthesis/arithmetic/__init__.py

@@ -1,16 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2024.
-#
-# 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 multi-controlled circuits synthesis"""
-
-from .adders import adder_qft_d00, adder_ripple_c04, adder_ripple_v95
-from .multipliers import multiplier_cumulative_h18, multiplier_qft_r17

qiskit/synthesis/arithmetic/adders/__init__.py

@@ -1,17 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2024.
-#
-# 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 multi-controlled circuits synthesis"""
-
-from .cdkm_ripple_carry_adder import adder_ripple_c04
-from .vbe_ripple_carry_adder import adder_ripple_v95
-from .draper_qft_adder import adder_qft_d00

qiskit/synthesis/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -1,154 +0,0 @@
-# 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

@@ -1,103 +0,0 @@
-# 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