cirq-core 1.6.0.dev20250501192724__py3-none-any.whl → 1.6.0.dev20250501231232__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.6.0.dev20250501192724"
+__version__ = "1.6.0.dev20250501231232"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.6.0.dev20250501192724"
+    assert cirq.__version__ == "1.6.0.dev20250501231232"

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Tools for measuring expectation values of Pauli strings with readout error mitigation."""
+import itertools
 import time
-from typing import Dict, List, Optional, Tuple, Union
+from typing import cast, Dict, FrozenSet, List, Optional, Sequence, Tuple, Union
 
 import attrs
 import numpy as np
@@ -59,8 +60,74 @@ class CircuitToPauliStringsMeasurementResult:
     results: List[PauliStringMeasurementResult]
 
 
+def _commute_or_identity(
+    op1: Union[ops.Pauli, ops.IdentityGate], op2: Union[ops.Pauli, ops.IdentityGate]
+) -> bool:
+    if op1 == ops.I or op2 == ops.I:
+        return True
+    return op1 == op2
+
+
+def _are_two_pauli_strings_qubit_wise_commuting(
+    pauli_str1: ops.PauliString,
+    pauli_str2: ops.PauliString,
+    all_qubits: Union[list[ops.Qid], FrozenSet[ops.Qid]],
+) -> bool:
+    for qubit in all_qubits:
+        op1 = pauli_str1.get(qubit, default=ops.I)
+        op2 = pauli_str2.get(qubit, default=ops.I)
+
+        if not _commute_or_identity(op1, op2):
+            return False
+    return True
+
+
+def _validate_group_paulis_qwc(
+    pauli_strs: list[ops.PauliString], all_qubits: Union[list[ops.Qid], FrozenSet[ops.Qid]]
+):
+    """Checks if a group of Pauli strings are Qubit-Wise Commuting.
+
+    Args:
+        pauli_strings: A list of cirq.PauliString objects.
+        all_qubits: A list of all qubits to consider for the QWC check.
+                    The check is performed for each qubit in this list.
+
+    Returns:
+        True if the group is QWC, False otherwise.
+    """
+    if len(pauli_strs) <= 1:
+        return True
+    for p1, p2 in itertools.combinations(pauli_strs, 2):
+        if not _are_two_pauli_strings_qubit_wise_commuting(p1, p2, all_qubits):
+            return False
+    return True
+
+
+def _validate_single_pauli_string(pauli_str: ops.PauliString):
+    if not isinstance(pauli_str, ops.PauliString):
+        raise TypeError(
+            f"All elements in the Pauli string lists must be cirq.PauliString "
+            f"instances, got {type(pauli_str)}."
+        )
+
+    if all(q == ops.I for q in pauli_str) or not pauli_str:
+        raise ValueError(
+            "Empty Pauli strings or Pauli strings consisting "
+            "only of Pauli I are not allowed. Please provide "
+            "valid input Pauli strings."
+        )
+    if pauli_str.coefficient.imag != 0:
+        raise ValueError(
+            "Cannot compute expectation value of a non-Hermitian PauliString. "
+            "Coefficient must be real."
+        )
+
+
 def _validate_input(
-    circuits_to_pauli: Dict[circuits.FrozenCircuit, list[ops.PauliString]],
+    circuits_to_pauli: Union[
+        Dict[circuits.FrozenCircuit, list[ops.PauliString]],
+        Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]],
+    ],
     pauli_repetitions: int,
     readout_repetitions: int,
     num_random_bitstrings: int,
@@ -73,25 +140,39 @@ def _validate_input(
         if not isinstance(circuit, circuits.FrozenCircuit):
             raise TypeError("All keys in 'circuits_to_pauli' must be FrozenCircuit instances.")
 
-    for pauli_strings in circuits_to_pauli.values():
-        for pauli_str in pauli_strings:
-            if not isinstance(pauli_str, ops.PauliString):
-                raise TypeError(
-                    f"All elements in the Pauli string lists must be cirq.PauliString "
-                    f"instances, got {type(pauli_str)}."
-                )
-
-            if all(q == ops.I for q in pauli_str):
-                raise ValueError(
-                    "Empty Pauli strings or Pauli strings consisting "
-                    "only of Pauli I are not allowed. Please provide "
-                    "valid input Pauli strings."
-                )
-            if pauli_str.coefficient.imag != 0:
-                raise ValueError(
-                    "Cannot compute expectation value of a non-Hermitian PauliString. "
-                    "Coefficient must be real."
-                )
+    first_value: Union[list[ops.PauliString], list[list[ops.PauliString]]] = next(
+        iter(circuits_to_pauli.values())  # type: ignore
+    )
+    for circuit, pauli_strs_list in circuits_to_pauli.items():
+        if isinstance(pauli_strs_list, Sequence) and isinstance(first_value[0], Sequence):
+            for pauli_strs in pauli_strs_list:
+                if not pauli_strs:
+                    raise ValueError("Empty group of Pauli strings is not allowed")
+                if not (
+                    isinstance(pauli_strs, Sequence) and isinstance(pauli_strs[0], ops.PauliString)
+                ):
+                    raise TypeError(
+                        f"Inconsistent type in list for circuit {circuit}. "
+                        f"Expected all elements to be sequences of ops.PauliString, "
+                        f"but found {type(pauli_strs)}."
+                    )
+                if not _validate_group_paulis_qwc(pauli_strs, circuit.all_qubits()):
+                    raise ValueError(
+                        f"Pauli group containing {pauli_strs} is invalid: "
+                        f"The group of Pauli strings are not "
+                        f"Qubit-Wise Commuting with each other."
+                    )
+                for pauli_str in pauli_strs:
+                    _validate_single_pauli_string(pauli_str)
+        elif isinstance(pauli_strs_list, Sequence) and isinstance(first_value[0], ops.PauliString):
+            for pauli_str in pauli_strs_list:  # type: ignore
+                _validate_single_pauli_string(pauli_str)
+        else:
+            raise TypeError(
+                f"Expected all elements to be either a sequence of PauliStrings"
+                f" or sequences of ops.PauliStrings. "
+                f"Got {type(pauli_strs_list)} instead."
+            )
 
     # Check rng is a numpy random generator
     if not isinstance(rng_or_seed, np.random.Generator) and not isinstance(rng_or_seed, int):
@@ -110,32 +191,39 @@ def _validate_input(
         raise ValueError("Must provide non-zero readout_repetitions for readout calibration.")
 
 
-def _pauli_string_to_basis_change_ops(
-    pauli_string: ops.PauliString, qid_list: list[ops.Qid]
-) -> List[ops.Operation]:
-    """Creates operations to change to the eigenbasis of the given Pauli string.
-
-    This function constructs a list of ops.Operation that performs basis changes
-    necessary to measure the given pauli_string in the computational basis.
-
-    Args:
-        pauli_string: The Pauli string to diagonalize.
-        qid_list: An ordered list of the qubits in the circuit.
-
-    Returns:
-        A list of Operations that, when applied before measurement in the
-        computational basis, effectively measures in the eigenbasis of
-        pauli_strings.
-    """
+def _normalize_input_paulis(
+    circuits_to_pauli: Union[
+        Dict[circuits.FrozenCircuit, list[ops.PauliString]],
+        Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]],
+    ],
+) -> Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]]:
+    first_value = next(iter(circuits_to_pauli.values()))
+    if (
+        first_value
+        and isinstance(first_value, list)
+        and isinstance(first_value[0], ops.PauliString)
+    ):
+        input_dict = cast(Dict[circuits.FrozenCircuit, List[ops.PauliString]], circuits_to_pauli)
+        normalized_circuits_to_pauli: Dict[circuits.FrozenCircuit, list[list[ops.PauliString]]] = {}
+        for circuit, paulis in input_dict.items():
+            normalized_circuits_to_pauli[circuit] = [[ps] for ps in paulis]
+        return normalized_circuits_to_pauli
+    return cast(Dict[circuits.FrozenCircuit, List[List[ops.PauliString]]], circuits_to_pauli)
+
+
+def _pauli_strings_to_basis_change_ops(
+    pauli_strings: list[ops.PauliString], qid_list: list[ops.Qid]
+):
     operations = []
-    for qubit in qid_list:  # Iterate over ALL qubits in the circuit
-        if qubit in pauli_string:
-            pauli_op = pauli_string[qubit]
+    for qubit in qid_list:
+        for pauli_str in pauli_strings:
+            pauli_op = pauli_str.get(qubit, default=ops.I)
             if pauli_op == ops.X:
                 operations.append(ops.ry(-np.pi / 2)(qubit))  # =cirq.H
+                break
             elif pauli_op == ops.Y:
                 operations.append(ops.rx(np.pi / 2)(qubit))
-            # If pauli_op is Z or I, no operation needed
+                break
     return operations
 
 
@@ -185,14 +273,14 @@ def _build_many_one_qubits_empty_confusion_matrix(qubits_length: int) -> list[np
 
 
 def _process_pauli_measurement_results(
-    qubits: List[ops.Qid],
-    pauli_strings: List[ops.PauliString],
-    circuit_results: List[ResultDict],
+    qubits: list[ops.Qid],
+    pauli_string_groups: list[list[ops.PauliString]],
+    circuit_results: list[ResultDict],
     calibration_results: Dict[Tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult],
     pauli_repetitions: int,
     timestamp: float,
     disable_readout_mitigation: bool = False,
-) -> List[PauliStringMeasurementResult]:
+) -> list[PauliStringMeasurementResult]:
     """Calculates both error-mitigated expectation values and unmitigated expectation values
     from measurement results.
 
