qiskit 1.4.1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/instruction.py

@@ -34,21 +34,17 @@ The circuit itself keeps this context.
 from __future__ import annotations
 
 import copy
-import warnings
 from itertools import zip_longest
 import math
-from typing import List, Type
+from typing import Type
 
 import numpy
 
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
-from qiskit.qobj.qasm_qobj import QasmQobjInstruction
 from qiskit.circuit.parameter import ParameterExpression
 from qiskit.circuit.operation import Operation
 
 from qiskit.circuit.annotated_operation import AnnotatedOperation, InverseModifier
-from qiskit.utils import deprecate_func
 
 _CUTOFF_PRECISION = 1e-10
 
@@ -61,7 +57,7 @@ class Instruction(Operation):
     _directive = False
     _standard_gate = None
 
-    def __init__(self, name, num_qubits, num_clbits, params, duration=None, unit="dt", label=None):
+    def __init__(self, name, num_qubits, num_clbits, params, label=None):
         """Create a new instruction.
 
         .. deprecated:: 1.3
@@ -75,9 +71,6 @@ class Instruction(Operation):
             num_clbits (int): instruction's clbit width
             params (list[int|float|complex|str|ndarray|list|ParameterExpression]):
                 list of parameters
-            duration (int|float): (DEPRECATED) instruction's duration. it must be
-                an integer if ``unit`` is ``'dt'``
-            unit (str): (DEPRECATED) time unit of duration
             label (str or None): An optional label for identifying the instruction.
 
         Raises:
@@ -103,30 +96,9 @@ class Instruction(Operation):
             if label is not None and not isinstance(label, str):
                 raise TypeError("label expects a string or None")
             self._label = label
-        # tuple (ClassicalRegister, int), tuple (Clbit, bool) or tuple (Clbit, int)
-        # when the instruction has a conditional ("if")
-        self._condition = None
         # list of instructions (and their contexts) that this instruction is composed of
         # empty definition means opaque or fundamental instruction
         self._definition = None
-        if duration is not None:
-            warnings.warn(
-                "Setting a custom duration per instruction is deprecated as of Qiskit "
-                "1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration "
-                "is defined in a backend's Target object.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        self._duration = duration
-        if unit is not None and unit != "dt":
-            warnings.warn(
-                "Setting a custom unit for duration per instruction is deprecated as of Qiskit "
-                "1.3.0. It will be removed in Qiskit 2.0.0. An instruction's duration "
-                "is defined in a backend's Target object which has a fixed unit in seconds.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        self._unit = unit
 
         self.params = params  # must be at last (other properties may be required for validation)
 
@@ -181,16 +153,6 @@ class Instruction(Operation):
         """
         return self.copy()
 
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0", is_property=True)
-    def condition(self):
-        """The classical condition on the instruction."""
-        return self._condition
-
-    @condition.setter
-    def condition(self, condition):
-        self._condition = condition
-
     def __eq__(self, other):
         """Two instructions are the same if they have the same name,
         same dimensions, and same params.
@@ -363,64 +325,6 @@ class Instruction(Operation):
 
         sel.add_equivalence(self, decomposition)
 
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
-    def duration(self):
-        """Get the duration."""
-        return self._duration
-
-    @duration.setter
-    def duration(self, value):
-        """Set the duration."""
-        self._duration = value
-
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
-    def unit(self):
-        """Get the time unit of duration."""
-        return self._unit
-
-    @unit.setter
-    def unit(self, value):
-        """Set the time unit of duration."""
-        self._unit = value
-
-    @deprecate_func(
-        since="1.2",
-        removal_timeline="in the 2.0 release",
-        additional_msg="The `Qobj` class and related functionality are part of the deprecated "
-        "`BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
-        "workflow requires `Qobj` it likely relies on deprecated functionality and "
-        "should be updated to use `BackendV2`.",
-    )
-    def assemble(self):
-        """Assemble a QasmQobjInstruction"""
-        return self._assemble()
-
-    def _assemble(self):
-        with warnings.catch_warnings():
-            # The class QasmQobjInstruction is deprecated
-            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-            instruction = QasmQobjInstruction(name=self.name)
-        # Evaluate parameters
-        if self.params:
-            params = [x.evalf(x) if hasattr(x, "evalf") else x for x in self.params]
-            instruction.params = params
-        # Add placeholder for qarg and carg params
-        if self.num_qubits:
-            instruction.qubits = list(range(self.num_qubits))
-        if self.num_clbits:
-            instruction.memory = list(range(self.num_clbits))
-        # Add label if defined
-        if self.label:
-            instruction.label = self.label
-        # Add condition parameters for assembler. This is needed to convert
-        # to a qobj conditional instruction at assemble time and after
-        # conversion will be deleted by the assembler.
-        if self._condition:
-            instruction._condition = self._condition
-        return instruction
-
     @property
     def label(self) -> str:
         """Return instruction label"""
@@ -524,27 +428,6 @@ class Instruction(Operation):
         inverse_gate.definition = inverse_definition
         return inverse_gate
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical, val):
-        """Set a classical equality condition on this instruction between the register or cbit
-        ``classical`` and value ``val``.
-
-        .. note::
-
-            This is a setter method, not an additive one.  Calling this multiple times will silently
-            override any previously set condition; it does not stack.
-        """
-        if not isinstance(classical, (ClassicalRegister, Clbit)):
-            raise CircuitError("c_if must be used with a classical register or classical bit")
-        if val < 0:
-            raise CircuitError("condition value should be non-negative")
-        if isinstance(classical, Clbit):
-            # Casting the conditional value as Boolean when
-            # the classical condition is on a classical bit.
-            val = bool(val)
-        self._condition = (classical, val)
-        return self
-
     def copy(self, name=None):
         """
         Copy of the instruction.
