qiskit 1.1.1__cp38-abi3-macosx_11_0_arm64.whl → 1.2.0__cp38-abi3-macosx_11_0_arm64.whl

qiskit/quantum_info/operators/channel/quantum_channel.py

@@ -66,12 +66,9 @@ class QuantumChannel(LinearOp):
     def __repr__(self):
         prefix = f"{self._channel_rep}("
         pad = len(prefix) * " "
-        return "{}{},\n{}input_dims={}, output_dims={})".format(
-            prefix,
-            np.array2string(np.asarray(self.data), separator=", ", prefix=prefix),
-            pad,
-            self.input_dims(),
-            self.output_dims(),
+        return (
+            f"{prefix}{np.array2string(np.asarray(self.data), separator=', ', prefix=prefix)}"
+            f",\n{pad}input_dims={self.input_dims()}, output_dims={self.output_dims()})"
         )
 
     def __eq__(self, other: Self):

qiskit/quantum_info/operators/channel/superop.py

@@ -355,8 +355,8 @@ class SuperOp(QuantumChannel):
                 raise QiskitError(f"Cannot apply Instruction: {obj.name}")
             if not isinstance(obj.definition, QuantumCircuit):
                 raise QiskitError(
-                    "{} instruction definition is {}; "
-                    "expected QuantumCircuit".format(obj.name, type(obj.definition))
+                    f"{obj.name} instruction definition is {type(obj.definition)}; "
+                    "expected QuantumCircuit"
                 )
             qubit_indices = {bit: idx for idx, bit in enumerate(obj.definition.qubits)}
             for instruction in obj.definition.data:

qiskit/quantum_info/operators/channel/transformations.py

@@ -228,7 +228,7 @@ def _choi_to_kraus(data, input_dim, output_dim, atol=ATOL_DEFAULT):
         # This should be a call to la.eigh, but there is an OpenBlas
         # threading issue that is causing segfaults.
         # Need schur here since la.eig does not
-        # guarentee orthogonality in degenerate subspaces
+        # guarantee orthogonality in degenerate subspaces
         w, v = la.schur(data, output="complex")
         w = w.diagonal().real
         # Check eigenvalues are non-negative

qiskit/quantum_info/operators/dihedral/dihedral.py

@@ -97,7 +97,7 @@ class CNOTDihedral(BaseOperator, AdjointMixin):
             with optimal number of two qubit gates*, `Quantum 4(369), 2020
             <https://quantum-journal.org/papers/q-2020-12-07-369/>`_
          2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta,
-            *Scalable randomised benchmarking of non-Clifford gates*,
+            *Scalable randomized benchmarking of non-Clifford gates*,
             npj Quantum Inf 2, 16012 (2016).
     """
 
@@ -325,7 +325,7 @@ class CNOTDihedral(BaseOperator, AdjointMixin):
                with optimal number of two qubit gates*, `Quantum 4(369), 2020
                <https://quantum-journal.org/papers/q-2020-12-07-369/>`_
             2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta,
-               *Scalable randomised benchmarking of non-Clifford gates*,
+               *Scalable randomized benchmarking of non-Clifford gates*,
                npj Quantum Inf 2, 16012 (2016).
         """
         # pylint: disable=cyclic-import
@@ -452,8 +452,7 @@ class CNOTDihedral(BaseOperator, AdjointMixin):
             new_qubits = [bit_indices[tup] for tup in instruction.qubits]
             if instruction.operation.name == "p":
                 params = 2 * np.pi - instruction.operation.params[0]
-                instruction.operation.params[0] = params
-                new_circ.append(instruction.operation, new_qubits)
+                new_circ.p(params, new_qubits)
             elif instruction.operation.name == "t":
                 instruction.operation.name = "tdg"
                 new_circ.append(instruction.operation, new_qubits)

qiskit/quantum_info/operators/dihedral/dihedral_circuits.py

@@ -92,9 +92,7 @@ def _append_circuit(elem, circuit, qargs=None):
         raise QiskitError(f"Cannot apply Instruction: {gate.name}")
     if not isinstance(gate.definition, QuantumCircuit):
         raise QiskitError(
-            "{} instruction definition is {}; expected QuantumCircuit".format(
-                gate.name, type(gate.definition)
-            )
+            f"{gate.name} instruction definition is {type(gate.definition)}; expected QuantumCircuit"
         )
 
     flat_instr = gate.definition

qiskit/quantum_info/operators/dihedral/random.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2019, 2021.
+# (C) Copyright IBM 2019, 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
@@ -49,9 +49,12 @@ def random_cnotdihedral(num_qubits, seed=None):
 
     # Random affine function
     # Random invertible binary matrix
-    from qiskit.synthesis.linear import random_invertible_binary_matrix
+    from qiskit.synthesis.linear import (  # pylint: disable=cyclic-import
+        random_invertible_binary_matrix,
+    )
 
-    linear = random_invertible_binary_matrix(num_qubits, seed=rng)
+    seed = rng.integers(100000, size=1, dtype=np.uint64)[0]
+    linear = random_invertible_binary_matrix(num_qubits, seed=seed).astype(int, copy=False)
     elem.linear = linear
 
     # Random shift

qiskit/quantum_info/operators/measures.py

@@ -93,7 +93,7 @@ def process_fidelity(
         if channel.dim != target.dim:
             raise QiskitError(
                 "Input quantum channel and target unitary must have the same "
-                "dimensions ({} != {}).".format(channel.dim, target.dim)
+                f"dimensions ({channel.dim} != {target.dim})."
             )
 
     # Validate complete-positivity and trace-preserving
@@ -316,7 +316,7 @@ def diamond_norm(choi: Choi | QuantumChannel, solver: str = "SCS", **kwargs) ->
     iden = sparse.eye(dim_out)
 
     # Watrous uses row-vec convention for his Choi matrix while we use
-    # col-vec. It turns out row-vec convention is requried for CVXPY too
+    # col-vec. It turns out row-vec convention is required for CVXPY too
     # since the cvxpy.kron function must have a constant as its first argument.
     c_r = cvxpy.bmat([[cvxpy.kron(iden, r0_r), x_r], [x_r.T, cvxpy.kron(iden, r1_r)]])
     c_i = cvxpy.bmat([[cvxpy.kron(iden, r0_i), x_i], [-x_i.T, cvxpy.kron(iden, r1_i)]])

qiskit/quantum_info/operators/op_shape.py

@@ -193,7 +193,7 @@ class OpShape:
                 if raise_exception:
                     raise QiskitError(
                         "Output dimensions do not match matrix shape "
-                        "({} != {})".format(reduce(mul, self._dims_l), shape[0])
+                        f"({reduce(mul, self._dims_l)} != {shape[0]})"
                     )
                 return False
         elif shape[0] != 2**self._num_qargs_l:
@@ -207,7 +207,7 @@ class OpShape:
                     if raise_exception:
                         raise QiskitError(
                             "Input dimensions do not match matrix shape "
-                            "({} != {})".format(reduce(mul, self._dims_r), shape[1])
+                            f"({reduce(mul, self._dims_r)} != {shape[1]})"
                         )
                     return False
             elif shape[1] != 2**self._num_qargs_r:
@@ -430,7 +430,7 @@ class OpShape:
                 if self._num_qargs_r != other._num_qargs_l or self._dims_r != other._dims_l:
                     raise QiskitError(
                         "Left and right compose dimensions don't match "
-                        "({} != {})".format(self.dims_r(), other.dims_l())
+                        f"({self.dims_r()} != {other.dims_l()})"
                     )
                 ret._dims_l = self._dims_l
                 ret._dims_r = other._dims_r
@@ -440,7 +440,7 @@ class OpShape:
                 if self._num_qargs_l != other._num_qargs_r or self._dims_l != other._dims_r:
                     raise QiskitError(
                         "Left and right compose dimensions don't match "
-                        "({} != {})".format(self.dims_l(), other.dims_r())
+                        f"({self.dims_l()} != {other.dims_r()})"
                     )
                 ret._dims_l = other._dims_l
                 ret._dims_r = self._dims_r
@@ -453,15 +453,13 @@ class OpShape:
             ret._num_qargs_l = self._num_qargs_l
             if len(qargs) != other._num_qargs_l:
                 raise QiskitError(
-                    "Number of qargs does not match ({} != {})".format(
-                        len(qargs), other._num_qargs_l
-                    )
+                    f"Number of qargs does not match ({len(qargs)} != {other._num_qargs_l})"
                 )
             if self._dims_r or other._dims_r:
                 if self.dims_r(qargs) != other.dims_l():
                     raise QiskitError(
                         "Subsystem dimension do not match on specified qargs "
-                        "{} != {}".format(self.dims_r(qargs), other.dims_l())
+                        f"{self.dims_r(qargs)} != {other.dims_l()}"
                     )
                 dims_r = list(self.dims_r())
                 for i, dim in zip(qargs, other.dims_r()):
@@ -475,15 +473,13 @@ class OpShape:
             ret._num_qargs_r = self._num_qargs_r
             if len(qargs) != other._num_qargs_r:
                 raise QiskitError(
-                    "Number of qargs does not match ({} != {})".format(
-                        len(qargs), other._num_qargs_r
-                    )
+                    f"Number of qargs does not match ({len(qargs)} != {other._num_qargs_r})"
                 )
             if self._dims_l or other._dims_l:
                 if self.dims_l(qargs) != other.dims_r():
                     raise QiskitError(
                         "Subsystem dimension do not match on specified qargs "
-                        "{} != {}".format(self.dims_l(qargs), other.dims_r())
+                        f"{self.dims_l(qargs)} != {other.dims_r()}"
                     )
                 dims_l = list(self.dims_l())
                 for i, dim in zip(qargs, other.dims_l()):
@@ -508,26 +504,22 @@ class OpShape:
             if self.dims_l(qargs) != other.dims_l():
                 raise QiskitError(
                     "Cannot add shapes width different left "
-                    "dimension on specified qargs {} != {}".format(
-                        self.dims_l(qargs), other.dims_l()
-                    )
+                    f"dimension on specified qargs {self.dims_l(qargs)} != {other.dims_l()}"
                 )
             if self.dims_r(qargs) != other.dims_r():
                 raise QiskitError(
                     "Cannot add shapes width different total right "
-                    "dimension on specified qargs{} != {}".format(
-                        self.dims_r(qargs), other.dims_r()
-                    )
+                    f"dimension on specified qargs{self.dims_r(qargs)} != {other.dims_r()}"
                 )
         elif self != other:
             if self._dim_l != other._dim_l:
                 raise QiskitError(
                     "Cannot add shapes width different total left "
-                    "dimension {} != {}".format(self._dim_l, other._dim_l)
+                    f"dimension {self._dim_l} != {other._dim_l}"
                 )
             if self._dim_r != other._dim_r:
                 raise QiskitError(
                     "Cannot add shapes width different total right "
-                    "dimension {} != {}".format(self._dim_r, other._dim_r)
+                    f"dimension {self._dim_r} != {other._dim_r}"
                 )
         return self

qiskit/quantum_info/operators/operator.py

@@ -128,12 +128,9 @@ class Operator(LinearOp):
     def __repr__(self):
         prefix = "Operator("
         pad = len(prefix) * " "
-        return "{}{},\n{}input_dims={}, output_dims={})".format(
-            prefix,
-            np.array2string(self.data, separator=", ", prefix=prefix),
-            pad,
-            self.input_dims(),
-            self.output_dims(),
+        return (
+            f"{prefix}{np.array2string(self.data, separator=', ', prefix=prefix)},\n"
+            f"{pad}input_dims={self.input_dims()}, output_dims={self.output_dims()})"
         )
 
     def __eq__(self, other):
@@ -414,6 +411,8 @@ class Operator(LinearOp):
 
         from qiskit.synthesis.permutation.permutation_utils import _inverse_pattern
 
+        op = Operator(circuit)
+
         if initial_layout is not None:
             input_qubits = [None] * len(layout.input_qubit_mapping)
             for q, p in layout.input_qubit_mapping.items():
@@ -421,22 +420,18 @@ class Operator(LinearOp):
 
             initial_permutation = initial_layout.to_permutation(input_qubits)
             initial_permutation_inverse = _inverse_pattern(initial_permutation)
+            op = op.apply_permutation(initial_permutation, True)
 
-        if final_layout is not None:
+            if final_layout is not None:
+                final_permutation = final_layout.to_permutation(circuit.qubits)
+                final_permutation_inverse = _inverse_pattern(final_permutation)
+                op = op.apply_permutation(final_permutation_inverse, False)
+            op = op.apply_permutation(initial_permutation_inverse, False)
+        elif final_layout is not None:
             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):
@@ -765,10 +760,8 @@ class Operator(LinearOp):
                 raise QiskitError(f"Cannot apply Operation: {obj.name}")
             if not isinstance(obj.definition, QuantumCircuit):
                 raise QiskitError(
-                    'Operation "{}" '
-                    "definition is {} but expected QuantumCircuit.".format(
-                        obj.name, type(obj.definition)
-                    )
+                    f'Operation "{obj.name}" '
+                    f"definition is {type(obj.definition)} but expected QuantumCircuit."
                 )
             if obj.definition.global_phase:
                 dimension = 2**obj.num_qubits

qiskit/quantum_info/operators/predicates.py

@@ -22,6 +22,7 @@ RTOL_DEFAULT = 1e-5
 
 
 def matrix_equal(mat1, mat2, ignore_phase=False, rtol=RTOL_DEFAULT, atol=ATOL_DEFAULT, props=None):
+    # pylint: disable-next=consider-using-f-string
     """Test if two arrays are equal.
 
     The final comparison is implemented using Numpy.allclose. See its

qiskit/quantum_info/operators/symplectic/base_pauli.py

@@ -215,12 +215,12 @@ class BasePauli(BaseOperator, AdjointMixin, MultiplyMixin):
         if qargs is not None and len(qargs) != other.num_qubits:
             raise QiskitError(
                 "Number of qubits of other Pauli does not match number of "
-                "qargs ({} != {}).".format(other.num_qubits, len(qargs))
+                f"qargs ({other.num_qubits} != {len(qargs)})."
             )
         if qargs is None and self.num_qubits != other.num_qubits:
             raise QiskitError(
                 "Number of qubits of other Pauli does not match the current "
-                "Pauli ({} != {}).".format(other.num_qubits, self.num_qubits)
+                f"Pauli ({other.num_qubits} != {self.num_qubits})."
             )
         if qargs is not None:
             inds = list(qargs)
@@ -262,15 +262,12 @@ class BasePauli(BaseOperator, AdjointMixin, MultiplyMixin):
         # Check dimension
         if qargs is not None and len(qargs) != other.num_qubits:
             raise QiskitError(
-                "Incorrect number of qubits for Clifford circuit ({} != {}).".format(
-                    other.num_qubits, len(qargs)
-                )
+                f"Incorrect number of qubits for Clifford circuit ({other.num_qubits} != {len(qargs)})."
             )
         if qargs is None and self.num_qubits != other.num_qubits:
             raise QiskitError(
-                "Incorrect number of qubits for Clifford circuit ({} != {}).".format(
-                    other.num_qubits, self.num_qubits
-                )
+                f"Incorrect number of qubits for Clifford circuit "
+                f"({other.num_qubits} != {self.num_qubits})."
             )
 
         # Evolve via Pauli
@@ -571,9 +568,8 @@ class BasePauli(BaseOperator, AdjointMixin, MultiplyMixin):
                 raise QiskitError(f"Cannot apply Instruction: {gate.name}")
             if not isinstance(gate.definition, QuantumCircuit):
                 raise QiskitError(
-                    "{} instruction definition is {}; expected QuantumCircuit".format(
-                        gate.name, type(gate.definition)
-                    )
+                    f"{gate.name} instruction definition is {type(gate.definition)};"
+                    f" expected QuantumCircuit"
                 )
 
             circuit = gate.definition

qiskit/quantum_info/operators/symplectic/clifford.py

@@ -185,7 +185,7 @@ class Clifford(BaseOperator, AdjointMixin, Operation):
                 isinstance(data, (list, np.ndarray))
                 and (data_asarray := np.asarray(data, dtype=bool)).ndim == 2
             ):
-                # This little dance is to avoid Numpy 1/2 incompatiblities between the availability
+                # This little dance is to avoid Numpy 1/2 incompatibilities between the availability
                 # and meaning of the 'copy' argument in 'array' and 'asarray', when the input needs
                 # its dtype converting.  'asarray' prefers to return 'self' if possible in both.
                 if copy and np.may_share_memory(data, data_asarray):

qiskit/quantum_info/operators/symplectic/pauli.py

@@ -77,7 +77,7 @@ class Pauli(BasePauli):
 
     An :math:`n`-qubit Pauli may be represented by a string consisting of
     :math:`n` characters from ``['I', 'X', 'Y', 'Z']``, and optionally phase
-    coefficient in :math:`['', '-i', '-', 'i']`. For example: ``XYZ`` or
+    coefficient in ``['', '-i', '-', 'i']``. For example: ``'XYZ'`` or
     ``'-iZIZ'``.
 
     In the string representation qubit-0 corresponds to the right-most
@@ -160,21 +160,23 @@ class Pauli(BasePauli):
     _CANONICAL_PHASE_LABEL = {"": 0, "-i": 1, "-": 2, "i": 3}
 
     def __init__(self, data: str | tuple | Pauli | ScalarOp | QuantumCircuit | None = None):
-        """Initialize the Pauli.
+        r"""Initialize the Pauli.
 
         When using the symplectic array input data both z and x arguments must
         be provided, however the first (z) argument can be used alone for string
-        label, Pauli operator, or ScalarOp input data.
+        label, Pauli operator, or :class:`.ScalarOp` input data.
 
         Args:
             data (str or tuple or Pauli or ScalarOp): input data for Pauli. If input is
-                a tuple it must be of the form ``(z, x)`` or (z, x, phase)`` where
-                ``z`` and ``x`` are boolean Numpy arrays, and phase is an integer from Z_4.
+                a tuple it must be of the form ``(z, x)`` or ``(z, x, phase)`` where
+                ``z`` and ``x`` are boolean Numpy arrays, and phase is an integer from
+                :math:`\mathbb{Z}_4`.
                 If input is a string, it must be a concatenation of a phase and a Pauli string
-                (e.g. 'XYZ', '-iZIZ') where a phase string is a combination of at most three
-                characters from ['+', '-', ''], ['1', ''], and ['i', 'j', ''] in this order,
-                e.g. '', '-1j' while a Pauli string is 1 or more characters of 'I', 'X', 'Y' or 'Z',
-                e.g. 'Z', 'XIYY'.
+                (e.g. ``'XYZ', '-iZIZ'``) where a phase string is a combination of at most three
+                characters from ``['+', '-', '']``, ``['1', '']``, and ``['i', 'j', '']`` in this order,
+                e.g. ``''``, ``'-1j'`` while a Pauli string is 1 or more
+                characters of ``'I'``, ``'X'``, ``'Y'``, or ``'Z'``,
+                e.g. ``'Z'``, ``'XIYY'``.
 
         Raises:
             QiskitError: if input array is invalid shape.
@@ -344,7 +346,7 @@ class Pauli(BasePauli):
         if max(qubits) > self.num_qubits - 1:
             raise QiskitError(
                 "Qubit index is larger than the number of qubits "
-                "({}>{}).".format(max(qubits), self.num_qubits - 1)
+                f"({max(qubits)}>{self.num_qubits - 1})."
             )
         if len(qubits) == self.num_qubits:
             raise QiskitError("Cannot delete all qubits of Pauli")
@@ -379,12 +381,12 @@ class Pauli(BasePauli):
         if len(qubits) != value.num_qubits:
             raise QiskitError(
                 "Number of indices does not match number of qubits for "
-                "the inserted Pauli ({}!={})".format(len(qubits), value.num_qubits)
+                f"the inserted Pauli ({len(qubits)}!={value.num_qubits})"
             )
         if max(qubits) > ret.num_qubits - 1:
             raise QiskitError(
                 "Index is too larger for combined Pauli number of qubits "
-                "({}>{}).".format(max(qubits), ret.num_qubits - 1)
+                f"({max(qubits)}>{ret.num_qubits - 1})."
             )
         # Qubit positions for original op
         self_qubits = [i for i in range(ret.num_qubits) if i not in qubits]

qiskit/quantum_info/operators/symplectic/pauli_list.py

@@ -382,8 +382,8 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         if not qubit:
             if max(ind) >= len(self):
                 raise QiskitError(
-                    "Indices {} are not all less than the size"
-                    " of the PauliList ({})".format(ind, len(self))
+                    f"Indices {ind} are not all less than the size"
+                    f" of the PauliList ({len(self)})"
                 )
             z = np.delete(self._z, ind, axis=0)
             x = np.delete(self._x, ind, axis=0)
@@ -394,8 +394,8 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         # Column (qubit) deletion
         if max(ind) >= self.num_qubits:
             raise QiskitError(
-                "Indices {} are not all less than the number of"
-                " qubits in the PauliList ({})".format(ind, self.num_qubits)
+                f"Indices {ind} are not all less than the number of"
+                f" qubits in the PauliList ({self.num_qubits})"
             )
         z = np.delete(self._z, ind, axis=1)
         x = np.delete(self._x, ind, axis=1)
@@ -432,8 +432,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         if not qubit:
             if ind > size:
                 raise QiskitError(
-                    "Index {} is larger than the number of rows in the"
-                    " PauliList ({}).".format(ind, size)
+                    f"Index {ind} is larger than the number of rows in the" f" PauliList ({size})."
                 )
             base_z = np.insert(self._z, ind, value._z, axis=0)
             base_x = np.insert(self._x, ind, value._x, axis=0)
@@ -443,8 +442,8 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         # Column insertion
         if ind > self.num_qubits:
             raise QiskitError(
-                "Index {} is greater than number of qubits"
-                " in the PauliList ({})".format(ind, self.num_qubits)
+                f"Index {ind} is greater than number of qubits"
+                f" in the PauliList ({self.num_qubits})"
             )
         if len(value) == 1:
             # Pad blocks to correct size
@@ -461,7 +460,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
             raise QiskitError(
                 "Input PauliList must have a single row, or"
                 " the same number of rows as the Pauli Table"
-                " ({}).".format(size)
+                f" ({size})."
             )
         # Build new array by blocks
         z = np.hstack([self.z[:, :ind], value_z, self.z[:, ind:]])
@@ -647,7 +646,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         index = index[sort_inds]
         unique = PauliList(BasePauli(self._z[index], self._x[index], self._phase[index]))
 
-        # Concatinate return tuples
+        # Concatenate return tuples
         ret = (unique,)
         if return_index:
             ret += (index,)

qiskit/quantum_info/operators/symplectic/random.py

@@ -163,7 +163,7 @@ def _sample_qmallows(n, rng=None):
     if rng is None:
         rng = np.random.default_rng()
 
-    # Hadmard layer
+    # Hadamard layer
     had = np.zeros(n, dtype=bool)
 
     # Permutation layer

qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py

@@ -135,19 +135,19 @@ class SparsePauliOp(LinearOp):
 
         pauli_list = PauliList(data.copy() if copy and hasattr(data, "copy") else data)
 
-        if isinstance(coeffs, np.ndarray):
-            dtype = object if coeffs.dtype == object else complex
-        elif coeffs is not None:
-            if not isinstance(coeffs, (np.ndarray, Sequence)):
-                coeffs = [coeffs]
-            if any(isinstance(coeff, ParameterExpression) for coeff in coeffs):
-                dtype = object
-            else:
-                dtype = complex
-
         if coeffs is None:
             coeffs = np.ones(pauli_list.size, dtype=complex)
         else:
+            if isinstance(coeffs, np.ndarray):
+                dtype = object if coeffs.dtype == object else complex
+            else:
+                if not isinstance(coeffs, Sequence):
+                    coeffs = [coeffs]
+                if any(isinstance(coeff, ParameterExpression) for coeff in coeffs):
+                    dtype = object
+                else:
+                    dtype = complex
+
             coeffs_asarray = np.asarray(coeffs, dtype=dtype)
             coeffs = (
                 coeffs_asarray.copy()
@@ -172,7 +172,7 @@ class SparsePauliOp(LinearOp):
         if self._coeffs.shape != (self._pauli_list.size,):
             raise QiskitError(
                 "coeff vector is incorrect shape for number"
-                " of Paulis {} != {}".format(self._coeffs.shape, self._pauli_list.size)
+                f" of Paulis {self._coeffs.shape} != {self._pauli_list.size}"
             )
         # Initialize LinearOp
         super().__init__(num_qubits=self._pauli_list.num_qubits)
@@ -186,11 +186,9 @@ class SparsePauliOp(LinearOp):
     def __repr__(self):
         prefix = "SparsePauliOp("
         pad = len(prefix) * " "
-        return "{}{},\n{}coeffs={})".format(
-            prefix,
-            self.paulis.to_labels(),
-            pad,
-            np.array2string(self.coeffs, separator=", "),
+        return (
+            f"{prefix}{self.paulis.to_labels()},\n{pad}"
+            f"coeffs={np.array2string(self.coeffs, separator=', ')})"
         )
 
     def __eq__(self, other):
@@ -939,7 +937,7 @@ class SparsePauliOp(LinearOp):
                 array (the default).
             force_serial: if ``True``, use an unthreaded implementation, regardless of the state of
                 the `Qiskit threading-control environment variables
-                <https://docs.quantum.ibm.com/start/configure-qiskit-local#environment-variables>`__.
+                <https://docs.quantum.ibm.com/guides/configure-qiskit-local#environment-variables>`__.
                 By default, this will use threaded parallelism over the available CPUs.
 
         Returns:

qiskit/quantum_info/quaternion.py

@@ -43,7 +43,7 @@ class Quaternion:
             out_data[3] = r(0) * q(3) - r(1) * q(2) + r(2) * q(1) + r(3) * q(0)
             return Quaternion(out_data)
         else:
-            raise Exception("Multiplication by other not supported.")
+            return NotImplemented
 
     def norm(self):
         """Norm of quaternion."""

qiskit/quantum_info/states/densitymatrix.py

@@ -123,11 +123,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
     def __repr__(self):
         prefix = "DensityMatrix("
         pad = len(prefix) * " "
-        return "{}{},\n{}dims={})".format(
-            prefix,
-            np.array2string(self._data, separator=", ", prefix=prefix),
-            pad,
-            self._op_shape.dims_l(),
+        return (
+            f"{prefix}{np.array2string(self._data, separator=', ', prefix=prefix)},\n"
+            f"{pad}dims={self._op_shape.dims_l()})"
         )
 
     @property
@@ -771,9 +769,8 @@ class DensityMatrix(QuantumState, TolerancesMixin):
             raise QiskitError(f"Cannot apply Instruction: {other.name}")
         if not isinstance(other.definition, QuantumCircuit):
             raise QiskitError(
-                "{} instruction definition is {}; expected QuantumCircuit".format(
-                    other.name, type(other.definition)
-                )
+                f"{other.name} instruction definition is {type(other.definition)};"
+                f" expected QuantumCircuit"
             )
         qubit_indices = {bit: idx for idx, bit in enumerate(other.definition.qubits)}
         for instruction in other.definition: