qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0rc1__cp38-abi3-win32.whl

qiskit/circuit/library/arithmetic/piecewise_linear_pauli_rotations.py

@@ -202,7 +202,7 @@ class PiecewiseLinearPauliRotations(FunctionalPauliRotations):
             if raise_on_failure:
                 raise CircuitError(
                     "Not enough qubits in the circuit, need at least "
-                    "{}.".format(self.num_state_qubits + 1)
+                    f"{self.num_state_qubits + 1}."
                 )
 
         if len(self.breakpoints) != len(self.slopes) or len(self.breakpoints) != len(self.offsets):

qiskit/circuit/library/arithmetic/piecewise_polynomial_pauli_rotations.py

@@ -218,8 +218,8 @@ class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
         """
 
         y = 0
-        for i in range(0, len(self.breakpoints)):
-            y = y + (x >= self.breakpoints[i]) * (np.poly1d(self.mapped_coeffs[i][::-1])(x))
+        for i, breakpt in enumerate(self.breakpoints):
+            y = y + (x >= breakpt) * (np.poly1d(self.mapped_coeffs[i][::-1])(x))
 
         return y
 
@@ -237,7 +237,7 @@ class PiecewisePolynomialPauliRotations(FunctionalPauliRotations):
             if raise_on_failure:
                 raise CircuitError(
                     "Not enough qubits in the circuit, need at least "
-                    "{}.".format(self.num_state_qubits + 1)
+                    f"{self.num_state_qubits + 1}."
                 )
 
         if len(self.breakpoints) != len(self.coeffs) + 1:

qiskit/circuit/library/arithmetic/polynomial_pauli_rotations.py

@@ -248,7 +248,7 @@ class PolynomialPauliRotations(FunctionalPauliRotations):
             if raise_on_failure:
                 raise CircuitError(
                     "Not enough qubits in the circuit, need at least "
-                    "{}.".format(self.num_state_qubits + 1)
+                    f"{self.num_state_qubits + 1}."
                 )
 
         return valid

qiskit/circuit/library/basis_change/__init__.py

@@ -12,4 +12,4 @@
 
 """The basis change circuits."""
 
-from .qft import QFT
+from .qft import QFT, QFTGate

qiskit/circuit/library/basis_change/qft.py

@@ -10,14 +10,13 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Quantum Fourier Transform Circuit."""
+"""Define a Quantum Fourier Transform circuit (QFT) and a native gate (QFTGate)."""
 
-from typing import Optional
+from __future__ import annotations
 import warnings
 import numpy as np
 
-from qiskit.circuit import QuantumCircuit, QuantumRegister, CircuitInstruction
-
+from qiskit.circuit.quantumcircuit import QuantumCircuit, QuantumRegister, CircuitInstruction, Gate
 from ..blueprintcircuit import BlueprintCircuit
 
 
