qiskit 1.1.0__cp38-abi3-win_amd64.whl → 1.1.1__cp38-abi3-win_amd64.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.1.0
+1.1.1

qiskit/circuit/__init__.py

@@ -816,10 +816,11 @@ method <https://numpy.org/devdocs/user/basics.interoperability.html#the-array-me
 ``__array__``.  This is used by :meth:`Gate.to_matrix`, and has the signature:
 
 .. currentmodule:: None
-.. py:method:: __array__(dtype=None, copy=None)
+.. py:method:: object.__array__(dtype=None, copy=None)
 
-    Return a Numpy array representing the gate.  This can use the gate's :attr:`~Instruction.params`
-    field, and may assume that these are numeric values (assuming the subclass expects that) and not
+    Return a Numpy array representing the gate. This can use the gate's
+    :attr:`~qiskit.circuit.Instruction.params` field, and may assume that these are numeric
+    values (assuming the subclass expects that) and not
     :ref:`compile-time parameters <circuit-compile-time-parameters>`.
 
     For greatest efficiency, the returned array should default to a dtype of :class:`complex`.

qiskit/circuit/library/data_preparation/pauli_feature_map.py

@@ -97,7 +97,7 @@ class PauliFeatureMap(NLocal):
         >>> from qiskit.circuit.library import EfficientSU2
         >>> prep = PauliFeatureMap(3, reps=3, paulis=['Z', 'YY', 'ZXZ'])
         >>> wavefunction = EfficientSU2(3)
