qiskit 1.0.2__cp38-abi3-win32.whl → 1.1.0__cp38-abi3-win32.whl

qiskit/qpy/type_keys.py

@@ -16,6 +16,7 @@
 QPY Type keys for several namespace.
 """
 
+import uuid
 from abc import abstractmethod
 from enum import Enum, IntEnum
 
@@ -456,6 +457,7 @@ class Expression(TypeKeyBase):
     CAST = b"c"
     UNARY = b"u"
     BINARY = b"b"
+    INDEX = b"i"
 
     @classmethod
     def assign(cls, obj):
@@ -471,6 +473,22 @@ class Expression(TypeKeyBase):
         raise NotImplementedError
 
 
+class ExprVarDeclaration(TypeKeyBase):
+    """Type keys for the ``EXPR_VAR_DECLARATION`` QPY item."""
+
+    INPUT = b"I"
+    CAPTURE = b"C"
+    LOCAL = b"L"
+
+    @classmethod
+    def assign(cls, obj):
+        raise NotImplementedError
+
+    @classmethod
+    def retrieve(cls, type_key):
+        raise NotImplementedError
+
+
 class ExprType(TypeKeyBase):
     """Type keys for the ``EXPR_TYPE`` QPY item."""
 
@@ -496,9 +514,12 @@ class ExprVar(TypeKeyBase):
 
     CLBIT = b"C"
     REGISTER = b"R"
+    UUID = b"U"
 
     @classmethod
     def assign(cls, obj):
+        if isinstance(obj, uuid.UUID):
+            return cls.UUID
         if isinstance(obj, Clbit):
             return cls.CLBIT
         if isinstance(obj, ClassicalRegister):

qiskit/quantum_info/analysis/distance.py

@@ -12,7 +12,7 @@
 
 """A collection of discrete probability metrics."""
 from __future__ import annotations
-import numpy as np
+import math
 
 
 def hellinger_distance(dist_p: dict, dist_q: dict) -> float:
@@ -43,13 +43,13 @@ def hellinger_distance(dist_p: dict, dist_q: dict) -> float:
     total = 0
     for key, val in p_normed.items():
         if key in q_normed:
-            total += (np.sqrt(val) - np.sqrt(q_normed[key])) ** 2
+            total += (math.sqrt(val) - math.sqrt(q_normed[key])) ** 2
             del q_normed[key]
         else:
             total += val
     total += sum(q_normed.values())
 
-    dist = np.sqrt(total) / np.sqrt(2)
+    dist = math.sqrt(total) / math.sqrt(2)
 
     return dist
 

qiskit/quantum_info/analysis/make_observable.py

@@ -13,6 +13,7 @@
 """Helper functions for building dictionaries from matrices and lists."""
 
 from __future__ import annotations
+import math
 import numpy as np
 
 
@@ -33,7 +34,7 @@ def make_dict_observable(matrix_observable: list | np.ndarray) -> dict:
     dict_observable = {}
     observable = np.array(matrix_observable)
     observable_size = len(observable)
-    observable_bits = int(np.ceil(np.log2(observable_size)))
+    observable_bits = math.ceil(math.log2(observable_size))
     binary_formatter = f"0{observable_bits}b"
     if observable.ndim == 2:
         observable = observable.diagonal()

qiskit/quantum_info/analysis/z2_symmetries.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import itertools
 from collections.abc import Iterable
 from copy import deepcopy
+import math
 from typing import Union, cast
 
 import numpy as np
@@ -121,7 +122,7 @@ class Z2Symmetries:
             A list of unitaries used to diagonalize the Hamiltonian.
         """
         cliffords = [
-            (SparsePauliOp(pauli_symm) + SparsePauliOp(sq_pauli)) / np.sqrt(2)
+            (SparsePauliOp(pauli_symm) + SparsePauliOp(sq_pauli)) / math.sqrt(2)
             for pauli_symm, sq_pauli in zip(self._symmetries, self._sq_paulis)
         ]
         return cliffords

qiskit/quantum_info/operators/channel/chi.py

