qiskit 1.1.2__cp38-abi3-macosx_10_9_universal2.whl → 1.2.0__cp38-abi3-macosx_10_9_universal2.whl

qiskit/quantum_info/states/stabilizerstate.py

@@ -297,7 +297,7 @@ class StabilizerState(QuantumState):
 
         # Otherwise pauli is (-1)^a prod_j S_j^b_j for Clifford stabilizers
         # If pauli anti-commutes with D_j then b_j = 1.
-        # Multiply pauli by stabilizers with anti-commuting destabilizers
+        # Multiply pauli by stabilizers with anti-commuting destabilisers
         pauli_z = (pauli.z).copy()  # Make a copy of pauli.z
         for p in range(num_qubits):
             # Check if destabilizer anti-commutes
@@ -386,8 +386,17 @@ class StabilizerState(QuantumState):
 
         return probs
 
-    def probabilities_dict(self, qargs: None | list = None, decimals: None | int = None) -> dict:
-        """Return the subsystem measurement probability dictionary.
+    def probabilities_dict_from_bitstring(
+        self,
+        outcome_bitstring: str,
+        qargs: None | list = None,
+        decimals: None | int = None,
+    ) -> dict[str, float]:
+        """Return the subsystem measurement probability dictionary utilizing
+        a targeted outcome_bitstring to perform the measurement for. This
+        will calculate a probability for only a single targeted
+        outcome_bitstring value, giving a performance boost over calculating
+        all possible outcomes.
 
         Measurement probabilities are with respect to measurement in the
         computation (diagonal) basis.
@@ -398,30 +407,44 @@ class StabilizerState(QuantumState):
         inserted between integers so that subsystems can be distinguished.
 
         Args:
+            outcome_bitstring (None or str): targeted outcome bitstring
+                to perform a measurement calculation for, this will significantly
+                reduce the number of calculation performed (Default: None)
             qargs (None or list): subsystems to return probabilities for,
-                if None return for all subsystems (Default: None).
+                    if None return for all subsystems (Default: None).
             decimals (None or int): the number of decimal places to round
-                values. If None no rounding is done (Default: None).
+                    values. If None no rounding is done (Default: None)
 
         Returns:
-            dict: The measurement probabilities in dict (ket) form.
+            dict[str, float]: The measurement probabilities in dict (ket) form.
         """
-        if qargs is None:
-            qubits = range(self.clifford.num_qubits)
-        else:
-            qubits = qargs
+        return self._get_probabilities_dict(
+            outcome_bitstring=outcome_bitstring, qargs=qargs, decimals=decimals
+        )
 
-        outcome = ["X"] * len(qubits)
-        outcome_prob = 1.0
-        probs = {}  # probabilities dictionary
+    def probabilities_dict(
+        self, qargs: None | list = None, decimals: None | int = None
+    ) -> dict[str, float]:
+        """Return the subsystem measurement probability dictionary.
 
-        self._get_probabilities(qubits, outcome, outcome_prob, probs)
+        Measurement probabilities are with respect to measurement in the
+        computation (diagonal) basis.
 
-        if decimals is not None:
-            for key, value in probs.items():
-                probs[key] = round(value, decimals)
+        This dictionary representation uses a Ket-like notation where the
+        dictionary keys are qudit strings for the subsystem basis vectors.
+        If any subsystem has a dimension greater than 10 comma delimiters are
+        inserted between integers so that subsystems can be distinguished.
 
-        return probs
+        Args:
+            qargs (None or list): subsystems to return probabilities for,
+                if None return for all subsystems (Default: None).
+            decimals (None or int): the number of decimal places to round
+                values. If None no rounding is done (Default: None).
+
+        Returns:
+            dict: The measurement probabilities in dict (key) form.
+        """
+        return self._get_probabilities_dict(outcome_bitstring=None, qargs=qargs, decimals=decimals)
 
     def reset(self, qargs: list | None = None) -> StabilizerState:
         """Reset state or subsystems to the 0-state.
@@ -623,7 +646,7 @@ class StabilizerState(QuantumState):
 
     @staticmethod
     def _rowsum_deterministic(clifford, aux_pauli, row):