-        >>> classifier = prep.compose(wavefunction
+        >>> classifier = prep.compose(wavefunction)
         >>> classifier.num_parameters
         27
         >>> classifier.count_ops()

qiskit/circuit/library/n_local/two_local.py

@@ -110,7 +110,7 @@ class TwoLocal(NLocal):
 
         >>> entangler_map = [[0, 3], [0, 2]]  # entangle the first and last two-way
         >>> two = TwoLocal(4, [], 'cry', entangler_map, reps=1)
-        >>> circuit = two + two
+        >>> circuit = two.compose(two)
         >>> print(circuit.decompose().draw())  # note, that the parameters are the same!
         q_0: ─────■───────────■───────────■───────────■──────
                   │           │           │           │

qiskit/circuit/parameterexpression.py

@@ -439,6 +439,9 @@ class ParameterExpression:
             raise TypeError("could not cast expression to int") from exc
 
     def __hash__(self):
+        if not self._parameter_symbols:
+            # For fully bound expressions, fall back to the underlying value
+            return hash(self.numeric())
         return hash((self._parameter_keys, self._symbol_expr))
 
     def __copy__(self):

qiskit/circuit/parametervector.py

@@ -50,11 +50,10 @@ class ParameterVectorElement(Parameter):
 class ParameterVector:
     """ParameterVector class to quickly generate lists of parameters."""
 
-    __slots__ = ("_name", "_params", "_size", "_root_uuid")
+    __slots__ = ("_name", "_params", "_root_uuid")
 
     def __init__(self, name, length=0):
         self._name = name
-        self._size = length
         self._root_uuid = uuid4()
         root_uuid_int = self._root_uuid.int
         self._params = [
@@ -76,32 +75,38 @@ class ParameterVector:
         return self._params.index(value)
 
     def __getitem__(self, key):
-        if isinstance(key, slice):
-            start, stop, step = key.indices(self._size)
-            return self.params[start:stop:step]
-
-        if key > self._size:
-            raise IndexError(f"Index out of range: {key} > {self._size}")
         return self.params[key]
 
     def __iter__(self):
-        return iter(self.params[: self._size])
+        return iter(self.params)
 
     def __len__(self):
-        return self._size
+        return len(self._params)
 
     def __str__(self):
-        return f"{self.name}, {[str(item) for item in self.params[: self._size]]}"
+        return f"{self.name}, {[str(item) for item in self.params]}"
 
     def __repr__(self):
         return f"{self.__class__.__name__}(name={self.name}, length={len(self)})"
 
     def resize(self, length):
-        """Resize the parameter vector.
-
-        If necessary, new elements are generated. If length is smaller than before, the
-        previous elements are cached and not re-generated if the vector is enlarged again.
+        """Resize the parameter vector.  If necessary, new elements are generated.
+
+        Note that the UUID of each :class:`.Parameter` element will be generated
+        deterministically given the root UUID of the ``ParameterVector`` and the index
+        of the element.  In particular, if a ``ParameterVector`` is resized to
+        be smaller and then later resized to be larger, the UUID of the later
+        generated element at a given index will be the same as the UUID of the
+        previous element at that index.
         This is to ensure that the parameter instances do not change.
+
+        >>> from qiskit.circuit import ParameterVector
+        >>> pv = ParameterVector("theta", 20)
+        >>> elt_19 = pv[19]
+        >>> rv.resize(10)
+        >>> rv.resize(20)
+        >>> pv[19] == elt_19
+        True
         """
         if length > len(self._params):
             root_uuid_int = self._root_uuid.int
@@ -111,4 +116,5 @@ class ParameterVector:
                     for i in range(len(self._params), length)
                 ]
             )
-        self._size = length
+        else:
+            del self._params[length:]

qiskit/circuit/quantumcircuit.py

@@ -45,7 +45,7 @@ from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.exceptions import CircuitError
 from . import _classical_resource_map
 from ._utils import sort_parameters
-from .controlflow import ControlFlowOp
+from .controlflow import ControlFlowOp, _builder_utils
 from .controlflow.builder import CircuitScopeInterface, ControlFlowBuilderBlock
 from .controlflow.break_loop import BreakLoopOp, BreakLoopPlaceholder
 from .controlflow.continue_loop import ContinueLoopOp, ContinueLoopPlaceholder
@@ -3307,6 +3307,9 @@ class QuantumCircuit:
     ) -> int:
         """Return circuit depth (i.e., length of critical path).
 
+        .. warning::
+            This operation is not well defined if the circuit contains control-flow operations.
+
         Args:
             filter_function: A function to decide which instructions count to increase depth.
                 Should take as a single positional input a :class:`CircuitInstruction`.
@@ -3332,59 +3335,40 @@ class QuantumCircuit:
 
                 assert qc.depth(lambda instr: len(instr.qubits) > 1) == 1
         """
-        # Assign each bit in the circuit a unique integer
-        # to index into op_stack.
-        bit_indices: dict[Qubit | Clbit, int] = {
-            bit: idx for idx, bit in enumerate(self.qubits + self.clbits)
+        obj_depths = {
+            obj: 0 for objects in (self.qubits, self.clbits, self.iter_vars()) for obj in objects
         }
 
-        # If no bits, return 0
-        if not bit_indices:
-            return 0
+        def update_from_expr(objects, node):
+            for var in expr.iter_vars(node):
+                if var.standalone:
+                    objects.add(var)
+                else:
+                    objects.update(_builder_utils.node_resources(var).clbits)
 
-        # A list that holds the height of each qubit
-        # and classical bit.
-        op_stack = [0] * len(bit_indices)
-
-        # Here we are playing a modified version of
-        # Tetris where we stack gates, but multi-qubit
-        # gates, or measurements have a block for each
-        # qubit or cbit that are connected by a virtual
-        # line so that they all stacked at the same depth.
-        # Conditional gates act on all cbits in the register
-        # they are conditioned on.
-        # The max stack height is the circuit depth.
         for instruction in self._data:
-            levels = []
-            reg_ints = []
-            for ind, reg in enumerate(instruction.qubits + instruction.clbits):
-                # Add to the stacks of the qubits and
-                # cbits used in the gate.
-                reg_ints.append(bit_indices[reg])
-                if filter_function(instruction):
-                    levels.append(op_stack[reg_ints[ind]] + 1)
-                else:
-                    levels.append(op_stack[reg_ints[ind]])
-            # Assuming here that there is no conditional
-            # snapshots or barriers ever.
-            if getattr(instruction.operation, "condition", None):
-                # Controls operate over all bits of a classical register
-                # or over a single bit
-                if isinstance(instruction.operation.condition[0], Clbit):
-                    condition_bits = [instruction.operation.condition[0]]
+            objects = set(itertools.chain(instruction.qubits, instruction.clbits))
+            if (condition := getattr(instruction.operation, "condition", None)) is not None:
+                objects.update(_builder_utils.condition_resources(condition).clbits)
+                if isinstance(condition, expr.Expr):
+                    update_from_expr(objects, condition)
                 else:
-                    condition_bits = instruction.operation.condition[0]
-                for cbit in condition_bits:
-                    idx = bit_indices[cbit]
-                    if idx not in reg_ints:
-                        reg_ints.append(idx)
-                        levels.append(op_stack[idx] + 1)
-
-            max_level = max(levels)
-            for ind in reg_ints:
-                op_stack[ind] = max_level
-
-        return max(op_stack)
+                    objects.update(_builder_utils.condition_resources(condition).clbits)
+            elif isinstance(instruction.operation, SwitchCaseOp):
+                update_from_expr(objects, expr.lift(instruction.operation.target))
+            elif isinstance(instruction.operation, Store):
+                update_from_expr(objects, instruction.operation.lvalue)
+                update_from_expr(objects, instruction.operation.rvalue)
+
+            # If we're counting this as adding to depth, do so.  If not, it still functions as a
+            # data synchronisation point between the objects (think "barrier"), so the depths still
+            # get updated to match the current max over the affected objects.
+            new_depth = max((obj_depths[obj] for obj in objects), default=0)
+            if filter_function(instruction):
+                new_depth += 1
+            for obj in objects:
+                obj_depths[obj] = new_depth
+        return max(obj_depths.values(), default=0)
 
     def width(self) -> int:
         """Return number of qubits plus clbits in circuit.

qiskit/dagcircuit/dagcircuit.py

@@ -544,7 +544,7 @@ class DAGCircuit:
 
     def remove_qregs(self, *qregs):
         """
-        Remove classical registers from the circuit, leaving underlying bits
+        Remove quantum registers from the circuit, leaving underlying bits
         in place.
 
         Raises:

qiskit/primitives/__init__.py

@@ -153,12 +153,12 @@ Here is an example of how a sampler is used.
     # collect 128 shots from the Bell circuit
     job = sampler.run([bell], shots=128)
     job_result = job.result()
-    print(f"The primitive-job finished with result {job_result}"))
+    print(f"The primitive-job finished with result {job_result}")
 
     # run a sampler job on the parameterized circuits
-    job2 = sampler.run([(pqc, theta1), (pqc2, theta2)]
+    job2 = sampler.run([(pqc, theta1), (pqc2, theta2)])
     job_result = job2.result()
-    print(f"The primitive-job finished with result {job_result}"))
+    print(f"The primitive-job finished with result {job_result}")
 
 
 Overview of EstimatorV1
@@ -214,7 +214,7 @@ Here is an example of how the estimator is used.
     # calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
     job = estimator.run([psi1], [H1], [theta1])
     job_result = job.result() # It will block until the job finishes.
-    print(f"The primitive-job finished with result {job_result}"))
+    print(f"The primitive-job finished with result {job_result}")
 
     # calculate [ <psi1(theta1)|H1|psi1(theta1)>,
     #             <psi2(theta2)|H2|psi2(theta2)>,

qiskit/providers/backend.py

@@ -88,12 +88,6 @@ class BackendV1(Backend, ABC):
             This next bit is necessary just because autosummary generally won't summarise private
             methods; changing that behaviour would have annoying knock-on effects through all the
             rest of the documentation, so instead we just hard-code the automethod directive.
-
-        In addition to the public abstract methods, subclasses should also implement the following
-        private methods:
-
-        .. automethod:: _default_options
-           :noindex:
         """
         self._configuration = configuration
         self._options = self._default_options()

qiskit/pulse/builder.py

@@ -74,8 +74,8 @@ a pulse:
 
 The builder initializes a :class:`.pulse.Schedule`, ``pulse_prog``
 and then begins to construct the program within the context. The output pulse
-schedule will survive after the context is exited and can be transpiled and executed like a
-normal Qiskit schedule using ``backend.run(transpile(pulse_prog, backend))``.
+schedule will survive after the context is exited and can be used like a
+normal Qiskit schedule.
 
 Pulse programming has a simple imperative style. This leaves the programmer
 to worry about the raw experimental physics of pulse programming and not

qiskit/qasm2/parse.py

@@ -16,6 +16,8 @@ import dataclasses
 import math
 from typing import Iterable, Callable
 
+import numpy as np
+
 from qiskit.circuit import (
     Barrier,
     CircuitInstruction,
@@ -30,6 +32,7 @@ from qiskit.circuit import (
     Reset,
     library as lib,
 )
+from qiskit.quantum_info import Operator
 from qiskit._accelerate.qasm2 import (
     OpCode,
     UnaryOpCode,
@@ -315,6 +318,11 @@ class _DefinedGate(Gate):
                 raise ValueError(f"received invalid bytecode to build gate: {op}")
         self._definition = qc
 
+    def __array__(self, dtype=None, copy=None):
+        if copy is False:
+            raise ValueError("unable to avoid copy while creating an array as requested")
+        return np.asarray(Operator(self.definition), dtype=dtype)
+
     # It's fiddly to implement pickling for PyO3 types (the bytecode stream), so instead if we need
     # to pickle ourselves, we just eagerly create the definition and pickle that.
 

qiskit/qasm3/exporter.py

@@ -837,7 +837,7 @@ class QASM3Builder:
                     statements.append(self.build_if_statement(instruction))
                 elif isinstance(instruction.operation, SwitchCaseOp):
                     statements.extend(self.build_switch_statement(instruction))
-                else:  # pragma: no cover
+                else:
                     raise RuntimeError(f"unhandled control-flow construct: {instruction.operation}")
                 continue
             # Build the node, ignoring any condition.
@@ -1130,7 +1130,7 @@ def _build_ast_type(type_: types.Type) -> ast.ClassicalType:
         return ast.BoolType()
     if type_.kind is types.Uint:
         return ast.UintType(type_.width)
-    raise RuntimeError(f"unhandled expr type '{type_}'")  # pragma: no cover
+    raise RuntimeError(f"unhandled expr type '{type_}'")
 
 
 class _ExprBuilder(expr.ExprVisitor[ast.Expression]):

qiskit/qpy/__init__.py

@@ -127,7 +127,7 @@ with. The following table lists the QPY versions that were supported in every
 Qiskit (and qiskit-terra prior to Qiskit 1.0.0) release going back to the introduction
 of QPY in qiskit-terra 0.18.0.
 
-.. list-table: QPY Format Version History
+.. list-table:: QPY Format Version History
    :header-rows: 1
 
    * - Qiskit (qiskit-terra for < 1.0.0) version
@@ -138,7 +138,7 @@ of QPY in qiskit-terra 0.18.0.
      - 12
    * - 1.0.2
      - 10, 11
-     - 12
+     - 11
    * - 1.0.1
      - 10, 11
      - 11

qiskit/qpy/binary_io/value.py

@@ -45,7 +45,7 @@ def _write_parameter_vec(file_obj, obj):
         struct.pack(
             formats.PARAMETER_VECTOR_ELEMENT_PACK,
             len(name_bytes),
-            obj._vector._size,
+            len(obj._vector),
             obj.uuid.bytes,
             obj._index,
         )

qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py

@@ -54,7 +54,7 @@ class SparsePauliOp(LinearOp):
     :class:`~qiskit.quantum_info.Operator` in terms of N-qubit
     :class:`~qiskit.quantum_info.PauliList` and complex coefficients.
 
-    It can be used for performing operator arithmetic for hundred of qubits
+    It can be used for performing operator arithmetic for hundreds of qubits
     if the number of non-zero Pauli basis terms is sufficiently small.
 
     The Pauli basis components are stored as a

qiskit/transpiler/passes/layout/vf2_layout.py

@@ -104,15 +104,21 @@ class VF2Layout(AnalysisPass):
                 limit on the number of trials will be set.
             target (Target): A target representing the backend device to run ``VF2Layout`` on.
                 If specified it will supersede a set value for ``properties`` and
-                ``coupling_map``.
+                ``coupling_map`` if the :class:`.Target` contains connectivity constraints. If the value
+                of ``target`` models an ideal backend without any constraints then the value of
+                ``coupling_map``
+                will be used.
 
         Raises:
             TypeError: At runtime, if neither ``coupling_map`` or ``target`` are provided.
         """
         super().__init__()
         self.target = target
-        if target is not None:
-            self.coupling_map = self.target.build_coupling_map()
+        if (
+            target is not None
+            and (target_coupling_map := self.target.build_coupling_map()) is not None
+        ):
+            self.coupling_map = target_coupling_map
         else:
             self.coupling_map = coupling_map
         self.properties = properties
@@ -145,7 +151,7 @@ class VF2Layout(AnalysisPass):
         )
         # Filter qubits without any supported operations. If they don't support any operations
         # They're not valid for layout selection
-        if self.target is not None:
+        if self.target is not None and self.target.qargs is not None:
             has_operations = set(itertools.chain.from_iterable(self.target.qargs))
             to_remove = set(range(len(cm_nodes))).difference(has_operations)
             if to_remove:

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -145,7 +145,7 @@ def score_layout(
 def build_average_error_map(target, properties, coupling_map):
     """Build an average error map used for scoring layouts pre-basis translation."""
     num_qubits = 0
-    if target is not None:
+    if target is not None and target.qargs is not None:
         num_qubits = target.num_qubits
         avg_map = ErrorMap(len(target.qargs))
     elif coupling_map is not None:
@@ -157,7 +157,7 @@ def build_average_error_map(target, properties, coupling_map):
         # object
         avg_map = ErrorMap(0)
     built = False
-    if target is not None:
+    if target is not None and target.qargs is not None:
         for qargs in target.qargs:
             if qargs is None:
                 continue

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -99,8 +99,34 @@ def generate_preset_pass_manager(
     This function is used to quickly generate a preset pass manager. A preset pass
     manager are the default pass managers used by the :func:`~.transpile`
     function. This function provides a convenient and simple method to construct
-    a standalone :class:`~.PassManager` object that mirrors what the transpile
+    a standalone :class:`~.PassManager` object that mirrors what the :func:`~.transpile`
+    function internally builds and uses.
 
+    The target constraints for the pass manager construction can be specified through a :class:`.Target`
+    instance, a :class:`.BackendV1` or :class:`.BackendV2` instance, or via loose constraints
+    (``basis_gates``, ``inst_map``, ``coupling_map``, ``backend_properties``, ``instruction_durations``,
+    ``dt`` or ``timing_constraints``).
+    The order of priorities for target constraints works as follows: if a ``target``
+    input is provided, it will take priority over any ``backend`` input or loose constraints.
+    If a ``backend`` is provided together with any loose constraint
+    from the list above, the loose constraint will take priority over the corresponding backend
+    constraint. This behavior is independent of whether the ``backend`` instance is of type
+    :class:`.BackendV1` or :class:`.BackendV2`, as summarized in the table below. The first column
+    in the table summarizes the potential user-provided constraints, and each cell shows whether
+    the priority is assigned to that specific constraint input or another input
+    (`target`/`backend(V1)`/`backend(V2)`).
+
+    ============================ ========= ======================== =======================
+    User Provided                target    backend(V1)              backend(V2)
+    ============================ ========= ======================== =======================
+    **basis_gates**              target    basis_gates              basis_gates
+    **coupling_map**             target    coupling_map             coupling_map
+    **instruction_durations**    target    instruction_durations    instruction_durations
+    **inst_map**                 target    inst_map                 inst_map
+    **dt**                       target    dt                       dt
+    **timing_constraints**       target    timing_constraints       timing_constraints
+    **backend_properties**       target    backend_properties       backend_properties
+    ============================ ========= ======================== =======================
 
     Args:
         optimization_level (int): The optimization level to generate a

qiskit/transpiler/target.py

@@ -890,7 +890,7 @@ class Target(Mapping):
             return False
         if qargs not in self._gate_map[operation_name]:
             return False
-        return getattr(self._gate_map[operation_name][qargs], "_calibration") is not None
+        return getattr(self._gate_map[operation_name][qargs], "_calibration", None) is not None
 
     def get_calibration(
         self,

qiskit/visualization/pulse_v2/device_info.py

@@ -40,7 +40,7 @@ from typing import Dict, List, Union, Optional
 
 from qiskit import pulse
 from qiskit.providers import BackendConfigurationError
-from qiskit.providers.backend import Backend
+from qiskit.providers.backend import Backend, BackendV2
 
 
 class DrawerBackendInfo(ABC):
@@ -106,40 +106,67 @@ class OpenPulseBackendInfo(DrawerBackendInfo):
         Returns:
             OpenPulseBackendInfo: New configured instance.
         """
-        configuration = backend.configuration()
-        defaults = backend.defaults()
-
-        # load name
-        name = backend.name()
-
-        # load cycle time
-        dt = configuration.dt
-
-        # load frequencies
         chan_freqs = {}
-
-        chan_freqs.update(
-            {pulse.DriveChannel(qind): freq for qind, freq in enumerate(defaults.qubit_freq_est)}
-        )
-        chan_freqs.update(
-            {pulse.MeasureChannel(qind): freq for qind, freq in enumerate(defaults.meas_freq_est)}
-        )
-        for qind, u_lo_mappers in enumerate(configuration.u_channel_lo):
-            temp_val = 0.0 + 0.0j
-            for u_lo_mapper in u_lo_mappers:
-                temp_val += defaults.qubit_freq_est[u_lo_mapper.q] * u_lo_mapper.scale
-            chan_freqs[pulse.ControlChannel(qind)] = temp_val.real
-
-        # load qubit channel mapping
         qubit_channel_map = defaultdict(list)
-        for qind in range(configuration.n_qubits):
-            qubit_channel_map[qind].append(configuration.drive(qubit=qind))
-            qubit_channel_map[qind].append(configuration.measure(qubit=qind))
-            for tind in range(configuration.n_qubits):
+
+        if hasattr(backend, "configuration") and hasattr(backend, "defaults"):
+            configuration = backend.configuration()
+            defaults = backend.defaults()
+
+            name = configuration.backend_name
+            dt = configuration.dt
+
+            # load frequencies
+            chan_freqs.update(
+                {
+                    pulse.DriveChannel(qind): freq
+                    for qind, freq in enumerate(defaults.qubit_freq_est)
+                }
+            )
+            chan_freqs.update(
+                {
+                    pulse.MeasureChannel(qind): freq
+                    for qind, freq in enumerate(defaults.meas_freq_est)
+                }
+            )
+            for qind, u_lo_mappers in enumerate(configuration.u_channel_lo):
+                temp_val = 0.0 + 0.0j
+                for u_lo_mapper in u_lo_mappers:
+                    temp_val += defaults.qubit_freq_est[u_lo_mapper.q] * u_lo_mapper.scale
+                chan_freqs[pulse.ControlChannel(qind)] = temp_val.real
+
+            # load qubit channel mapping
+            for qind in range(configuration.n_qubits):
+                qubit_channel_map[qind].append(configuration.drive(qubit=qind))
+                qubit_channel_map[qind].append(configuration.measure(qubit=qind))
+                for tind in range(configuration.n_qubits):
+                    try:
+                        qubit_channel_map[qind].extend(configuration.control(qubits=(qind, tind)))
+                    except BackendConfigurationError:
+                        pass
+        elif isinstance(backend, BackendV2):
+            # Pure V2 model doesn't contain channel frequency information.
+            name = backend.name
+            dt = backend.dt
+
+            # load qubit channel mapping
+            for qind in range(backend.num_qubits):
+                # channels are NotImplemented by default so we must catch arbitrary error.
+                try:
+                    qubit_channel_map[qind].append(backend.drive_channel(qind))
+                except Exception:  # pylint: disable=broad-except
+                    pass
                 try:
-                    qubit_channel_map[qind].extend(configuration.control(qubits=(qind, tind)))
-                except BackendConfigurationError:
+                    qubit_channel_map[qind].append(backend.measure_channel(qind))
+                except Exception:  # pylint: disable=broad-except
                     pass
+                for tind in range(backend.num_qubits):
+                    try:
+                        qubit_channel_map[qind].extend(backend.control_channel(qubits=(qind, tind)))
+                    except Exception:  # pylint: disable=broad-except
+                        pass
+        else:
+            raise RuntimeError("Backend object not yet supported")
 
         return OpenPulseBackendInfo(
             name=name, dt=dt, channel_frequency_map=chan_freqs, qubit_channel_map=qubit_channel_map

{qiskit-1.1.0.dist-info → qiskit-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qiskit
-Version: 1.1.0
+Version: 1.1.1
 Summary: An open-source SDK for working with quantum computers at the level of extended quantum circuits, operators, and primitives.
 Author-email: Qiskit Development Team <qiskit@us.ibm.com>
 License: Apache 2.0

{qiskit-1.1.0.dist-info → qiskit-1.1.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
-qiskit/VERSION.txt,sha256=bKLjNWAUJBMx-ys5lCj8ojxVjj89Qo7c9PVusP6QcGk,7
+qiskit/VERSION.txt,sha256=dMjc2JXhJypCdsbOugtKCo2X_3sayRGbj3p4aF5cRbE,7
 qiskit/__init__.py,sha256=PTwlA7M5Dus-K_dduuXXJ67b1oKWVPe2CO5ajl48wuE,5205
-qiskit/_accelerate.pyd,sha256=hvMCZHWgt3-zQSbl68ix_0myK8V1cXMJXaTpsQY6HJI,4397056
+qiskit/_accelerate.pyd,sha256=9Ds12pyIx0b5dPRRpIoMltrtktrDoOexJE9uJ3vTNqk,4185088
 qiskit/_numpy_compat.py,sha256=RkmlmU5qD-3lSt_tgnNtdj7h6Kvz8VfYWY5izxLySV0,2887
 qiskit/exceptions.py,sha256=UamBNQmDJTx6ruzmj7iXgcsrBcvkfE-bZ4TH2-K_ngw,5772
 qiskit/user_config.py,sha256=9CH_kB-b5hr2FwRJAY6SYeaPuMn6l5stZGAJ_DqDH3c,9413
@@ -10,7 +10,7 @@ qiskit/assembler/assemble_circuits.py,sha256=HX6w6kRRkDiWrPVIjMGI6M5OPmu7AYtH7sX
 qiskit/assembler/assemble_schedules.py,sha256=2H_qYFs9BuZ2-14N6y_hwSnRJhc7XvjlyRfPEt-Bu34,16024
 qiskit/assembler/disassemble.py,sha256=PejiCw2wSCxIWDjWLJCAFXGJXJiL3ziIe61yEbHeTu8,12525
 qiskit/assembler/run_config.py,sha256=xVw70UASYS5jGtac6mSK6iKCkAzn3Nux6rksbZ2eC6E,2538
-qiskit/circuit/__init__.py,sha256=aKYL_AonI_MH73zFntlFFscRpS62vOaczMKG0ltrBMA,59748
+qiskit/circuit/__init__.py,sha256=M58Xx7V2LdYsrUOyy05rA114ZqlIaD8LS-osvgm7ouE,59774
 qiskit/circuit/_classical_resource_map.py,sha256=cmB2ZvY7_r9uxBdWjnYKUguQErVrm6DB6IXt5i75Yno,7132
 qiskit/circuit/_standard_gates_commutations.py,sha256=Y9S2xI_SNSJ3OMiZQl7qRe5HsFeNK0M28coATKJ4-UQ,89014
 qiskit/circuit/_utils.py,sha256=LVSo5VKNyz-mhUet4KSR99V2vRPpAFcU-YeDFSZc3Ew,7107
@@ -33,10 +33,10 @@ qiskit/circuit/instructionset.py,sha256=xYT7kxTVKLoBE_OOwIpl5w46kvXJLouFLUiBQJwM
 qiskit/circuit/measure.py,sha256=kSmG-pF_yeT3lgAYsDO6SMcSmszPApeuLNM_EHWp0Ck,1514
 qiskit/circuit/operation.py,sha256=EJd_2FCv1jTNhk8Gr95vQ8-01tbxvN8Bfp29LnuBLuw,2086
 qiskit/circuit/parameter.py,sha256=CpRLDEFHqHBwF0otXs9vqdtfpFg0dpa3f8CP9qarG-U,7101
-qiskit/circuit/parameterexpression.py,sha256=kqJFbOHEaH0202cAcfzcHMs9cWH--hozqmLYBVHX4hE,23691
+qiskit/circuit/parameterexpression.py,sha256=8I388AZIPm5QL6zwM2OJQx36Px9Oah8ugzpKh1K4SBI,23851
 qiskit/circuit/parametertable.py,sha256=cR1rmaDO4DLya8TSjYOlgwn3p_RGmEXreD2ZdggQuiU,10096
-qiskit/circuit/parametervector.py,sha256=ADqDsapodXlNldJ80zzrpsEVotQtOp_7ux08oK1mPQY,3694
-qiskit/circuit/quantumcircuit.py,sha256=ktO40He6A4PIz5yg-m2IzVEDoZMZPsRliDp-VixuBXY,299898
+qiskit/circuit/parametervector.py,sha256=wDs0v8j3D66xovwF5j46WKV50GmHZqL8WBfs4kjznbE,3955
+qiskit/circuit/quantumcircuit.py,sha256=8kji5Kwaj4tNxaCNyPdzr2ezftPg3ECE-6XR-0Bh59c,299578
 qiskit/circuit/quantumcircuitdata.py,sha256=4Uxn0UBVvDPy5T1wqQ0sLqkbRm9oV1qWK2kQ0aQLveE,5131
 qiskit/circuit/quantumregister.py,sha256=l0GNoPpOO-cY2PK7oTr4CJeVbnMV_voEdyrcBXXbCTY,2109
 qiskit/circuit/register.py,sha256=LxDOATHKWEvXO-eQ7roWqtABVbQ-nsyI93kHHkWCiSo,8718
@@ -112,7 +112,7 @@ qiskit/circuit/library/boolean_logic/quantum_or.py,sha256=TPuBnFFTq73iirb4NG10O9
 qiskit/circuit/library/boolean_logic/quantum_xor.py,sha256=EfSMyh-6bRWdPybhllHu3DTGDPkqdvoBbn9ta023xnI,2382
 qiskit/circuit/library/data_preparation/__init__.py,sha256=8Se7T5ulK9w4UiwaBRDutXw-qCXu4ckiUcoLWo4C6-c,2302
 qiskit/circuit/library/data_preparation/initializer.py,sha256=PKuJxkUhWnLdLPIgSdvwZlsUE3UmyRqZDmweeb9KuWU,4134
-qiskit/circuit/library/data_preparation/pauli_feature_map.py,sha256=VM51q5S86ZT8TwKBRjUOkIZ75PUZZadE1OL8WDqTyB4,12900
+qiskit/circuit/library/data_preparation/pauli_feature_map.py,sha256=no7p1BZQO57kdjkZK42j-Rv1yg4yYlFKjPRBliLDGbA,12901
 qiskit/circuit/library/data_preparation/state_preparation.py,sha256=e5W3Mi3irGh5XZlOxwWtPuKxgPWAKR-8cySzRxJ3iCU,17788
 qiskit/circuit/library/data_preparation/z_feature_map.py,sha256=Fgf0b9JcIJOjswC8Ov0ozDH3fd25-iMu_HiuQjhUxSM,6451
 qiskit/circuit/library/data_preparation/zz_feature_map.py,sha256=vVXgWdrdowqK_-Y0Dbf00dLiniIP0hgcs0whvTWHkQk,6523
@@ -141,7 +141,7 @@ qiskit/circuit/library/n_local/n_local.py,sha256=tBKBZSZJZoeEgqAB_2Cy6NNcImJxSoL
 qiskit/circuit/library/n_local/pauli_two_design.py,sha256=nePU6ghb16nAHQ4oJIDuy7iZTDd6zStavfEs1hD2pxE,6280
 qiskit/circuit/library/n_local/qaoa_ansatz.py,sha256=Wm_T1kpCAV6azHyIP0O2lWqzeMSM7f3_hXbAN_fRGbo,11623
 qiskit/circuit/library/n_local/real_amplitudes.py,sha256=XhmlA9TUnhIzapzK0b9_3re-RMKUKbO_SvADcIaGN4s,14316
-qiskit/circuit/library/n_local/two_local.py,sha256=xBH9NyLIjdzGKmA2OpXzzI-Cp4n8hhgZM2mjYyv1BYg,17018
+qiskit/circuit/library/n_local/two_local.py,sha256=Hn-a-RwDxK1iU2ouR0FFVL1YERdpaxKzrSQh-PsYUNo,17025
 qiskit/circuit/library/standard_gates/__init__.py,sha256=gdy7ltiXjf-hYMtDoNRsk3LfCA5fnhGmoTy0pTzxhj0,3846
 qiskit/circuit/library/standard_gates/dcx.py,sha256=g9TMsMuoMq0aXLO5rFw5VrDUL2vL6owAsA_7Lvh_VNc,2491
 qiskit/circuit/library/standard_gates/ecr.py,sha256=VbuvPkJYDhPFeo1CFHdmeETDsO2198ZUGxWU5DCPQ0I,4811
@@ -270,7 +270,7 @@ qiskit/converters/dagdependency_to_circuit.py,sha256=4Wcdt78M5FkVTJbCiFozaTbnyUf
 qiskit/converters/dagdependency_to_dag.py,sha256=kOekDX-6ixJxmIDnpQfAtSX-llDZBDO1MPe1SuFY7Zo,1664
 qiskit/dagcircuit/__init__.py,sha256=28PM2IY8dnLbOFsWnNJ8qYh8bmJNs9mRqfCJLXZDx6Q,1236
 qiskit/dagcircuit/collect_blocks.py,sha256=yVavjvZku5ff__n0DZQw_EtY9AqW5N5v-Ke3UrF7PYA,16868
-qiskit/dagcircuit/dagcircuit.py,sha256=ZyxlKu0oz6OjwBjQLlOV1v3-eedNHn8RxHaVJAjrGZM,105921
+qiskit/dagcircuit/dagcircuit.py,sha256=-iU9hdvz1K3gSn_IUCmE3cFoQKlsSNj-FaCDheX3ZYA,105919
 qiskit/dagcircuit/dagdependency.py,sha256=6SzV_U_bRFw8lMARcs5cR7hXRnAxW-XILHJZ7MwQLws,24593
 qiskit/dagcircuit/dagdependency_v2.py,sha256=7qzS6HD6cxZdUdV8J3afixx7QRZsYb9OxEgSk5Tvlyw,25767
 qiskit/dagcircuit/dagdepnode.py,sha256=IYk05RDg2yl2Sq8eHD2jpfUywOihwWbsMysbbeVidXM,5419
@@ -282,7 +282,7 @@ qiskit/passmanager/compilation_status.py,sha256=wfmBWuaJxjzi5WZP3e6rKGLXEnee7AL5
 qiskit/passmanager/exceptions.py,sha256=oeYTNpgIr9TLGXUqyvSgHEBPQYvWrn4jTvZeFG4ZnbI,647
 qiskit/passmanager/flow_controllers.py,sha256=MSEInSYu13wg4xSnAwa9RO2B_GaC9sHIwolqP9eNnE0,4037
 qiskit/passmanager/passmanager.py,sha256=f5C2lkT1mNLwF1SeHxgiPDUjtRtMCuElwIcO00Dl1Xo,12068
-qiskit/primitives/__init__.py,sha256=52GpkR0F3h7bz75eIzSh1zcMpXpw7OdlC8vlLKJxuY0,17410
+qiskit/primitives/__init__.py,sha256=EIRcDdeTqUixoZrp-v_zmuSoDcQU4nFkgl5bx_SDKUw,17408
 qiskit/primitives/backend_estimator.py,sha256=x1PORGLQeUbCeBH9rYtYHK3xpzHQ-S5dGjxufpj8i9I,18912
 qiskit/primitives/backend_estimator_v2.py,sha256=RuxWHuf46bEiF6v02q2sqfXMUf_-vf-_oX5vi7LVnJU,17799
 qiskit/primitives/backend_sampler.py,sha256=VqHJLVLOO-Wa3GVfxfZi82edp_WV69S0Krjj8e6DCsw,8020
@@ -315,7 +315,7 @@ qiskit/primitives/containers/sampler_pub.py,sha256=LQgkp3X_ERyrYTSwX_cecqLVWZU4v
 qiskit/primitives/containers/sampler_pub_result.py,sha256=fkMyYsQPwDD-6FVfeVk06E2m81DyXjm5tZHju7y0wrk,2864
 qiskit/primitives/containers/shape.py,sha256=RMAXIMhNLiwt1WhvJbSvsyPYGgf-K5bT28fUXVMM02I,4028
 qiskit/providers/__init__.py,sha256=PwugFS2IaQTFm8hJUIEBLlkH-u2WxxaX4jhCSTV2DV8,36266
-qiskit/providers/backend.py,sha256=HQJxEB_ov2x70fRCWDZCVh2R-M-2IiQbB3nmGfgHKmY,25351
+qiskit/providers/backend.py,sha256=ZGNjvguCJ6BQNDRS7m-rMJrFJlqk3OASO5yEp-ALJys,25157
 qiskit/providers/backend_compat.py,sha256=88kTdcXbZ_u10e1TNr0JQBZDQx91ApIAzgQw3NVkkHw,19179
 qiskit/providers/exceptions.py,sha256=-bvWhJW0KXjIamvZP3xyUnlGovIr_eoFO5hQxy2_zQE,1214
 qiskit/providers/job.py,sha256=WVWt5KznhzEHwMJ-BxXcSjI-YpUGA5lxWMy7tEbsElM,5195
@@ -371,7 +371,7 @@ qiskit/providers/models/backendstatus.py,sha256=HtmjmOaWDk_IFnG3hz_10vXo-Zi94o6H
 qiskit/providers/models/jobstatus.py,sha256=tbWUMxGV4QkW1w2894XKsj5R-QO9NNrNBScraJRqL5E,2013
 qiskit/providers/models/pulsedefaults.py,sha256=OVV8GiDvxZYxdLPA_SIHM4PDTwsVJvdUrDMELLR8JRA,10774
 qiskit/pulse/__init__.py,sha256=qTnVoMBAx8QAnULuc1xl6737gzyZ_zPQQKPaNJka1sY,4019
-qiskit/pulse/builder.py,sha256=WOTWq0ooDIdwIBb5HiCaFsPJ9Dsz8YFriPxG8duYgdU,73311
+qiskit/pulse/builder.py,sha256=hyuOgbyRHnn3iSK7L4i3Mbrm9Q9sfdJeu05XP5eO5JY,73238
 qiskit/pulse/calibration_entries.py,sha256=uNXGUZRLbBWFEPC5-P5WT0O0r3Fw0ufavQ-OpNvpkgU,14234
 qiskit/pulse/channels.py,sha256=YqCVqTcGr1INqZRWSBZq3-adgAWPBJVRNLG_P11OQvM,7660
 qiskit/pulse/configuration.py,sha256=9dqg1EOZ8iuc4G5_L7wysapnYc300ZHJE6xWk94kc6A,8122
@@ -413,12 +413,12 @@ qiskit/qasm/libs/dummy/stdgates.inc,sha256=2AlDwtsjKDozEEfmXLN9ae1Dfy6rMC9-1Za9a
 qiskit/qasm2/__init__.py,sha256=KnBPjbtzQX_csz-ml90YwrP5EcyD-IDVRaDgAP56O4k,25768
 qiskit/qasm2/exceptions.py,sha256=MxBVJ6OQOPsJV2c5qjPDRZ7TRoK2jFAFFP9iytB7HzI,950
 qiskit/qasm2/export.py,sha256=3wBWrH4ixSvqEhSVnxmgW-xwf9jVELXfXRjSQ0Oe_jk,13651
-qiskit/qasm2/parse.py,sha256=oYoGmBa7nQT_sviuYi07iuzCcDcYgh5rWgIagvNSnbI,17519
+qiskit/qasm2/parse.py,sha256=sLBSnk29FouJNx7IsWfPSSRUw-GdyZwrhJqXzl6WT7U,17819
 qiskit/qasm3/__init__.py,sha256=8rMz61K4rTXwJFYgG2mjfcNXKPn3H9L69yqpezBaecA,13603
 qiskit/qasm3/ast.py,sha256=-QSKUyRBVT2rRh5nRBUnC98YG3uBr0wNqr0CgsiiZLU,16632
 qiskit/qasm3/exceptions.py,sha256=dlLYUf4zVG1L4ccvXG0MVtzzcIYqshjBejWRz031ykQ,936
 qiskit/qasm3/experimental.py,sha256=cwIF1YlMzZPvR2BgY3n1D6-TqNTko83Y-qzuKO4c8vw,2062
-qiskit/qasm3/exporter.py,sha256=vXvPwClQ0vRm-PRJQMNdPIMhiCRnyOtx6CgVurRcEvY,55089
+qiskit/qasm3/exporter.py,sha256=7EPCdTZ312HgqK-kNykXxMM7LGLybsWE5cwyk8GyBD4,55049
 qiskit/qasm3/printer.py,sha256=r6V_XHHjlurzTKxCxzNuo9e1NOXvooTsVHNMXeRnwQE,22356
 qiskit/qobj/__init__.py,sha256=xQxWIQ7MUJ0Ovo24Ii2JeUKtzeS4jcIhe2FecQZAJ4U,2024
 qiskit/qobj/common.py,sha256=kDAZYND6HpgNeiXP4BpX_-Rv4TXiSNLzm1tHVwZOlKs,2180
@@ -428,7 +428,7 @@ qiskit/qobj/utils.py,sha256=WktCR0agE6LPP9tStWmXRsCJjvMFy7-RzKb-45s9ip8,934
 qiskit/qobj/converters/__init__.py,sha256=eouPijW91tEX8ptE86TbAOYw53VWNC8lqZpxe4O8LKY,709
 qiskit/qobj/converters/lo_config.py,sha256=RdG3GsVDH0s2iKsRyWD4o1dql_RcBD0QGKlMUnrI1ZM,6630
 qiskit/qobj/converters/pulse_instruction.py,sha256=-Gv997JTgESSfCtlezBjTeVSVQFryBPvP5tzPQdthds,30973
-qiskit/qpy/__init__.py,sha256=BQuxRwjuMx24kh_fThECCOi_u2xTEoP0gaD1XByBQmk,58100
+qiskit/qpy/__init__.py,sha256=N5HEforbnQRZh_jehEod2HRDN2fgQOSnhFSJOpaMJH0,58101
 qiskit/qpy/common.py,sha256=kKc8VZQP2wzezcYOG0aReyi_HupTFr99z_sNXqIGQOk,10593
 qiskit/qpy/exceptions.py,sha256=BX1ILW35oUPDmotmttybw2bY1IvUwziOVpsf7z_mIkY,1900
 qiskit/qpy/formats.py,sha256=kxItULKeSVP70rjUjzERSmA1bq19mMJijOwRVOdJEq8,11663
@@ -437,7 +437,7 @@ qiskit/qpy/type_keys.py,sha256=i1l-be3tSjQMbcCkJEMUF2xBEz4BNazPtIwVmp96Bno,16331
 qiskit/qpy/binary_io/__init__.py,sha256=kBTRGy5cJdiDk-X1CSjSEpgLV-i_xT0IqcmI1a_AhOY,1109
 qiskit/qpy/binary_io/circuits.py,sha256=clQwvu38kErdX3sSBS6JtSP2oFPO6nRSrVPhK9oP9WU,58434
 qiskit/qpy/binary_io/schedules.py,sha256=FB90J0rGviR2PnNWRHwMxvpeC-7jdV9UW4mzgBlLfLw,24549
-qiskit/qpy/binary_io/value.py,sha256=B794HhcnXnB1K2eShgSEvEdxe5v3Ln17rm-_Cwpxe2g,29302
+qiskit/qpy/binary_io/value.py,sha256=aftPBM6jOo9ctkf8oJn5tlk5p7Y05zfM3UEqfbH2NTA,29301
 qiskit/quantum_info/__init__.py,sha256=n8hLJIMlnYnxOAGHxF1bkd4q_CRGphhYIqhic1FYjMo,3497
 qiskit/quantum_info/quaternion.py,sha256=7GfudivfOREo-XrL-lnNkaqOF_-Sy9yEu8IkfAUOA2I,5076
 qiskit/quantum_info/random.py,sha256=N9f6Vgo_oWf03xbV3drM6Pmi0jWw7w2SC6hpO5BQiaE,941
@@ -484,7 +484,7 @@ qiskit/quantum_info/operators/symplectic/pauli.py,sha256=T9kgBSYOLoukFlduipcfenY
 qiskit/quantum_info/operators/symplectic/pauli_list.py,sha256=-NOxF9sDxHPGFRONi_D-TCaq-hP6tXWUMqO_AnvduHs,47436
 qiskit/quantum_info/operators/symplectic/pauli_utils.py,sha256=mK4Unq150o-Mxz90OxZKEFH_ViQuMFpLYRbuYJEWFmE,1342
 qiskit/quantum_info/operators/symplectic/random.py,sha256=YNzT-f_3Y4h0GVzpaFcZWF1O-Rwi9fW37wVRHaO65Rc,9161
-qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py,sha256=fxBwLSSulOd_n0r7XGwqauxxO4cm-1rfm288Entp6Jo,48091
+qiskit/quantum_info/operators/symplectic/sparse_pauli_op.py,sha256=UhMhsv6iu-UhSnG7et7CyFynwDVDVmniBb8W_nUyTuc,48092
 qiskit/quantum_info/operators/utils/__init__.py,sha256=lzQzcOH2CG2pPKkGT54lMIUTres_kprzbmMTVrI646c,724
 qiskit/quantum_info/operators/utils/anti_commutator.py,sha256=rTJvRxRxK1-CvCABRD0dE8e0OSDXPiA_0wV_IahhzAs,1013
 qiskit/quantum_info/operators/utils/commutator.py,sha256=xGwTSrqUvlt93VLdKknmxx4xRKtHRAYmovRY-364gWk,993
@@ -598,7 +598,7 @@ qiskit/transpiler/instruction_durations.py,sha256=MDapHK_QWKFnas8PtcUUP_Q2Z7JUxo
 qiskit/transpiler/layout.py,sha256=-HDL9VFBgwN5OQcoRUJWXizalr9XaoSA0JIBULr_YAA,28818
 qiskit/transpiler/passmanager.py,sha256=KakI7BZyCt0WfU1yVstlqPeyCRGgyTSUFRJdZxmd3TM,20687
 qiskit/transpiler/passmanager_config.py,sha256=kFsJ6EdGtAmoRxWJW4Cb4__fWX7OrTv4SccwWsrxgj4,9413
-qiskit/transpiler/target.py,sha256=SP4Eqg14egtKc5v1T68-opYirw36htHTbzKY9a_K_EY,73649
+qiskit/transpiler/target.py,sha256=mBdgzixGnMCIBfTQlkCu2WunDwdGjIomunELSUVOKC0,73655
 qiskit/transpiler/timing_constraints.py,sha256=YMwO31Im7h0Wxgu11ZPyp5uy60l5Ys24Oepa66M4sD8,2441
 qiskit/transpiler/passes/__init__.py,sha256=avKaK0s0H9uJY_-NSpXQ_CHkwN6jb588P2bJpsfi4o4,8032
 qiskit/transpiler/passes/analysis/__init__.py,sha256=ygrX-YFaHzfMLqf53ftQ-2DXO4_4PwSEOHkYZkOuMXg,898
@@ -638,9 +638,9 @@ qiskit/transpiler/passes/layout/sabre_layout.py,sha256=-IsKcnhNd6ipyfFLUt8Pm5xRl
 qiskit/transpiler/passes/layout/sabre_pre_layout.py,sha256=UGKRc_D4PQQxwdVrdf0enKl2FhREDeEUIGUaF7QHINM,9275
 qiskit/transpiler/passes/layout/set_layout.py,sha256=mnRg2YdQ_u64pqDLpXox-pOYn--68UuXgM-6lKdBhHs,2576
 qiskit/transpiler/passes/layout/trivial_layout.py,sha256=E4JV8B_aomdILUNorxvFN_memUJ2oR3apGtXHnJNSRQ,2445
-qiskit/transpiler/passes/layout/vf2_layout.py,sha256=zpyTRwEGtCi2Hl3hKDXl1npTIa6vO5IlcFq0luhs_So,11863
+qiskit/transpiler/passes/layout/vf2_layout.py,sha256=JhuLg3r6AUgiEUnZ8Kycl4ccUYCle1UTNBG7O49GgZY,12230
 qiskit/transpiler/passes/layout/vf2_post_layout.py,sha256=apt6L42IpQLi21ZMZcrlgVs_1hD7_elyZ_rA3-YBWgI,20103
-qiskit/transpiler/passes/layout/vf2_utils.py,sha256=dzuiy9vlOSQx5pEnV3tYGM9lNuMKjT0X_898mE8Egwg,11033
+qiskit/transpiler/passes/layout/vf2_utils.py,sha256=ok8rT51qziNzFXyOOJIDhVHt4VywymnRiIWJY8oyXT0,11091
 qiskit/transpiler/passes/optimization/__init__.py,sha256=_qFlllN45SqoGGDz8nFXOat4U7EmP2NzRsAgOPj2-UA,2067
 qiskit/transpiler/passes/optimization/_gate_extension.py,sha256=FAizDJc9m0y1blUd28qZK0rCKDeiK48fOvYh1lghAZ0,3386
 qiskit/transpiler/passes/optimization/collect_1q_runs.py,sha256=JGzjVY_TdtNAST8ZSrjtg6fEFj8UVEGATneuGlx-DtQ,1145
@@ -739,7 +739,7 @@ qiskit/transpiler/passes/utils/minimum_point.py,sha256=B4mjyZmKQcMQoTA8bhLbIPXXt
 qiskit/transpiler/passes/utils/remove_barriers.py,sha256=6tt0RX7mFpHubyQe22uSVSEMQJm-IAqIaXIibjBloUw,1463
 qiskit/transpiler/passes/utils/remove_final_measurements.py,sha256=VWFXt3_IhmuS7XgxKJodL2WdEOdhfgxtRmxGnUFN6jA,4831
 qiskit/transpiler/passes/utils/unroll_forloops.py,sha256=mkjucqYOXyfJpCT3dtXUMJeiEUoi6NegGfAubXmmZRo,3201
-qiskit/transpiler/preset_passmanagers/__init__.py,sha256=BZea_OE81DKw_3EjgwDzsdljuzNOXk5B9YDlCgDjtMo,13171
+qiskit/transpiler/preset_passmanagers/__init__.py,sha256=wcHVUBLRxSl_f4z_uXvVjfqHcQGVkm4ni3U1EwKih60,15276
 qiskit/transpiler/preset_passmanagers/builtin_plugins.py,sha256=tHt9yWaOpjFqJ7zl6iAioScPlwJ8PtYhSNc3aUr_Iqs,41096
 qiskit/transpiler/preset_passmanagers/common.py,sha256=HDSbsy9-9plLLihY8jRgv7qXb2DfilYcD3vu5vBhoDk,26558
 qiskit/transpiler/preset_passmanagers/level0.py,sha256=sW9M7wxJwR0lDkjRcJzV7LQXA53rDgXmLyRWDWhSerM,4395
@@ -783,7 +783,7 @@ qiskit/visualization/circuit/styles/iqp.json,sha256=aQPwtgjjO9YH10g37pfp65CzH9tA
 qiskit/visualization/circuit/styles/textbook.json,sha256=-2PK89N8_nTIQ_1FfdSbwvLar1HY75xwmQ_Ey3ehJ0A,4081
 qiskit/visualization/pulse_v2/__init__.py,sha256=DM6NXc90jzLxrLXmLV3UMPCkqy9PwtBbdLp8qoWm8R8,710
 qiskit/visualization/pulse_v2/core.py,sha256=nnmIUvGEfVrZDH8DYVsKDmJZRLQOJ_zQpgBCpicvj8Y,34412
-qiskit/visualization/pulse_v2/device_info.py,sha256=_cSHAOrIlBFQ7a19EPZ-WmA2j55Y5FJ3mZu4N0R7OA8,5788
+qiskit/visualization/pulse_v2/device_info.py,sha256=BDMuwbDVLD2Io9aQdGMx-9ShtnQgl_5fhtqrTA5KR1Y,7197
 qiskit/visualization/pulse_v2/drawings.py,sha256=nAHNBYaA_aMgW0H52DALOUzNBEcUBlP5edhqJrMN0D0,9791
 qiskit/visualization/pulse_v2/events.py,sha256=ntqeacv0r_OVA8XvIDuR8E75PGvAdauGWnoL3wMe4wQ,10644
 qiskit/visualization/pulse_v2/interface.py,sha256=hsjsu971lb6rciNa_zKSVmM4GGyQL84IC1yjqj-jbAA,25122
@@ -810,9 +810,9 @@ qiskit/visualization/timeline/types.py,sha256=jtpipQWUpahayNPQYKUst4GG6BqauovO0q
 qiskit/visualization/timeline/plotters/__init__.py,sha256=Klg9a1cSUIQhc815g8OpnD5vO1hcI51L9KlFfKzcuRg,588
 qiskit/visualization/timeline/plotters/base_plotter.py,sha256=taRkL2ZbyorRUEf6nJS8egdzKW2eznQ3w5oBLtMG_U8,1805
 qiskit/visualization/timeline/plotters/matplotlib.py,sha256=WwLfEm3-fS8BQMxwExmiIpcwvt7IAak4pYyTGNFZdbI,7144
-qiskit-1.1.0.dist-info/LICENSE.txt,sha256=pUbmRuPr1gJTTTWZu2c8UmNSntz-pDdKfGR-86NRkok,11619
-qiskit-1.1.0.dist-info/METADATA,sha256=m22DIzgTXLM4AygLse6FcLKPtCzeKDyCKyahafpzjs4,13130
-qiskit-1.1.0.dist-info/WHEEL,sha256=Aavq5XXl58tL6bL-VsXq6M2KHwSF4I7YrvRYfeAzm5A,100
-qiskit-1.1.0.dist-info/entry_points.txt,sha256=uQCOTD4Z3t6tvAzZ5Ql1hwGTDdKvYWfW93C8oTvYH80,3301
-qiskit-1.1.0.dist-info/top_level.txt,sha256=_vjFXLv7qrHyJJOC2-JXfG54o4XQygW9GuQPxgtSt9Q,7
-qiskit-1.1.0.dist-info/RECORD,,
+qiskit-1.1.1.dist-info/LICENSE.txt,sha256=pUbmRuPr1gJTTTWZu2c8UmNSntz-pDdKfGR-86NRkok,11619
+qiskit-1.1.1.dist-info/METADATA,sha256=RxYcmOaofompo7DYm5qLD9HexRyPJ7NsGnmES6_XYfk,13130
+qiskit-1.1.1.dist-info/WHEEL,sha256=Aavq5XXl58tL6bL-VsXq6M2KHwSF4I7YrvRYfeAzm5A,100
+qiskit-1.1.1.dist-info/entry_points.txt,sha256=uQCOTD4Z3t6tvAzZ5Ql1hwGTDdKvYWfW93C8oTvYH80,3301
+qiskit-1.1.1.dist-info/top_level.txt,sha256=_vjFXLv7qrHyJJOC2-JXfG54o4XQygW9GuQPxgtSt9Q,7
+qiskit-1.1.1.dist-info/RECORD,,