qiskit 1.3.2__cp39-abi3-win32.whl → 1.3.3__cp39-abi3-win32.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.3.2
+1.3.3

qiskit/circuit/__init__.py

@@ -294,6 +294,7 @@ main related classes are:
 * :class:`Parameter`, the atom of compile-time expressions
 * :class:`ParameterExpression`, a symbolic calculation on parameters
 * :class:`ParameterVector`, a convenience collection of many :class:`Parameter`\ s
+* :class:`ParameterVectorElement`, a subclass of :class:`Parameter` used by :class:`ParameterVector`
 
 The :mod:`qiskit.circuit` module also exposes some calculation classes that work with circuits to
 assist compilation workflows.  These include:
@@ -667,12 +668,14 @@ execution.  You can do this assignment using :meth:`QuantumCircuit.assign_parame
 
 You may want to use many parameters that are related to each other.  To make this easier (and to
 avoid you needing to come up with many names), you can use the convenience constructor
-:class:`ParameterVector`.  The elements of the vector are all valid :class:`Parameter` instances.
+:class:`ParameterVector`.  The elements of the vector are all valid :class:`Parameter` instances, of
+a special subclass :class:`ParameterVectorElement`.
 
 .. autosummary::
     :toctree: ../stubs/
 
     ParameterVector
+    ParameterVectorElement
 
 .. _circuit-control-flow-repr:
 
@@ -1289,7 +1292,7 @@ from .measure import Measure
 from .reset import Reset
 from .store import Store
 from .parameter import Parameter
-from .parametervector import ParameterVector
+from .parametervector import ParameterVector, ParameterVectorElement
 from .parameterexpression import ParameterExpression
 from .quantumcircuitdata import CircuitInstruction
 from .equivalence import EquivalenceLibrary

qiskit/circuit/delay.py

@@ -81,6 +81,11 @@ class Delay(Instruction):
         """
         return self.__array__(dtype=complex)
 
+    def __eq__(self, other):
+        return (
+            isinstance(other, Delay) and self.unit == other.unit and self._compare_parameters(other)
+        )
+
     def __repr__(self):
         """Return the official string representing the delay."""
         return f"{self.__class__.__name__}(duration={self.params[0]}[unit={self.unit}])"

qiskit/circuit/library/standard_gates/rz.py

@@ -37,17 +37,17 @@ class RZGate(Gate):
     .. code-block:: text
 
              ┌───────┐
-        q_0: ┤ Rz(λ) ├
+        q_0: ┤ Rz(φ) ├
              └───────┘
 
     **Matrix Representation:**
 
     .. math::
 
-        RZ(\lambda) = \exp\left(-i\frac{\lambda}{2}Z\right) =
+        RZ(\phi) = \exp\left(-i\frac{\phi}{2}Z\right) =
             \begin{pmatrix}
-                e^{-i\frac{\lambda}{2}} & 0 \\
-                0 & e^{i\frac{\lambda}{2}}
+                e^{-i\frac{\phi}{2}} & 0 \\
+                0 & e^{i\frac{\phi}{2}}
             \end{pmatrix}
 
     .. seealso::
@@ -57,7 +57,7 @@ class RZGate(Gate):
 
             .. math::
 
-                U1(\lambda) = e^{i{\lambda}/2}RZ(\lambda)
+                U1(\theta=\phi) = e^{i{\phi}/2}RZ(\phi)
 
         Reference for virtual Z gate implementation:
         `1612.00858 <https://arxiv.org/abs/1612.00858>`_
@@ -186,10 +186,10 @@ class CRZGate(ControlledGate):
     .. math::
 
         CRZ(\theta)\ q_0, q_1 =
-            I \otimes |0\rangle\langle 0| + RZ(\theta) \otimes |1\rangle\langle 1| =
+            I \otimes |0\rangle\langle 0| + RZ(\phi=\theta) \otimes |1\rangle\langle 1| =
             \begin{pmatrix}
                 1 & 0 & 0 & 0 \\
-                0 & e^{-i\frac{\lambda}{2}} & 0 & 0 \\
+                0 & e^{-i\frac{\theta}{2}} & 0 & 0 \\
                 0 & 0 & 1 & 0 \\
                 0 & 0 & 0 & e^{i\frac{\theta}{2}}
             \end{pmatrix}

qiskit/circuit/library/standard_gates/xx_minus_yy.py

@@ -63,36 +63,6 @@ class XXMinusYYGate(Gate):
                 0 & 0 & 1 & 0 \\
                 -i\sin\left(\rotationangle\right)e^{i\beta} & 0 & 0 & \cos\left(\rotationangle\right)
             \end{pmatrix}
