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

qiskit/circuit/library/grover_operator.py

@@ -16,266 +16,10 @@ from __future__ import annotations
 from typing import List, Optional, Union
 import numpy
 
-from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister, AncillaQubit
+from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info import Statevector, Operator, DensityMatrix
-from qiskit.utils.deprecation import deprecate_func
 from .standard_gates import MCXGate
-from .generalized_gates import DiagonalGate
-
-
-def grover_operator(
-    oracle: QuantumCircuit | Statevector,
-    state_preparation: QuantumCircuit | None = None,
-    zero_reflection: QuantumCircuit | DensityMatrix | Operator | None = None,
-    reflection_qubits: list[int] | None = None,
-    insert_barriers: bool = False,
-    name: str = "Q",
-):
-    r"""Construct the Grover operator.
-
-    Grover's search algorithm [1, 2] consists of repeated applications of the so-called
-    Grover operator used to amplify the amplitudes of the desired output states.
-    This operator, :math:`\mathcal{Q}`, consists of the phase oracle, :math:`\mathcal{S}_f`,
-    zero phase-shift or zero reflection, :math:`\mathcal{S}_0`, and an
-    input state preparation :math:`\mathcal{A}`:
-
-    .. math::
-        \mathcal{Q} = \mathcal{A} \mathcal{S}_0 \mathcal{A}^\dagger \mathcal{S}_f
-
-    In the standard Grover search we have :math:`\mathcal{A} = H^{\otimes n}`:
-
-    .. math::
-        \mathcal{Q} = H^{\otimes n} \mathcal{S}_0 H^{\otimes n} \mathcal{S}_f
-                    = D \mathcal{S_f}
-
-    The operation :math:`D = H^{\otimes n} \mathcal{S}_0 H^{\otimes n}` is also referred to as
-    diffusion operator. In this formulation we can see that Grover's operator consists of two
-    steps: first, the phase oracle multiplies the good states by -1 (with :math:`\mathcal{S}_f`)
-    and then the whole state is reflected around the mean (with :math:`D`).
-
-    This class allows setting a different state preparation, as in quantum amplitude
-    amplification (a generalization of Grover's algorithm), :math:`\mathcal{A}` might not be
-    a layer of Hardamard gates [3].
-
-    The action of the phase oracle :math:`\mathcal{S}_f` is defined as
-
-    .. math::
-        \mathcal{S}_f: |x\rangle \mapsto (-1)^{f(x)}|x\rangle
-
-    where :math:`f(x) = 1` if :math:`x` is a good state and 0 otherwise. To highlight the fact
-    that this oracle flips the phase of the good states and does not flip the state of a result
-    qubit, we call :math:`\mathcal{S}_f` a phase oracle.
-
-    Note that you can easily construct a phase oracle from a bitflip oracle by sandwiching the
-    controlled X gate on the result qubit by a X and H gate. For instance
-
-    .. parsed-literal::
-
-        Bitflip oracle     Phaseflip oracle
-        q_0: ──■──         q_0: ────────────■────────────
-             ┌─┴─┐              ┌───┐┌───┐┌─┴─┐┌───┐┌───┐
-        out: ┤ X ├         out: ┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├
-             └───┘              └───┘└───┘└───┘└───┘└───┘
-
-    There is some flexibility in defining the oracle and :math:`\mathcal{A}` operator. Before the
-    Grover operator is applied in Grover's algorithm, the qubits are first prepared with one
-    application of the :math:`\mathcal{A}` operator (or Hadamard gates in the standard formulation).
-    Thus, we always have operation of the form
-    :math:`\mathcal{A} \mathcal{S}_f \mathcal{A}^\dagger`. Therefore it is possible to move
-    bitflip logic into :math:`\mathcal{A}` and leaving the oracle only to do phaseflips via Z gates
-    based on the bitflips. One possible use-case for this are oracles that do not uncompute the
-    state qubits.
-
-    The zero reflection :math:`\mathcal{S}_0` is usually defined as
-
-    .. math::
-        \mathcal{S}_0 = 2 |0\rangle^{\otimes n} \langle 0|^{\otimes n} - \mathbb{I}_n
-
-    where :math:`\mathbb{I}_n` is the identity on :math:`n` qubits.
-    By default, this class implements the negative version
-    :math:`2 |0\rangle^{\otimes n} \langle 0|^{\otimes n} - \mathbb{I}_n`, since this can simply
-    be implemented with a multi-controlled Z sandwiched by X gates on the target qubit and the
-    introduced global phase does not matter for Grover's algorithm.
-
-    Examples:
-
-        We can construct a Grover operator just from the phase oracle:
-
-        .. plot::
-            :include-source:
-            :context:
-
-            from qiskit.circuit import QuantumCircuit
-            from qiskit.circuit.library import grover_operator
-
-            oracle = QuantumCircuit(2)
-            oracle.z(0)  # good state = first qubit is |1>
-            grover_op = grover_operator(oracle, insert_barriers=True)
-            grover_op.draw("mpl")
-
-        We can also modify the state preparation:
-
-        .. plot::
-            :include-source:
-            :context:
-
-            oracle = QuantumCircuit(1)
-            oracle.z(0)  # the qubit state |1> is the good state
-            state_preparation = QuantumCircuit(1)
-            state_preparation.ry(0.2, 0)  # non-uniform state preparation
-            grover_op = grover_operator(oracle, state_preparation)
-            grover_op.draw("mpl")
-
-        In addition, we can also mark which qubits the zero reflection should act on. This
-        is useful in case that some qubits are just used as scratch space but should not affect
-        the oracle:
-
-        .. plot::
-            :include-source:
-            :context:
-
-            oracle = QuantumCircuit(4)
-            oracle.z(3)
-            reflection_qubits = [0, 3]
-            state_preparation = QuantumCircuit(4)
-            state_preparation.cry(0.1, 0, 3)
-            state_preparation.ry(0.5, 3)
-            grover_op = grover_operator(oracle, state_preparation, reflection_qubits=reflection_qubits)
-            grover_op.draw("mpl")
-
-
-        The oracle and the zero reflection can also be passed as :mod:`qiskit.quantum_info`
-        objects:
-
-        .. plot::
-            :include-source:
-            :context:
-
-            from qiskit.quantum_info import Statevector, DensityMatrix, Operator
-
-            mark_state = Statevector.from_label("011")
-            reflection = 2 * DensityMatrix.from_label("000") - Operator.from_label("III")
-            grover_op = grover_operator(oracle=mark_state, zero_reflection=reflection)
-            grover_op.draw("mpl")
-
-        For a large number of qubits, the multi-controlled X gate used for the zero-reflection
-        can be synthesized in different fashions. Depending on the number of available qubits,
-        the compiler will choose a different implementation:
-
-        .. code-block:: python
-
-            from qiskit import transpile, Qubit
-            from qiskit.circuit import QuantumCircuit
-            from qiskit.circuit.library import grover_operator
-
-            oracle = QuantumCircuit(10)
-            oracle.z(oracle.qubits)
-            grover_op = grover_operator(oracle)
-
-            # without extra qubit space, the MCX synthesis is expensive
-            basis_gates = ["u", "cx"]
-            tqc = transpile(grover_op, basis_gates=basis_gates)
-            is_2q = lambda inst: len(inst.qubits) == 2
-            print("2q depth w/o scratch qubits:", tqc.depth(filter_function=is_2q))  # > 350
-
-            # add extra bits that can be used as scratch space
-            grover_op.add_bits([Qubit() for _ in range(num_qubits)])
-            tqc = transpile(grover_op, basis_gates=basis_gates)
-            print("2q depth w/ scratch qubits:", tqc.depth(filter_function=is_2q)) # < 100
-
-    Args:
-        oracle: The phase oracle implementing a reflection about the bad state. Note that this
-            is not a bitflip oracle, see the docstring for more information.
-        state_preparation: The operator preparing the good and bad state.
-            For Grover's algorithm, this is a n-qubit Hadamard gate and for amplitude
-            amplification or estimation the operator :math:`\mathcal{A}`.
-        zero_reflection: The reflection about the zero state, :math:`\mathcal{S}_0`.
-        reflection_qubits: Qubits on which the zero reflection acts on.
-        insert_barriers: Whether barriers should be inserted between the reflections and A.
-        name: The name of the circuit.
-
-    References:
-        [1]: L. K. Grover (1996), A fast quantum mechanical algorithm for database search,
-            `arXiv:quant-ph/9605043 <https://arxiv.org/abs/quant-ph/9605043>`_.
-        [2]: I. Chuang & M. Nielsen, Quantum Computation and Quantum Information,
-            Cambridge: Cambridge University Press, 2000. Chapter 6.1.2.
-        [3]: Brassard, G., Hoyer, P., Mosca, M., & Tapp, A. (2000).
-            Quantum Amplitude Amplification and Estimation.
-            `arXiv:quant-ph/0005055 <http://arxiv.org/abs/quant-ph/0005055>`_.
-    """
-    # We inherit the ancillas/qubits structure from the oracle, if it is given as circuit.
-    if isinstance(oracle, QuantumCircuit):
-        circuit = oracle.copy_empty_like(name=name, vars_mode="drop")
-    else:
-        circuit = QuantumCircuit(oracle.num_qubits, name=name)
-
-    # (1) Add the oracle.
-    # If the oracle is given as statevector, turn it into a circuit that implements the
-    # reflection about the state.
-    if isinstance(oracle, Statevector):
-        diagonal = DiagonalGate((-1) ** oracle.data)
-        circuit.append(diagonal, circuit.qubits)
-    else:
-        circuit.compose(oracle, inplace=True)
-
-    if insert_barriers:
-        circuit.barrier()
-
-    # (2) Add the inverse state preparation.
-    # For this we need to know the target qubits that we apply the zero reflection to.
-    # If the reflection qubits are not given, we assume they are the qubits that are not
-    # of type ``AncillaQubit`` in the oracle.
-    if reflection_qubits is None:
-        reflection_qubits = [
-            i for i, qubit in enumerate(circuit.qubits) if not isinstance(qubit, AncillaQubit)
-        ]
-
-    if state_preparation is None:
-        circuit.h(reflection_qubits)  # H is self-inverse
-    else:
-        circuit.compose(state_preparation.inverse(), inplace=True)
-
-    if insert_barriers:
-        circuit.barrier()
-
-    # (3) Add the zero reflection.
-    if zero_reflection is None:
-        num_reflection = len(reflection_qubits)
-
-        circuit.x(reflection_qubits)
-        if num_reflection == 1:
-            circuit.z(
-                reflection_qubits[0]
-            )  # MCX does not support 0 controls, hence this is separate
-        else:
-            mcx = MCXGate(num_reflection - 1)
-
-            circuit.h(reflection_qubits[-1])
-            circuit.append(mcx, reflection_qubits)
-            circuit.h(reflection_qubits[-1])
-        circuit.x(reflection_qubits)
-
-    elif isinstance(zero_reflection, (Operator, DensityMatrix)):
-        diagonal = DiagonalGate(zero_reflection.data.diagonal())
-        circuit.append(diagonal, circuit.qubits)
-
-    else:
-        circuit.compose(zero_reflection, inplace=True)
-
-    if insert_barriers:
-        circuit.barrier()
-
-    # (4) Add the state preparation.
-    if state_preparation is None:
-        circuit.h(reflection_qubits)
-    else:
-        circuit.compose(state_preparation, inplace=True)
-
-    # minus sign
-    circuit.global_phase = numpy.pi
-
-    return circuit
 
 
 class GroverOperator(QuantumCircuit):
