qiskit 1.3.0rc2__cp39-abi3-win32.whl → 1.3.2__cp39-abi3-win32.whl

qiskit/qpy/__init__.py

@@ -447,10 +447,10 @@ characters:
    * - ``u``
      - substitution
 
-If the type value is ``f`` ,``c`` or ``i``, the corresponding ``lhs`` or `rhs``
+If the type value is ``f``, ``c``, or ``i``, the corresponding ``lhs`` or ``rhs``
 field widths are 128 bits each. In the case of floats, the literal value is encoded as a double
 with 0 padding, while complex numbers are encoded as real part followed by imaginary part,
-taking up 64 bits each. For ``i`, the value is encoded as a 64 bit signed integer with 0 padding
+taking up 64 bits each. For ``i``, the value is encoded as a 64 bit signed integer with 0 padding
 for the full 128 bit width. ``n`` is used to represent a ``None`` and typically isn't directly used
 as it indicates an argument that's not used. For ``p`` the data is the UUID for the
 :class:`.Parameter` which can be looked up in the symbol map described in the
@@ -546,7 +546,7 @@ Type code  Meaning
 Changes to EXPR_VAR
 ~~~~~~~~~~~~~~~~~~~
 
-The EXPR_VAR variable has gained a new type code and payload, in addition to the pre-existing ones:
+The ``EXPR_VAR`` variable has gained a new type code and payload, in addition to the pre-existing ones:
 
 ===========================  =========  ============================================================
 Python class                 Type code  Payload
@@ -693,9 +693,9 @@ Each of these are described in the following table:
 ======================  =========  =======================================================  ========
 Qiskit class            Type code  Payload                                                  Children
 ======================  =========  =======================================================  ========
-:class:`~.expr.Var`     ``x``      One EXPR_VAR.                                            0
+:class:`~.expr.Var`     ``x``      One ``EXPR_VAR``.                                        0
 
-:class:`~.expr.Value`   ``v``      One EXPR_VALUE.                                          0
+:class:`~.expr.Value`   ``v``      One ``EXPR_VALUE``.                                      0
 
 :class:`~.expr.Cast`    ``c``      One ``_Bool``  that corresponds to the value of          1
                                    ``implicit``.

qiskit/quantum_info/operators/channel/chi.py

@@ -18,6 +18,8 @@ Chi-matrix representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -31,6 +33,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_chi
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Chi(QuantumChannel):
     r"""Pauli basis Chi-matrix representation of a quantum channel.
@@ -59,21 +64,16 @@ class Chi(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Chi-matrix operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data is not an N-qubit channel or

qiskit/quantum_info/operators/channel/choi.py

@@ -18,6 +18,8 @@ Choi-matrix representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -32,6 +34,9 @@ from qiskit.quantum_info.operators.channel.transformations import _bipartite_ten
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Choi(QuantumChannel):
     r"""Choi-matrix representation of a Quantum Channel.