-
-    .. note::
-
-        In Qiskit's convention, higher qubit indices are more significant
-        (little endian convention). In the above example we apply the gate
-        on (q_0, q_1) which results in adding the (optional) phase defined
-        by :math:`\beta` on q_1. Instead, if we apply it on (q_1, q_0), the
-        phase is added on q_0. If :math:`\beta` is set to its default value
-        of :math:`0`, the gate is equivalent in big and little endian.
-
-        .. code-block:: text
-
-                 ┌───────────────┐
-            q_0: ┤1              ├
-                 │  (XX-YY)(θ,β) │
-            q_1: ┤0              ├
-                 └───────────────┘
-
-        .. math::
-
-            \newcommand{\rotationangle}{\frac{\theta}{2}}
-
-            R_{XX-YY}(\theta, \beta) q_1, q_0 =
-            RZ_0(\beta) \cdot \exp\left(-i \frac{\theta}{2} \frac{XX-YY}{2}\right) \cdot RZ_0(-\beta) =
-            \begin{pmatrix}
-                \cos\left(\rotationangle\right) & 0 & 0 & -i\sin\left(\rotationangle\right)e^{i\beta} \\
-                0 & 1 & 0 & 0 \\
-                0 & 0 & 1 & 0 \\
-                -i\sin\left(\rotationangle\right)e^{-i\beta} & 0 & 0 & \cos\left(\rotationangle\right)
-            \end{pmatrix}
     """
 
     _standard_gate = StandardGate.XXMinusYYGate

qiskit/circuit/parametervector.py

@@ -18,7 +18,12 @@ from .parameter import Parameter
 
 
 class ParameterVectorElement(Parameter):
-    """An element of a ParameterVector."""
+    """An element of a :class:`ParameterVector`.
+
+    .. note::
+        There is very little reason to ever construct this class directly.  Objects of this type are
+        automatically constructed efficiently as part of creating a :class:`ParameterVector`.
+    """
 
     ___slots__ = ("_vector", "_index")
 
@@ -48,7 +53,18 @@ class ParameterVectorElement(Parameter):
 
 
 class ParameterVector:
-    """ParameterVector class to quickly generate lists of parameters."""
+    """A container of many related :class:`Parameter` objects.
+
+    This class is faster to construct than constructing many :class:`Parameter` objects
+    individually, and the individual names of the parameters will all share a common stem (the name
+    of the vector).  For a vector called ``v`` with length 3, the individual elements will have
+    names ``v[0]``, ``v[1]`` and ``v[2]``.
+
+    The elements of a vector are sorted by the name of the vector, then the numeric value of their
+    index.
+
+    This class fulfill the :class:`collections.abc.Sequence` interface.
+    """
 
     __slots__ = ("_name", "_params", "_root_uuid")
 
@@ -62,16 +78,20 @@ class ParameterVector:
 
     @property
     def name(self):
-        """Returns the name of the ParameterVector."""
+        """The name of the :class:`ParameterVector`."""
         return self._name
 
     @property
     def params(self):
-        """Returns the list of parameters in the ParameterVector."""
+        """A list of the contained :class:`ParameterVectorElement` instances.
+
+        It is not safe to mutate this list."""
         return self._params
 
     def index(self, value):
-        """Returns first index of value."""
+        """Find the index of a :class:`ParameterVectorElement` within the list.
+
+        It is typically much faster to use the :attr:`ParameterVectorElement.index` property."""
         return self._params.index(value)
 
     def __getitem__(self, key):

qiskit/circuit/quantumcircuit.py

@@ -6646,7 +6646,10 @@ class QuantumCircuit:
             if len(qubits) == len([done for done in dones.values() if done]):  # all done
                 return max(stop for stop in stops.values())
 
-        return 0  # If there are no instructions over bits
+        if len(stops) > 0:  # not all but some qubits has instructions
+            return max(stops.values())
+        else:
+            return 0  # If there are no instructions over bits
 
 
 class _OuterCircuitScopeInterface(CircuitScopeInterface):

qiskit/compiler/transpiler.py

@@ -191,7 +191,7 @@ def transpile(  # pylint: disable=too-many-return-statements
             This can also be the external plugin name to use for the ``routing`` stage.
             You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
             ``"routing"`` for the ``stage_name`` argument.
-        translation_method: Name of translation pass ('unroller', 'translator', 'synthesis')
+        translation_method: Name of translation pass (``"translator"`` or ``"synthesis"``)
             This can also be the external plugin name to use for the ``translation`` stage.
             You can see a list of installed plugins by using :func:`~.list_stage_plugins` with
             ``"translation"`` for the ``stage_name`` argument.

qiskit/quantum_info/operators/channel/transformations.py

@@ -234,8 +234,23 @@ def _choi_to_kraus(data, input_dim, output_dim, atol=ATOL_DEFAULT):
         #
         # So the eigenvalues are on the diagonal, therefore the basis-transformation matrix must be
         # a spanning set of the eigenspace.
+        #
+        # In addition, to prevent `numpy.linalg` errors when the matrix A is ill-conditioned,
+        # we apply a small perturbation, replacing A by A + eI. Since (A + eI)x = kx is
+        # equivalent to Ax = (k-e)x, it means that the eigenvectors of A + eI and A are the same,
+        # and we can perfectly recover the eigenvalues of A from the eigenvalues of A + eI by
+        # subtracting e.
+        apply_perturbation = np.linalg.cond(data) >= 1e10
+
+        if apply_perturbation:
+            data += 1e-10 * np.eye(data.shape[0])
+
         triangular, vecs = scipy.linalg.schur(data)
         values = triangular.diagonal().real
+
+        if apply_perturbation:
+            values = values - 1e-10
+
         # If we're not a CP map, fall-through back to the generalization handling.  Since we needed
         # to get the eigenvalues anyway, we can do the CP check manually rather than deferring to a
         # separate re-calculation.