@@ -611,12 +494,6 @@ class Instruction(Operation):
     def repeat(self, n):
         """Creates an instruction with ``self`` repeated :math`n` times.
 
-        If this operation has a conditional, the output instruction will have the same conditional
-        and the inner repeated operations will be unconditional; instructions within a compound
-        definition cannot be conditioned on registers within Qiskit's data model.  This means that
-        it is not valid to apply a repeated instruction to a clbit that it both writes to and reads
-        from in its condition.
-
         Args:
             n (int): Number of times to repeat the instruction
 
@@ -640,28 +517,12 @@ class Instruction(Operation):
             qargs = tuple(qc.qubits)
             cargs = tuple(qc.clbits)
             base = self.copy()
-            if self._condition:
-                # Condition is handled on the outer instruction.
-                base = base.to_mutable()
-                base.condition = None
             for _ in [None] * n:
                 qc._append(CircuitInstruction(base, qargs, cargs))
 
             instruction.definition = qc
-        if self._condition:
-            instruction = instruction.c_if(*self._condition)
         return instruction
 
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0", is_property=True)
-    def condition_bits(self) -> List[Clbit]:
-        """Get Clbits in condition."""
-        from qiskit.circuit.controlflow import condition_resources  # pylint: disable=cyclic-import
-
-        if self._condition is None:
-            return []
-        return list(condition_resources(self._condition).clbits)
-
     @property
     def name(self):
         """Return the name."""

qiskit/circuit/instructionset.py

@@ -17,14 +17,15 @@ Instruction collection.
 from __future__ import annotations
 
 from collections.abc import MutableSequence
-from typing import Callable
+from typing import Callable, TYPE_CHECKING
 
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.utils import deprecate_func
-from .classicalregister import Clbit, ClassicalRegister
 from .operation import Operation
 from .quantumcircuitdata import CircuitInstruction
 
+if TYPE_CHECKING:
+    from qiskit.circuit import Clbit, ClassicalRegister
+
 
 class InstructionSet:
     """Instruction collection, and their contexts."""
@@ -50,9 +51,9 @@ class InstructionSet:
 
                 .. note::
 
-                    The callback ``resource_requester`` is called once for each call to
-                    :meth:`.c_if`, and assumes that a call implies that the resource will now be
-                    used.  It may throw an error if the resource is not valid for usage.
+                    The callback ``resource_requester`` assumes that a call implies that the
+                    resource will now be used.  It may throw an error if the resource is not valid
+                    for usage.
 
         """
         self._instructions: list[
@@ -106,54 +107,6 @@ class InstructionSet:
                 )
         return self
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
-    def c_if(self, classical: Clbit | ClassicalRegister | int, val: int) -> "InstructionSet":
-        """Set a classical equality condition on all the instructions in this set between the
-        :obj:`.ClassicalRegister` or :obj:`.Clbit` ``classical`` and value ``val``.
-
-        .. note::
-            You should prefer to use the :meth:`.QuantumCircuit.if_test` builder interface, rather
-            than using this method.
-
-        .. note::
-
-            This is a setter method, not an additive one.  Calling this multiple times will silently
-            override any previously set condition on any of the contained instructions; it does not
-            stack.
-
-        Args:
-            classical: the classical resource the equality condition should be on.  If this is given
-                as an integer, it will be resolved into a :obj:`.Clbit` using the same conventions
-                as the circuit these instructions are attached to.
-            val: the value the classical resource should be equal to.
-
-        Returns:
-            This same instance of :obj:`.InstructionSet`, but now mutated to have the given equality
-            condition.
-
-        Raises:
-            CircuitError: if the passed classical resource is invalid, or otherwise not resolvable
-                to a concrete resource that these instructions are permitted to access.
-        """
-        if self._requester is None and not isinstance(classical, (Clbit, ClassicalRegister)):
-            raise CircuitError(
-                "Cannot pass an index as a condition variable without specifying a requester"
-                " when creating this InstructionSet."
-            )
-        if self._requester is not None:
-            classical = self._requester(classical)
-        for idx, instruction in enumerate(self._instructions):
-            if isinstance(instruction, CircuitInstruction):
-                updated = instruction.operation.c_if(classical, val)
-                self._instructions[idx] = instruction.replace(operation=updated)
-            else:
-                data, idx = instruction
-                instruction = data[idx]
-                data[idx] = instruction.replace(
-                    operation=instruction.operation.c_if(classical, val)
-                )
-        return self
-
     # Legacy support for properties.  Added in Terra 0.21 to support the internal switch in
     # `QuantumCircuit.data` from the 3-tuple to `CircuitInstruction`.
 

