qiskit 1.4.1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/quantum_info/states/stabilizerstate.py

@@ -24,7 +24,7 @@ import numpy as np
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.op_shape import OpShape
 from qiskit.quantum_info.operators.operator import Operator
-from qiskit.quantum_info.operators.symplectic import Clifford, Pauli, PauliList
+from qiskit.quantum_info.operators.symplectic import Clifford, Pauli, PauliList, SparsePauliOp
 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
@@ -38,7 +38,9 @@ class StabilizerState(QuantumState):
     Stabilizer simulator using the convention from reference [1].
     Based on the internal class :class:`~qiskit.quantum_info.Clifford`.
 
-    .. code-block::
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit import QuantumCircuit
         from qiskit.quantum_info import StabilizerState, Pauli
@@ -67,7 +69,9 @@ class StabilizerState(QuantumState):
     Given a list of stabilizers, :meth:`qiskit.quantum_info.StabilizerState.from_stabilizer_list`
     returns a state stabilized by the list
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit.quantum_info import StabilizerState
 
@@ -255,7 +259,34 @@ class StabilizerState(QuantumState):
         ret._data = self.clifford.compose(other.clifford, qargs=qargs)
         return ret
 
-    def expectation_value(self, oper: Pauli, qargs: None | list = None) -> complex:
+    def expectation_value(self, oper: Pauli | SparsePauliOp, qargs: None | list = None) -> complex:
+        """Compute the expectation value of a Pauli or SparsePauliOp operator.
+
+        Args:
+            oper: A Pauli or SparsePauliOp operator to evaluate the expectation value.
+            qargs: Subsystems to apply the operator on.
+
+        Returns:
+            The expectation value.
+
+        Raises:
+            QiskitError: if oper is not a Pauli or SparsePauliOp operator.
+        """
+        if isinstance(oper, Pauli):
+            return self._expectation_value_pauli(oper, qargs)
+
+        if isinstance(oper, SparsePauliOp):
+            return sum(
+                coeff * self._expectation_value_pauli(Pauli((z, x)), qargs)
+                for z, x, coeff in zip(oper.paulis.z, oper.paulis.x, oper.coeffs)
+            )
+
+        raise QiskitError(
+            "Operator for expectation value is not a Pauli or SparsePauliOp operator, "
+            f"but {type(oper)}."
+        )
+
+    def _expectation_value_pauli(self, oper: Pauli, qargs: None | list = None) -> complex:
         """Compute the expectation value of a Pauli operator.
 
         Args:

qiskit/quantum_info/states/statevector.py

@@ -198,7 +198,7 @@ class Statevector(QuantumState, TolerancesMixin):
     def _ipython_display_(self):
         out = self.draw()
         if isinstance(out, str):
-            print(out)
+            print(out)  # pylint: disable=bad-builtin
         else:
             from IPython.display import display
 
@@ -545,7 +545,9 @@ class Statevector(QuantumState, TolerancesMixin):
             Consider a 2-qubit product state
             :math:`|\\psi\\rangle=|+\\rangle\\otimes|0\\rangle`.
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 from qiskit.quantum_info import Statevector
 
@@ -572,7 +574,9 @@ class Statevector(QuantumState, TolerancesMixin):
             We can also permute the order of qubits in the ``qargs`` list
             to change the qubit position in the probabilities output
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 from qiskit.quantum_info import Statevector
 
@@ -796,7 +800,9 @@ class Statevector(QuantumState, TolerancesMixin):
             The ket-form of a 2-qubit statevector
             :math:`|\psi\rangle = |-\rangle\otimes |0\rangle`
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 from qiskit.quantum_info import Statevector
 
@@ -810,7 +816,9 @@ class Statevector(QuantumState, TolerancesMixin):
             For non-qubit subsystems the integer range can go from 0 to 9. For
             example in a qutrit system
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 import numpy as np
                 from qiskit.quantum_info import Statevector
@@ -829,7 +837,9 @@ class Statevector(QuantumState, TolerancesMixin):
             following example is for a 20-dimensional system consisting of
             a qubit and 10-dimensional qudit.
 
-            .. code-block::
+            .. plot::
+               :include-source:
+               :nofigs:
 
                 import numpy as np
                 from qiskit.quantum_info import Statevector

qiskit/result/__init__.py

@@ -48,26 +48,14 @@ Expectation values
 
 .. autofunction:: sampled_expectation_value
 
-Mitigation
-==========
-.. autosummary::
-   :toctree: ../stubs/
-
-   BaseReadoutMitigator
-   CorrelatedReadoutMitigator
-   LocalReadoutMitigator
-
 """
 
