Merge branch 'main' into remove-controlled-cz-case

Author: daxfohl

cirq-core/cirq/circuits/circuit.py

@@ -1172,7 +1172,7 @@ def to_text_diagram(
         *,
         use_unicode_characters: bool = True,
         transpose: bool = False,
-        include_tags: bool = True,
+        include_tags: bool | Iterable[type] = True,
         precision: int | None = 3,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
     ) -> str:
@@ -1182,7 +1182,10 @@ def to_text_diagram(
             use_unicode_characters: Determines if unicode characters are
                 allowed (as opposed to ascii-only diagrams).
             transpose: Arranges qubit wires vertically instead of horizontally.
-            include_tags: Whether tags on TaggedOperations should be printed
+            include_tags: Controls which tags attached to operations are
+                included. ``True`` includes all tags, ``False`` includes none,
+                or a collection of tag classes may be specified to include only
+                those tags.
             precision: Number of digits to display in text diagram
             qubit_order: Determines how qubits are ordered in the diagram.
 
@@ -1209,7 +1212,7 @@ def to_text_diagram_drawer(
         use_unicode_characters: bool = True,
         qubit_namer: Callable[[cirq.Qid], str] | None = None,
         transpose: bool = False,
-        include_tags: bool = True,
+        include_tags: bool | Iterable[type] = True,
         draw_moment_groups: bool = True,
         precision: int | None = 3,
         qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
@@ -1224,7 +1227,10 @@ def to_text_diagram_drawer(
                 allowed (as opposed to ascii-only diagrams).
             qubit_namer: Names qubits in diagram. Defaults to using _circuit_diagram_info_ or str.
             transpose: Arranges qubit wires vertically instead of horizontally.
-            include_tags: Whether to include tags in the operation.
+            include_tags: Controls which tags attached to operations are
+                included. ``True`` includes all tags, ``False`` includes none,
+                or a collection of tag classes may be specified to include only
+                those tags.
             draw_moment_groups: Whether to draw moment symbol or not
             precision: Number of digits to use when representing numbers.
             qubit_order: Determines how qubits are ordered in the diagram.
@@ -2534,7 +2540,7 @@ def _draw_moment_annotations(
     get_circuit_diagram_info: Callable[
         [cirq.Operation, cirq.CircuitDiagramInfoArgs], cirq.CircuitDiagramInfo
     ],
-    include_tags: bool,
+    include_tags: bool | Iterable[type],
     first_annotation_row: int,
     transpose: bool,
 ):
@@ -2566,7 +2572,7 @@ def _draw_moment_in_diagram(
     get_circuit_diagram_info: (
         Callable[[cirq.Operation, cirq.CircuitDiagramInfoArgs], cirq.CircuitDiagramInfo] | None
     ),
-    include_tags: bool,
+    include_tags: bool | Iterable[type],
     first_annotation_row: int,
     transpose: bool,
 ):
@@ -2637,8 +2643,16 @@ def _draw_moment_in_diagram(
         desc = _formatted_phase(global_phase, use_unicode_characters, precision)
         if desc:
             y = max(label_map.values(), default=0) + 1
-            if tags and include_tags:
-                desc = desc + f"[{', '.join(map(str, tags))}]"
+            visible_tags = protocols.CircuitDiagramInfoArgs(
+                known_qubits=None,
+                known_qubit_count=None,
+                use_unicode_characters=True,
+                precision=None,
+                label_map=None,
+                include_tags=include_tags,
+            ).tags_to_include(tags)
+            if visible_tags:
+                desc = desc + f"[{', '.join(map(str, visible_tags))}]"
             out_diagram.write(x0, y, desc)
 
     if not non_global_ops:

cirq-core/cirq/circuits/moment.py

@@ -565,7 +565,7 @@ def to_text_diagram(
         extra_qubits: Iterable[cirq.Qid] = (),
         use_unicode_characters: bool = True,
         precision: int | None = None,
-        include_tags: bool = True,
+        include_tags: bool | Iterable[type] = True,
     ) -> str:
         """Create a text diagram for the moment.
 
@@ -583,8 +583,10 @@ def to_text_diagram(
             precision: How precise numbers, such as angles, should be. Use None
                 for infinite precision, or an integer for a certain number of
                 digits of precision.
-            include_tags: Whether or not to include operation tags in the
-                diagram.
+            include_tags: Controls which tags attached to operations are
+                included. ``True`` includes all tags, ``False`` includes none,
+                or a collection of tag classes may be specified to include only
+                those tags.
 
         Returns:
             The text diagram rendered into text.

cirq-core/cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py

@@ -28,7 +28,9 @@
 from cirq.experiments.readout_confusion_matrix import TensoredConfusionMatrices
 
 if TYPE_CHECKING:
-    from cirq.experiments import SingleQubitReadoutCalibrationResult
+    from cirq.experiments.single_qubit_readout_calibration import (
+        SingleQubitReadoutCalibrationResult,
+    )
     from cirq.study import ResultDict
 
 
@@ -217,6 +219,11 @@ def _normalize_input_paulis(
     return cast(dict[circuits.FrozenCircuit, list[list[ops.PauliString]]], circuits_to_pauli)
 
 
+def _extract_readout_qubits(pauli_strings: list[ops.PauliString]) -> list[ops.Qid]:
+    """Extracts unique qubits from a list of QWC Pauli strings."""
+    return sorted(set(q for ps in pauli_strings for q in ps.qubits))
+
+
 def _pauli_strings_to_basis_change_ops(
     pauli_strings: list[ops.PauliString], qid_list: list[ops.Qid]
 ):
@@ -315,16 +322,38 @@ def _process_pauli_measurement_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_readout_qubits = _extract_readout_qubits(pauli_strs)
+
+        calibration_result = (
+            calibration_results[tuple(pauli_readout_qubits)]
+            if disable_readout_mitigation is False
+            else None
+        )
 
         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))
-            )
+            if disable_readout_mitigation:
+                pauli_str_calibration_result = None
+                confusion_matrices = _build_many_one_qubits_empty_confusion_matrix(
+                    len(qubits_sorted)
+                )
+            else:
+                if calibration_result is None:
+                    # This case should be logically impossible if mitigation is on,
+                    # so we raise an error.
+                    raise ValueError(
+                        f"Readout mitigation is enabled, but no calibration result was "
+                        f"found for qubits {pauli_readout_qubits}."
+                    )
+                pauli_str_calibration_result = calibration_result.readout_result_for_qubits(
+                    qubits_sorted
+                )
+                confusion_matrices = _build_many_one_qubits_confusion_matrix(
+                    pauli_str_calibration_result
+                )
+
             tensored_cm = TensoredConfusionMatrices(
                 confusion_matrices,
                 [[q] for q in qubits_sorted],
@@ -356,11 +385,7 @@ def _process_pauli_measurement_results(
                     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
-                    ),
+                    calibration_result=pauli_str_calibration_result,
                 )
             )
 
@@ -428,8 +453,7 @@ def measure_pauli_strings(
     unique_qubit_tuples = set()
     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)))
+            unique_qubit_tuples.add(tuple(_extract_readout_qubits(pauli_strings)))
     # qubits_list is a list of qubit tuples
     qubits_list = sorted(unique_qubit_tuples)
 

cirq-core/cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py

@@ -23,7 +23,10 @@
 
 import cirq
 from cirq.contrib.paulistring import measure_pauli_strings
-from cirq.experiments import SingleQubitReadoutCalibrationResult
+from cirq.contrib.paulistring.pauli_string_measurement_with_readout_mitigation import (
+    _process_pauli_measurement_results,
+)
+from cirq.experiments.single_qubit_readout_calibration import SingleQubitReadoutCalibrationResult
 from cirq.experiments.single_qubit_readout_calibration_test import NoisySingleQubitReadoutSampler
 
 
@@ -867,3 +870,37 @@ def test_group_paulis_type_mismatch() -> None:
         measure_pauli_strings(
             circuits_to_pauli, cirq.Simulator(), 1000, 1000, 1000, np.random.default_rng()
         )
+
+
+def test_process_pauli_measurement_results_raises_error_on_missing_calibration() -> None:
+    """Test that the function raises an error if the calibration result is missing."""
+    qubits: list[cirq.Qid] = [q for q in cirq.LineQubit.range(5)]
+
+    measurement_op = cirq.measure(*qubits, key='m')
+    test_circuits = list[cirq.Circuit]()
+    for _ in range(3):
+        circuit_list = []
+
+        circuit = _create_ghz(5, qubits) + measurement_op
+        circuit_list.append(circuit)
+    test_circuits.extend(circuit_list)
+
+    pauli_strings = [_generate_random_pauli_string(qubits, True) for _ in range(3)]
+    sampler = cirq.Simulator()
+
+    circuit_results = sampler.run_batch(test_circuits, repetitions=1000)
+
+    empty_calibration_result_dict = {tuple(qubits): None}
+
+    with pytest.raises(
+        ValueError,
+        match="Readout mitigation is enabled, but no calibration result was found for qubits",
+    ):
+        _process_pauli_measurement_results(
+            qubits,
+            [pauli_strings],
+            circuit_results[0],  # type: ignore[arg-type]
+            empty_calibration_result_dict,  # type: ignore[arg-type]
+            1000,
+            1.0,
+        )

cirq-core/cirq/contrib/quantum_volume/quantum_volume.py

@@ -127,7 +127,7 @@ def sample_heavy_set(
     # Add measure gates to the end of (a copy of) the circuit. Ensure that those
     # gates measure those in the given mapping, preserving this order.
     qubits = circuit.all_qubits()
-    key = None
+    key: Callable[[cirq.Qid], cirq.Qid] | None = None
     if mapping:
         # Add any qubits that were not explicitly mapped, so they aren't lost in
         # the sorting.
@@ -137,7 +137,7 @@ def sample_heavy_set(
     # Don't do a single large measurement gate because then the key will be one
     # large string. Instead, do a bunch of single-qubit measurement gates so we
     # preserve the qubit keys.
-    sorted_qubits = sorted(qubits, key=key)  # type: ignore[arg-type]
+    sorted_qubits = sorted(qubits, key=key)
     circuit_copy = circuit + [cirq.measure(q) for q in sorted_qubits]
 
     # Run the sampler to compare each output against the Heavy Set.

cirq-core/cirq/experiments/single_qubit_readout_calibration.py

@@ -179,6 +179,17 @@ def plot_integrated_histogram(
         ax.set_ylabel('Percentile')
         return ax
 
+    def readout_result_for_qubits(
+        self, readout_qubits: list[ops.Qid]
+    ) -> SingleQubitReadoutCalibrationResult:
+        """Builds a calibration result for the specific readout qubits."""
+        return SingleQubitReadoutCalibrationResult(
+            zero_state_errors={qubit: self.zero_state_errors[qubit] for qubit in readout_qubits},
+            one_state_errors={qubit: self.one_state_errors[qubit] for qubit in readout_qubits},
+            timestamp=self.timestamp,
+            repetitions=self.repetitions,
+        )
+
     @classmethod
     def _from_json_dict_(
         cls, zero_state_errors, one_state_errors, repetitions, timestamp, **kwargs

cirq-core/cirq/linalg/predicates.py

@@ -115,8 +115,12 @@ def is_unitary(matrix: np.ndarray, *, rtol: float = 1e-5, atol: float = 1e-8) ->
     Returns:
         Whether the matrix is unitary within the given tolerance.
     """
-    return matrix.shape[0] == matrix.shape[1] and np.allclose(
-        matrix.dot(np.conj(matrix.T)), np.eye(matrix.shape[0]), rtol=rtol, atol=atol
+    return (
+        matrix.ndim == 2
+        and matrix.shape[0] == matrix.shape[1]
+        and np.allclose(
+            matrix.dot(np.conj(matrix.T)), np.eye(matrix.shape[0]), rtol=rtol, atol=atol
+        )
     )
 
 

cirq-core/cirq/linalg/predicates_test.py

@@ -103,10 +103,13 @@ def test_is_hermitian_tolerance():
 
 
 def test_is_unitary():
+    assert not cirq.is_unitary(np.empty((0,)))
     assert cirq.is_unitary(np.empty((0, 0)))
     assert not cirq.is_unitary(np.empty((1, 0)))
     assert not cirq.is_unitary(np.empty((0, 1)))
+    assert not cirq.is_unitary(np.empty((0, 0, 0)))
 
+    assert not cirq.is_unitary(np.array(1))
     assert cirq.is_unitary(np.array([[1]]))
     assert cirq.is_unitary(np.array([[-1]]))
     assert cirq.is_unitary(np.array([[1j]]))

cirq-core/cirq/ops/raw_types.py

@@ -913,11 +913,12 @@ def _resolve_parameters_(
 
     def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         sub_op_info = protocols.circuit_diagram_info(self.sub_operation, args, NotImplemented)
-        # Add tag to wire symbol if it exists.
-        if sub_op_info is not NotImplemented and args.include_tags and sub_op_info.wire_symbols:
-            sub_op_info.wire_symbols = (
-                sub_op_info.wire_symbols[0] + f"[{', '.join(map(str, self._tags))}]",
-            ) + sub_op_info.wire_symbols[1:]
+        if sub_op_info is not NotImplemented and sub_op_info.wire_symbols:
+            visible_tags = args.tags_to_include(self._tags)
+            if visible_tags:
+                sub_op_info.wire_symbols = (
+                    sub_op_info.wire_symbols[0] + f"[{', '.join(map(str, visible_tags))}]",
+                ) + sub_op_info.wire_symbols[1:]
         return sub_op_info
 
     @cached_method

cirq-core/cirq/ops/raw_types_test.py

@@ -554,6 +554,8 @@ def __str__(self):
     diagram_with_non_string_tag = "(1, 1): ───H[<taggy>]───"
     assert c.to_text_diagram() == diagram_with_non_string_tag
     assert c.to_text_diagram(include_tags=False) == diagram_without_tags
+    assert c.to_text_diagram(include_tags={str}) == diagram_without_tags
+    assert c.to_text_diagram(include_tags={TaggyTag}) == diagram_with_non_string_tag
 
 
 def test_circuit_diagram_tagged_global_phase() -> None:
@@ -651,7 +653,7 @@ def test_tagged_operation_forwards_protocols() -> None:
     np.testing.assert_equal(cirq.unitary(tagged_h), cirq.unitary(h))
     assert cirq.has_unitary(tagged_h)
     assert cirq.decompose(tagged_h) == cirq.decompose(h)
-    assert [*tagged_h._decompose_()] == cirq.decompose(h)
+    assert [*tagged_h._decompose_()] == cirq.decompose_once(h)
     assert cirq.pauli_expansion(tagged_h) == cirq.pauli_expansion(h)
     assert cirq.equal_up_to_global_phase(h, tagged_h)
     assert np.isclose(cirq.kraus(h), cirq.kraus(tagged_h)).all()