Deprecate qiskit.extensions

qiskit/assembler/disassemble.py

@@ -36,6 +36,20 @@
 # and a header dictionary.
 PulseModule = NewType("PulseModule", Tuple[List[pulse.Schedule], Dict[str, Any], Dict[str, Any]])
 
+# Prevent the disassembler from accessing deprecated circuit methods. This can happen for
+# gates where the name of the gate matches a circuit method (e.g. Isometry.name is "isometry")
+# and the circuit attribute is also QuantumCircuit.isometry
+_DEPRECATED_CIRCUIT_METHODS = [
+    "isometry",
+    "snapshot",
+    "ucrx",
+    "ucry",
+    "ucrz",
+    "squ",
+    "diagonal",
+    "hamiltonian",
+]
+
 
 def disassemble(qobj) -> Union[CircuitModule, PulseModule]:
     """Disassemble a qobj and return the circuits or pulse schedules, run_config, and user header.
@@ -165,16 +179,12 @@ def _experiments_to_circuits(qobj):
                     clbits.append(creg_dict[clbit_label[0]][clbit_label[1]])
             except Exception:  # pylint: disable=broad-except
                 pass
-            if hasattr(circuit, name):
+            # TODO remove the check that name is not in the deprecated circuit methods
+            # once the methods have been removed
+            if hasattr(circuit, name) and name not in _DEPRECATED_CIRCUIT_METHODS:
                 instr_method = getattr(circuit, name)
-                if i.name in ["snapshot"]:
-                    _inst = instr_method(
-                        i.label, snapshot_type=i.snapshot_type, qubits=qubits, params=params
-                    )
-                elif i.name == "initialize":
+                if i.name == "initialize":
                     _inst = instr_method(params, qubits)
-                elif i.name == "isometry":
-                    _inst = instr_method(*params, qubits, clbits)
                 elif i.name in ["mcx", "mcu1", "mcp"]:
                     _inst = instr_method(*params, qubits[:-1], qubits[-1], *clbits)
                 else:

qiskit/circuit/add_control.py

@@ -14,7 +14,7 @@
 from __future__ import annotations
 
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.extensions import UnitaryGate
+from qiskit.circuit.library import UnitaryGate
 from . import ControlledGate, Gate, QuantumRegister, QuantumCircuit
 from ._utils import _ctrl_state_to_int
 

qiskit/circuit/gate.py

@@ -66,7 +66,9 @@ def power(self, exponent: float):
             CircuitError: If Gate is not unitary
         """
         from qiskit.quantum_info.operators import Operator  # pylint: disable=cyclic-import
-        from qiskit.extensions.unitary import UnitaryGate  # pylint: disable=cyclic-import
+        from qiskit.circuit.library.generalized_gates import (
+            UnitaryGate,
+        )  # pylint: disable=cyclic-import
         from scipy.linalg import schur
 
         # Should be diagonalized because it's a unitary.

qiskit/circuit/library/__init__.py

@@ -181,6 +181,7 @@
    :template: autosummary/class_no_inherited_members.rst
 
    Diagonal
+   DiagonalGate
    MCMT
    MCMTVChain
    Permutation
@@ -195,9 +196,17 @@
    MCXGrayCode
    MCXRecursive
    MCXVChain
+   MGCupDiag
    RVGate
    PauliGate
    LinearFunction
+   Isometry
+   UnitaryGate
+   UCGate
+   UCPauliRotGate
+   UCRXGate
+   UCRYGate
+   UCRZGate
 
 Boolean Logic Circuits
 ======================
@@ -324,6 +333,7 @@
    PhaseOracle
    EvolvedOperatorAnsatz
    PauliEvolutionGate
+   HamiltonianGate
 
 
 N-local circuits
@@ -360,6 +370,7 @@
    ZFeatureMap
    ZZFeatureMap
    StatePreparation
+   Initialize
 
 Template circuits
 =================
@@ -492,6 +503,7 @@
 from .blueprintcircuit import BlueprintCircuit
 from .generalized_gates import (
     Diagonal,
+    DiagonalGate,
     MCMT,
     MCMTVChain,
     Permutation,
@@ -505,8 +517,17 @@
     RVGate,
     PauliGate,
     LinearFunction,
+    Isometry,
+    UnitaryGate,
+    UCGate,
+    UCPauliRotGate,
+    UCRXGate,
+    UCRYGate,
+    UCRZGate,
+    MCGupDiag,
 )
 from .pauli_evolution import PauliEvolutionGate
+from .hamiltonian_gate import HamiltonianGate
 from .boolean_logic import (
     AND,
     OR,
@@ -542,7 +563,13 @@
     ExcitationPreserving,
     QAOAAnsatz,
 )
-from .data_preparation import PauliFeatureMap, ZFeatureMap, ZZFeatureMap, StatePreparation
+from .data_preparation import (
+    PauliFeatureMap,
+    ZFeatureMap,
+    ZZFeatureMap,
+    StatePreparation,
+    Initialize,
+)
 from .quantum_volume import QuantumVolume
 from .fourier_checking import FourierChecking
 from .graph_state import GraphState

qiskit/circuit/library/arithmetic/exact_reciprocal.py

@@ -14,7 +14,7 @@
 from math import isclose
 import numpy as np
 from qiskit.circuit import QuantumCircuit, QuantumRegister
-from qiskit.extensions.quantum_initializer import UCRYGate
+from qiskit.circuit.library.generalized_gates import UCRYGate
 
 
 class ExactReciprocal(QuantumCircuit):

qiskit/circuit/library/data_preparation/__init__.py

@@ -42,5 +42,6 @@
 from .z_feature_map import ZFeatureMap
 from .zz_feature_map import ZZFeatureMap
 from .state_preparation import StatePreparation