-        """Updating an auxilary Pauli aux_pauli in the
+        """Updating an auxiliary Pauli aux_pauli in the
         deterministic rowsum calculation.
         The StabilizerState itself is not updated."""
 
@@ -644,22 +667,48 @@ class StabilizerState(QuantumState):
     # -----------------------------------------------------------------------
     # Helper functions for calculating the probabilities
     # -----------------------------------------------------------------------
-    def _get_probabilities(self, qubits, outcome, outcome_prob, probs):
-        """Recursive helper function for calculating the probabilities"""
+    def _get_probabilities(
+        self,
+        qubits: range,
+        outcome: list[str],
+        outcome_prob: float,
+        probs: dict[str, float],
+        outcome_bitstring: str = None,
+    ):
+        """Recursive helper function for calculating the probabilities
 
-        qubit_for_branching = -1
-        ret = self.copy()
+        Args:
+            qubits (range): range of qubits
+            outcome (list[str]): outcome being built
+            outcome_prob (float): probability of the outcome
+            probs (dict[str, float]): holds the outcomes and probability results
+            outcome_bitstring (str): target outcome to measure which reduces measurements, None
+                if not targeting a specific target
+        """
+        qubit_for_branching: int = -1
 
+        ret: StabilizerState = self.copy()
+
+        # Find outcomes for each qubit
         for i in range(len(qubits)):
-            qubit = qubits[len(qubits) - i - 1]
             if outcome[i] == "X":
-                is_deterministic = not any(ret.clifford.stab_x[:, qubit])
-                if is_deterministic:
-                    single_qubit_outcome = ret._measure_and_update(qubit, 0)
-                    if single_qubit_outcome:
-                        outcome[i] = "1"
+                # Retrieve the qubit for the current measurement
+                qubit = qubits[(len(qubits) - i - 1)]
+                # Determine if the probability is deterministic
+                if not any(ret.clifford.stab_x[:, qubit]):
+                    single_qubit_outcome: np.int64 = ret._measure_and_update(qubit, 0)
+                    if outcome_bitstring is None or (
+                        int(outcome_bitstring[i]) == single_qubit_outcome
+                    ):
+                        # No outcome_bitstring target, or using outcome_bitstring target and
+                        # the single_qubit_outcome equals the desired outcome_bitstring target value,
+                        # then use current outcome_prob value
+                        outcome[i] = str(single_qubit_outcome)
                     else:
-                        outcome[i] = "0"
+                        # If the single_qubit_outcome does not equal the outcome_bitsring target
+                        # then we know that the probability will be 0
+                        outcome[i] = str(outcome_bitstring[i])
+                        outcome_prob = 0
                 else:
                     qubit_for_branching = i
 
@@ -668,15 +717,57 @@ class StabilizerState(QuantumState):
             probs[str_outcome] = outcome_prob
             return
 
-        for single_qubit_outcome in range(0, 2):
+        for single_qubit_outcome in (
+            range(0, 2)
+            if (outcome_bitstring is None)
+            else [int(outcome_bitstring[qubit_for_branching])]
+        ):
             new_outcome = outcome.copy()
-            if single_qubit_outcome:
-                new_outcome[qubit_for_branching] = "1"
-            else:
-                new_outcome[qubit_for_branching] = "0"
+            new_outcome[qubit_for_branching] = str(single_qubit_outcome)
 
             stab_cpy = ret.copy()
             stab_cpy._measure_and_update(
-                qubits[len(qubits) - qubit_for_branching - 1], single_qubit_outcome
+                qubits[(len(qubits) - qubit_for_branching - 1)], single_qubit_outcome
+            )
+            stab_cpy._get_probabilities(
+                qubits, new_outcome, (0.5 * outcome_prob), probs, outcome_bitstring
             )
-            stab_cpy._get_probabilities(qubits, new_outcome, 0.5 * outcome_prob, probs)
+
+    def _get_probabilities_dict(
+        self,
+        outcome_bitstring: None | str = None,
+        qargs: None | list = None,
+        decimals: None | int = None,
+    ) -> dict[str, float]:
+        """Helper Function for calculating the subsystem measurement probability dictionary.
+        When the targeted outcome_bitstring value is set, then only the single outcome_bitstring
+        probability will be calculated.
+
+        Args:
+            outcome_bitstring (None or str): targeted outcome bitstring
+                to perform a measurement calculation for, this will significantly
+                reduce the number of calculation performed (Default: None)
+            qargs (None or list): subsystems to return probabilities for,
+                if None return for all subsystems (Default: None).
+            decimals (None or int): the number of decimal places to round
+                values. If None no rounding is done (Default: None).
+
+        Returns:
+            dict: The measurement probabilities in dict (key) form.
+        """
+        if qargs is None:
+            qubits = range(self.clifford.num_qubits)
+        else:
+            qubits = qargs
+
+        outcome = ["X"] * len(qubits)
+        outcome_prob = 1.0
+        probs: dict[str, float] = {}  # Probabilities dict to return with the measured values
+
+        self._get_probabilities(qubits, outcome, outcome_prob, probs, outcome_bitstring)
+
+        if decimals is not None:
+            for key, value in probs.items():
+                probs[key] = round(value, decimals)
+
+        return probs

qiskit/quantum_info/states/statevector.py

@@ -117,11 +117,9 @@ class Statevector(QuantumState, TolerancesMixin):
     def __repr__(self):
         prefix = "Statevector("
         pad = len(prefix) * " "
-        return "{}{},\n{}dims={})".format(
-            prefix,
-            np.array2string(self._data, separator=", ", prefix=prefix),
-            pad,
-            self._op_shape.dims_l(),
+        return (
+            f"{prefix}{np.array2string(self._data, separator=', ', prefix=prefix)},\n{pad}"
+            f"dims={self._op_shape.dims_l()})"
         )
 
     @property
@@ -940,9 +938,7 @@ class Statevector(QuantumState, TolerancesMixin):
             raise QiskitError(f"Cannot apply Instruction: {obj.name}")
         if not isinstance(obj.definition, QuantumCircuit):
             raise QiskitError(
-                "{} instruction definition is {}; expected QuantumCircuit".format(
-                    obj.name, type(obj.definition)
-                )
+                f"{obj.name} instruction definition is {type(obj.definition)}; expected QuantumCircuit"
             )
 
         if obj.definition.global_phase:

qiskit/result/counts.py

@@ -101,7 +101,7 @@ class Counts(dict):
             else:
                 raise TypeError(
                     "Invalid input key type %s, must be either an int "
-                    "key or string key with hexademical value or bit string"
+                    "key or string key with hexadecimal value or bit string"
                 )
         header = {}
         self.creg_sizes = creg_sizes
@@ -130,7 +130,7 @@ class Counts(dict):
         max_values_counts = [x[0] for x in self.items() if x[1] == max_value]
         if len(max_values_counts) != 1:
             raise exceptions.QiskitError(
-                "Multiple values have the same maximum counts: %s" % ",".join(max_values_counts)
+                f"Multiple values have the same maximum counts: {','.join(max_values_counts)}"
             )
         return max_values_counts[0]
 

qiskit/result/mitigation/correlated_readout_mitigator.py

@@ -54,8 +54,8 @@ class CorrelatedReadoutMitigator(BaseReadoutMitigator):
         else:
             if len(qubits) != matrix_qubits_num:
                 raise QiskitError(
-                    "The number of given qubits ({}) is different than the number of "
-                    "qubits inferred from the matrices ({})".format(len(qubits), matrix_qubits_num)
+                    f"The number of given qubits ({len(qubits)}) is different than the number of "
+                    f"qubits inferred from the matrices ({matrix_qubits_num})"
                 )
             self._qubits = qubits
             self._num_qubits = len(self._qubits)

qiskit/result/mitigation/local_readout_mitigator.py

@@ -68,8 +68,8 @@ class LocalReadoutMitigator(BaseReadoutMitigator):
         else:
             if len(qubits) != len(assignment_matrices):
                 raise QiskitError(
-                    "The number of given qubits ({}) is different than the number of qubits "
-                    "inferred from the matrices ({})".format(len(qubits), len(assignment_matrices))
+                    f"The number of given qubits ({len(qubits)}) is different than the number of qubits "
+                    f"inferred from the matrices ({len(assignment_matrices)})"
                 )
             self._qubits = qubits
             self._num_qubits = len(self._qubits)

qiskit/result/mitigation/utils.py

@@ -120,9 +120,7 @@ def marganalize_counts(
         clbits_len = len(clbits) if not clbits is None else 0
         if clbits_len not in (0, qubits_len):
             raise QiskitError(
-                "Num qubits ({}) does not match number of clbits ({}).".format(
-                    qubits_len, clbits_len
-                )
+                f"Num qubits ({qubits_len}) does not match number of clbits ({clbits_len})."
             )
         counts = marginal_counts(counts, clbits)
     if clbits is None and qubits is not None:

qiskit/result/models.py

@@ -13,6 +13,7 @@
 """Schema and helper models for schema-conformant Results."""
 
 import copy
+import warnings
 
 from qiskit.qobj.utils import MeasReturnType, MeasLevel
 from qiskit.qobj import QobjExperimentHeader
@@ -66,8 +67,7 @@ class ExperimentResultData:
         string_list = []
         for field in self._data_attributes:
             string_list.append(f"{field}={getattr(self, field)}")
-        out = "ExperimentResultData(%s)" % ", ".join(string_list)
-        return out
+        return f"ExperimentResultData({', '.join(string_list)})"
 
     def to_dict(self):
         """Return a dictionary format representation of the ExperimentResultData