-from .result import Result
+from .counts import Counts
+from .distributions import QuasiDistribution, ProbDistribution
 from .exceptions import ResultError
+from .models import MeasLevel, MeasReturnType
+from .result import Result
+from .sampled_expval import sampled_expectation_value
 from .utils import marginal_counts
 from .utils import marginal_distribution
 from .utils import marginal_memory
-from .counts import Counts
-
-from .distributions import QuasiDistribution, ProbDistribution
-from .sampled_expval import sampled_expectation_value
-from .mitigation.base_readout_mitigator import BaseReadoutMitigator
-from .mitigation.correlated_readout_mitigator import CorrelatedReadoutMitigator
-from .mitigation.local_readout_mitigator import LocalReadoutMitigator

qiskit/result/models.py

@@ -13,13 +13,26 @@
 """Schema and helper models for schema-conformant Results."""
 
 import copy
-import warnings
+from enum import Enum, IntEnum
 
-from qiskit.qobj.utils import MeasReturnType, MeasLevel
-from qiskit.qobj import QobjExperimentHeader
 from qiskit.exceptions import QiskitError
 
 
+class MeasReturnType(str, Enum):
+    """meas_return allowed values defined by legacy PulseQobjConfig object but still used by Result."""
+
+    AVERAGE = "avg"
+    SINGLE = "single"
+
+
+class MeasLevel(IntEnum):
+    """MeasLevel allowed values defined by legacy PulseQobjConfig object but still used by Result."""
+
+    RAW = 0
+    KERNELED = 1
+    CLASSIFIED = 2
+
+
 class ExperimentResultData:
     """Class representing experiment result data"""
 
@@ -132,7 +145,7 @@ class ExperimentResult:
             status (str): The status of the experiment
             seed (int): The seed used for simulation (if run on a simulator)
             meas_return (str): The type of measurement returned
-            header (qiskit.qobj.QobjExperimentHeader): A free form dictionary
+            header (dict): A free form dictionary
                 header for the experiment
             kwargs: Arbitrary extra fields
 
@@ -197,7 +210,7 @@ class ExperimentResult:
             "meas_level": self.meas_level,
         }
         if hasattr(self, "header"):
-            out_dict["header"] = self.header.to_dict()
+            out_dict["header"] = self.header
         if hasattr(self, "status"):
             out_dict["status"] = self.status
         if hasattr(self, "seed"):
@@ -223,11 +236,6 @@ class ExperimentResult:
 
         in_data = copy.copy(data)
         data_obj = ExperimentResultData.from_dict(in_data.pop("data"))
-        if "header" in in_data:
-            with warnings.catch_warnings():
-                # The class QobjExperimentHeader is deprecated
-                warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-                in_data["header"] = QobjExperimentHeader.from_dict(in_data.pop("header"))
         shots = in_data.pop("shots")
         success = in_data.pop("success")
 

qiskit/result/result.py

@@ -12,154 +12,60 @@
 
 """Model for schema-conformant Results."""
 
-from collections.abc import Iterable
 import copy
 import warnings
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.pulse.schedule import Schedule
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.states import statevector
-from qiskit.result.models import ExperimentResult
+from qiskit.result.models import ExperimentResult, MeasLevel
 from qiskit.result import postprocess
 from qiskit.result.counts import Counts
