qiskit 1.1.0__cp38-abi3-manylinux_2_17_i686.manylinux2014_i686.whl → 1.1.1__cp38-abi3-manylinux_2_17_i686.manylinux2014_i686.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