@@ -157,25 +157,23 @@ class ExperimentResult:
         self._metadata.update(kwargs)
 
     def __repr__(self):
-        out = "ExperimentResult(shots={}, success={}, meas_level={}, data={}".format(
-            self.shots,
-            self.success,
-            self.meas_level,
-            self.data,
+        out = (
+            f"ExperimentResult(shots={self.shots}, success={self.success},"
+            f" meas_level={self.meas_level}, data={self.data}"
         )
         if hasattr(self, "header"):
-            out += ", header=%s" % self.header
+            out += f", header={self.header}"
         if hasattr(self, "status"):
-            out += ", status=%s" % self.status
+            out += f", status={self.status}"
         if hasattr(self, "seed"):
-            out += ", seed=%s" % self.seed
+            out += f", seed={self.seed}"
         if hasattr(self, "meas_return"):
-            out += ", meas_return=%s" % self.meas_return
-        for key in self._metadata:
-            if isinstance(self._metadata[key], str):
-                value_str = "'%s'" % self._metadata[key]
+            out += f", meas_return={self.meas_return}"
+        for key, value in self._metadata.items():
+            if isinstance(value, str):
+                value_str = f"'{value}'"
             else:
-                value_str = repr(self._metadata[key])
+                value_str = repr(value)
             out += f", {key}={value_str}"
         out += ")"
         return out
@@ -226,7 +224,10 @@ class ExperimentResult:
         in_data = copy.copy(data)
         data_obj = ExperimentResultData.from_dict(in_data.pop("data"))
         if "header" in in_data:
-            in_data["header"] = QobjExperimentHeader.from_dict(in_data.pop("header"))
+            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

@@ -69,23 +69,16 @@ class Result:
 
     def __repr__(self):
         out = (
-            "Result(backend_name='%s', backend_version='%s', qobj_id='%s', "
-            "job_id='%s', success=%s, results=%s"
-            % (
-                self.backend_name,
-                self.backend_version,
-                self.qobj_id,
-                self.job_id,
-                self.success,
-                self.results,
-            )
+            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" results={self.results}"
         )
         out += f", date={self.date}, status={self.status}, header={self.header}"
-        for key in self._metadata:
-            if isinstance(self._metadata[key], str):
-                value_str = "'%s'" % self._metadata[key]
+        for key, value in self._metadata.items():
+            if isinstance(value, str):
+                value_str = f"'{value}'"
             else:
-                value_str = repr(self._metadata[key])
+                value_str = repr(value)
             out += f", {key}={value_str}"
         out += ")"
         return out
@@ -132,7 +125,9 @@ 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:
-            in_data["header"] = QobjHeader.from_dict(in_data.pop("header"))
+            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):
@@ -236,10 +231,10 @@ class Result:
 
         except KeyError as ex:
             raise QiskitError(
-                'No memory for experiment "{}". '
+                f'No memory for experiment "{repr(experiment)}". '
                 "Please verify that you either ran a measurement level 2 job "
                 'with the memory flag set, eg., "memory=True", '
-                "or a measurement level 0/1 job.".format(repr(experiment))
+                "or a measurement level 0/1 job."
             ) from ex
 
     def get_counts(self, experiment=None):
