qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/arithmetic/polynomial_pauli_rotations.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 from itertools import product
 
-from qiskit.circuit import QuantumRegister, QuantumCircuit
+from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
 
 from .functional_pauli_rotations import FunctionalPauliRotations
@@ -253,52 +253,68 @@ class PolynomialPauliRotations(FunctionalPauliRotations):
 
         return valid
 
-    def _get_rotation_coefficients(self) -> dict[tuple[int, ...], float]:
-        """Compute the coefficient of each monomial.
+    def _build(self):
+        """If not already built, build the circuit."""
+        if self._is_built:
+            return
 
-        Returns:
-            A dictionary with pairs ``{control_state: rotation angle}`` where ``control_state``
-            is a tuple of ``0`` or ``1`` bits.
-        """
-        # determine the control states
-        all_combinations = list(product([0, 1], repeat=self.num_state_qubits))
-        valid_combinations = []
-        for combination in all_combinations:
-            if 0 < sum(combination) <= self.degree:
-                valid_combinations += [combination]
+        super()._build()
 
-        rotation_coeffs = {control_state: 0.0 for control_state in valid_combinations}
+        gate = PolynomialPauliRotationsGate(self.num_state_qubits, self.coeffs, self.basis)
+        self.append(gate, self.qubits)
 
-        # compute the coefficients for the control states
-        for i, coeff in enumerate(self.coeffs[1:]):
-            i += 1  # since we skip the first element we need to increase i by one
 
-            # iterate over the multinomial coefficients
-            for comb, num_combs in _multinomial_coefficients(self.num_state_qubits, i).items():
-                control_state: tuple[int, ...] = ()
-                power = 1
-                for j, qubit in enumerate(comb):
-                    if qubit > 0:  # means we control on qubit i
-                        control_state += (1,)
-                        power *= 2 ** (j * qubit)
-                    else:
-                        control_state += (0,)
+class PolynomialPauliRotationsGate(Gate):
+    r"""A gate implementing polynomial Pauli rotations.
 
-                # Add angle
-                rotation_coeffs[control_state] += coeff * num_combs * power
+    For a polynomial :math:`p(x)`, a basis state :math:`|i\rangle` and a target qubit
+    :math:`|0\rangle` this operator acts as:
 
-        return rotation_coeffs
+    .. math::
 
-    def _build(self):
-        """If not already built, build the circuit."""
-        if self._is_built:
-            return
+        |i\rangle |0\rangle \mapsto \cos\left(\frac{p(i)}{2}\right) |i\rangle |0\rangle
+        + \sin\left(\frac{p(i)}{2}\right) |i\rangle |1\rangle
 
-        super()._build()
+    Let n be the number of qubits representing the state, d the degree of p(x) and q_i the qubits,
+    where q_0 is the least significant qubit. Then for
 
-        circuit = QuantumCircuit(*self.qregs, name=self.name)
-        qr_state = circuit.qubits[: self.num_state_qubits]
-        qr_target = circuit.qubits[self.num_state_qubits]
+    .. math::
+
+        x = \sum_{i=0}^{n-1} 2^i q_i,
+
+    we can write
+
+    .. math::
+
+        p(x) = \sum_{j=0}^{j=d} c_j x^j
+
+    where :math:`c` are the input coefficients, ``coeffs``.
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        coeffs: list[float] | None = None,
+        basis: str = "Y",
+        label: str | None = None,
+    ) -> None:
+        """Prepare an approximation to a state with amplitudes specified by a polynomial.
+
+        Args:
+            num_state_qubits: The number of qubits representing the state.
+            coeffs: The coefficients of the polynomial. ``coeffs[i]`` is the coefficient of the
+                i-th power of x. Defaults to linear: [0, 1].
+            basis: The type of Pauli rotation ('X', 'Y', 'Z').
+            label: A label for the gate.
+        """
+        self.coeffs = coeffs or [0, 1]
+        self.basis = basis.lower()
+        super().__init__("PolyPauli", num_state_qubits + 1, [], label=label)
+
+    def _define(self):
+        circuit = QuantumCircuit(self.num_qubits)
+        qr_state = circuit.qubits[: self.num_qubits - 1]
+        qr_target = circuit.qubits[-1]
 
         rotation_coeffs = self._get_rotation_coefficients()
 
@@ -332,4 +348,42 @@ class PolynomialPauliRotations(FunctionalPauliRotations):
                 else:
                     circuit.crz(rotation_coeffs[c], qr_control[0], qr_target)
 
-        self.append(circuit.to_gate(), self.qubits)
+        self.definition = circuit
+
+    def _get_rotation_coefficients(self) -> dict[tuple[int, ...], float]:
+        """Compute the coefficient of each monomial.
+
+        Returns:
+            A dictionary with pairs ``{control_state: rotation angle}`` where ``control_state``
+            is a tuple of ``0`` or ``1`` bits.
+        """
+        # determine the control states
+        num_state_qubits = self.num_qubits - 1
+        degree = len(self.coeffs) - 1
+        all_combinations = list(product([0, 1], repeat=num_state_qubits))
+        valid_combinations = []
+        for combination in all_combinations:
+            if 0 < sum(combination) <= degree:
+                valid_combinations += [combination]
+
+        rotation_coeffs = {control_state: 0.0 for control_state in valid_combinations}
+
+        # compute the coefficients for the control states
+        for i, coeff in enumerate(self.coeffs[1:]):
+            i += 1  # since we skip the first element we need to increase i by one
+
+            # iterate over the multinomial coefficients
+            for comb, num_combs in _multinomial_coefficients(num_state_qubits, i).items():
+                control_state: tuple[int, ...] = ()
+                power = 1
+                for j, qubit in enumerate(comb):
+                    if qubit > 0:  # means we control on qubit i
+                        control_state += (1,)
+                        power *= 2 ** (j * qubit)
+                    else:
+                        control_state += (0,)
+
+                # Add angle
+                rotation_coeffs[control_state] += coeff * num_combs * power
+
+        return rotation_coeffs

qiskit/circuit/library/arithmetic/quadratic_form.py

@@ -12,13 +12,18 @@
 
 """A circuit implementing a quadratic form on binary variables."""
 
+from __future__ import annotations
+
 from typing import Union, Optional, List
 import math
+from collections.abc import Sequence
 
 import numpy as np
 
-from qiskit.circuit import QuantumCircuit, QuantumRegister, ParameterExpression
-from ..basis_change import QFT
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ParameterExpression, Gate, CircuitError
+from ..basis_change import QFT, QFTGate
+
+_ValueType = Union[int, float, np.integer, np.floating, ParameterExpression]
 
 
 class QuadraticForm(QuantumCircuit):
@@ -171,6 +176,101 @@ class QuadraticForm(QuantumCircuit):
     ) -> int:
         """Get the number of required result qubits.
 