@@ -317,7 +61,7 @@ class GroverOperator(QuantumCircuit):
     Note that you can easily construct a phase oracle from a bitflip oracle by sandwiching the
     controlled X gate on the result qubit by a X and H gate. For instance
 
-    .. code-block:: text
+    .. parsed-literal::
 
         Bitflip oracle     Phaseflip oracle
         q_0: ──■──         q_0: ────────────■────────────
@@ -406,13 +150,6 @@ class GroverOperator(QuantumCircuit):
         «state_2: ┤2                ├┤1              ├┤ UCRZ(pi/4) ├┤ H ├
         «         └─────────────────┘└───────────────┘└────────────┘└───┘
 
-    .. seealso::
-
-        The :func:`.grover_operator` implements the same functionality but keeping the
-        :class:`.MCXGate` abstract, such that the compiler may choose the optimal decomposition.
-        We recommend using :func:`.grover_operator` for performance reasons, which does not
-        wrap the circuit into an opaque gate.
-
     References:
         [1]: L. K. Grover (1996), A fast quantum mechanical algorithm for database search,
             `arXiv:quant-ph/9605043 <https://arxiv.org/abs/quant-ph/9605043>`_.
@@ -423,11 +160,6 @@ class GroverOperator(QuantumCircuit):
             `arXiv:quant-ph/0005055 <http://arxiv.org/abs/quant-ph/0005055>`_.
     """
 
-    @deprecate_func(
-        since="1.3",
-        additional_msg="Use qiskit.circuit.library.grover_operator instead.",
-        pending=True,
-    )
     def __init__(
         self,
         oracle: Union[QuantumCircuit, Statevector],

qiskit/circuit/library/hidden_linear_function.py

@@ -12,12 +12,11 @@
 
 """Hidden Linear Function circuit."""
 
-from __future__ import annotations
+from typing import Union, List
 
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.utils.deprecation import deprecate_func
 
 
 class HiddenLinearFunction(QuantumCircuit):
@@ -68,12 +67,7 @@ class HiddenLinearFunction(QuantumCircuit):
     `arXiv:1704.00690 <https://arxiv.org/abs/1704.00690>`_
     """
 