qiskit/circuit/library/__init__.py

@@ -53,7 +53,9 @@ and :meth:`~qiskit.circuit.Gate.control`, which we can generally only apply to u
 
 For example:
 
-.. code-block::
+.. plot::
+   :include-source:
+   :nofigs:
 
     from qiskit.circuit.library import XGate
     gate = XGate()
@@ -156,7 +158,9 @@ These "gates" (many are :class:`~qiskit.circuit.QuantumCircuit` subclasses) allo
 set the amount of qubits involved at instantiation time.
 
 
-.. code-block::
+.. plot::
+   :include-source:
+   :nofigs:
 
     from qiskit.circuit.library import DiagonalGate
 
@@ -255,6 +259,7 @@ Amplitude Functions
    :template: autosummary/class_no_inherited_members.rst
 
    LinearAmplitudeFunction
+   LinearAmplitudeFunctionGate
 
 Functional Pauli Rotations
 --------------------------
@@ -265,10 +270,15 @@ Functional Pauli Rotations
 
    FunctionalPauliRotations
    LinearPauliRotations
+   LinearPauliRotationsGate
    PolynomialPauliRotations
+   PolynomialPauliRotationsGate
    PiecewiseLinearPauliRotations
+   PiecewiseLinearPauliRotationsGate
    PiecewisePolynomialPauliRotations