@@ -16,9 +16,11 @@ Chi-matrix representation of a Quantum Channel.
 """
 
 from __future__ import annotations
-import copy
+import copy as _copy
+import math
 import numpy as np
 
+from qiskit import _numpy_compat
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.instruction import Instruction
 from qiskit.exceptions import QiskitError
@@ -96,7 +98,7 @@ class Chi(QuantumChannel):
             if output_dims:
                 output_dim = np.prod(input_dims)
             if output_dims is None and input_dims is None:
-                output_dim = int(np.sqrt(dim_l))
+                output_dim = int(math.sqrt(dim_l))
                 input_dim = dim_l // output_dim
             elif input_dims is None:
                 input_dim = dim_l // output_dim
@@ -125,15 +127,14 @@ class Chi(QuantumChannel):
             if output_dims is None:
                 output_dims = data.output_dims()
         # Check input is N-qubit channel
-        num_qubits = int(np.log2(input_dim))
+        num_qubits = int(math.log2(input_dim))
         if 2**num_qubits != input_dim or input_dim != output_dim:
             raise QiskitError("Input is not an n-qubit Chi matrix.")
         super().__init__(chi_mat, num_qubits=num_qubits)
 
-    def __array__(self, dtype=None):
-        if dtype:
-            return np.asarray(self.data, dtype=dtype)
-        return self.data
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        dtype = self.data.dtype
+        return np.array(self.data, dtype=dtype, copy=copy)
 
     @property
     def _bipartite_shape(self):
@@ -180,7 +181,7 @@ class Chi(QuantumChannel):
 
     @classmethod
     def _tensor(cls, a, b):
-        ret = copy.copy(a)
+        ret = _copy.copy(a)
         ret._op_shape = a._op_shape.tensor(b._op_shape)
         ret._data = np.kron(a._data, b.data)
         return ret

qiskit/quantum_info/operators/channel/choi.py

@@ -16,9 +16,11 @@ Choi-matrix representation of a Quantum Channel.
 """
 
 from __future__ import annotations
-import copy
+import copy as _copy
+import math
 import numpy as np
 
+from qiskit import _numpy_compat
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.instruction import Instruction
 from qiskit.exceptions import QiskitError
@@ -103,7 +105,7 @@ class Choi(QuantumChannel):
             if output_dims:
                 output_dim = np.prod(output_dims)
             if output_dims is None and input_dims is None:
-                output_dim = int(np.sqrt(dim_l))
+                output_dim = int(math.sqrt(dim_l))
                 input_dim = dim_l // output_dim
             elif input_dims is None:
                 input_dim = dim_l // output_dim
@@ -133,10 +135,9 @@ class Choi(QuantumChannel):
             choi_mat = _to_choi(rep, data._data, input_dim, output_dim)
         super().__init__(choi_mat, op_shape=op_shape)
 
-    def __array__(self, dtype=None):
-        if dtype:
-            return np.asarray(self.data, dtype=dtype)
-        return self.data
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        dtype = self.data.dtype if dtype is None else dtype
+        return np.array(self.data, dtype=dtype, copy=copy)
 
     @property
     def _bipartite_shape(self):
@@ -151,12 +152,12 @@ class Choi(QuantumChannel):
     # ---------------------------------------------------------------------
 
     def conjugate(self):
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.conj(self._data)
         return ret
 
     def transpose(self):
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._op_shape = self._op_shape.transpose()
         # Make bipartite matrix
         d_in, d_out = self.dim
@@ -205,7 +206,7 @@ class Choi(QuantumChannel):
 
     @classmethod
     def _tensor(cls, a, b):