@@ -203,7 +291,7 @@ def _process_pauli_measurement_results(
 
     Args:
         qubits: Qubits to build confusion matrices for. In a sorted order.
-        pauli_strings: The list of PauliStrings that are measured.
+        pauli_strings: The lists of QWC Pauli string groups that are measured.
         circuit_results: A list of ResultDict obtained
             from running the Pauli measurement circuits.
         confusion_matrices: A list of confusion matrices from calibration results.
@@ -218,62 +306,66 @@ def _process_pauli_measurement_results(
 
     pauli_measurement_results: List[PauliStringMeasurementResult] = []
 
-    for pauli_index, circuit_result in enumerate(circuit_results):
+    for pauli_group_index, circuit_result in enumerate(circuit_results):
         measurement_results = circuit_result.measurements["m"]
+        pauli_strs = pauli_string_groups[pauli_group_index]
 
-        pauli_string = pauli_strings[pauli_index]
-        qubits_sorted = sorted(pauli_string.qubits)
-        qubit_indices = [qubits.index(q) for q in qubits_sorted]
+        for pauli_str in pauli_strs:
+            qubits_sorted = sorted(pauli_str.qubits)
+            qubit_indices = [qubits.index(q) for q in qubits_sorted]
 
-        confusion_matrices = (
-            _build_many_one_qubits_confusion_matrix(calibration_results[tuple(qubits_sorted)])
-            if disable_readout_mitigation is False
-            else _build_many_one_qubits_empty_confusion_matrix(len(qubits_sorted))
-        )
-        tensored_cm = TensoredConfusionMatrices(
-            confusion_matrices,
-            [[q] for q in qubits_sorted],
-            repetitions=pauli_repetitions,
-            timestamp=timestamp,
-        )
+            confusion_matrices = (
+                _build_many_one_qubits_confusion_matrix(calibration_results[tuple(qubits_sorted)])
+                if disable_readout_mitigation is False
+                else _build_many_one_qubits_empty_confusion_matrix(len(qubits_sorted))
+            )
+            tensored_cm = TensoredConfusionMatrices(
+                confusion_matrices,
+                [[q] for q in qubits_sorted],
+                repetitions=pauli_repetitions,
+                timestamp=timestamp,
+            )
 
-        #  Create a mask for the relevant qubits in the measurement results
-        relevant_bits = measurement_results[:, qubit_indices]
+            #  Create a mask for the relevant qubits in the measurement results
+            relevant_bits = measurement_results[:, qubit_indices]
 
-        # Calculate the mitigated expectation.
-        raw_mitigated_values, raw_d_m = tensored_cm.readout_mitigation_pauli_uncorrelated(
-            qubits_sorted, relevant_bits
-        )
-        mitigated_values_with_coefficient = raw_mitigated_values * pauli_string.coefficient.real
-        d_m_with_coefficient = raw_d_m * abs(pauli_string.coefficient.real)
-
-        # Calculate the unmitigated expectation.
-        parity = np.sum(relevant_bits, axis=1) % 2
-        raw_unmitigated_values = 1 - 2 * np.mean(parity)
-        raw_d_unmit = 2 * np.sqrt(np.mean(parity) * (1 - np.mean(parity)) / pauli_repetitions)
-        unmitigated_value_with_coefficient = raw_unmitigated_values * pauli_string.coefficient
-        d_unmit_with_coefficient = raw_d_unmit * abs(pauli_string.coefficient)
-
-        pauli_measurement_results.append(
-            PauliStringMeasurementResult(
-                pauli_string=pauli_strings[pauli_index],
-                mitigated_expectation=mitigated_values_with_coefficient,
-                mitigated_stddev=d_m_with_coefficient,
-                unmitigated_expectation=unmitigated_value_with_coefficient,
-                unmitigated_stddev=d_unmit_with_coefficient,
-                calibration_result=(
-                    calibration_results[tuple(qubits_sorted)]
-                    if disable_readout_mitigation is False
-                    else None
-                ),
+            # Calculate the mitigated expectation.
+            raw_mitigated_values, raw_d_m = tensored_cm.readout_mitigation_pauli_uncorrelated(
+                qubits_sorted, relevant_bits
+            )
+            mitigated_values_with_coefficient = raw_mitigated_values * pauli_str.coefficient.real
+            d_m_with_coefficient = raw_d_m * abs(pauli_str.coefficient.real)
+
+            # Calculate the unmitigated expectation.
+            parity = np.sum(relevant_bits, axis=1) % 2
+            raw_unmitigated_values = 1 - 2 * np.mean(parity)
+            raw_d_unmit = 2 * np.sqrt(np.mean(parity) * (1 - np.mean(parity)) / pauli_repetitions)
+            unmitigated_value_with_coefficient = raw_unmitigated_values * pauli_str.coefficient.real
+            d_unmit_with_coefficient = raw_d_unmit * abs(pauli_str.coefficient.real)
+
+            pauli_measurement_results.append(
+                PauliStringMeasurementResult(
+                    pauli_string=pauli_str,
+                    mitigated_expectation=mitigated_values_with_coefficient,
+                    mitigated_stddev=d_m_with_coefficient,
+                    unmitigated_expectation=unmitigated_value_with_coefficient,
+                    unmitigated_stddev=d_unmit_with_coefficient,
+                    calibration_result=(
+                        calibration_results[tuple(qubits_sorted)]
+                        if disable_readout_mitigation is False
+                        else None
+                    ),
+                )
             )
-        )
 
     return pauli_measurement_results
 
 
 def measure_pauli_strings(
-    circuits_to_pauli: Dict[circuits.FrozenCircuit, list[ops.PauliString]],
+    circuits_to_pauli: Union[
+        Dict[circuits.FrozenCircuit, List[ops.PauliString]],
+        Dict[circuits.FrozenCircuit, List[List[ops.PauliString]]],
+    ],
     sampler: work.Sampler,
     pauli_repetitions: int,
     readout_repetitions: int,
@@ -283,8 +375,8 @@ def measure_pauli_strings(
     """Measures expectation values of Pauli strings on given circuits with/without
     readout error mitigation.
 
-    This function takes a list of circuits and corresponding List[PauliString] to measure.
-    For each circuit-List[PauliString] pair, it:
+    This function takes a dictionary mapping circuits to lists of QWC Pauli string groups.
+    For each circuit and its associated list of QWC pauli string group, it:
     1.  Constructs circuits to measure the Pauli string expectation value by
         adding basis change moments and measurement operations.
     2.  Runs shuffled readout benchmarking on these circuits to calibrate readout errors.
@@ -293,8 +385,13 @@ def measure_pauli_strings(
     each Pauli string.
 
     Args:
-        circuits_to_pauli: A dictionary mapping circuits to a list of Pauli strings
-            to measure.
+        circuits_to_pauli: A dictionary mapping circuits to either:
+            - A list of QWC groups (List[List[ops.PauliString]]). Each QWC group
+              is a list of PauliStrings that are mutually Qubit-Wise Commuting.
+              Pauli strings within the same group will be calculated using the
+              same measurement results.
+            - A list of PauliStrings (List[ops.PauliString]). In this case, each
+              PauliString is treated as its own measurement group.
         sampler: The sampler to use.
         pauli_repetitions: The number of repetitions for each circuit when measuring
             Pauli strings.
@@ -319,24 +416,27 @@ def measure_pauli_strings(
         rng_or_seed,
     )
 
+    normalized_circuits_to_pauli = _normalize_input_paulis(circuits_to_pauli)
+
     # Extract unique qubit tuples from input pauli strings
     unique_qubit_tuples = set()
-    for pauli_strings in circuits_to_pauli.values():
-        for pauli_string in pauli_strings:
-            unique_qubit_tuples.add(tuple(sorted(pauli_string.qubits)))
+    for pauli_string_groups in normalized_circuits_to_pauli.values():
+        for pauli_strings in pauli_string_groups:
+            for pauli_string in pauli_strings:
+                unique_qubit_tuples.add(tuple(sorted(pauli_string.qubits)))
     # qubits_list is a list of qubit tuples
     qubits_list = sorted(unique_qubit_tuples)
 
-    # Build the basis-change circuits for each Pauli string
+    # Build the basis-change circuits for each Pauli string group
     pauli_measurement_circuits = list[circuits.Circuit]()
-    for input_circuit, pauli_strings in circuits_to_pauli.items():
+    for input_circuit, pauli_string_groups in normalized_circuits_to_pauli.items():
         qid_list = list(sorted(input_circuit.all_qubits()))
         basis_change_circuits = []
         input_circuit_unfrozen = input_circuit.unfreeze()
-        for pauli_string in pauli_strings:
+        for pauli_strings in pauli_string_groups:
             basis_change_circuit = (
                 input_circuit_unfrozen
-                + _pauli_string_to_basis_change_ops(pauli_string, qid_list)
+                + _pauli_strings_to_basis_change_ops(pauli_strings, qid_list)
                 + ops.measure(*qid_list, key="m")
             )
             basis_change_circuits.append(basis_change_circuit)
@@ -356,14 +456,18 @@ def measure_pauli_strings(
     # Process the results to calculate expectation values
     results: List[CircuitToPauliStringsMeasurementResult] = []
     circuit_result_index = 0
-    for input_circuit, pauli_strings in circuits_to_pauli.items():
+    for input_circuit, pauli_string_groups in normalized_circuits_to_pauli.items():
+
         qubits_in_circuit = tuple(sorted(input_circuit.all_qubits()))
 
         disable_readout_mitigation = False if num_random_bitstrings != 0 else True
+
         pauli_measurement_results = _process_pauli_measurement_results(
             list(qubits_in_circuit),
-            pauli_strings,
-            circuits_results[circuit_result_index : circuit_result_index + len(pauli_strings)],
+            pauli_string_groups,
+            circuits_results[
+                circuit_result_index : circuit_result_index + len(pauli_string_groups)
+            ],
             calibration_results,
             pauli_repetitions,
             time.time(),
@@ -375,5 +479,5 @@ def measure_pauli_strings(
             )
         )
 
-        circuit_result_index += len(pauli_strings)
+        circuit_result_index += len(pauli_string_groups)
     return results

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import itertools
 import random
 from typing import Dict, Sequence
 
@@ -32,9 +33,14 @@ def _create_ghz(number_of_qubits: int, qubits: Sequence[cirq.Qid]) -> cirq.Circu
     return ghz_circuit
 
 
-def _generate_random_pauli_string(qubits: Sequence[cirq.Qid], enable_coeff: bool = False):
+def _generate_random_pauli_string(
+    qubits: Sequence[cirq.Qid], enable_coeff: bool = False, allow_pauli_i: bool = True
+):
     pauli_ops = [cirq.I, cirq.X, cirq.Y, cirq.Z]
 
+    if not allow_pauli_i:
+        pauli_ops = [cirq.X, cirq.Y, cirq.Z]
+
     operators = {q: random.choice(pauli_ops) for q in qubits}
     # Ensure at least one non-identity.
     operators[random.choice(qubits)] = random.choice(pauli_ops[1:])
@@ -45,6 +51,49 @@ def _generate_random_pauli_string(qubits: Sequence[cirq.Qid], enable_coeff: bool
     return cirq.PauliString(operators)
 
 
+def _generate_qwc_paulis(
+    input_pauli: cirq.PauliString, num_output: int, exclude_input_pauli: bool = False
+) -> list[cirq.PauliString]:
+    """Generates PauliStrings that are Qubit-Wise Commuting (QWC)
+    with the input_pauli.
+
+    All operations in input_pauli must not be pauli I.
+    """
+    allowed_paulis_per_qubit = []
+    qubits = input_pauli.qubits
+
+    for qubit in qubits:
+        pauli_op = input_pauli.get(qubit, cirq.I)
+
+        allowed_pauli_op = []
+        if pauli_op == cirq.I:
+            allowed_pauli_op = [cirq.I, cirq.X, cirq.Y, cirq.Z]  # pragma: no cover
+        elif pauli_op == cirq.X:
+            allowed_pauli_op = [cirq.I, cirq.X]
+        elif pauli_op == cirq.Y:
+            allowed_pauli_op = [cirq.I, cirq.Y]
+        elif pauli_op == cirq.Z:
+            allowed_pauli_op = [cirq.I, cirq.Z]
+
+        allowed_paulis_per_qubit.append(allowed_pauli_op)
+
+    qwc_paulis: list[cirq.PauliString] = []
+
+    for pauli_combination in itertools.product(*allowed_paulis_per_qubit):
+        pauli_dict = {}
+        for i, qid in enumerate(qubits):
+            pauli_dict[qid] = pauli_combination[i]
+
+        qwc_pauli: cirq.PauliString = cirq.PauliString(pauli_dict)
+        if exclude_input_pauli and qwc_pauli == input_pauli:
+            continue  # pragma: no cover
+        if all(q == cirq.I for q in qwc_pauli):
+            continue
+        qwc_paulis.append(qwc_pauli)
+
+    return qwc_paulis if num_output > len(qwc_paulis) else random.sample(qwc_paulis, num_output)
+
+
 def _ideal_expectation_based_on_pauli_string(
     pauli_string: cirq.PauliString, final_state_vector: np.ndarray
 ) -> float:
@@ -149,6 +198,60 @@ def test_pauli_string_measurement_errors_with_coefficient_no_noise() -> None:
             }
 
 
+def test_group_pauli_string_measurement_errors_no_noise_with_coefficient() -> None:
+    """Test that the mitigated expectation is close to the ideal expectation
+    based on the group of Pauli strings"""
+
+    qubits = cirq.LineQubit.range(5)
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+    sampler = cirq.Simulator()
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits, enable_coeff=True, allow_pauli_i=False), 100, True
+        )
+        for _ in range(3)
+    ]
+    circuits_to_pauli[circuit].append([cirq.PauliString({q: cirq.X for q in qubits})])
+
+    circuits_with_pauli_expectations = measure_pauli_strings(
+        circuits_to_pauli, sampler, 100, 100, 100, 100
+    )
+
+    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
+        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
+
+        expected_val_simulation = sampler.simulate(
+            circuit_with_pauli_expectations.circuit.unfreeze()
+        )
+        final_state_vector = expected_val_simulation.final_state_vector
+
+        for pauli_string_measurement_results in circuit_with_pauli_expectations.results:
+            # Since there is no noise, the mitigated and unmitigated expectations should be the same
+            assert np.isclose(
+                pauli_string_measurement_results.mitigated_expectation,
+                pauli_string_measurement_results.unmitigated_expectation,
+            )
+            assert np.isclose(
+                pauli_string_measurement_results.mitigated_expectation,
+                _ideal_expectation_based_on_pauli_string(
+                    pauli_string_measurement_results.pauli_string, final_state_vector
+                ),
+                atol=4 * pauli_string_measurement_results.mitigated_stddev,
+            )
+            assert isinstance(
+                pauli_string_measurement_results.calibration_result,
+                SingleQubitReadoutCalibrationResult,
+            )
+            assert pauli_string_measurement_results.calibration_result.zero_state_errors == {
+                q: 0 for q in pauli_string_measurement_results.pauli_string.qubits
+            }
+            assert pauli_string_measurement_results.calibration_result.one_state_errors == {
+                q: 0 for q in pauli_string_measurement_results.pauli_string.qubits
+            }
+
+
 def test_pauli_string_measurement_errors_with_noise() -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string"""
@@ -196,6 +299,57 @@ def test_pauli_string_measurement_errors_with_noise() -> None:
                 assert 0.0045 < error < 0.0055
 
 
+def test_group_pauli_string_measurement_errors_with_noise() -> None:
+    """Test that the mitigated expectation is close to the ideal expectation
+    based on the group Pauli strings"""
+    qubits = cirq.LineQubit.range(7)
+    circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.005, seed=1234)
+    simulator = cirq.Simulator()
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits, enable_coeff=True, allow_pauli_i=False), 5
+        )
+    ]
+
+    circuits_with_pauli_expectations = measure_pauli_strings(
+        circuits_to_pauli, sampler, 800, 1000, 800, np.random.default_rng()
+    )
+
+    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
+        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
+
+        expected_val_simulation = simulator.simulate(
+            circuit_with_pauli_expectations.circuit.unfreeze()
+        )
+        final_state_vector = expected_val_simulation.final_state_vector
+
+        for pauli_string_measurement_results in circuit_with_pauli_expectations.results:
+            assert np.isclose(
+                pauli_string_measurement_results.mitigated_expectation,
+                _ideal_expectation_based_on_pauli_string(
+                    pauli_string_measurement_results.pauli_string, final_state_vector
+                ),
+                atol=4 * pauli_string_measurement_results.mitigated_stddev,
+            )
+
+            assert isinstance(
+                pauli_string_measurement_results.calibration_result,
+                SingleQubitReadoutCalibrationResult,
+            )
+
+            for (
+                error
+            ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
+                assert 0.08 < error < 0.12
+            for (
+                error
+            ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
+                assert 0.0045 < error < 0.0055
+
+
 def test_many_circuits_input_measurement_with_noise() -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string for multiple circuits"""
@@ -285,6 +439,36 @@ def test_allow_measurement_without_readout_mitigation() -> None:
             assert pauli_string_measurement_results.calibration_result is None
 
 
+def test_allow_group_pauli_measurement_without_readout_mitigation() -> None:
+    """Test that the function allows to measure without error mitigation"""
+    qubits = cirq.LineQubit.range(7)
+    circuit = cirq.FrozenCircuit(_create_ghz(7, qubits))
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.005, seed=1234)
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit] = [
+        _generate_qwc_paulis(_generate_random_pauli_string(qubits, True), 2, True),
+        _generate_qwc_paulis(_generate_random_pauli_string(qubits), 4),
+        _generate_qwc_paulis(_generate_random_pauli_string(qubits), 6),
+    ]
+
+    circuits_with_pauli_expectations = measure_pauli_strings(
+        circuits_to_pauli, sampler, 100, 100, 0, np.random.default_rng()
+    )
+
+    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
+        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
+
+        for pauli_string_measurement_results in circuit_with_pauli_expectations.results:
+            # Since there's no mitigation, the mitigated and unmitigated expectations
+            # should be the same
+            assert np.isclose(
+                pauli_string_measurement_results.mitigated_expectation,
+                pauli_string_measurement_results.unmitigated_expectation,
+            )
+            assert pauli_string_measurement_results.calibration_result is None
+
+
 def test_many_circuits_with_coefficient() -> None:
     """Test that the mitigated expectation is close to the ideal expectation
     based on the Pauli string for multiple circuits"""
@@ -344,6 +528,77 @@ def test_many_circuits_with_coefficient() -> None:
                 assert 0.0045 < error < 0.0055
 
 
+def test_many_group_pauli_in_circuits_with_coefficient() -> None:
+    """Test that the mitigated expectation is close to the ideal expectation
+    based on the Pauli string for multiple circuits"""
+    qubits_1 = cirq.LineQubit.range(3)
+    qubits_2 = [
+        cirq.GridQubit(0, 1),
+        cirq.GridQubit(1, 1),
+        cirq.GridQubit(1, 0),
+        cirq.GridQubit(1, 2),
+        cirq.GridQubit(2, 1),
+    ]
+    qubits_3 = cirq.LineQubit.range(8)
+
+    circuit_1 = cirq.FrozenCircuit(_create_ghz(3, qubits_1))
+    circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
+    circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit_1] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_1, enable_coeff=True, allow_pauli_i=False), 4
+        )
+    ]
+    circuits_to_pauli[circuit_2] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_2, enable_coeff=True, allow_pauli_i=False), 5
+        )
+    ]
+    circuits_to_pauli[circuit_3] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_3, enable_coeff=True, allow_pauli_i=False), 6
+        )
+    ]
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.03, p1=0.005, seed=1234)
+    simulator = cirq.Simulator()
+
+    circuits_with_pauli_expectations = measure_pauli_strings(
+        circuits_to_pauli, sampler, 1000, 1000, 1000, np.random.default_rng()
+    )
+
+    for circuit_with_pauli_expectations in circuits_with_pauli_expectations:
+        assert isinstance(circuit_with_pauli_expectations.circuit, cirq.FrozenCircuit)
+
+        expected_val_simulation = simulator.simulate(
+            circuit_with_pauli_expectations.circuit.unfreeze()
+        )
+        final_state_vector = expected_val_simulation.final_state_vector
+
+        for pauli_string_measurement_results in circuit_with_pauli_expectations.results:
+            assert np.isclose(
+                pauli_string_measurement_results.mitigated_expectation,
+                _ideal_expectation_based_on_pauli_string(
+                    pauli_string_measurement_results.pauli_string, final_state_vector
+                ),
+                atol=4 * pauli_string_measurement_results.mitigated_stddev,
+            )
+            assert isinstance(
+                pauli_string_measurement_results.calibration_result,
+                SingleQubitReadoutCalibrationResult,
+            )
+            for (
+                error
+            ) in pauli_string_measurement_results.calibration_result.zero_state_errors.values():
+                assert 0.025 < error < 0.035
+            for (
+                error
+            ) in pauli_string_measurement_results.calibration_result.one_state_errors.values():
+                assert 0.0045 < error < 0.0055
+
+
 def test_coefficient_not_real_number() -> None:
     """Test that the coefficient of input pauli string is not real.
     Should return error in this case"""
@@ -416,12 +671,13 @@ def test_invalid_input_pauli_string_type() -> None:
     circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
 
     circuits_to_pauli: Dict[cirq.FrozenCircuit, cirq.FrozenCircuit] = {}
-    circuits_to_pauli[circuit_1] = circuit_2
+    circuits_to_pauli[circuit_1] = [_generate_random_pauli_string(qubits_1)]  # type: ignore
+    circuits_to_pauli[circuit_2] = [circuit_1, circuit_2]  # type: ignore
 
     with pytest.raises(
         TypeError,
         match="All elements in the Pauli string lists must be cirq.PauliString "
-        "instances, got <class 'cirq.circuits.moment.Moment'>.",
+        "instances, got <class 'cirq.circuits.frozen_circuit.FrozenCircuit'>.",
     ):
         measure_pauli_strings(
             circuits_to_pauli,  # type: ignore[arg-type]
@@ -521,3 +777,91 @@ def test_rng_type_mismatch() -> None:
         measure_pauli_strings(
             circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, "test"  # type: ignore[arg-type]
         )
+
+
+def test_pauli_type_mismatch() -> None:
+    """Test that the input paulis are not a sequence of PauliStrings."""
+    qubits = cirq.LineQubit.range(5)
+
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, int] = {}
+    circuits_to_pauli[circuit] = 1
+    with pytest.raises(
+        TypeError,
+        match="Expected all elements to be either a sequence of PauliStrings or sequences of"
+        " ops.PauliStrings. Got <class 'int'> instead.",
+    ):
+        measure_pauli_strings(
+            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, "test"  # type: ignore[arg-type]
+        )
+
+
+def test_group_paulis_are_not_qwc() -> None:
+    """Test that the group paulis are not qwc."""
+    qubits = cirq.LineQubit.range(5)
+
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+
+    pauli_str1: cirq.PauliString = cirq.PauliString({qubits[0]: cirq.X, qubits[1]: cirq.Y})
+    pauli_str2: cirq.PauliString = cirq.PauliString({qubits[0]: cirq.Y})
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli[circuit] = [[pauli_str1, pauli_str2]]  # type: ignore
+    with pytest.raises(
+        ValueError,
+        match="The group of Pauli strings are not " "Qubit-Wise Commuting with each other.",
+    ):
+        measure_pauli_strings(
+            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+        )
+
+
+def test_empty_group_paulis_not_allowed() -> None:
+    """Test that the group paulis are empty"""
+    qubits = cirq.LineQubit.range(5)
+
+    circuit = cirq.FrozenCircuit(_create_ghz(5, qubits))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[cirq.PauliString]] = {}
+    circuits_to_pauli[circuit] = [[]]  # type: ignore
+    with pytest.raises(ValueError, match="Empty group of Pauli strings is not allowed"):
+        measure_pauli_strings(
+            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+        )
+
+
+def test_group_paulis_type_mismatch() -> None:
+    """Test that the group paulis type is not correct"""
+    qubits_1 = cirq.LineQubit.range(3)
+    qubits_2 = [
+        cirq.GridQubit(0, 1),
+        cirq.GridQubit(1, 1),
+        cirq.GridQubit(1, 0),
+        cirq.GridQubit(1, 2),
+        cirq.GridQubit(2, 1),
+    ]
+    qubits_3 = cirq.LineQubit.range(8)
+
+    circuit_1 = cirq.FrozenCircuit(_create_ghz(3, qubits_1))
+    circuit_2 = cirq.FrozenCircuit(_create_ghz(5, qubits_2))
+    circuit_3 = cirq.FrozenCircuit(_create_ghz(8, qubits_3))
+
+    circuits_to_pauli: Dict[cirq.FrozenCircuit, list[list[cirq.PauliString]]] = {}
+    circuits_to_pauli[circuit_1] = [
+        _generate_qwc_paulis(
+            _generate_random_pauli_string(qubits_1, enable_coeff=True, allow_pauli_i=False), 6
+        )
+        for _ in range(3)
+    ]
+    circuits_to_pauli[circuit_2] = [_generate_random_pauli_string(qubits_2, True) for _ in range(3)]
+    circuits_to_pauli[circuit_3] = [_generate_random_pauli_string(qubits_3, True) for _ in range(3)]
+
+    with pytest.raises(
+        TypeError,
+        match="Expected all elements to be sequences of ops.PauliString, "
+        "but found <class 'cirq.ops.pauli_string.PauliString'>.",
+    ):
+        measure_pauli_strings(
+            circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
+        )

{cirq_core-1.6.0.dev20250501192724.dist-info → cirq_core-1.6.0.dev20250501231232.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.6.0.dev20250501192724
+Version: 1.6.0.dev20250501231232
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.6.0.dev20250501192724.dist-info → cirq_core-1.6.0.dev20250501231232.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=0m3sYIyxRNv9jvAo6rzJ-cnbpny3KGnAByrbU7bApgQ,34720
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=cfocxtT1BJ4HkfZ-VO8YyIhPP-xfqHDkLrzz6eeO5U0,8421
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=TLk7J9TWh5C-KK9rqIeJeWRMcGs6VROp63QG6R8pFOE,1206
-cirq/_version_test.py,sha256=QFgtKxa4_ejhCTh5ghsOfhAI-qagt91wqkpb1sAx9eI,147
+cirq/_version.py,sha256=A1Q3pZC0Q7bB_vgobf71D8jfZOCjjZZzsMV86g5J2K4,1206
+cirq/_version_test.py,sha256=yrAKSgPL3X-cwPELPoppKh2xaGkiMQ82dgKn7ZCGqvU,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=-4KqEEYb6aps-seafnFTHTp3SZc0D8mr4O-pCKIajn8,13653
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -96,8 +96,8 @@ cirq/contrib/paulistring/optimize.py,sha256=ArUWzXYpHq9SE7K9FdqsJ5WJg1ZvHs8DP6zH
 cirq/contrib/paulistring/optimize_test.py,sha256=jdZBpXIialcHQGsp8LIuIpU9M5wBQX9HgnqqiMv5l8U,3559
 cirq/contrib/paulistring/pauli_string_dag.py,sha256=vg0994h84zHIejSdwfqR-mdwmHOWWOAOOcGuStfKPdk,1106
 cirq/contrib/paulistring/pauli_string_dag_test.py,sha256=4XQ2IoXx-2g5OUU1SMCLbEvDWoGyDg9FMy3_rTTqfBk,1124
-cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py,sha256=6sX2EBxwtgZ0F3ANaJVvfO_GEedLBSzu_K8wQA2Zq7c,15674
-cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py,sha256=r2maZa_9bhuolXWn2OaSe3DucOFchIMoZrX3gWs1_l8,21435
+cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py,sha256=zn9Iakv-dGlZXkcEzonflGvEAdF-6wO6C_nIPSJ3Qvc,20084
+cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py,sha256=R53mh_wnXuYsSJgnqWH5mSHGTivsYhEMnSemyFF6PYg,35465
 cirq/contrib/paulistring/pauli_string_optimize.py,sha256=KPFjsf_gzgvN7_hIcNslawcI2RGJKf5F0pDmYTHNAb8,2867
 cirq/contrib/paulistring/pauli_string_optimize_test.py,sha256=2wSpV7EVwuuK8wI_Pp31V4vCIkq-CEmQz3EjaFWi8fM,2895
 cirq/contrib/paulistring/recombine.py,sha256=zm5AJL80Xl4hgTe9U1YUEgWfcHZys_YcWNpnv02DcL0,4355
@@ -1209,8 +1209,8 @@ cirq/work/sampler.py,sha256=sW0RhIelGABAKbqTM58shwyyCPgf86JIv9IGdJe__js,19186
 cirq/work/sampler_test.py,sha256=mdk1J-WrvbPUYhY41VhWf9_te4DnXr_XMPcugWwc4-I,13281
 cirq/work/zeros_sampler.py,sha256=8_Ne6dBkDANtTZuql7Eb0Qg_E_P3-_gu-ybFzxTbKAQ,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.6.0.dev20250501192724.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.6.0.dev20250501192724.dist-info/METADATA,sha256=toJorOr1WMshis6jIfx3Sm-bnAVTy0i73ph9yR5vVLM,4908
-cirq_core-1.6.0.dev20250501192724.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-cirq_core-1.6.0.dev20250501192724.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.6.0.dev20250501192724.dist-info/RECORD,,
+cirq_core-1.6.0.dev20250501231232.dist-info/licenses/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.6.0.dev20250501231232.dist-info/METADATA,sha256=tJLjTAFl6fI7cJe2iMXNyEskoVXcxnu9JGqT4nPcISY,4908
+cirq_core-1.6.0.dev20250501231232.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+cirq_core-1.6.0.dev20250501231232.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.6.0.dev20250501231232.dist-info/RECORD,,