+   PiecewisePolynomialPauliRotationsGate
    PiecewiseChebyshev
+   PiecewiseChebyshevGate
 
 Adders
 ------
@@ -280,7 +290,6 @@ Adders
    DraperQFTAdder
    CDKMRippleCarryAdder
    VBERippleCarryAdder
-   WeightedAdder
    ModularAdderGate
    HalfAdderGate
    FullAdderGate
@@ -304,6 +313,7 @@ Comparators
    :template: autosummary/class_no_inherited_members.rst
 
    IntegerComparator
+   IntegerComparatorGate
 
 Functions on binary variables
 -----------------------------
@@ -313,6 +323,7 @@ Functions on binary variables
    :template: autosummary/class_no_inherited_members.rst
 
    QuadraticForm
+   QuadraticFormGate
 
 Other arithmetic functions
 --------------------------
@@ -322,6 +333,9 @@ Other arithmetic functions
    :template: autosummary/class_no_inherited_members.rst
 
    ExactReciprocal
+   ExactReciprocalGate
+   WeightedAdder
+   WeightedSumGate
 
 Particular Quantum Circuits
 ===========================
@@ -341,6 +355,8 @@ quantum circuits of interest:
    QuantumVolume
    PhaseEstimation
    GroverOperator
+   BitFlipOracleGate
+   PhaseOracleGate
    PhaseOracle
    PauliEvolutionGate
    HamiltonianGate
@@ -447,7 +463,9 @@ to replace the match with the inverse of the remainder from the template.
 
 In this example, the identity constant in a template is checked:
 
-.. code-block::
+.. plot::
+   :include-source:
+   :nofigs:
 
     from qiskit.circuit.library.templates import template_nct_4b_1
     from qiskit.quantum_info import Operator