+        Args:
+            quadratic: A matrix containing the quadratic coefficients.
+            linear: An array containing the linear coefficients.
+            offset: A constant offset.
+
+        Returns:
+            The number of qubits needed to represent the value of the quadratic form
+            in twos complement.
+        """
+        return QuadraticFormGate.required_result_qubits(quadratic, linear, offset)
+
+
+class QuadraticFormGate(Gate):
+    r"""Implements a quadratic form on binary variables encoded in qubit registers.
+
+    A quadratic form on binary variables is a quadratic function :math:`Q` acting on a binary
+    variable of :math:`n` bits, :math:`x = x_0 ... x_{n-1}`. For an integer matrix :math:`A`,
+    an integer vector :math:`b` and an integer :math:`c` the function can be written as
+
+    .. math::
+
+        Q(x) = x^T A x + x^T b + c
+
+    If :math:`A`, :math:`b` or :math:`c` contain scalar values, this circuit computes only
+    an approximation of the quadratic form.
+
+    Provided with :math:`m` qubits to encode the value, this circuit computes :math:`Q(x) \mod 2^m`
+    in [two's complement](https://stackoverflow.com/questions/1049722/what-is-2s-complement)
+    representation.
+
+    .. math::
+
+        |x\rangle_n |0\rangle_m \mapsto |x\rangle_n |(Q(x) + 2^m) \mod 2^m \rangle_m
+
+    Since we use two's complement e.g. the value of :math:`Q(x) = 3` requires 2 bits to represent
+    the value and 1 bit for the sign: `3 = '011'` where the first `0` indicates a positive value.
+    On the other hand, :math:`Q(x) = -3` would be `-3 = '101'`, where the first `1` indicates
+    a negative value and `01` is the two's complement of `3`.
+
+    If the value of :math:`Q(x)` is too large to be represented with `m` qubits, the resulting
+    bitstring is :math:`(Q(x) + 2^m) \mod 2^m)`.
+
+    The implementation of this circuit is discussed in [1], Fig. 6.
+
+    References:
+        [1]: Gilliam et al., Grover Adaptive Search for Constrained Polynomial Binary Optimization.
+             `arXiv:1912.04088 <https://arxiv.org/pdf/1912.04088.pdf>`_
+
+    """
+
+    def __init__(
+        self,
+        num_result_qubits: int | None = None,
+        quadratic: Sequence[Sequence[float]] | None = None,
+        linear: Sequence[Sequence[float]] | None = None,
+        offset: float | None = None,
+        label: str = "Q(x)",
+    ):
+        # check inputs match
+        if quadratic is not None and linear is not None:
+            if len(quadratic) != len(linear):
+                raise ValueError("Mismatching sizes of quadratic and linear.")
+
+        # temporarily set quadratic and linear to [] instead of None so we can iterate over them
+        if quadratic is None:
+            quadratic = []
+
+        if linear is None:
+            linear = []
+
+        if offset is None:
+            offset = 0
+
+        self.num_input_qubits = np.max([1, len(linear), len(quadratic)])
+
+        # deduce number of result bits if not added
+        if num_result_qubits is None:
+            num_result_qubits = self.required_result_qubits(quadratic, linear, offset)
+
+        self.num_result_qubits = num_result_qubits
+        self.quadratic = quadratic
+        self.linear = linear
+        self.offset = offset
+
+        num_qubits = int(self.num_input_qubits + self.num_result_qubits)
+        super().__init__("QuadraticForm", num_qubits, [], label=label)
+
+    @staticmethod
+    def required_result_qubits(
+        quadratic: Sequence[Sequence[float]],
+        linear: Sequence[float],
+        offset: float,
+    ) -> int:
+        """Get the number of required result qubits.
+
         Args:
             quadratic: A matrix containing the quadratic coefficients.
             linear: An array containing the linear coefficients.
@@ -196,3 +296,69 @@ class QuadraticForm(QuantumCircuit):
         num_result_qubits = 1 + max(num_qubits_for_min, num_qubits_for_max)
 
         return num_result_qubits
+
+    def validate_parameter(self, parameter):
+        if isinstance(parameter, _ValueType):
+            return parameter
+
+        if isinstance(parameter, (np.ndarray, Sequence)):
+            if all(isinstance(el, _ValueType) for el in parameter):
+                return parameter
+            for params in parameter:
+                if not all(isinstance(el, _ValueType) for el in params):
+                    raise CircuitError(
+                        f"Invalid parameter type {type(parameter)} for QuadraticFormGate"
+                    )
+
+            return parameter
+
+        return super().validate_parameter(parameter)
+
+    def _define(self):
+        quadratic, linear, offset = self.quadratic, self.linear, self.offset
+
+        qr_input = QuantumRegister(self.num_input_qubits)
+        qr_result = QuantumRegister(self.num_result_qubits)
+        circuit = QuantumCircuit(qr_input, qr_result)
+
+        # set quadratic and linear again to None if they were None
+        if len(quadratic) == 0:
+            quadratic = None
+
+        if len(linear) == 0:
+            linear = None
+
+        scaling = np.pi * 2 ** (1 - self.num_result_qubits)
+
+        # initial QFT
+        qft = QFTGate(self.num_result_qubits)
+        circuit.append(qft, qr_result)
+
+        # constant coefficient
+        if offset != 0:
+            for i, q_i in enumerate(qr_result):
+                circuit.p(scaling * 2**i * offset, q_i)
+
+        # the linear part consists of the vector and the diagonal of the
+        # matrix, since x_i * x_i = x_i, as x_i is a binary variable
+        for j in range(self.num_input_qubits):
+            value = linear[j] if linear is not None else 0
+            value += quadratic[j][j] if quadratic is not None else 0
+            if value != 0:
+                for i, q_i in enumerate(qr_result):
+                    circuit.cp(scaling * 2**i * value, qr_input[j], q_i)
+
+        # the quadratic part adds A_ij and A_ji as x_i x_j == x_j x_i
+        if quadratic is not None:
+            for j in range(self.num_input_qubits):
+                for k in range(j + 1, self.num_input_qubits):
+                    value = quadratic[j][k] + quadratic[k][j]
+                    if value != 0:
+                        for i, q_i in enumerate(qr_result):
+                            circuit.mcp(scaling * 2**i * value, [qr_input[j], qr_input[k]], q_i)
+
+        # add the inverse QFT
+        iqft = qft.inverse()
+        circuit.append(iqft, qr_result)
+
+        self.definition = circuit

qiskit/circuit/library/arithmetic/weighted_adder.py

@@ -12,10 +12,12 @@
 
 """Compute the weighted sum of qubit states."""
 
+from __future__ import annotations
+
 from typing import List, Optional
 import numpy as np
 
-from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit
+from qiskit.circuit import QuantumRegister, AncillaRegister, QuantumCircuit, Gate
 
 from ..blueprintcircuit import BlueprintCircuit
 
@@ -335,3 +337,73 @@ class WeightedAdder(BlueprintCircuit):
                         circuit.x(qr_sum[j])
 
         self.append(circuit.to_gate(), self.qubits)
+
+
+class WeightedSumGate(Gate):
+    r"""A gate to compute the weighted sum of qubit registers.
+
+    Given :math:`n` qubit basis states :math:`q_0, \ldots, q_{n-1} \in \{0, 1\}` and non-negative
+    integer weights :math:`\lambda_0, \ldots, \lambda_{n-1}`, this implements the operation
+
+    .. math::
+
+        |q_0 \ldots q_{n-1}\rangle |0\rangle_s
+        \mapsto |q_0 \ldots q_{n-1}\rangle |\sum_{j=0}^{n-1} \lambda_j q_j\rangle_s
+
+    where :math:`s` is the number of sum qubits required.
+    This can be computed as
+
+    .. math::
+
+        s = 1 + \left\lfloor \log_2\left( \sum_{j=0}^{n-1} \lambda_j \right) \right\rfloor
+
+    or :math:`s = 1` if the sum of the weights is 0 (then the expression in the logarithm is
+    invalid).
+
+    For qubits in a circuit diagram, the first weight applies to the upper-most qubit.
+    For an example where the state of 4 qubits is added into a sum register, the circuit can
+    be schematically drawn as
+
+    .. code-block:: text
+
+                   ┌──────────────┐
+          state_0: ┤0             ├ | state_0 * weights[0]
+                   │              │ |
+          state_1: ┤1             ├ | + state_1 * weights[1]
+                   │              │ |
+          state_2: ┤2             ├ | + state_2 * weights[2]
+                   │              │ |
+          state_3: ┤3 WeightedSum ├ | + state_3 * weights[3]
+                   │              │
+            sum_0: ┤4             ├ |
+                   │              │ |
+            sum_1: ┤5             ├ | = sum_0 * 2^0 + sum_1 * 2^1 + sum_2 * 2^2
+                   │              │ |
+            sum_2: ┤6             ├ |
+                   └──────────────┘
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        weights: list[int] | None = None,
+        label: str | None = None,
+    ) -> None:
+        """
+        Args:
+            num_state_qubits: The number of state qubits.
+            weights: List of weights, one for each state qubit. If none are provided they
+                default to 1 for every qubit.
+            label: The name of the circuit.
+        """
+        if weights is None:
+            weights = [1] * num_state_qubits
+
+        self.num_state_qubits = num_state_qubits
+
+        if sum(weights) > 0:
+            self.num_sum_qubits = int(np.floor(np.log2(sum(weights))) + 1)
+        else:
+            self.num_sum_qubits = 1
+
+        super().__init__("WeightedSum", self.num_state_qubits + self.num_sum_qubits, weights, label)

qiskit/circuit/library/bit_flip_oracle.py

@@ -0,0 +1,130 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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.
+
+"""Bit-flip Oracle object."""
+
+from __future__ import annotations
+
+from qiskit.circuit import Gate
+
+from qiskit.synthesis.boolean.boolean_expression import BooleanExpression
+
+
+class BitFlipOracleGate(Gate):
+    r"""Implements a bit-flip oracle
+
+    The Bit-flip Oracle Gate object constructs circuits for any arbitrary
+    input logical expressions. A logical expression is composed of logical operators
+    `&` (logical `AND`), `|` (logical  `OR`),
+    `~` (logical  `NOT`), and `^` (logical  `XOR`).
+    as well as symbols for literals (variables).
+    For example, `'a & b'`, and `(v0 | ~v1) & (~v2 & v3)`
+    are both valid string representation of boolean logical expressions.
+
+    A bit-flip oracle for a boolean function `f(x)` performs the following
+    quantum operation:
+
+    .. math::
+
+            |x\rangle|y\rangle \mapsto |x\rangle|f(x)\oplus y\rangle
+
+    For convenience, this oracle, in addition to parsing arbitrary logical expressions,
+    also supports input strings in the `DIMACS CNF format
+    <https://web.archive.org/web/20190325181937/https://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+    which is the standard format for specifying SATisfiability (SAT) problem instances in
+    `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
+    which is a conjunction of one or more clauses, where a clause is a disjunction of one
+    or more literals.
+    See :meth:`qiskit.circuit.library.bit_flip_oracle.BitFlipOracleGate.from_dimacs_file`.
+
+    From 16 variables on, possible performance issues should be expected when using the
+    default synthesizer.
+    """
+
+    def __init__(
+        self,
+        expression: str,
+        var_order: list[str] | None = None,
+        label: str | None = None,
+    ) -> None:
+        """
+        Args:
+            expression: A Python-like boolean expression.
+            var_order: A list with the order in which variables will be created.
+               (default: by appearance)
+            label: A label for the gate to display in visualizations. Per default, the label is
+                set to display the textual represntation of the boolean expression (truncated if needed)
+        """
+        self.boolean_expression = BooleanExpression(expression, var_order=var_order)
+
+        if label is None:
+            short_expr_for_name = (expression[:15] + "...") if len(expression) > 15 else expression
+            label = short_expr_for_name
+
+        super().__init__(
+            name="Bit-flip Oracle",
+            num_qubits=self.boolean_expression.num_bits + 1,
+            params=[],
+            label=label,
+        )
+
+    def _define(self):
+        """Defined by the synthesized bit-flip oracle"""
+        self.definition = self.boolean_expression.synth(circuit_type="bit")
+
+    @classmethod
+    def from_dimacs_file(cls, filename: str) -> BitFlipOracleGate:
+        r"""Create a BitFlipOracleGate from the string in the DIMACS format.
+
+        It is possible to build a BitFlipOracleGate from a file in `DIMACS CNF format
+        <https://web.archive.org/web/20190325181937/https://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+        which is the standard format for specifying SATisfiability (SAT) problem instances in
+        `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
+        which is a conjunction of one or more clauses, where a clause is a disjunction of one
+        or more literals.
+
+        The following is an example of a CNF expressed in the DIMACS format:
+
+        .. code:: text
+
+          c DIMACS CNF file with 3 satisfying assignments: 1 -2 3, -1 -2 -3, 1 2 -3.
+          p cnf 3 5
+          -1 -2 -3 0
+          1 -2 3 0
+          1 2 -3 0
+          1 -2 -3 0
+          -1 2 3 0
+
+        The first line, following the `c` character, is a comment. The second line specifies that
+        the CNF is over three boolean variables --- let us call them  :math:`x_1, x_2, x_3`, and
+        contains five clauses.  The five clauses, listed afterwards, are implicitly joined by the
+        logical `AND` operator, :math:`\land`, while the variables in each clause, represented by
+        their indices, are implicitly disjoined by the logical `OR` operator, :math:`\lor`. The
+        :math:`-` symbol preceding a boolean variable index corresponds to the logical `NOT`
+        operator, :math:`\lnot`. Character `0` (zero) marks the end of each clause.  Essentially,
+        the code above corresponds to the following CNF:
+
+        :math:`(\lnot x_1 \lor \lnot x_2 \lor \lnot x_3)
+        \land (x_1 \lor \lnot x_2 \lor x_3)
+        \land (x_1 \lor x_2 \lor \lnot x_3)
+        \land (x_1 \lor \lnot x_2 \lor \lnot x_3)
+        \land (\lnot x_1 \lor x_2 \lor x_3)`.
+
+
+        Args:
+            filename: A file in DIMACS format.
+
+        Returns:
+            BitFlipOracleGate: A quantum gate with a bit-flip oracle.
+        """
+        expr = BooleanExpression.from_dimacs_file(filename)
+        return cls(expr)

qiskit/circuit/library/blueprintcircuit.py

@@ -14,10 +14,12 @@
 
 from __future__ import annotations
 from abc import ABC, abstractmethod
+import copy as _copy
 
 from qiskit._accelerate.circuit import CircuitData
-from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.circuit import QuantumRegister, ClassicalRegister
 from qiskit.circuit.parametertable import ParameterView
+from qiskit.circuit.quantumcircuit import QuantumCircuit, _copy_metadata
 
 
 class BlueprintCircuit(QuantumCircuit, ABC):
@@ -37,7 +39,6 @@ class BlueprintCircuit(QuantumCircuit, ABC):
         super().__init__(*regs, name=name)
         self._qregs: list[QuantumRegister] = []
         self._cregs: list[ClassicalRegister] = []
-        self._qubit_indices = {}
         self._is_built = False
         self._is_initialized = True
 
@@ -67,14 +68,24 @@ class BlueprintCircuit(QuantumCircuit, ABC):
 
     def _invalidate(self) -> None:
         """Invalidate the current circuit build."""
+        # Take out the registers before invalidating
+        qregs = self._data.qregs
+        cregs = self._data.cregs
         self._data = CircuitData(self._data.qubits, self._data.clbits)
+        # Re-add the registers
+        for qreg in qregs:
+            self._data.add_qreg(qreg)
+        for creg in cregs:
+            self._data.add_creg(creg)
         self.global_phase = 0
         self._is_built = False
 
     @property
     def qregs(self):
         """A list of the quantum registers associated with the circuit."""
-        return self._qregs
+        if not self._is_initialized:
+            return self._qregs
+        return super().qregs
 
     @qregs.setter
     def qregs(self, qregs):
@@ -85,7 +96,6 @@ class BlueprintCircuit(QuantumCircuit, ABC):
             return
         self._qregs = []
         self._ancillas = []
-        self._qubit_indices = {}
         self._data = CircuitData(clbits=self._data.clbits)
         self.global_phase = 0
         self._is_built = False
@@ -262,19 +272,45 @@ class BlueprintCircuit(QuantumCircuit, ABC):
             self._build()
         return super().num_connected_components(unitary_only=unitary_only)
 
-    def copy_empty_like(self, name=None, *, vars_mode="alike"):
-        if not self._is_built:
-            self._build()
-        cpy = super().copy_empty_like(name=name, vars_mode=vars_mode)
-        # The base `copy_empty_like` will typically trigger code that `BlueprintCircuit` treats as
-        # an "invalidation", so we have to manually restore properties deleted by that that
-        # `copy_empty_like` is supposed to propagate.
-        cpy.global_phase = self.global_phase
+    def copy_empty_like(
+        self, name: str | None = None, *, vars_mode: str = "alike"
+    ) -> QuantumCircuit:
+        """Return an empty :class:`.QuantumCircuit` of same size and metadata.
+
+        See also :meth:`.QuantumCircuit.copy_empty_like` for more details on copied metadata.
+
+        Args:
+            name: Name for the copied circuit. If None, then the name stays the same.
+            vars_mode: The mode to handle realtime variables in.
+
+        Returns:
+            An empty circuit of same dimensions. Note that the result is no longer a
+            :class:`.BlueprintCircuit`.
+        """
+
+        cpy = QuantumCircuit(*self.qregs, *self.cregs, name=name, global_phase=self.global_phase)
+        _copy_metadata(self, cpy, vars_mode)
         return cpy
 
-    def copy(self, name=None):
+    def copy(self, name: str | None = None) -> BlueprintCircuit:
+        """Copy the blueprint circuit.
+
+        Args:
+            name: Name to be given to the copied circuit. If None, then the name stays the same.
+
+        Returns:
+            A deepcopy of the current blueprint circuit, with the specified name.
+        """
         if not self._is_built:
             self._build()
-        circuit_copy = super().copy(name=name)
-        circuit_copy._is_built = self._is_built
-        return circuit_copy
+
+        cpy = _copy.copy(self)
+        _copy_metadata(self, cpy, "alike")
+
+        cpy._is_built = self._is_built
+        cpy._data = self._data.copy()
+
+        if name is not None:
+            cpy.name = name
+
+        return cpy