-from qiskit.qobj.utils import MeasLevel
-from qiskit.qobj import QobjHeader
-
-_MISSING = object()
 
 
 class Result:
     """Model for Results.
 
-    .. deprecated:: 1.4
-        The use of positional arguments in the constructor of :class:`.Result`
-        is deprecated as of Qiskit 1.4, and will be disabled in Qiskit 2.0.
-        Please set all arguments using kwarg syntax, i.e: ``Result(backend_name="name", ....)``.
-        In addition to this, the ``qobj_id`` argument is deprecated and will no longer
-        be used in Qiskit 2.0. It will, however, still be possible to set ``qobj_id`` as a
-        generic kwarg, which will land in the metadata field with the other generic kwargs.
-
-    Args:
-        backend_name (str): (REQUIRED) backend name.
-        backend_version (str): (REQUIRED) backend version, in the form X.Y.Z.
-        qobj_id (str): (REQUIRED) user-generated Qobj id.
-        job_id (str): (REQUIRED) unique execution id from the backend.
-        success (bool): (REQUIRED) True if complete input qobj executed correctly. (Implies
+    Attributes:
+        backend_name (str): backend name.
+        backend_version (str): backend version, in the form X.Y.Z.
+        job_id (str): unique execution id from the backend.
+        success (bool): True if complete input executed correctly. (Implies
             each experiment success)
-        results (list[ExperimentResult]): (REQUIRED) corresponding results for array of
-            experiments of the input qobj
-        date (str): (OPTIONAL) date of the experiment
-        header(dict): (OPTIONAL)experiment header
-        kwargs: generic keyword arguments. (OPTIONAL) These will be stored in the metadata field.
+        results (list[ExperimentResult]): corresponding results for array of
+            experiments of the input
     """
 
     _metadata = {}
 
     def __init__(
         self,
-        *args,
+        *,
+        backend_name=None,
+        backend_version=None,
+        job_id=None,
+        success=None,
+        results=None,
         date=None,
         status=None,
         header=None,
         **kwargs,
     ):
-        # The following arguments are required.
-        required_args = {
-            "backend_name": _MISSING,
-            "backend_version": _MISSING,
-            "qobj_id": _MISSING,
-            "job_id": _MISSING,
-            "success": _MISSING,
-            "results": _MISSING,
-        }
-        # Step 1: iterate over kwargs.
-        # An item from required_args might be set as a kwarg, so we must separate
-        # true kwargs from "required_args" kwargs.
-        true_kwargs = {}
-        for key, value in kwargs.items():
-            if key in required_args:
-                required_args[key] = value
-            else:
-                true_kwargs[key] = value
-        # Step 2: iterate over args, which are expected in the order of the index_map below.
-        index_map = ["backend_name", "backend_version", "qobj_id", "job_id", "success", "results"]
-        raise_qobj = False
-        missing_args = []
-        for index, name in enumerate(index_map):
-            try:
-                value = args[index]
-                required_args[name] = value
-                # The use of args is deprecated in 1.4 and will be removed in 2.0.
-                # Furthermore, qobj_id will be ignored if set as a kwarg in 2.0.
-                if name == "qobj_id":
-                    warnings.warn(
-                        "The use of positional arguments in `qiskit.result.result.Result.__init__()` "
-                        "is deprecated as of Qiskit 1.4, and will be disabled in Qiskit 2.0. "
-                        "Please set this value using kwarg syntax, "
-                        f"i.e: `Result(...,{name}={name}_value)`. "
-                        "The `qobj_id` argument will no longer be used in Qiskit 2.0, "
-                        "but it will still be possible to "
-                        "set as a kwarg that will land in the metadata field.",
-                        category=DeprecationWarning,
-                        stacklevel=2,
-                    )
-                else:
-                    warnings.warn(
-                        "The use of positional arguments in `qiskit.result.result.Result.__init__()` "
-                        "is deprecated as of Qiskit 1.4, and will be disabled in Qiskit 2.0. "
-                        "Please set this value using kwarg syntax, "
-                        f"i.e: `Result(...,{name}={name}_value)`. ",
-                        category=DeprecationWarning,
-                        stacklevel=2,
-                    )
-            except IndexError:
-                if required_args[name] is _MISSING:
-                    missing_args = [
-                        key for (key, value) in required_args.items() if value is _MISSING
-                    ]
-                elif name == "qobj_id":
-                    raise_qobj = True
-                break
-
-        # The deprecation warning should be raised outside of the try-except,
-        # not to show a confusing trace that points to the IndexError
-        if len(missing_args) > 1:
-            raise TypeError(
-                f"Result.__init__() missing {len(missing_args)} required arguments: {missing_args}"
-            )
-        if len(missing_args) == 1:
-            raise TypeError(f"Result.__init__() missing a required argument: {missing_args[0]}")
-        if raise_qobj:
-            # qobj_id will be ignored if set as a kwarg in 2.0.
-            warnings.warn(
-                "The `qobj_id` argument will no longer be used in Qiskit 2.0, "
-                "but it will still be possible to "
-                "set as a kwarg that will land in the metadata field.",
-                category=DeprecationWarning,
-                stacklevel=2,
-            )
-
         self._metadata = {}