+from .initializer import Initialize
 
-__all__ = ["PauliFeatureMap", "ZFeatureMap", "ZZFeatureMap", "StatePreparation"]
+__all__ = ["PauliFeatureMap", "ZFeatureMap", "ZZFeatureMap", "StatePreparation", "Initialize"]

qiskit/circuit/library/data_preparation/initializer.py

@@ -0,0 +1,93 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""
+Initialize qubit registers to desired arbitrary state.
+"""
+
+from __future__ import annotations
+from collections.abc import Sequence
+
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import QuantumRegister
+from qiskit.circuit import Instruction
+from qiskit.circuit.library.data_preparation import StatePreparation
+from qiskit.quantum_info import Statevector
+
+_EPS = 1e-10  # global variable used to chop very small numbers to zero
+
+
+class Initialize(Instruction):
+    """Complex amplitude initialization.
+
+    Class that initializes some flexible collection of qubit registers, implemented by calling
+    the :class:`qiskit.extensions.StatePreparation` Class.
+    Note that Initialize is an Instruction and not a Gate since it contains a reset instruction,
+    which is not unitary.
+    """
+
+    def __init__(
+        self,
+        params: Statevector | Sequence[complex] | str | int,
+        num_qubits: int | None = None,
+        normalize: bool = False,
+    ) -> None:
+        r"""
+        Args:
+            params: The state to initialize to, can be either of the following.
+                * Statevector or vector of complex amplitudes to initialize to.
+                * Labels of basis states of the Pauli eigenstates Z, X, Y. See
+                  :meth:`.Statevector.from_label`. Notice the order of the labels is reversed with
+                  respect to the qubit index to be applied to. Example label '01' initializes the
+                  qubit zero to :math:`|1\rangle` and the qubit one to :math:`|0\rangle`.
+                * An integer that is used as a bitmap indicating which qubits to initialize to
+                  :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit
+                  2 to :math:`|1\rangle` and qubit 1 to :math:`|0\rangle`.
+
+            num_qubits: This parameter is only used if params is an int. Indicates the total
+                number of qubits in the `initialize` call. Example: `initialize` covers 5 qubits
+                and params is 3. This allows qubits 0 and 1 to be initialized to :math:`|1\rangle`
+                and the remaining 3 qubits to be initialized to :math:`|0\rangle`.
+            normalize: Whether to normalize an input array to a unit vector.
+        """
+        self._stateprep = StatePreparation(params, num_qubits, normalize=normalize)
+
+        super().__init__("initialize", self._stateprep.num_qubits, 0, self._stateprep.params)
+
+    def _define(self):
+        q = QuantumRegister(self.num_qubits, "q")
+        initialize_circuit = QuantumCircuit(q, name="init_def")
+        initialize_circuit.reset(q)
+        initialize_circuit.append(self._stateprep, q)
+        self.definition = initialize_circuit
+
+    def gates_to_uncompute(self) -> QuantumCircuit:
+        """Call to create a circuit with gates that take the desired vector to zero.
+
+        Returns:
+            Circuit to take ``self.params`` vector to :math:`|{00\\ldots0}\\rangle`
+        """
+        return self._stateprep._gates_to_uncompute()
+
+    @property
+    def params(self):
+        """Return initialize params."""
+        return self._stateprep.params
+
+    @params.setter
+    def params(self, parameters: Statevector | Sequence[complex] | str | int) -> None:
+        """Set initialize params."""
+        self._stateprep.params = parameters
+
+    def broadcast_arguments(self, qargs, cargs):
+        return self._stateprep.broadcast_arguments(qargs, cargs)

qiskit/circuit/library/evolved_operator_ansatz.py

@@ -175,7 +175,7 @@ def preferred_init_points(self):
 
     def _evolve_operator(self, operator, time):
         from qiskit.opflow import OperatorBase, EvolutionBase
-        from qiskit.extensions import HamiltonianGate
+        from qiskit.circuit.library import HamiltonianGate
 
         if isinstance(operator, OperatorBase):
             if not isinstance(self.evolution, EvolutionBase):

qiskit/circuit/library/fourier_checking.py

@@ -18,6 +18,8 @@
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
 
+from .generalized_gates.diagonal import Diagonal
+
 
 class FourierChecking(QuantumCircuit):
     """Fourier checking circuit.
@@ -83,11 +85,11 @@ def __init__(self, f: List[int], g: List[int]) -> None:
 
         circuit.h(circuit.qubits)
 
-        circuit.diagonal(f, circuit.qubits)
+        circuit.compose(Diagonal(f), inplace=True)
 
         circuit.h(circuit.qubits)
 
-        circuit.diagonal(g, circuit.qubits)
+        circuit.compose(Diagonal(g), inplace=True)
 
         circuit.h(circuit.qubits)
 

qiskit/circuit/library/generalized_gates/__init__.py

@@ -12,11 +12,19 @@
 
 """The circuit library module on generalized gates."""
 
-from .diagonal import Diagonal
+from .diagonal import Diagonal, DiagonalGate
 from .permutation import Permutation, PermutationGate
 from .mcmt import MCMT, MCMTVChain
 from .gms import GMS, MSGate
 from .gr import GR, GRX, GRY, GRZ
 from .pauli import PauliGate
 from .rv import RVGate
 from .linear_function import LinearFunction
+from .isometry import Isometry
+from .uc import UCGate
+from .uc_pauli_rot import UCPauliRotGate
+from .ucrx import UCRXGate
+from .ucry import UCRYGate
+from .ucrz import UCRZGate
+from .unitary import UnitaryGate
+from .mcg_up_to_diagonal import MCGupDiag