@@ -613,20 +631,30 @@ from .arithmetic import (
     MultiplierGate,
     FunctionalPauliRotations,
     LinearPauliRotations,
+    LinearPauliRotationsGate,
     PiecewiseLinearPauliRotations,
+    PiecewiseLinearPauliRotationsGate,
     PiecewisePolynomialPauliRotations,
+    PiecewisePolynomialPauliRotationsGate,
     PolynomialPauliRotations,
+    PolynomialPauliRotationsGate,
     IntegerComparator,
+    IntegerComparatorGate,
     WeightedAdder,
+    WeightedSumGate,
     QuadraticForm,
+    QuadraticFormGate,
     LinearAmplitudeFunction,
+    LinearAmplitudeFunctionGate,
     VBERippleCarryAdder,
     CDKMRippleCarryAdder,
     DraperQFTAdder,
     PiecewiseChebyshev,
+    PiecewiseChebyshevGate,
     HRSCumulativeMultiplier,
     RGQFTMultiplier,
     ExactReciprocal,
+    ExactReciprocalGate,
 )
 
 from .n_local import (
@@ -664,6 +692,7 @@ from .hidden_linear_function import HiddenLinearFunction, hidden_linear_function
 from .iqp import IQP, iqp, random_iqp
 from .phase_estimation import PhaseEstimation, phase_estimation
 from .grover_operator import GroverOperator, grover_operator
-from .phase_oracle import PhaseOracle
+from .phase_oracle import PhaseOracle, PhaseOracleGate
+from .bit_flip_oracle import BitFlipOracleGate
 from .overlap import UnitaryOverlap, unitary_overlap
 from .standard_gates import get_standard_gate_name_mapping

qiskit/circuit/library/arithmetic/__init__.py

@@ -13,14 +13,22 @@
 """The arithmetic circuit library."""
 
 from .functional_pauli_rotations import FunctionalPauliRotations
-from .integer_comparator import IntegerComparator
-from .linear_pauli_rotations import LinearPauliRotations
-from .piecewise_linear_pauli_rotations import PiecewiseLinearPauliRotations
-from .piecewise_polynomial_pauli_rotations import PiecewisePolynomialPauliRotations
-from .polynomial_pauli_rotations import PolynomialPauliRotations
-from .weighted_adder import WeightedAdder
-from .quadratic_form import QuadraticForm
-from .linear_amplitude_function import LinearAmplitudeFunction
+from .integer_comparator import IntegerComparator, IntegerComparatorGate
+from .linear_pauli_rotations import LinearPauliRotations, LinearPauliRotationsGate
+from .piecewise_linear_pauli_rotations import (
+    PiecewiseLinearPauliRotations,
+    PiecewiseLinearPauliRotationsGate,
+)
+from .piecewise_polynomial_pauli_rotations import (
+    PiecewisePolynomialPauliRotations,
+    PiecewisePolynomialPauliRotationsGate,
+)
+from .polynomial_pauli_rotations import PolynomialPauliRotations, PolynomialPauliRotationsGate
+from .weighted_adder import WeightedAdder, WeightedSumGate
+from .quadratic_form import QuadraticForm, QuadraticFormGate
+from .linear_amplitude_function import LinearAmplitudeFunction, LinearAmplitudeFunctionGate
+from .piecewise_chebyshev import PiecewiseChebyshev, PiecewiseChebyshevGate
+from .exact_reciprocal import ExactReciprocal, ExactReciprocalGate
 from .adders import (
     VBERippleCarryAdder,
     CDKMRippleCarryAdder,
@@ -29,6 +37,4 @@ from .adders import (
     HalfAdderGate,
     FullAdderGate,
 )
-from .piecewise_chebyshev import PiecewiseChebyshev
 from .multipliers import HRSCumulativeMultiplier, RGQFTMultiplier, MultiplierGate
-from .exact_reciprocal import ExactReciprocal

qiskit/circuit/library/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -84,7 +84,7 @@ class CDKMRippleCarryAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.HalfAdderGate`: A generic inplace adder. This
+        :class:`.AdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
         :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This

qiskit/circuit/library/arithmetic/adders/draper_qft_adder.py

@@ -15,7 +15,7 @@
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.library.basis_change import QFT
 
 from .adder import Adder
@@ -54,7 +54,7 @@ class DraperQFTAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.HalfAdderGate`: A generic inplace adder. This
+        :class:`.AdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
     **References:**

qiskit/circuit/library/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -60,7 +60,7 @@ class VBERippleCarryAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.HalfAdderGate`: A generic inplace adder. This
+        :class:`.AdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
         :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This

qiskit/circuit/library/arithmetic/exact_reciprocal.py

@@ -13,7 +13,7 @@
 
 from math import isclose
 import numpy as np
-from qiskit.circuit import QuantumCircuit, QuantumRegister
+from qiskit.circuit import QuantumCircuit, QuantumRegister, Gate
 from qiskit.circuit.library.generalized_gates import UCRYGate
 
 
@@ -46,43 +46,86 @@ class ExactReciprocal(QuantumCircuit):
         """
         qr_state = QuantumRegister(num_state_qubits, "state")
         qr_flag = QuantumRegister(1, "flag")
-        circuit = QuantumCircuit(qr_state, qr_flag, name=name)
+        super().__init__(qr_state, qr_flag, name=name)
+
+        reciprocal = ExactReciprocalGate(num_state_qubits, scaling, neg_vals, label=name)
+        self.append(reciprocal, self.qubits)
+
+
+class ExactReciprocalGate(Gate):
+    r"""Implements an exact reciprocal function.
+
+    For a state :math:`|x\rangle` and a scaling factor :math:`s`, this gate implements the operation
+
+    .. math::
+
+        |x\rangle |0\rangle \mapsto
+            \cos\left(\arcsin\left(s\frac{2^n}{x}\right)\right)|x\rangle|0\rangle +
+            \left(s\frac{2^n}{x}\right)|x\rangle|1\rangle.
+
+    States representing :math:`x = 0` or :math:`s 2^n / x \geq 1` are left unchanged, since
+    this function would not be defined.
+    """
+
+    def __init__(
+        self, num_state_qubits: int, scaling: float, neg_vals: bool = False, label: str = "1/x"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits representing the value to invert.
+            scaling: Scaling factor :math:`s` of the reciprocal function, i.e. to compute
+                :math:`s / x`.
+            neg_vals: Whether :math:`x` might represent negative values. In this case the first
+                qubit is the sign, with :math:`|1\rangle` for negative and :math:`|0\rangle` for
+                positive.  For the negative case it is assumed that the remaining string represents
+                :math:`1 - x`. This is because :math:`e^{-2 \pi i x} = e^{2 \pi i (1 - x)}` for
+                :math:`x \in [0,1)`.
+            label: The label of the object.
+
+        .. note::
+
+            It is assumed that the binary string :math:`x` represents a number < 1.
+        """
+        super().__init__("ExactReciprocal", num_state_qubits + 1, [], label=label)
+
+        self.scaling = scaling
+        self.neg_vals = neg_vals
+
+    def _define(self):
+        num_state_qubits = self.num_qubits - 1
+        qr_state = QuantumRegister(num_state_qubits, "state")
+        qr_flag = QuantumRegister(1, "flag")
+        circuit = QuantumCircuit(qr_state, qr_flag)
 
         angles = [0.0]
-        nl = 2 ** (num_state_qubits - 1) if neg_vals else 2**num_state_qubits
+        nl = 2 ** (num_state_qubits - 1) if self.neg_vals else 2**num_state_qubits
 
         # Angles to rotate by scaling / x, where x = i / nl
         for i in range(1, nl):
-            if isclose(scaling * nl / i, 1, abs_tol=1e-5):
+            if isclose(self.scaling * nl / i, 1, abs_tol=1e-5):
                 angles.append(np.pi)
-            elif scaling * nl / i < 1:
-                angles.append(2 * np.arcsin(scaling * nl / i))
+            elif self.scaling * nl / i < 1:
+                angles.append(2 * np.arcsin(self.scaling * nl / i))
             else:
                 angles.append(0.0)
 
-        circuit.compose(
-            UCRYGate(angles), [qr_flag[0]] + qr_state[: len(qr_state) - neg_vals], inplace=True
-        )
+        circuit.append(UCRYGate(angles), [qr_flag[0]] + qr_state[: len(qr_state) - self.neg_vals])
 
-        if neg_vals:
-            circuit.compose(
+        if self.neg_vals:
+            circuit.append(
                 UCRYGate([-theta for theta in angles]).control(),
                 [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
-                inplace=True,
             )
             angles_neg = [0.0]
             for i in range(1, nl):
-                if isclose(scaling * (-1) / (1 - i / nl), -1, abs_tol=1e-5):
+                if isclose(self.scaling * (-1) / (1 - i / nl), -1, abs_tol=1e-5):
                     angles_neg.append(-np.pi)
-                elif np.abs(scaling * (-1) / (1 - i / nl)) < 1:
-                    angles_neg.append(2 * np.arcsin(scaling * (-1) / (1 - i / nl)))
+                elif np.abs(self.scaling * (-1) / (1 - i / nl)) < 1:
+                    angles_neg.append(2 * np.arcsin(self.scaling * (-1) / (1 - i / nl)))
                 else:
                     angles_neg.append(0.0)
-            circuit.compose(
-                UCRYGate(angles_neg).control(),
-                [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
-                inplace=True,
+            circuit.append(
+                UCRYGate(angles_neg).control(), [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1]
             )
 
-        super().__init__(*circuit.qregs, name=name)
-        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+        self.definition = circuit