-    @deprecate_func(
-        since="1.3",
-        additional_msg="Use qiskit.circuit.library.hidden_linear_function instead.",
-        pending=True,
-    )
-    def __init__(self, adjacency_matrix: list | np.ndarray) -> None:
+    def __init__(self, adjacency_matrix: Union[List[List[int]], np.ndarray]) -> None:
         """Create new HLF circuit.
 
         Args:
@@ -83,79 +77,22 @@ class HiddenLinearFunction(QuantumCircuit):
         Raises:
             CircuitError: If A is not symmetric.
         """
-        circuit = hidden_linear_function(adjacency_matrix)
-        super().__init__(*circuit.qregs, name=circuit.name)
-        self.append(circuit.to_gate(), self.qubits)
-
-
-def hidden_linear_function(adjacency_matrix: list | np.ndarray) -> QuantumCircuit:
-    r"""Circuit to solve the hidden linear function problem.
-
-    The 2D Hidden Linear Function problem is determined by a 2D adjacency
-    matrix A, where only elements that are nearest-neighbor on a grid have
-    non-zero entries. Each row/column corresponds to one binary variable
-    :math:`x_i`.
+        adjacency_matrix = np.asarray(adjacency_matrix)
+        if not np.allclose(adjacency_matrix, adjacency_matrix.transpose()):
+            raise CircuitError("The adjacency matrix must be symmetric.")
+
+        num_qubits = len(adjacency_matrix)
+        circuit = QuantumCircuit(num_qubits, name=f"hlf: {adjacency_matrix}")
+
+        circuit.h(range(num_qubits))
+        for i in range(num_qubits):
+            for j in range(i + 1, num_qubits):
+                if adjacency_matrix[i][j]:
+                    circuit.cz(i, j)
+        for i in range(num_qubits):
+            if adjacency_matrix[i][i]:
+                circuit.s(i)
+        circuit.h(range(num_qubits))
 
-    The hidden linear function problem is as follows:
-
-    Consider the quadratic form
-
-    .. math::
-
-        q(x) = \sum_{i,j=1}^{n}{x_i x_j} ~(\mathrm{mod}~ 4)
-
-    and restrict :math:`q(x)` onto the nullspace of A. This results in a linear
-    function.
-
-    .. math::
-
-        2 \sum_{i=1}^{n}{z_i x_i} ~(\mathrm{mod}~ 4)  \forall  x \in \mathrm{Ker}(A)
-
-    and the goal is to recover this linear function (equivalently a vector
-    :math:`[z_0, ..., z_{n-1}]`). There can be multiple solutions.
-
-    In [1] it is shown that the present circuit solves this problem
-    on a quantum computer in constant depth, whereas any corresponding
-    solution on a classical computer would require circuits that grow
-    logarithmically with :math:`n`. Thus this circuit is an example
-    of quantum advantage with shallow circuits.
-
-    **Reference Circuit:**
-
-    .. plot::
-       :include-source:
-
-       from qiskit.circuit.library import hidden_linear_function
-       A = [[1, 1, 0], [1, 0, 1], [0, 1, 1]]
-       circuit = hidden_linear_function(A)
-       circuit.draw('mpl')
-
-    Args:
-        adjacency_matrix: a symmetric n-by-n list of 0-1 lists.
-            n will be the number of qubits.
-
-    Raises:
-        CircuitError: If A is not symmetric.
-
-    **Reference:**
-
-    [1] S. Bravyi, D. Gosset, R. Koenig, Quantum Advantage with Shallow Circuits, 2017.
-    `arXiv:1704.00690 <https://arxiv.org/abs/1704.00690>`_
-    """
-    adjacency_matrix = np.asarray(adjacency_matrix)
-    if not np.allclose(adjacency_matrix, adjacency_matrix.transpose()):
-        raise CircuitError("The adjacency matrix must be symmetric.")
-
-    num_qubits = len(adjacency_matrix)
-    circuit = QuantumCircuit(num_qubits, name=f"hlf: {adjacency_matrix}")
-
-    circuit.h(range(num_qubits))
-    for i in range(num_qubits):
-        for j in range(i + 1, num_qubits):
-            if adjacency_matrix[i][j]:
-                circuit.cz(i, j)
-    for i in range(num_qubits):
-        if adjacency_matrix[i][i]:
-            circuit.s(i)
-    circuit.h(range(num_qubits))
-    return circuit
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/iqp.py