@@ -377,14 +372,14 @@ class Result:
             ]
 
             if len(exp) == 0:
-                raise QiskitError('Data for experiment "%s" could not be found.' % key)
+                raise QiskitError(f'Data for experiment "{key}" could not be found.')
             if len(exp) == 1:
                 exp = exp[0]
             else:
                 warnings.warn(
-                    'Result object contained multiple results matching name "%s", '
+                    f'Result object contained multiple results matching name "{key}", '
                     "only first match will be returned. Use an integer index to "
-                    "retrieve results for all entries." % key
+                    "retrieve results for all entries."
                 )
                 exp = exp[0]
 

qiskit/scheduler/lowering.py

@@ -145,9 +145,9 @@ def lower_gates(
         elif isinstance(instruction.operation, Measure):
             if len(inst_qubits) != 1 and len(instruction.clbits) != 1:
                 raise QiskitError(
-                    "Qubit '{}' or classical bit '{}' errored because the "
+                    f"Qubit '{inst_qubits}' or classical bit '{instruction.clbits}' errored because the "
                     "circuit Measure instruction only takes one of "
-                    "each.".format(inst_qubits, instruction.clbits)
+                    "each."
                 )
             qubit_mem_slots[inst_qubits[0]] = clbit_indices[instruction.clbits[0]]
         else:

qiskit/synthesis/__init__.py

@@ -91,6 +91,7 @@ Basis Change Synthesis
 ======================
 
 .. autofunction:: synth_qft_line
+.. autofunction:: synth_qft_full
 
 Unitary Synthesis
 =================
@@ -162,7 +163,7 @@ from .stabilizer import (
     synth_circuit_from_stabilizers,
 )
 from .discrete_basis import SolovayKitaevDecomposition, generate_basic_approximations
-from .qft import synth_qft_line
+from .qft import synth_qft_line, synth_qft_full
 from .unitary.qsd import qs_decomposition
 from .unitary import aqc
 from .one_qubit import OneQubitEulerDecomposer

qiskit/synthesis/clifford/__init__.py

@@ -14,6 +14,6 @@
 
 from .clifford_decompose_full import synth_clifford_full
 from .clifford_decompose_ag import synth_clifford_ag
-from .clifford_decompose_bm import synth_clifford_bm, _decompose_clifford_1q
+from .clifford_decompose_bm import synth_clifford_bm
 from .clifford_decompose_greedy import synth_clifford_greedy
 from .clifford_decompose_layers import synth_clifford_layers, synth_clifford_depth_lnn

qiskit/synthesis/clifford/clifford_decompose_ag.py

@@ -30,7 +30,7 @@ from qiskit.quantum_info.operators.symplectic.clifford_circuits import (
     _append_x,
     _append_z,
 )
-from .clifford_decompose_bm import _decompose_clifford_1q
+from .clifford_decompose_bm import synth_clifford_bm
 
 
 def synth_clifford_ag(clifford: Clifford) -> QuantumCircuit:
@@ -50,7 +50,7 @@ def synth_clifford_ag(clifford: Clifford) -> QuantumCircuit:
     """
     # Use 1-qubit decomposition method
     if clifford.num_qubits == 1:
-        return _decompose_clifford_1q(clifford.tableau)
+        return synth_clifford_bm(clifford)
 
     # Compose a circuit which we will convert to an instruction
     circuit = QuantumCircuit(clifford.num_qubits, name=str(clifford))