@@ -75,12 +74,12 @@ class QFT(BlueprintCircuit):
 
     def __init__(
         self,
-        num_qubits: Optional[int] = None,
+        num_qubits: int | None = None,
         approximation_degree: int = 0,
         do_swaps: bool = True,
         inverse: bool = False,
         insert_barriers: bool = False,
-        name: Optional[str] = None,
+        name: str | None = None,
     ) -> None:
         """Construct a new QFT circuit.
 
@@ -293,3 +292,38 @@ class QFT(BlueprintCircuit):
 
         wrapped = circuit.to_instruction() if self.insert_barriers else circuit.to_gate()
         self.compose(wrapped, qubits=self.qubits, inplace=True)
+
+
+class QFTGate(Gate):
+    r"""Quantum Fourier Transform Gate.
+
+    The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation
+
+    .. math::
+
+        |j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} |k\rangle
+
+    """
+
+    def __init__(
+        self,
+        num_qubits: int,
+    ):
+        """
+        Args:
+            num_qubits: The number of qubits on which the QFT acts.
+        """
+        super().__init__(name="qft", num_qubits=num_qubits, params=[])
+
+    def __array__(self, dtype=complex):
+        """Return a numpy array for the QFTGate."""
+        n = self.num_qubits
+        nums = np.arange(2**n)
+        outer = np.outer(nums, nums)
+        return np.exp(2j * np.pi * outer * (0.5**n), dtype=dtype) * (0.5 ** (n / 2))
+
+    def _define(self):
+        """Provide a specific decomposition of the QFTGate into a quantum circuit."""
+        from qiskit.synthesis.qft import synth_qft_full
+
+        self.definition = synth_qft_full(num_qubits=self.num_qubits)

qiskit/circuit/library/blueprintcircuit.py

@@ -17,7 +17,7 @@ from abc import ABC, abstractmethod
 
 from qiskit._accelerate.circuit import CircuitData
 from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
-from qiskit.circuit.parametertable import ParameterTable, ParameterView
+from qiskit.circuit.parametertable import ParameterView
 
 
 class BlueprintCircuit(QuantumCircuit, ABC):
@@ -68,7 +68,6 @@ class BlueprintCircuit(QuantumCircuit, ABC):
     def _invalidate(self) -> None:
         """Invalidate the current circuit build."""
         self._data = CircuitData(self._data.qubits, self._data.clbits)
-        self._parameter_table = ParameterTable()
         self.global_phase = 0
         self._is_built = False
 
@@ -88,7 +87,6 @@ class BlueprintCircuit(QuantumCircuit, ABC):
         self._ancillas = []
         self._qubit_indices = {}
         self._data = CircuitData(clbits=self._data.clbits)
-        self._parameter_table = ParameterTable()
         self.global_phase = 0
         self._is_built = False
 
@@ -122,10 +120,10 @@ class BlueprintCircuit(QuantumCircuit, ABC):
             self._build()
         return super().parameters
 
-    def _append(self, instruction, _qargs=None, _cargs=None):
+    def _append(self, instruction, _qargs=None, _cargs=None, *, _standard_gate=False):
         if not self._is_built:
             self._build()
-        return super()._append(instruction, _qargs, _cargs)
+        return super()._append(instruction, _qargs, _cargs, _standard_gate=_standard_gate)
 
     def compose(
         self,

qiskit/circuit/library/data_preparation/__init__.py

@@ -41,7 +41,14 @@ of the complete initial data.
 from .pauli_feature_map import PauliFeatureMap
 from .z_feature_map import ZFeatureMap
 from .zz_feature_map import ZZFeatureMap
-from .state_preparation import StatePreparation
+from .state_preparation import StatePreparation, UniformSuperpositionGate
 from .initializer import Initialize
 
-__all__ = ["PauliFeatureMap", "ZFeatureMap", "ZZFeatureMap", "StatePreparation", "Initialize"]
+__all__ = [
+    "PauliFeatureMap",
+    "ZFeatureMap",
+    "ZZFeatureMap",
+    "StatePreparation",
+    "UniformSuperpositionGate",
+    "Initialize",
+]

qiskit/circuit/library/data_preparation/initializer.py

@@ -36,6 +36,14 @@ class Initialize(Instruction):
     the :class:`~.library.StatePreparation` class.
     Note that ``Initialize`` is an :class:`~.circuit.Instruction` and not a :class:`.Gate` since it
     contains a reset instruction, which is not unitary.
+
+    The initial state is prepared based on the :class:`~.library.Isometry` synthesis described in [1].
+
+    References:
+        1. Iten et al., Quantum circuits for isometries (2016).
+           `Phys. Rev. A 93, 032318
+           <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.93.032318>`__.
+
     """
 
     def __init__(

qiskit/circuit/library/data_preparation/state_preparation.py

@@ -11,7 +11,6 @@
 # that they have been altered from the originals.
 """Prepare a quantum state from the state where all qubits are 0."""
 
-import cmath
 from typing import Union, Optional
 
 import math
@@ -21,13 +20,14 @@ from qiskit.exceptions import QiskitError
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.library.standard_gates.x import CXGate, XGate
+from qiskit.circuit.library.standard_gates.x import XGate
 from qiskit.circuit.library.standard_gates.h import HGate
 from qiskit.circuit.library.standard_gates.s import SGate, SdgGate
-from qiskit.circuit.library.standard_gates.ry import RYGate
-from qiskit.circuit.library.standard_gates.rz import RZGate
+from qiskit.circuit.library.generalized_gates import Isometry
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.quantum_info.states.statevector import Statevector  # pylint: disable=cyclic-import
+from qiskit.quantum_info.states.statevector import (
+    Statevector,
+)  # pylint: disable=cyclic-import
 
 _EPS = 1e-10  # global variable used to chop very small numbers to zero
 
@@ -71,13 +71,13 @@ class StatePreparation(Gate):
         Raises:
             QiskitError: ``num_qubits`` parameter used when ``params`` is not an integer
 
-        When a Statevector argument is passed the state is prepared using a recursive
-        initialization algorithm, including optimizations, from [1], as well
-        as some additional optimizations including removing zero rotations and double cnots.
+        When a Statevector argument is passed the state is prepared based on the
+        :class:`~.library.Isometry` synthesis described in [1].
 
-        **References:**
-        [1] Shende, Bullock, Markov. Synthesis of Quantum Logic Circuits (2004)
-        [`https://arxiv.org/abs/quant-ph/0406176v5`]
+        References:
+            1. Iten et al., Quantum circuits for isometries (2016).
+               `Phys. Rev. A 93, 032318
+               <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.93.032318>`__.
 
         """
         self._params_arg = params
@@ -119,7 +119,7 @@ class StatePreparation(Gate):
         elif self._from_int:
             self.definition = self._define_from_int()
         else:
-            self.definition = self._define_synthesis()
+            self.definition = self._define_synthesis_isom()
 
     def _define_from_label(self):
         q = QuantumRegister(self.num_qubits, "q")
@@ -156,8 +156,8 @@ class StatePreparation(Gate):
         # Raise if number of bits is greater than num_qubits
         if len(intstr) > self.num_qubits:
             raise QiskitError(
-                "StatePreparation integer has %s bits, but this exceeds the"
-                " number of qubits in the circuit, %s." % (len(intstr), self.num_qubits)
+                f"StatePreparation integer has {len(intstr)} bits, but this exceeds the"
+                f" number of qubits in the circuit, {self.num_qubits}."
             )
 
         for qubit, bit in enumerate(intstr):
@@ -168,29 +168,18 @@ class StatePreparation(Gate):
         # we don't need to invert anything
         return initialize_circuit
 
-    def _define_synthesis(self):
-        """Calculate a subcircuit that implements this initialization
+    def _define_synthesis_isom(self):
+        """Calculate a subcircuit that implements this initialization via isometry"""
+        q = QuantumRegister(self.num_qubits, "q")
+        initialize_circuit = QuantumCircuit(q, name="init_def")
 
-        Implements a recursive initialization algorithm, including optimizations,
-        from "Synthesis of Quantum Logic Circuits" Shende, Bullock, Markov
-        https://arxiv.org/abs/quant-ph/0406176v5
-
-        Additionally implements some extra optimizations: remove zero rotations and
-        double cnots.
-        """
-        # call to generate the circuit that takes the desired vector to zero
-        disentangling_circuit = self._gates_to_uncompute()
+        isom = Isometry(self._params_arg, 0, 0)
+        initialize_circuit.append(isom, q[:])
 
         # invert the circuit to create the desired vector from zero (assuming
         # the qubits are in the zero state)
-        if self._inverse is False:
-            initialize_instr = disentangling_circuit.to_instruction().inverse()
-        else:
-            initialize_instr = disentangling_circuit.to_instruction()
-
-        q = QuantumRegister(self.num_qubits, "q")
-        initialize_circuit = QuantumCircuit(q, name="init_def")
-        initialize_circuit.append(initialize_instr, q[:])
+        if self._inverse is True:
+            return initialize_circuit.inverse()
 
         return initialize_circuit
 
@@ -225,9 +214,9 @@ class StatePreparation(Gate):
 
         if self.num_qubits != len(flat_qargs):
             raise QiskitError(
-                "StatePreparation parameter vector has %d elements, therefore expects %s "
-                "qubits. However, %s were provided."
-                % (2**self.num_qubits, self.num_qubits, len(flat_qargs))
+                f"StatePreparation parameter vector has {2**self.num_qubits}"
+                f" elements, therefore expects {self.num_qubits} "
+                f"qubits. However, {len(flat_qargs)} were provided."
             )
         yield flat_qargs, []
 
@@ -239,8 +228,8 @@ class StatePreparation(Gate):
             if parameter in ["0", "1", "+", "-", "l", "r"]:
                 return parameter
             raise CircuitError(
-                "invalid param label {} for instruction {}. Label should be "
-                "0, 1, +, -, l, or r ".format(type(parameter), self.name)
+                f"invalid param label {type(parameter)} for instruction {self.name}. Label should be "
+                "0, 1, +, -, l, or r "
             )
 
         # StatePreparation instruction parameter can be int, float, and complex.
@@ -254,163 +243,94 @@ class StatePreparation(Gate):
     def _return_repeat(self, exponent: float) -> "Gate":
         return Gate(name=f"{self.name}*{exponent}", num_qubits=self.num_qubits, params=[])
 
-    def _gates_to_uncompute(self):
-        """Call to create a circuit with gates that take the desired vector to zero.
 
-        Returns:
-            QuantumCircuit: circuit to take self.params vector to :math:`|{00\\ldots0}\\rangle`
-        """
-        q = QuantumRegister(self.num_qubits)
-        circuit = QuantumCircuit(q, name="disentangler")
+class UniformSuperpositionGate(Gate):
+    r"""Implements a uniform superposition state.
 
-        # kick start the peeling loop, and disentangle one-by-one from LSB to MSB
-        remaining_param = self.params
+    This gate is used to create the uniform superposition state
+    :math:`\frac{1}{\sqrt{M}} \sum_{j=0}^{M-1}  |j\rangle` when it acts on an input
+    state :math:`|0...0\rangle`. Note, that `M` is not required to be
+    a power of 2, in which case the uniform superposition could be
+    prepared by a single layer of Hadamard gates.
 
-        for i in range(self.num_qubits):
-            # work out which rotations must be done to disentangle the LSB
-            # qubit (we peel away one qubit at a time)
-            (remaining_param, thetas, phis) = StatePreparation._rotations_to_disentangle(
-                remaining_param
-            )
+    .. note::
 
-            # perform the required rotations to decouple the LSB qubit (so that
-            # it can be "factored" out, leaving a shorter amplitude vector to peel away)
+        This class uses the Shukla-Vedula algorithm [1], which only needs
+        :math:`O(\log_2 (M))` qubits and :math:`O(\log_2 (M))` gates,
+        to prepare the superposition.
 
-            add_last_cnot = True
-            if np.linalg.norm(phis) != 0 and np.linalg.norm(thetas) != 0:
-                add_last_cnot = False
-
-            if np.linalg.norm(phis) != 0:
-                rz_mult = self._multiplex(RZGate, phis, last_cnot=add_last_cnot)
-                circuit.append(rz_mult.to_instruction(), q[i : self.num_qubits])
-
-            if np.linalg.norm(thetas) != 0:
-                ry_mult = self._multiplex(RYGate, thetas, last_cnot=add_last_cnot)
-                circuit.append(ry_mult.to_instruction().reverse_ops(), q[i : self.num_qubits])
-        circuit.global_phase -= np.angle(sum(remaining_param))
-        return circuit
-
-    @staticmethod
-    def _rotations_to_disentangle(local_param):
-        """
-        Static internal method to work out Ry and Rz rotation angles used
-        to disentangle the LSB qubit.
-        These rotations make up the block diagonal matrix U (i.e. multiplexor)
-        that disentangles the LSB.
-
-        [[Ry(theta_1).Rz(phi_1)  0   .   .   0],
-        [0         Ry(theta_2).Rz(phi_2) .  0],
-                                    .
-                                        .
-        0         0           Ry(theta_2^n).Rz(phi_2^n)]]
-        """
-        remaining_vector = []
-        thetas = []
-        phis = []
-
-        param_len = len(local_param)
-
-        for i in range(param_len // 2):
-            # Ry and Rz rotations to move bloch vector from 0 to "imaginary"
-            # qubit
-            # (imagine a qubit state signified by the amplitudes at index 2*i
-            # and 2*(i+1), corresponding to the select qubits of the
-            # multiplexor being in state |i>)
-            (remains, add_theta, add_phi) = StatePreparation._bloch_angles(
-                local_param[2 * i : 2 * (i + 1)]
-            )
+    **References:**
+    [1]: A. Shukla and P. Vedula (2024), An efficient quantum algorithm for preparation
+    of uniform quantum superposition states, `Quantum Inf Process 23, 38
+    <https://link.springer.com/article/10.1007/s11128-024-04258-4>`_.
+    """
 
-            remaining_vector.append(remains)
+    def __init__(
+        self,
+        num_superpos_states: int = 2,
+        num_qubits: Optional[int] = None,
+    ):
+        r"""
+        Args:
+            num_superpos_states (int):
+                A positive integer M = num_superpos_states (> 1) representing the number of computational
+                basis states with an amplitude of 1/sqrt(M) in the uniform superposition
+                state (:math:`\frac{1}{\sqrt{M}} \sum_{j=0}^{M-1}  |j\rangle`, where
+                :math:`1< M <= 2^n`). Note that the remaining (:math:`2^n - M`) computational basis
+                states have zero amplitudes. Here M need not be an integer power of 2.
 
-            # rotations for all imaginary qubits of the full vector
-            # to move from where it is to zero, hence the negative sign
-            thetas.append(-add_theta)
-            phis.append(-add_phi)
+            num_qubits (int):
+                A positive integer representing the number of qubits used.  If num_qubits is None
+                or is not specified, then num_qubits is set to ceil(log2(num_superpos_states)).
 
-        return remaining_vector, thetas, phis
+        Raises:
+            ValueError: num_qubits must be an integer greater than or equal to log2(num_superpos_states).
 
-    @staticmethod
-    def _bloch_angles(pair_of_complex):
         """
-        Static internal method to work out rotation to create the passed-in
-        qubit from the zero vector.
-        """
-        [a_complex, b_complex] = pair_of_complex
-        # Force a and b to be complex, as otherwise numpy.angle might fail.
-        a_complex = complex(a_complex)
-        b_complex = complex(b_complex)
-        mag_a = abs(a_complex)
-        final_r = math.sqrt(mag_a**2 + abs(b_complex) ** 2)
-        if final_r < _EPS:
-            theta = 0
-            phi = 0
-            final_r = 0
-            final_t = 0
+        if num_superpos_states <= 1:
+            raise ValueError("num_superpos_states must be a positive integer greater than 1.")
+        if num_qubits is None:
+            num_qubits = int(math.ceil(math.log2(num_superpos_states)))
         else:
-            theta = 2 * math.acos(mag_a / final_r)
-            a_arg = cmath.phase(a_complex)
-            b_arg = cmath.phase(b_complex)
-            final_t = a_arg + b_arg
-            phi = b_arg - a_arg
-
-        return final_r * cmath.exp(1.0j * final_t / 2), theta, phi
-
-    def _multiplex(self, target_gate, list_of_angles, last_cnot=True):
-        """
-        Return a recursive implementation of a multiplexor circuit,
-        where each instruction itself has a decomposition based on
-        smaller multiplexors.
+            if not (isinstance(num_qubits, int) and (num_qubits >= math.log2(num_superpos_states))):
+                raise ValueError(
+                    "num_qubits must be an integer greater than or equal to log2(num_superpos_states)."
+                )
+        super().__init__("USup", num_qubits, [num_superpos_states])
 
-        The LSB is the multiplexor "data" and the other bits are multiplexor "select".
-
-        Args:
-            target_gate (Gate): Ry or Rz gate to apply to target qubit, multiplexed
-                over all other "select" qubits
-            list_of_angles (list[float]): list of rotation angles to apply Ry and Rz
-            last_cnot (bool): add the last cnot if last_cnot = True
-
-        Returns:
-            DAGCircuit: the circuit implementing the multiplexor's action
-        """
-        list_len = len(list_of_angles)
-        local_num_qubits = int(math.log2(list_len)) + 1
-
-        q = QuantumRegister(local_num_qubits)
-        circuit = QuantumCircuit(q, name="multiplex" + str(local_num_qubits))
-
-        lsb = q[0]
-        msb = q[local_num_qubits - 1]
+    def _define(self):
 
-        # case of no multiplexing: base case for recursion
-        if local_num_qubits == 1:
-            circuit.append(target_gate(list_of_angles[0]), [q[0]])
-            return circuit
+        qc = QuantumCircuit(self._num_qubits)
 
-        # calc angle weights, assuming recursion (that is the lower-level
-        # requested angles have been correctly implemented by recursion
-        angle_weight = np.kron([[0.5, 0.5], [0.5, -0.5]], np.identity(2 ** (local_num_qubits - 2)))
+        num_superpos_states = self.params[0]
 
-        # calc the combo angles
-        list_of_angles = angle_weight.dot(np.array(list_of_angles)).tolist()
+        if (
+            num_superpos_states & (num_superpos_states - 1)
+        ) == 0:  # if num_superpos_states is an integer power of 2
+            m = int(math.log2(num_superpos_states))
+            qc.h(range(m))
+            self.definition = qc
+            return
 
-        # recursive step on half the angles fulfilling the above assumption
-        multiplex_1 = self._multiplex(target_gate, list_of_angles[0 : (list_len // 2)], False)
-        circuit.append(multiplex_1.to_instruction(), q[0:-1])
+        n_value = [int(x) for x in reversed(np.binary_repr(num_superpos_states))]
+        k = len(n_value)
+        l_value = [index for (index, item) in enumerate(n_value) if item == 1]  # Locations of '1's
 
-        # attach CNOT as follows, thereby flipping the LSB qubit
-        circuit.append(CXGate(), [msb, lsb])
+        qc.x(l_value[1:k])
+        m_current_value = 2 ** l_value[0]
+        theta = -2 * np.arccos(np.sqrt(m_current_value / num_superpos_states))
 
-        # implement extra efficiency from the paper of cancelling adjacent
-        # CNOTs (by leaving out last CNOT and reversing (NOT inverting) the
-        # second lower-level multiplex)
-        multiplex_2 = self._multiplex(target_gate, list_of_angles[(list_len // 2) :], False)
-        if list_len > 1:
-            circuit.append(multiplex_2.to_instruction().reverse_ops(), q[0:-1])
-        else:
-            circuit.append(multiplex_2.to_instruction(), q[0:-1])
+        if l_value[0] > 0:  # if num_superpos_states is even
+            qc.h(range(l_value[0]))
+        qc.ry(theta, l_value[1])
+        qc.ch(l_value[1], range(l_value[0], l_value[1]), ctrl_state="0")
 
-        # attach a final CNOT
-        if last_cnot:
-            circuit.append(CXGate(), [msb, lsb])
+        for m in range(1, len(l_value) - 1):
+            theta = -2 * np.arccos(
+                np.sqrt(2 ** l_value[m] / (num_superpos_states - m_current_value))
+            )
+            qc.cry(theta, l_value[m], l_value[m + 1], ctrl_state="0")
+            qc.ch(l_value[m + 1], range(l_value[m], l_value[m + 1]), ctrl_state="0")
+            m_current_value = m_current_value + 2 ** l_value[m]
 
-        return circuit
+        self.definition = qc

qiskit/circuit/library/generalized_gates/isometry.py

@@ -45,10 +45,10 @@ class Isometry(Instruction):
 
     The decomposition is based on [1].
 
-    **References:**
-
-    [1] Iten et al., Quantum circuits for isometries (2016).
-        `Phys. Rev. A 93, 032318 <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.93.032318>`__.
+    References:
+        1. Iten et al., Quantum circuits for isometries (2016).
+           `Phys. Rev. A 93, 032318
+           <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.93.032318>`__.
 
     """
 
@@ -123,8 +123,8 @@ class Isometry(Instruction):
         #  later here instead.
         gate = self.inv_gate()
         gate = gate.inverse()
-        q = QuantumRegister(self.num_qubits)
-        iso_circuit = QuantumCircuit(q)
+        q = QuantumRegister(self.num_qubits, "q")
+        iso_circuit = QuantumCircuit(q, name="isometry")
         iso_circuit.append(gate, q[:])
         self.definition = iso_circuit
 
@@ -139,8 +139,8 @@ class Isometry(Instruction):
         Call to create a circuit with gates that take the desired isometry to the first 2^m columns
          of the 2^n*2^n identity matrix (see https://arxiv.org/abs/1501.06911)
         """
-        q = QuantumRegister(self.num_qubits)
-        circuit = QuantumCircuit(q)
+        q = QuantumRegister(self.num_qubits, "q")
+        circuit = QuantumCircuit(q, name="isometry_to_uncompute")
         (
             q_input,
             q_ancillas_for_output,

qiskit/circuit/library/generalized_gates/linear_function.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017, 2021.
+# (C) Copyright IBM 2017, 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
@@ -16,7 +16,6 @@ from __future__ import annotations
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.synthesis.linear import check_invertible_binary_matrix
 from qiskit.circuit.library.generalized_gates.permutation import PermutationGate
 
 # pylint: disable=cyclic-import
@@ -115,6 +114,8 @@ class LinearFunction(Gate):
 
             # Optionally, check that the matrix is invertible
             if validate_input:
+                from qiskit.synthesis.linear import check_invertible_binary_matrix
+
                 if not check_invertible_binary_matrix(linear):
                     raise CircuitError(
                         "A linear function must be represented by an invertible matrix."

qiskit/circuit/library/generalized_gates/mcg_up_to_diagonal.py

@@ -68,8 +68,8 @@ class MCGupDiag(Gate):
     def _define(self):
         mcg_up_diag_circuit, _ = self._dec_mcg_up_diag()
         gate = mcg_up_diag_circuit.to_instruction()
-        q = QuantumRegister(self.num_qubits)
-        mcg_up_diag_circuit = QuantumCircuit(q)
+        q = QuantumRegister(self.num_qubits, "q")
+        mcg_up_diag_circuit = QuantumCircuit(q, name="mcg_up_to_diagonal")
         mcg_up_diag_circuit.append(gate, q[:])
         self.definition = mcg_up_diag_circuit
 
@@ -108,8 +108,8 @@ class MCGupDiag(Gate):
             q=[q_target,q_controls,q_ancilla_zero,q_ancilla_dirty]
         """
         diag = np.ones(2 ** (self.num_controls + 1)).tolist()
-        q = QuantumRegister(self.num_qubits)
-        circuit = QuantumCircuit(q)
+        q = QuantumRegister(self.num_qubits, "q")
+        circuit = QuantumCircuit(q, name="mcg_up_to_diagonal")
         (q_target, q_controls, q_ancillas_zero, q_ancillas_dirty) = self._define_qubit_role(q)
         # ToDo: Keep this threshold updated such that the lowest gate count is achieved:
         # ToDo: we implement the MCG with a UCGate up to diagonal if the number of controls is