@@ -13,12 +13,10 @@
 """Instantaneous quantum polynomial circuit."""
 
 from __future__ import annotations
-from collections.abc import Sequence
 
 import numpy as np
 from qiskit.circuit import QuantumCircuit
-from qiskit.utils.deprecation import deprecate_func
-from qiskit._accelerate.circuit_library import py_iqp, py_random_iqp
+from qiskit.circuit.exceptions import CircuitError
 
 
 class IQP(QuantumCircuit):
@@ -62,11 +60,6 @@ class IQP(QuantumCircuit):
     `arXiv:1504.07999 <https://arxiv.org/abs/1504.07999>`_
     """
 
-    @deprecate_func(
-        since="1.3",
-        additional_msg="Use the qiskit.circuit.library.iqp function instead.",
-        pending=True,
-    )
     def __init__(self, interactions: list | np.ndarray) -> None:
         """Create IQP circuit.
 
@@ -76,100 +69,28 @@ class IQP(QuantumCircuit):
         Raises:
             CircuitError: if the inputs is not as symmetric matrix.
         """
-        circuit = iqp(interactions)
-        super().__init__(*circuit.qregs, name=circuit.name)
-        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
-
-
-def iqp(
-    interactions: Sequence[Sequence[int]],
-) -> QuantumCircuit:
-    r"""Instantaneous quantum polynomial time (IQP) circuit.
-
-    The circuit consists of a column of Hadamard gates, a column of powers of T gates,
-    a sequence of powers of CS gates (up to :math:`\frac{n^2-n}{2}` of them), and a final column of
-    Hadamard gates, as introduced in [1].
-
-    The circuit is parameterized by an :math:`n \times n` interactions matrix. The powers of each
-    T gate are given by the diagonal elements of the interactions matrix. The powers of the CS gates
-    are given by the upper triangle of the interactions matrix.
-
-    **Reference Circuit:**
-
-    .. plot::
-
-       from qiskit.circuit.library import iqp
-       A = [[6, 5, 3], [5, 4, 5], [3, 5, 1]]
-       circuit = iqp(A)
-       circuit.draw("mpl")
-
-    **Expanded Circuit:**
-
-        .. plot::
-
-           from qiskit.circuit.library import iqp
-           from qiskit.visualization.library import _generate_circuit_library_visualization
-           A = [[6, 5, 3], [5, 4, 5], [3, 5, 1]]
-           circuit = iqp(A)
-           _generate_circuit_library_visualization(circuit)
+        num_qubits = len(interactions)
+        interactions = np.array(interactions)
+        if not np.allclose(interactions, interactions.transpose()):
+            raise CircuitError("The interactions matrix is not symmetric")
 