@@ -64,21 +69,16 @@ class Choi(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Choi matrix operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data cannot be initialized as a

qiskit/quantum_info/operators/channel/ptm.py

@@ -18,6 +18,8 @@ Pauli Transfer Matrix (PTM) representation of a Quantum Channel.
 from __future__ import annotations
 import copy as _copy
 import math
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -30,6 +32,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_ptm
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class PTM(QuantumChannel):
     r"""Pauli Transfer Matrix (PTM) representation of a Quantum Channel.
@@ -67,21 +72,16 @@ class PTM(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a PTM quantum channel operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data is not an N-qubit channel or

qiskit/quantum_info/operators/channel/quantum_channel.py

@@ -53,9 +53,9 @@ class QuantumChannel(LinearOp):
         """Initialize a quantum channel Superoperator operator.
 
         Args:
-            data (array or list): quantum channel data array.
-            op_shape (OpShape): the operator shape of the channel.
-            num_qubits (int): the number of qubits if the channel is N-qubit.
+            data: quantum channel data array.
+            op_shape: the operator shape of the channel.
+            num_qubits: the number of qubits if the channel is N-qubit.
 
         Raises:
             QiskitError: if arguments are invalid.

qiskit/quantum_info/operators/channel/stinespring.py

@@ -17,6 +17,8 @@ from __future__ import annotations
 import copy
 import math
 from numbers import Number
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
@@ -32,6 +34,9 @@ from qiskit.quantum_info.operators.channel.transformations import _to_stinesprin
 from qiskit.quantum_info.operators.mixins import generate_apidocs
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Stinespring(QuantumChannel):
     r"""Stinespring representation of a quantum channel.
@@ -64,21 +69,16 @@ class Stinespring(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: int | tuple | None = None,
         output_dims: int | tuple | None = None,
     ):
         """Initialize a quantum channel Stinespring operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data cannot be initialized as a

qiskit/quantum_info/operators/channel/superop.py

@@ -33,6 +33,7 @@ from qiskit.quantum_info.operators.op_shape import OpShape
 from qiskit.quantum_info.operators.operator import Operator
 
 if TYPE_CHECKING:
+    from qiskit import circuit
     from qiskit.quantum_info.states.densitymatrix import DensityMatrix
     from qiskit.quantum_info.states.statevector import Statevector
 
@@ -62,21 +63,16 @@ class SuperOp(QuantumChannel):
 
     def __init__(
         self,
-        data: QuantumCircuit | Instruction | BaseOperator | np.ndarray,
+        data: QuantumCircuit | circuit.instruction.Instruction | BaseOperator | np.ndarray,
         input_dims: tuple | None = None,
         output_dims: tuple | None = None,
     ):
         """Initialize a quantum channel Superoperator operator.
 
         Args:
-            data (QuantumCircuit or
-                  Instruction or
-                  BaseOperator or
-                  matrix): data to initialize superoperator.
-            input_dims (tuple): the input subsystem dimensions.
-                                [Default: None]
-            output_dims (tuple): the output subsystem dimensions.
-                                 [Default: None]
+            data: data to initialize superoperator.
+            input_dims: the input subsystem dimensions.
+            output_dims: the output subsystem dimensions.
 
         Raises:
             QiskitError: if input data cannot be initialized as a

qiskit/quantum_info/operators/symplectic/pauli_list.py

@@ -445,16 +445,14 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
                 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
-            value_x = np.vstack(size * [value.x])
-            value_z = np.vstack(size * [value.z])
-            value_phase = np.vstack(size * [value.phase])
-        elif len(value) == size:
+        if len(value) == size:
             #  Blocks are already correct size
             value_x = value.x
             value_z = value.z
-            value_phase = value.phase
+        elif len(value) == 1:
+            # Pad blocks to correct size
+            value_x = np.vstack(size * [value.x])
+            value_z = np.vstack(size * [value.z])
         else:
             # Blocks are incorrect size
             raise QiskitError(
@@ -465,7 +463,7 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         # Build new array by blocks
         z = np.hstack([self.z[:, :ind], value_z, self.z[:, ind:]])
         x = np.hstack([self.x[:, :ind], value_x, self.x[:, ind:]])
-        phase = self.phase + value_phase
+        phase = self.phase + value.phase
 
         return PauliList.from_symplectic(z, x, phase)
 
@@ -1121,6 +1119,8 @@ class PauliList(BasePauli, LinearMixin, GroupMixin):
         Returns:
             PauliList: the constructed PauliList.
         """
+        if isinstance(phase, np.ndarray) and np.ndim(phase) > 1:
+            raise ValueError(f"phase should be at most 1D but has {np.ndim(phase)} dimensions.")
         base_z, base_x, base_phase = cls._from_array(z, x, phase)
         return cls(BasePauli(base_z, base_x, base_phase))
 

qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py

@@ -165,7 +165,16 @@ class SparsePauliOp(LinearOp):
             # move the phase of `pauli_list` to `self._coeffs`
             phase = pauli_list._phase
             count_y = pauli_list._count_y()
-            self._coeffs = np.asarray((-1j) ** (phase - count_y) * coeffs, dtype=coeffs.dtype)
+
+            # Compute exponentiation via integer arithmetic and lookup table to avoid
+            # floating point errors
+            exponent = (phase - count_y) % 4
+            lookup = np.array([1 + 0j, -1j, -1 + 0j, 1j], dtype=coeffs.dtype)
+
+            vals = lookup[exponent]
+            self._coeffs = vals * coeffs
+
+            # Update pauli_list phase
             pauli_list._phase = np.mod(count_y, 4)
             self._pauli_list = pauli_list
 

qiskit/quantum_info/states/densitymatrix.py

@@ -17,6 +17,8 @@ DensityMatrix quantum state class.
 from __future__ import annotations
 import copy as _copy
 from numbers import Number
+from typing import TYPE_CHECKING
+
 import numpy as np
 
 from qiskit import _numpy_compat
@@ -37,27 +39,27 @@ from qiskit.quantum_info.operators.channel.superop import SuperOp
 from qiskit._accelerate.pauli_expval import density_expval_pauli_no_x, density_expval_pauli_with_x
 from qiskit.quantum_info.states.statevector import Statevector
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class DensityMatrix(QuantumState, TolerancesMixin):
     """DensityMatrix class"""
 
     def __init__(
         self,
-        data: np.ndarray | list | QuantumCircuit | Instruction | QuantumState,
+        data: np.ndarray | list | QuantumCircuit | circuit.instruction.Instruction | QuantumState,
         dims: int | tuple | list | None = None,
     ):
         """Initialize a density matrix object.
 
         Args:
-            data (np.ndarray or list or matrix_like or QuantumCircuit or
-                  qiskit.circuit.Instruction):
-                A statevector, quantum instruction or an object with a ``to_operator`` or
+            data: A statevector, quantum instruction or an object with a ``to_operator`` or
                 ``to_matrix`` method from which the density matrix can be constructed.
                 If a vector the density matrix is constructed as the projector of that vector.
                 If a quantum instruction, the density matrix is constructed by assuming all
                 qubits are initialized in the zero state.
-            dims (int or tuple or list): Optional. The subsystem dimension
-                    of the state (See additional information).
+            dims: The subsystem dimension of the state (See additional information).
 
         Raises:
             QiskitError: if input data is not valid.
@@ -303,19 +305,17 @@ class DensityMatrix(QuantumState, TolerancesMixin):
 
     def evolve(
         self,
-        other: Operator | QuantumChannel | Instruction | QuantumCircuit,
+        other: Operator | QuantumChannel | circuit.instruction.Instruction | QuantumCircuit,
         qargs: list[int] | None = None,
     ) -> DensityMatrix:
         """Evolve a quantum state by an operator.
 
         Args:
-            other (Operator or QuantumChannel
-                   or Instruction or Circuit): The operator to evolve by.
-            qargs (list): a list of QuantumState subsystem positions to apply
-                           the operator on.
+            other: The operator to evolve by.
+            qargs: a list of QuantumState subsystem positions to apply the operator on.
 
         Returns:
-            DensityMatrix: the output density matrix.
+            The output density matrix.
 
         Raises:
             QiskitError: if the operator dimension does not match the
@@ -598,7 +598,9 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         return DensityMatrix(state, dims=dims)
 
     @classmethod
-    def from_instruction(cls, instruction: Instruction | QuantumCircuit) -> DensityMatrix:
+    def from_instruction(
+        cls, instruction: circuit.instruction.Instruction | QuantumCircuit
+    ) -> DensityMatrix:
         """Return the output density matrix of an instruction.
 
         The statevector is initialized in the state :math:`|{0,\\ldots,0}\\rangle` of
@@ -606,10 +608,10 @@ class DensityMatrix(QuantumState, TolerancesMixin):
         by the input instruction, and the output statevector returned.
 
         Args:
-            instruction (qiskit.circuit.Instruction or QuantumCircuit): instruction or circuit
+            instruction: instruction or circuit
 
         Returns:
-            DensityMatrix: the final density matrix.
+            The final density matrix.
 
         Raises:
             QiskitError: if the instruction contains invalid instructions for

qiskit/quantum_info/states/stabilizerstate.py

@@ -17,6 +17,7 @@ Stabilizer state class.
 from __future__ import annotations
 
 from collections.abc import Collection
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -28,6 +29,9 @@ from qiskit.quantum_info.operators.symplectic.clifford_circuits import _append_x
 from qiskit.quantum_info.states.quantum_state import QuantumState
 from qiskit.circuit import QuantumCircuit, Instruction
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class StabilizerState(QuantumState):
     """StabilizerState class.
@@ -79,17 +83,14 @@ class StabilizerState(QuantumState):
 
     def __init__(
         self,
-        data: StabilizerState | Clifford | Pauli | QuantumCircuit | Instruction,
+        data: StabilizerState | Clifford | Pauli | QuantumCircuit | circuit.instruction.Instruction,
         validate: bool = True,
     ):
         """Initialize a StabilizerState object.
 
         Args:
-            data (StabilizerState or Clifford or Pauli or QuantumCircuit or
-                  qiskit.circuit.Instruction):
-                Data from which the stabilizer state can be constructed.
-            validate (boolean): validate that the stabilizer state data is
-                a valid Clifford.
+            data: Data from which the stabilizer state can be constructed.
+            validate: validate that the stabilizer state data is a valid Clifford.
         """
 
         # Initialize from another StabilizerState

qiskit/quantum_info/states/statevector.py

@@ -18,6 +18,7 @@ import copy as _copy
 import math
 import re
 from numbers import Number
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -37,27 +38,34 @@ from qiskit._accelerate.pauli_expval import (
     expval_pauli_with_x,
 )
 
+if TYPE_CHECKING:
+    from qiskit import circuit
+
 
 class Statevector(QuantumState, TolerancesMixin):
     """Statevector class"""
 
     def __init__(
         self,
-        data: np.ndarray | list | Statevector | Operator | QuantumCircuit | Instruction,
+        data: (
+            np.ndarray
+            | list
+            | Statevector
+            | Operator
+            | QuantumCircuit
+            | circuit.instruction.Instruction
+        ),
         dims: int | tuple | list | None = None,
     ):
         """Initialize a statevector object.
 
         Args:
-            data (np.array or list or Statevector or Operator or QuantumCircuit or
-                  qiskit.circuit.Instruction):
-                Data from which the statevector can be constructed. This can be either a complex
+            data: Data from which the statevector can be constructed. This can be either a complex
                 vector, another statevector, a ``Operator`` with only one column or a
                 ``QuantumCircuit`` or ``Instruction``.  If the data is a circuit or instruction,
                 the statevector is constructed by assuming that all qubits are initialized to the
                 zero state.
-            dims (int or tuple or list): Optional. The subsystem dimension of
-                                         the state (See additional information).
+            dims: The subsystem dimension of the state (See additional information).
 
         Raises:
             QiskitError: if input data is not valid.
@@ -173,6 +181,7 @@ class Statevector(QuantumState, TolerancesMixin):
             Plot one of the Bell states
 
             .. plot::
+               :alt: Output from the previous code.
                :include-source:
 
                 from numpy import sqrt

qiskit/synthesis/arithmetic/multipliers/hrs_cumulative_multiplier.py

@@ -27,6 +27,7 @@ def multiplier_cumulative_h18(
     performs a non-modular multiplication on two 3-qubit sized registers is:
 
     .. plot::
+        :alt: Circuit diagram output by the previous code.
         :include-source:
 
         from qiskit.synthesis.arithmetic import multiplier_cumulative_h18

qiskit/synthesis/arithmetic/multipliers/rg_qft_multiplier.py

@@ -35,6 +35,7 @@ def multiplier_qft_r17(
     For example, on 3 state qubits, a full multiplier is given by:
 
     .. plot::
+        :alt: Circuit diagram output by the previous code.
         :include-source:
 
         from qiskit.synthesis.arithmetic import multiplier_qft_r17

qiskit/synthesis/evolution/product_formula.py

@@ -191,12 +191,6 @@ class ProductFormula(EvolutionSynthesis):
             "preserve_order": self.preserve_order,
         }
 
-    def _normalize_coefficients(
-        self, paulis: list[str | list[int], float | complex | ParameterExpression]
-    ) -> list[str | list[int] | ParameterValueType]:
-        """Ensure the coefficients are real (or parameter expressions)."""
-        return [[(op, qubits, real_or_fail(coeff)) for op, qubits, coeff in ops] for ops in paulis]
-
     def _custom_evolution(self, num_qubits, pauli_rotations):
         """Implement the evolution for the non-standard path.
 

qiskit/synthesis/evolution/suzuki_trotter.py

@@ -18,7 +18,9 @@ import inspect
 import typing
 from collections.abc import Callable
 from itertools import chain
+import numpy as np
 
+from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info.operators import SparsePauliOp, Pauli
 from qiskit.utils.deprecation import deprecate_arg
@@ -138,7 +140,7 @@ class SuzukiTrotter(ProductFormula):
 
         .. code-block:: text
 
-            ("X", [0], t), ("ZZ", [0, 1], 2t), ("X", [0], 2)
+            ("X", [0], t), ("ZZ", [0, 1], 2t), ("X", [0], t)
 
         Note that the rotation angle contains a factor of 2, such that that evolution
         of a Pauli :math:`P` over time :math:`t`, which is :math:`e^{itP}`, is represented
@@ -157,7 +159,10 @@ class SuzukiTrotter(ProductFormula):
         time = evolution.time
 
         def to_sparse_list(operator):
-            paulis = (time * (2 / self.reps) * operator).to_sparse_list()
+            paulis = [
+                (pauli, indices, real_or_fail(coeff) * time * 2 / self.reps)
+                for pauli, indices, coeff in operator.to_sparse_list()
+            ]
             if not self.preserve_order:
                 return reorder_paulis(paulis)
 
@@ -171,9 +176,6 @@ class SuzukiTrotter(ProductFormula):
             # here would be the location to do so.
             non_commuting = [[op] for op in to_sparse_list(operators)]
 
-        # normalize coefficients, i.e. ensure they are float or ParameterExpression
-        non_commuting = self._normalize_coefficients(non_commuting)
-
         # we're already done here since Lie Trotter does not do any operator repetition
         product_formula = self._recurse(self.order, non_commuting)
         flattened = self.reps * list(chain.from_iterable(product_formula))
@@ -213,3 +215,18 @@ class SuzukiTrotter(ProductFormula):
                 ],
             )
             return outer + inner + outer
+
+
+def real_or_fail(value, tol=100):
+    """Return real if close, otherwise fail. Unbound parameters are left unchanged.
+
+    Based on NumPy's ``real_if_close``, i.e. ``tol`` is in terms of machine precision for float.
+    """
+    if isinstance(value, ParameterExpression):
+        return value
+
+    abstol = tol * np.finfo(float).eps
+    if abs(np.imag(value)) < abstol:
+        return np.real(value)
+
+    raise ValueError(f"Encountered complex value {value}, but expected real.")