-        ret = copy.copy(a)
+        ret = _copy.copy(a)
         ret._op_shape = a._op_shape.tensor(b._op_shape)
         ret._data = _bipartite_tensor(
             a._data, b.data, shape1=a._bipartite_shape, shape2=b._bipartite_shape

qiskit/quantum_info/operators/channel/kraus.py

@@ -16,6 +16,7 @@ Kraus representation of a Quantum Channel.
 
 from __future__ import annotations
 import copy
+import math
 from numbers import Number
 import numpy as np
 
@@ -315,7 +316,7 @@ class Kraus(QuantumChannel):
             return ret
         # If the number is real we can update the Kraus operators
         # directly
-        val = np.sqrt(other)
+        val = math.sqrt(other)
         kraus_r = None
         kraus_l = [val * k for k in self._data[0]]
         if self._data[1] is not None:

qiskit/quantum_info/operators/channel/ptm.py

@@ -16,9 +16,11 @@ Pauli Transfer Matrix (PTM) representation of a Quantum Channel.
 """
 
 from __future__ import annotations
-import copy
+import copy as _copy
+import math
 import numpy as np
 
+from qiskit import _numpy_compat
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.instruction import Instruction
 from qiskit.exceptions import QiskitError
@@ -100,11 +102,11 @@ class PTM(QuantumChannel):
             if input_dims:
                 input_dim = np.prod(input_dims)
             else:
-                input_dim = int(np.sqrt(din))
+                input_dim = int(math.sqrt(din))
             if output_dims:
                 output_dim = np.prod(input_dims)
             else:
-                output_dim = int(np.sqrt(dout))
+                output_dim = int(math.sqrt(dout))
             if output_dim**2 != dout or input_dim**2 != din or input_dim != output_dim:
                 raise QiskitError("Invalid shape for PTM matrix.")
         else:
@@ -127,15 +129,14 @@ class PTM(QuantumChannel):
             if output_dims is None:
                 output_dims = data.output_dims()
         # Check input is N-qubit channel
-        num_qubits = int(np.log2(input_dim))
+        num_qubits = int(math.log2(input_dim))
         if 2**num_qubits != input_dim or input_dim != output_dim:
             raise QiskitError("Input is not an n-qubit Pauli transfer matrix.")
         super().__init__(ptm, num_qubits=num_qubits)
 
-    def __array__(self, dtype=None):
-        if dtype:
-            np.asarray(self.data, dtype=dtype)
-        return self.data
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        dtype = self.data.dtype if dtype is None else dtype
+        return np.array(self.data, dtype=dtype, copy=copy)
 
     @property
     def _bipartite_shape(self):
@@ -193,7 +194,7 @@ class PTM(QuantumChannel):
 
     @classmethod
     def _tensor(cls, a, b):
-        ret = copy.copy(a)
+        ret = _copy.copy(a)
         ret._op_shape = a._op_shape.tensor(b._op_shape)
         ret._data = np.kron(a._data, b.data)
         return ret

qiskit/quantum_info/operators/channel/quantum_channel.py

@@ -16,6 +16,7 @@ Abstract base class for Quantum Channels.
 
 from __future__ import annotations
 import copy
+import math
 import sys
 from abc import abstractmethod
 from numbers import Number, Integral
@@ -249,7 +250,7 @@ class QuantumChannel(LinearOp):
         """
 
         # Check if input is an N-qubit CPTP channel.
-        num_qubits = int(np.log2(self._input_dim))
+        num_qubits = int(math.log2(self._input_dim))
         if self._input_dim != self._output_dim or 2**num_qubits != self._input_dim:
             raise QiskitError(
                 "Cannot convert QuantumChannel to Instruction: channel is not an N-qubit channel."

qiskit/quantum_info/operators/channel/stinespring.py

@@ -15,6 +15,7 @@ Stinespring representation of a Quantum Channel.
 
 from __future__ import annotations
 import copy
+import math
 from numbers import Number
 import numpy as np
 
@@ -281,7 +282,7 @@ class Stinespring(QuantumChannel):
             return ret
         # If the number is real we can update the Kraus operators
         # directly
-        num = np.sqrt(other)
+        num = math.sqrt(other)
         stine_l, stine_r = self._data
         stine_l = num * self._data[0]
         stine_r = None

qiskit/quantum_info/operators/channel/superop.py

@@ -15,11 +15,13 @@ Superoperator representation of a Quantum Channel."""
 
 from __future__ import annotations
 
-import copy
+import copy as _copy
+import math
 from typing import TYPE_CHECKING
 
 import numpy as np
 
+from qiskit import _numpy_compat
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.exceptions import QiskitError
@@ -94,8 +96,8 @@ class SuperOp(QuantumChannel):
             super_mat = np.asarray(data, dtype=complex)
             # Determine total input and output dimensions
             dout, din = super_mat.shape
-            input_dim = int(np.sqrt(din))
-            output_dim = int(np.sqrt(dout))
+            input_dim = int(math.sqrt(din))
+            output_dim = int(math.sqrt(dout))
             if output_dim**2 != dout or input_dim**2 != din:
                 raise QiskitError("Invalid shape for SuperOp matrix.")
             op_shape = OpShape.auto(
@@ -126,10 +128,9 @@ class SuperOp(QuantumChannel):
         # Initialize QuantumChannel
         super().__init__(super_mat, op_shape=op_shape)
 
-    def __array__(self, dtype=None):
-        if dtype:
-            return np.asarray(self.data, dtype=dtype)
-        return self.data
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        dtype = self.data.dtype if dtype is None else dtype
+        return np.array(self.data, dtype=dtype, copy=copy)
 
     @property
     def _tensor_shape(self):
@@ -148,18 +149,18 @@ class SuperOp(QuantumChannel):
     # ---------------------------------------------------------------------
 
     def conjugate(self):
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.conj(self._data)
         return ret
 
     def transpose(self):
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.transpose(self._data)
         ret._op_shape = self._op_shape.transpose()
         return ret
 
     def adjoint(self):
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.conj(np.transpose(self._data))
         ret._op_shape = self._op_shape.transpose()
         return ret
@@ -176,7 +177,7 @@ class SuperOp(QuantumChannel):
 
     @classmethod
     def _tensor(cls, a, b):
-        ret = copy.copy(a)
+        ret = _copy.copy(a)
         ret._op_shape = a._op_shape.tensor(b._op_shape)
         ret._data = _bipartite_tensor(
             a._data, b.data, shape1=a._bipartite_shape, shape2=b._bipartite_shape

qiskit/quantum_info/operators/channel/transformations.py

@@ -18,6 +18,7 @@ Transformations between QuantumChannel representations.
 """
 
 from __future__ import annotations
+import math
 import numpy as np
 
 from qiskit.exceptions import QiskitError
@@ -328,25 +329,25 @@ def _kraus_to_superop(data):
 
 def _chi_to_choi(data, input_dim):
     """Transform Chi representation to a Choi representation."""
-    num_qubits = int(np.log2(input_dim))
+    num_qubits = int(math.log2(input_dim))
     return _transform_from_pauli(data, num_qubits)
 
 
 def _choi_to_chi(data, input_dim):
     """Transform Choi representation to the Chi representation."""
-    num_qubits = int(np.log2(input_dim))
+    num_qubits = int(math.log2(input_dim))
     return _transform_to_pauli(data, num_qubits)
 
 
 def _ptm_to_superop(data, input_dim):
     """Transform PTM representation to SuperOp representation."""
-    num_qubits = int(np.log2(input_dim))
+    num_qubits = int(math.log2(input_dim))
     return _transform_from_pauli(data, num_qubits)
 
 
 def _superop_to_ptm(data, input_dim):
     """Transform SuperOp representation to PTM representation."""
-    num_qubits = int(np.log2(input_dim))
+    num_qubits = int(math.log2(input_dim))
     return _transform_to_pauli(data, num_qubits)
 
 
@@ -375,12 +376,12 @@ def _bipartite_tensor(mat1, mat2, shape1=None, shape2=None):
     dim_a0, dim_a1 = mat1.shape
     dim_b0, dim_b1 = mat2.shape
     if shape1 is None:
-        sdim_a0 = int(np.sqrt(dim_a0))
-        sdim_a1 = int(np.sqrt(dim_a1))
+        sdim_a0 = int(math.sqrt(dim_a0))
+        sdim_a1 = int(math.sqrt(dim_a1))
         shape1 = (sdim_a0, sdim_a0, sdim_a1, sdim_a1)
     if shape2 is None:
-        sdim_b0 = int(np.sqrt(dim_b0))
-        sdim_b1 = int(np.sqrt(dim_b1))
+        sdim_b0 = int(math.sqrt(dim_b0))
+        sdim_b1 = int(math.sqrt(dim_b1))
         shape2 = (sdim_b0, sdim_b0, sdim_b1, sdim_b1)
     # Check dimensions
     if len(shape1) != 4 or shape1[0] * shape1[1] != dim_a0 or shape1[2] * shape1[3] != dim_a1:
@@ -416,7 +417,7 @@ def _transform_to_pauli(data, num_qubits):
     # to avoid rounding errors from square-roots of 2.
     cob = basis_mat
     for _ in range(num_qubits - 1):
-        dim = int(np.sqrt(len(cob)))
+        dim = int(math.sqrt(len(cob)))
         cob = np.reshape(
             np.transpose(
                 np.reshape(np.kron(basis_mat, cob), (4, dim * dim, 2, 2, dim, dim)),
@@ -437,7 +438,7 @@ def _transform_from_pauli(data, num_qubits):
     # to avoid rounding errors from square-roots of 2.
     cob = basis_mat
     for _ in range(num_qubits - 1):
-        dim = int(np.sqrt(len(cob)))
+        dim = int(math.sqrt(len(cob)))
         cob = np.reshape(
             np.transpose(
                 np.reshape(np.kron(basis_mat, cob), (2, 2, dim, dim, 4, dim * dim)),
@@ -462,6 +463,6 @@ def _check_nqubit_dim(input_dim, output_dim):
         raise QiskitError(
             f"Not an n-qubit channel: input_dim ({input_dim}) != output_dim ({output_dim})"
         )
-    num_qubits = int(np.log2(input_dim))
+    num_qubits = int(math.log2(input_dim))
     if 2**num_qubits != input_dim:
         raise QiskitError("Not an n-qubit channel: input_dim != 2 ** n")

qiskit/quantum_info/operators/dihedral/dihedral.py

@@ -357,10 +357,11 @@ class CNOTDihedral(BaseOperator, AdjointMixin):
         _append_circuit(elem, circuit)
         return elem
 
-    def __array__(self, dtype=None):
-        if dtype:
-            return np.asarray(self.to_matrix(), dtype=dtype)
-        return self.to_matrix()
+    def __array__(self, dtype=None, copy=None):
+        if copy is False:
+            raise ValueError("unable to avoid copy while creating an array as requested")
+        arr = self.to_matrix()
+        return arr if dtype is None else arr.astype(dtype, copy=False)
 
     def to_matrix(self):
         """Convert operator to Numpy matrix."""

qiskit/quantum_info/operators/operator.py

@@ -16,13 +16,14 @@ Matrix Operator class.
 
 from __future__ import annotations
 
-import copy
+import copy as _copy
 import re
 from numbers import Number
 from typing import TYPE_CHECKING
 
 import numpy as np
 
+from qiskit import _numpy_compat
 from qiskit.circuit.instruction import Instruction
 from qiskit.circuit.library.standard_gates import HGate, IGate, SGate, TGate, XGate, YGate, ZGate
 from qiskit.circuit.operation import Operation
@@ -81,6 +82,9 @@ class Operator(LinearOp):
             a Numpy array of shape (2**N, 2**N) qubit systems will be used. If
             the input operator is not an N-qubit operator, it will assign a
             single subsystem with dimension specified by the shape of the input.
+            Note that two operators initialized via this method are only considered equivalent if they
+            match up to their canonical qubit order (or: permutation). See :meth:`.Operator.from_circuit`
+            to specify a different qubit permutation.
         """
         op_shape = None
         if isinstance(data, (list, np.ndarray)):
@@ -117,10 +121,9 @@ class Operator(LinearOp):
             shape=self._data.shape,
         )
 
-    def __array__(self, dtype=None):
-        if dtype:
-            return np.asarray(self.data, dtype=dtype)
-        return self.data
+    def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
+        dtype = self.data.dtype if dtype is None else dtype
+        return np.array(self.data, dtype=dtype, copy=copy)
 
     def __repr__(self):
         prefix = "Operator("
@@ -391,8 +394,7 @@ class Operator(LinearOp):
         Returns:
             Operator: An operator representing the input circuit
         """
-        dimension = 2**circuit.num_qubits
-        op = cls(np.eye(dimension))
+
         if layout is None:
             if not ignore_set_layout:
                 layout = getattr(circuit, "_layout", None)
@@ -403,27 +405,38 @@ class Operator(LinearOp):
                 initial_layout=layout,
                 input_qubit_mapping={qubit: index for index, qubit in enumerate(circuit.qubits)},
             )
+
+        initial_layout = layout.initial_layout if layout is not None else None
+
         if final_layout is None:
             if not ignore_set_layout and layout is not None:
                 final_layout = getattr(layout, "final_layout", None)
 
-        qargs = None
-        # If there was a layout specified (either from the circuit
-        # or via user input) use that to set qargs to permute qubits
-        # based on that layout
-        if layout is not None:
-            physical_to_virtual = layout.initial_layout.get_physical_bits()
-            qargs = [
-                layout.input_qubit_mapping[physical_to_virtual[physical_bit]]
-                for physical_bit in range(len(physical_to_virtual))
-            ]
-        # Convert circuit to an instruction
-        instruction = circuit.to_instruction()
-        op._append_instruction(instruction, qargs=qargs)
-        # If final layout is set permute output indices based on layout
+        from qiskit.synthesis.permutation.permutation_utils import _inverse_pattern
+
+        if initial_layout is not None:
+            input_qubits = [None] * len(layout.input_qubit_mapping)
+            for q, p in layout.input_qubit_mapping.items():
+                input_qubits[p] = q
+
+            initial_permutation = initial_layout.to_permutation(input_qubits)
+            initial_permutation_inverse = _inverse_pattern(initial_permutation)
+
         if final_layout is not None:
-            perm_pattern = [final_layout._v2p[v] for v in circuit.qubits]
-            op = op.apply_permutation(perm_pattern, front=False)
+            final_permutation = final_layout.to_permutation(circuit.qubits)
+            final_permutation_inverse = _inverse_pattern(final_permutation)
+
+        op = Operator(circuit)
+
+        if initial_layout:
+            op = op.apply_permutation(initial_permutation, True)
+
+        if final_layout:
+            op = op.apply_permutation(final_permutation_inverse, False)
+
+        if initial_layout:
+            op = op.apply_permutation(initial_permutation_inverse, False)
+
         return op
 
     def is_unitary(self, atol=None, rtol=None):
@@ -447,13 +460,13 @@ class Operator(LinearOp):
 
     def conjugate(self):
         # Make a shallow copy and update array
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.conj(self._data)
         return ret
 
     def transpose(self):
         # Make a shallow copy and update array
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = np.transpose(self._data)
         ret._op_shape = self._op_shape.transpose()
         return ret
@@ -523,7 +536,7 @@ class Operator(LinearOp):
         """
         if self.input_dims() != self.output_dims():
             raise QiskitError("Can only power with input_dims = output_dims.")
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         if isinstance(n, int):
             ret._data = np.linalg.matrix_power(self.data, n)
         else:
@@ -550,7 +563,7 @@ class Operator(LinearOp):
 
     @classmethod
     def _tensor(cls, a, b):
-        ret = copy.copy(a)
+        ret = _copy.copy(a)
         ret._op_shape = a._op_shape.tensor(b._op_shape)
         ret._data = np.kron(a.data, b.data)
         return ret
@@ -585,7 +598,7 @@ class Operator(LinearOp):
         self._op_shape._validate_add(other._op_shape, qargs)
         other = ScalarOp._pad_with_identity(self, other, qargs)
 
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = self.data + other.data
         return ret
 
@@ -603,7 +616,7 @@ class Operator(LinearOp):
         """
         if not isinstance(other, Number):
             raise QiskitError("other is not a number")
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         ret._data = other * self._data
         return ret
 
@@ -643,7 +656,7 @@ class Operator(LinearOp):
         Returns:
             Operator: the operator with reversed subsystem order.
         """
-        ret = copy.copy(self)
+        ret = _copy.copy(self)
         axes = tuple(range(self._op_shape._num_qargs_l - 1, -1, -1))
         axes = axes + tuple(len(axes) + i for i in axes)
         ret._data = np.reshape(