-    **References:**
-
-    [1] M. J. Bremner et al. Average-case complexity versus approximate
-    simulation of commuting quantum computations,
-    Phys. Rev. Lett. 117, 080501 (2016).
-    `arXiv:1504.07999 <https://arxiv.org/abs/1504.07999>`_
-
-    Args:
-        interactions: The interactions as symmetric square matrix. If ``None``, then the
-            ``num_qubits`` argument must be set and a random IQP circuit will be generated.
-
-    Returns:
-        An IQP circuit.
-    """
-    # if no interactions are given, generate them
-    num_qubits = len(interactions)
-    interactions = np.asarray(interactions).astype(np.int64)
-
-    # set the label -- if the number of qubits is too large, do not show the interactions matrix
-    if num_qubits < 5 and interactions is not None:
-        label = np.array_str(interactions)
-        name = "iqp:" + label.replace("\n", ";")
-    else:
-        name = "iqp"
+        a_str = np.array_str(interactions)
+        a_str.replace("\n", ";")
+        name = "iqp:" + a_str.replace("\n", ";")
 
-    circuit = QuantumCircuit._from_circuit_data(py_iqp(interactions), add_regs=True)
-    circuit.name = name
-    return circuit
+        circuit = QuantumCircuit(num_qubits, name=name)
 
+        circuit.h(range(num_qubits))
+        for i in range(num_qubits):
+            for j in range(i + 1, num_qubits):
+                if interactions[i][j] % 4 != 0:
+                    circuit.cp(interactions[i][j] * np.pi / 2, i, j)
 
-def random_iqp(
-    num_qubits: int,
-    seed: int | None = None,
-) -> QuantumCircuit:
-    r"""A random instantaneous quantum polynomial time (IQP) circuit.
+        for i in range(num_qubits):
+            if interactions[i][i] % 8 != 0:
+                circuit.p(interactions[i][i] * np.pi / 8, i)
 