-        self.backend_name = required_args["backend_name"]
-        self.backend_version = required_args["backend_version"]
-        self.qobj_id = required_args["qobj_id"]
-        self.job_id = required_args["job_id"]
-        self.success = required_args["success"]
-        self.results = (
-            [required_args["results"]]
-            if not isinstance(required_args["results"], Iterable)
-            else required_args["results"]
-        )
+        self.backend_name = backend_name
+        self.backend_version = backend_version
+        self.job_id = job_id
+        self.success = success
+        self.results = results
         self.date = date
         self.status = status
         self.header = header
-        self._metadata.update(true_kwargs)
+        self._metadata.update(kwargs)
 
     def __repr__(self):
         out = (
             f"Result(backend_name='{self.backend_name}', backend_version='{self.backend_version}',"
-            f" qobj_id='{self.qobj_id}', job_id='{self.job_id}', success={self.success},"
+            f" job_id='{self.job_id}', success={self.success},"
             f" results={self.results}"
         )
         out += f", date={self.date}, status={self.status}, header={self.header}"
@@ -183,7 +89,6 @@ class Result:
             "backend_version": self.backend_version,
             "date": self.date,
             "header": None if self.header is None else self.header.to_dict(),
-            "qobj_id": self.qobj_id,
             "job_id": self.job_id,
             "status": self.status,
             "success": self.success,
@@ -213,10 +118,6 @@ class Result:
 
         in_data = copy.copy(data)
         in_data["results"] = [ExperimentResult.from_dict(x) for x in in_data.pop("results")]
-        if in_data.get("header") is not None:
-            with warnings.catch_warnings():
-                warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-                in_data["header"] = QobjHeader.from_dict(in_data.pop("header"))
         return cls(**in_data)
 
     def data(self, experiment=None):
@@ -301,7 +202,7 @@ class Result:
         exp_result = self._get_experiment(experiment)
         try:
             try:  # header is not available
-                header = exp_result.header.to_dict()
+                header = exp_result.header
             except (AttributeError, QiskitError):
                 header = None
 
@@ -352,7 +253,7 @@ class Result:
         for key in exp_keys:
             exp = self._get_experiment(key)
             try:
-                header = exp.header.to_dict()
+                header = exp.header
             except (AttributeError, QiskitError):  # header is not available
                 header = None
 
@@ -443,8 +344,8 @@ class Result:
                 )
             key = 0
 
-        # Key is a QuantumCircuit/Schedule or str: retrieve result by name.
-        if isinstance(key, (QuantumCircuit, Schedule)):
+        # Key is a QuantumCircuit or str: retrieve result by name.
+        if isinstance(key, QuantumCircuit):
             key = key.name
         # Key is an integer: return result by index.
         if isinstance(key, int):
@@ -453,11 +354,12 @@ class Result:
             except IndexError as ex:
                 raise QiskitError(f'Result for experiment "{key}" could not be found.') from ex
         else:
-            # Look into `result[x].header.name` for the names.
+            # Look into `result[x].header["name"]` for the names.
             exp = [
                 result
                 for result in self.results
-                if getattr(getattr(result, "header", None), "name", "") == key
+                if getattr(result, "header", None) is not None
+                and getattr(result, "header").get("name", "") == key
             ]
 
             if len(exp) == 0:

qiskit/result/sampled_expval.py

@@ -30,8 +30,7 @@ def sampled_expectation_value(dist, oper):
 
     Parameters:
         dist (Counts or QuasiDistribution or ProbDistribution or dict): Input sampled distribution
-        oper (str or Pauli or PauliOp or PauliSumOp or SparsePauliOp): The operator for
-                                                                       the observable
+        oper (str or Pauli or SparsePauliOp): The operator for the observable
 
     Returns:
         float: The expectation value

qiskit/result/utils.py

@@ -24,7 +24,6 @@ from qiskit.result.result import Result
 from qiskit.result.counts import Counts
 from qiskit.result.distributions.probability import ProbDistribution
 from qiskit.result.distributions.quasi import QuasiDistribution