-    See :func:`iqp` for more details on the IQP circuit.
+        circuit.h(range(num_qubits))
 
-    Example:
-
-    .. plot::
-       :include-source:
-
-       from qiskit.circuit.library import random_iqp
-
-       circuit = random_iqp(3)
-       circuit.draw("mpl")
-
-    Args:
-        num_qubits: The number of qubits in the circuit.
-        seed: A seed for the random number generator, in case the interactions matrix is
-            randomly generated.
-
-    Returns:
-        An IQP circuit.
-    """
-    # set the label -- if the number of qubits is too large, do not show the interactions matrix
-    circuit = QuantumCircuit._from_circuit_data(py_random_iqp(num_qubits, seed), add_regs=True)
-    circuit.name = "iqp"
-    return circuit
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/n_local/__init__.py

@@ -12,34 +12,22 @@
 
 """The circuit library module containing N-local circuits."""
 
-from .n_local import NLocal, n_local
+from .n_local import NLocal
 from .two_local import TwoLocal
-from .pauli_two_design import PauliTwoDesign, pauli_two_design
-from .real_amplitudes import RealAmplitudes, real_amplitudes
-from .efficient_su2 import EfficientSU2, efficient_su2
-from .evolved_operator_ansatz import (
-    EvolvedOperatorAnsatz,
-    evolved_operator_ansatz,
-    hamiltonian_variational_ansatz,
-)
-from .excitation_preserving import ExcitationPreserving, excitation_preserving
-from .qaoa_ansatz import QAOAAnsatz, qaoa_ansatz
+from .pauli_two_design import PauliTwoDesign
+from .real_amplitudes import RealAmplitudes
+from .efficient_su2 import EfficientSU2
+from .evolved_operator_ansatz import EvolvedOperatorAnsatz
+from .excitation_preserving import ExcitationPreserving
+from .qaoa_ansatz import QAOAAnsatz
 
 __all__ = [
-    "n_local",
     "NLocal",
     "TwoLocal",
-    "real_amplitudes",
     "RealAmplitudes",
-    "pauli_two_design",
     "PauliTwoDesign",
-    "efficient_su2",
     "EfficientSU2",
-    "hamiltonian_variational_ansatz",
-    "evolved_operator_ansatz",
     "EvolvedOperatorAnsatz",
-    "excitation_preserving",
     "ExcitationPreserving",
-    "qaoa_ansatz",
     "QAOAAnsatz",
 ]