-
 from qiskit.result.postprocess import _bin_to_hex
 
 from qiskit._accelerate import results as results_rs  # pylint: disable=no-name-in-module
@@ -74,10 +73,10 @@ def marginal_counts(
             experiment_result.data.counts = new_counts_hex
 
             if indices is not None:
-                experiment_result.header.memory_slots = len(indices)
-                csize = getattr(experiment_result.header, "creg_sizes", None)
+                experiment_result.header["memory_slots"] = len(indices)
+                csize = experiment_result.header.get("creg_sizes", None)
                 if csize is not None:
-                    experiment_result.header.creg_sizes = _adjust_creg_sizes(csize, indices)
+                    experiment_result.header["creg_sizes"] = _adjust_creg_sizes(csize, indices)
 
             if getattr(experiment_result.data, "memory", None) is not None and indices is not None:
                 if marginalize_memory is False:

qiskit/synthesis/__init__.py

@@ -119,6 +119,7 @@ Two-Qubit Synthesis
    TwoQubitBasisDecomposer
    XXDecomposer
    TwoQubitWeylDecomposition
+   TwoQubitControlledUDecomposer
 
 .. autofunction:: two_qubit_cnot_decompose
 
@@ -147,9 +148,24 @@ Adders
 Multipliers
 -----------
 
-.. autofunction:: multiplier_cumulative_h18 
+.. autofunction:: multiplier_cumulative_h18
 .. autofunction:: multiplier_qft_r17
 
+Sums
+----
+
+.. autofunction:: synth_weighted_sum_carry
+
+
+Unary Arithmetic Synthesis
+==========================
+
+Integer comparators
+-------------------
+
+.. autofunction:: synth_integer_comparator_2s
+.. autofunction:: synth_integer_comparator_greedy
+
 """
 
 from .evolution import (
@@ -200,6 +216,7 @@ from .two_qubit.two_qubit_decompose import (
     TwoQubitBasisDecomposer,
     two_qubit_cnot_decompose,
     TwoQubitWeylDecomposition,
+    TwoQubitControlledUDecomposer,
 )
 from .multi_controlled import (
     synth_mcmt_vchain,
@@ -217,4 +234,7 @@ from .arithmetic import (
     adder_ripple_v95,
     multiplier_cumulative_h18,
     multiplier_qft_r17,
+    synth_integer_comparator_greedy,
+    synth_integer_comparator_2s,
+    synth_weighted_sum_carry,
 )

qiskit/synthesis/arithmetic/__init__.py

@@ -10,7 +10,9 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Module containing multi-controlled circuits synthesis"""
+"""Synthesis for arithmetic circuits."""
 
+from .comparators import synth_integer_comparator_2s, synth_integer_comparator_greedy
 from .adders import adder_qft_d00, adder_ripple_c04, adder_ripple_v95
 from .multipliers import multiplier_cumulative_h18, multiplier_qft_r17
+from .weighted_sum import synth_weighted_sum_carry

qiskit/synthesis/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -13,7 +13,7 @@
 """Compute the sum of two qubit registers using ripple-carry approach."""
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister, AncillaRegister
+from qiskit.circuit import QuantumRegister, AncillaRegister
 
 
 def adder_ripple_c04(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:

qiskit/synthesis/arithmetic/adders/draper_qft_adder.py

@@ -15,7 +15,7 @@
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.library.basis_change import QFTGate
 
 

qiskit/synthesis/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -13,10 +13,10 @@
 """Compute the sum of two qubit registers using Classical Addition."""
 
 from __future__ import annotations
-from qiskit.circuit.bit import Bit
+from qiskit.circuit import Bit
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister, AncillaRegister
+from qiskit.circuit import QuantumRegister, AncillaRegister
 
 
 def adder_ripple_v95(num_state_qubits: int, kind: str = "half") -> QuantumCircuit:

qiskit/{providers/fake_provider/backends_v1/fake_20q → synthesis/arithmetic/comparators}/__init__.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2023.
+# (C) Copyright IBM 2017, 2024.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -10,9 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
+"""Comparator synthesis algorithms."""
 
-"""
-A 20 qubit fake :class:`.BackendV1` without pulse capabilities.
-"""
-
-from .fake_20q import Fake20QV1
+from .compare_2s import synth_integer_comparator_2s
+from .compare_greedy import synth_integer_comparator_greedy