cirq-core 1.3.0.dev20231201141002__py3-none-any.whl → 1.4.0__py3-none-any.whl

cirq/ops/gate_operation.py

@@ -15,6 +15,7 @@
 """Basic types defining qubits, gates, and operations."""
 
 import re
+import warnings
 from typing import (
     AbstractSet,
     Any,
@@ -35,7 +36,7 @@ from typing_extensions import Self
 
 import numpy as np
 
-from cirq import protocols, value
+from cirq import ops, protocols, value
 from cirq.ops import raw_types, gate_features, control_values as cv
 from cirq.type_workarounds import NotImplementedType
 
@@ -348,6 +349,14 @@ class GateOperation(raw_types.Operation):
         return self.gate._rmul_with_qubits(self._qubits, other)
 
     def _qasm_(self, args: 'protocols.QasmArgs') -> Optional[str]:
+        if isinstance(self.gate, ops.GlobalPhaseGate):
+            warnings.warn(
+                "OpenQASM 2.0 does not support global phase."
+                "Since the global phase does not affect the measurement results, "
+                "the conversion to QASM is disregarded."
+            )
+            return ""
+
         return protocols.qasm(self.gate, args=args, qubits=self.qubits, default=None)
 
     def _equal_up_to_global_phase_(

cirq/ops/named_qubit.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import functools
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
+import weakref
+from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
 
 from cirq import protocols
 from cirq.ops import raw_types
@@ -31,34 +32,55 @@ class _BaseNamedQid(raw_types.Qid):
     _comp_key: Optional[str] = None
     _hash: Optional[int] = None
 
-    def __getstate__(self):
-        # Don't save hash when pickling; see #3777.
-        state = self.__dict__
-        if "_hash" in state or "_comp_key" in state:
-            state = state.copy()
-            if "_hash" in state:
-                del state["_hash"]
-            if "_comp_key" in state:
-                del state["_comp_key"]
-        return state
-
     def __hash__(self) -> int:
         if self._hash is None:
             self._hash = hash((self._name, self._dimension))
         return self._hash
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseNamedQid):
-            return self._name == other._name and self._dimension == other._dimension
+            return self is other or (
+                self._name == other._name and self._dimension == other._dimension
+            )
         return NotImplemented
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         # Explicitly implemented for performance (vs delegating to Qid).
         if isinstance(other, _BaseNamedQid):
-            return self._name != other._name or self._dimension != other._dimension
+            return self is not other and (
+                self._name != other._name or self._dimension != other._dimension
+            )
         return NotImplemented
 
+    def __lt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseNamedQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 < k1 or (k0 == k1 and self._dimension < other._dimension)
+        return super().__lt__(other)
+
+    def __le__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseNamedQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 < k1 or (k0 == k1 and self._dimension <= other._dimension)
+        return super().__le__(other)
+
+    def __ge__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseNamedQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 > k1 or (k0 == k1 and self._dimension >= other._dimension)
+        return super().__ge__(other)
+
+    def __gt__(self, other) -> bool:
+        # Explicitly implemented for performance (vs delegating to Qid).
+        if isinstance(other, _BaseNamedQid):
+            k0, k1 = self._comparison_key(), other._comparison_key()
+            return k0 > k1 or (k0 == k1 and self._dimension > other._dimension)
+        return super().__gt__(other)
+
     def _comparison_key(self):
         if self._comp_key is None:
             self._comp_key = _pad_digits(self._name)
@@ -86,7 +108,11 @@ class NamedQid(_BaseNamedQid):
     correctly come before 'qid22'.
     """
 
-    def __init__(self, name: str, dimension: int) -> None:
+    # Cache of existing NamedQid instances, returned by __new__ if available.
+    # Holds weak references so instances can still be garbage collected.
+    _cache = weakref.WeakValueDictionary[Tuple[str, int], 'cirq.NamedQid']()
+
+    def __new__(cls, name: str, dimension: int) -> 'cirq.NamedQid':
         """Initializes a `NamedQid` with a given name and dimension.
 
         Args:
@@ -94,9 +120,19 @@ class NamedQid(_BaseNamedQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
-        self.validate_dimension(dimension)
-        self._name = name
-        self._dimension = dimension
+        key = (name, dimension)
+        inst = cls._cache.get(key)
+        if inst is None:
+            cls.validate_dimension(dimension)
+            inst = super().__new__(cls)
+            inst._name = name
+            inst._dimension = dimension
+            cls._cache[key] = inst
+        return inst
+
+    def __getnewargs__(self):
+        """Returns a tuple of args to pass to __new__ when unpickling."""
+        return (self._name, self._dimension)
 
     def __repr__(self) -> str:
         return f'cirq.NamedQid({self._name!r}, dimension={self._dimension})'
@@ -143,18 +179,28 @@ class NamedQubit(_BaseNamedQid):
 
     _dimension = 2
 
-    def __init__(self, name: str) -> None:
-        """Initializes a `NamedQubit` with a given name.
+    # Cache of existing NamedQubit instances, returned by __new__ if available.
+    # Holds weak references so instances can still be garbage collected.
+    _cache = weakref.WeakValueDictionary[str, 'cirq.NamedQubit']()
+
+    def __new__(cls, name: str) -> 'cirq.NamedQubit':
+        """Initializes a `NamedQid` with a given name and dimension.
 
         Args:
             name: The name.
+            dimension: The dimension of the qid's Hilbert space, i.e.
+                the number of quantum levels.
         """
-        self._name = name
-
-    def _cmp_tuple(self):
-        cls = NamedQid if type(self) is NamedQubit else type(self)
-        # Must be same as Qid._cmp_tuple but with cls in place of type(self).
-        return (cls.__name__, repr(cls), self._comparison_key(), self._dimension)
+        inst = cls._cache.get(name)
+        if inst is None:
+            inst = super().__new__(cls)
+            inst._name = name
+            cls._cache[name] = inst
+        return inst
+
+    def __getnewargs__(self):
+        """Returns a tuple of args to pass to __new__ when unpickling."""
+        return (self._name,)
 
     def __str__(self) -> str:
         return self._name

cirq/ops/named_qubit_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import cirq
+from cirq.devices.grid_qubit_test import _test_qid_pickled_hash
 from cirq.ops.named_qubit import _pad_digits
 
 
@@ -41,6 +42,24 @@ def test_named_qubit_repr():
     assert repr(qid) == "cirq.NamedQid('a', dimension=3)"
 
 
+def test_named_qubit_pickled_hash():
+    # Use a name that is unlikely to be used by any other tests.
+    x = "test_named_qubit_pickled_hash"
+    q_bad = cirq.NamedQubit(x)
+    cirq.NamedQubit._cache.pop(x)
+    q = cirq.NamedQubit(x)
+    _test_qid_pickled_hash(q, q_bad)
+
+
+def test_named_qid_pickled_hash():
+    # Use a name that is unlikely to be used by any other tests.
+    x = "test_named_qid_pickled_hash"
+    q_bad = cirq.NamedQid(x, dimension=3)
+    cirq.NamedQid._cache.pop((x, 3))
+    q = cirq.NamedQid(x, dimension=3)
+    _test_qid_pickled_hash(q, q_bad)
+
+
 def test_named_qubit_order():
     order = cirq.testing.OrderTester()
     order.add_ascending(

cirq/ops/parity_gates.py

@@ -399,6 +399,11 @@ class MSGate(XXPowGate):
             return 'cirq.ms(np.pi/2)'
         return f'cirq.ms({self._exponent!r}*np.pi/2)'
 
+    # the default namespace is already occupied by cirq_ionq.MSGate
+    @classmethod
+    def _json_namespace_(cls) -> str:
+        return 'cirq'
+
     def _json_dict_(self) -> Dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ["rads"])
 

cirq/ops/parity_gates_test.py

@@ -258,7 +258,7 @@ def test_trace_distance():
 def test_ms_arguments():
     eq_tester = cirq.testing.EqualsTester()
     eq_tester.add_equality_group(
-        cirq.ms(np.pi / 2), cirq.ops.MSGate(rads=np.pi / 2), cirq.XXPowGate(global_shift=-0.5)
+        cirq.ms(np.pi / 2), cirq.MSGate(rads=np.pi / 2), cirq.XXPowGate(global_shift=-0.5)
     )
     eq_tester.add_equality_group(
         cirq.ms(np.pi / 4), cirq.XXPowGate(exponent=0.5, global_shift=-0.5)
@@ -323,15 +323,7 @@ b: ───×───────────MS(π)───
 
 
 def test_json_serialization():
-    def custom_resolver(cirq_type: str):
-        if cirq_type == "MSGate":
-            return cirq.ops.MSGate
-        return None
-
-    assert cirq.read_json(
-        json_text=cirq.to_json(cirq.ms(np.pi / 2)), resolvers=[custom_resolver]
-    ) == cirq.ms(np.pi / 2)
-    assert custom_resolver('X') is None
+    assert cirq.read_json(json_text=cirq.to_json(cirq.ms(np.pi / 2))) == cirq.ms(np.pi / 2)
 
 
 @pytest.mark.parametrize('gate_cls', (cirq.XXPowGate, cirq.YYPowGate, cirq.ZZPowGate))

cirq/ops/pauli_gates.py

@@ -15,6 +15,7 @@ import abc
 from typing import Any, cast, Tuple, TYPE_CHECKING, Union, Dict
 
 from cirq._doc import document
+from cirq._import import LazyLoader
 from cirq.ops import common_gates, raw_types, identity
 from cirq.type_workarounds import NotImplementedType
 
@@ -29,6 +30,9 @@ if TYPE_CHECKING:
     )  # pragma: no cover
 
 
+pauli_string = LazyLoader("pauli_string", globals(), "cirq.ops.pauli_string")
+
+
 class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
     """Represents the Pauli gates.
 
@@ -97,9 +101,8 @@ class Pauli(raw_types.Gate, metaclass=abc.ABCMeta):
         """
         if len(qubits) != 1:
             raise ValueError(f'Expected a single qubit, got <{qubits!r}>.')
-        from cirq.ops.pauli_string import SingleQubitPauliStringGateOperation
 
-        return SingleQubitPauliStringGateOperation(self, qubits[0])
+        return pauli_string.SingleQubitPauliStringGateOperation(self, qubits[0])
 
     @property
     def _canonical_exponent(self):

cirq/ops/pauli_string.py

@@ -42,7 +42,7 @@ import numpy as np
 import sympy
 
 import cirq
-from cirq import value, protocols, linalg, qis
+from cirq import value, protocols, linalg, qis, _compat
 from cirq._doc import document
 from cirq._import import LazyLoader
 from cirq.ops import (
@@ -184,7 +184,7 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         Raises:
             TypeError: If the `qubit_pauli_map` has values that are not Paulis.
         """
-        if qubit_pauli_map is not None:
+        if _compat.__cirq_debug__.get() and qubit_pauli_map is not None:
             for v in qubit_pauli_map.values():
                 if not isinstance(v, pauli_gates.Pauli):
                     raise TypeError(f'{v} is not a Pauli')

cirq/ops/permutation_gate.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Iterable, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, Dict, Sequence, Tuple, TYPE_CHECKING
 
 from cirq import protocols, value
 from cirq.ops import raw_types, swap_gates
@@ -74,23 +74,21 @@ class QubitPermutationGate(raw_types.Gate):
         return True
 
     def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
-        n = len(qubits)
-        qubit_ids = [*range(n)]
-        is_sorted = False
-
-        def _swap_if_out_of_order(idx: int) -> Iterable['cirq.Operation']:
-            nonlocal is_sorted
-            if self._permutation[qubit_ids[idx]] > self._permutation[qubit_ids[idx + 1]]:
-                yield swap_gates.SWAP(qubits[idx], qubits[idx + 1])
-                qubit_ids[idx + 1], qubit_ids[idx] = qubit_ids[idx], qubit_ids[idx + 1]
-                is_sorted = False
-
-        while not is_sorted:
-            is_sorted = True
-            for i in range(0, n - 1, 2):
-                yield from _swap_if_out_of_order(i)
-            for i in range(1, n - 1, 2):
-                yield from _swap_if_out_of_order(i)
+        permutation = [p for p in self.permutation]
+
+        for i in range(len(permutation)):
+
+            if permutation[i] == -1:
+                continue
+            cycle = [i]
+            while permutation[cycle[-1]] != i:
+                cycle.append(permutation[cycle[-1]])
+
+            for j in cycle:
+                permutation[j] = -1
+
+            for idx in cycle[1:]:
+                yield swap_gates.SWAP(qubits[cycle[0]], qubits[idx])
 
     def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs'):
         # Compute the permutation index list.

cirq/ops/phased_iswap_gate_test.py

@@ -34,9 +34,7 @@ def test_phased_iswap_init():
 
 def test_phased_iswap_equality():
     eq = cirq.testing.EqualsTester()
-    eq.add_equality_group(
-        cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4), cirq.ISWAP**0.4
-    )
+    eq.add_equality_group(cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4), cirq.ISWAP**0.4)
     eq.add_equality_group(
         cirq.PhasedISwapPowGate(phase_exponent=0, exponent=0.4, global_shift=0.3),
         cirq.ISwapPowGate(global_shift=0.3) ** 0.4,

cirq/ops/phased_x_gate.py

@@ -28,7 +28,7 @@ from cirq.type_workarounds import NotImplementedType
 
 @value.value_equality(manual_cls=True, approximate=True)
 class PhasedXPowGate(raw_types.Gate):
-    r"""A gate equivalent to $Z^{p} X^t Z^{-p}$.
+    r"""A gate equivalent to $Z^{-p} X^t Z^{p}$ (in time order).
 
     The unitary matrix of `cirq.PhasedXPowGate(exponent=t, phase_exponent=p)` is:
     $$

cirq/ops/phased_x_z_gate.py

@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 
 @value.value_equality(approximate=True)
 class PhasedXZGate(raw_types.Gate):
-    r"""A single qubit gate equivalent to the circuit $Z^z Z^{a} X^x Z^{-a}$.
+    r"""A single qubit gate equivalent to the circuit $Z^{-a} X^x Z^{a} Z^z$ (in time order).
 
     The unitary matrix of `cirq.PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)` is:
     $$
@@ -67,6 +67,22 @@ class PhasedXZGate(raw_types.Gate):
         self._z_exponent = z_exponent
         self._axis_phase_exponent = axis_phase_exponent
 
+    @classmethod
+    def from_zyz_angles(cls, z0_rad: float, y_rad: float, z1_rad: float) -> 'cirq.PhasedXZGate':
+        """Create a PhasedXZGate from ZYZ angles.
+
+        The returned gate is equivalent to $Rz(z0_rad) Ry(y_rad) Rz(z1_rad)$ (in time order).
+        """
+        return cls.from_zyz_exponents(z0=z0_rad / np.pi, y=y_rad / np.pi, z1=z1_rad / np.pi)
+
+    @classmethod
+    def from_zyz_exponents(cls, z0: float, y: float, z1: float) -> 'cirq.PhasedXZGate':
+        """Create a PhasedXZGate from ZYZ exponents.
+
+        The returned gate is equivalent to $Z^z0 Y^y Z^z1$ (in time order).
+        """
+        return PhasedXZGate(axis_phase_exponent=-z0 + 0.5, x_exponent=y, z_exponent=z0 + z1)
+
     def _canonical(self) -> 'cirq.PhasedXZGate':
         x = self.x_exponent
         z = self.z_exponent

cirq/ops/phased_x_z_gate_test.py

@@ -34,6 +34,30 @@ def test_eq():
     eq.add_equality_group(cirq.PhasedXZGate(x_exponent=1, z_exponent=0, axis_phase_exponent=0))
 
 
+@pytest.mark.parametrize('z0_rad', [-np.pi / 5, 0, np.pi / 5, np.pi / 4, np.pi / 2, np.pi])
+@pytest.mark.parametrize('y_rad', [0, np.pi / 5, np.pi / 4, np.pi / 2, np.pi])
+@pytest.mark.parametrize('z1_rad', [-np.pi / 5, 0, np.pi / 5, np.pi / 4, np.pi / 2, np.pi])
+def test_from_zyz_angles(z0_rad: float, y_rad: float, z1_rad: float) -> None:
+    q = cirq.q(0)
+    phxz = cirq.PhasedXZGate.from_zyz_angles(z0_rad, y_rad, z1_rad)
+    zyz = cirq.Circuit(cirq.rz(z0_rad).on(q), cirq.ry(y_rad).on(q), cirq.rz(z1_rad).on(q))
+    cirq.testing.assert_allclose_up_to_global_phase(
+        cirq.unitary(phxz), cirq.unitary(zyz), atol=1e-8
+    )
+
+
+@pytest.mark.parametrize('z0', [-0.2, 0, 0.2, 0.25, 0.5, 1])
+@pytest.mark.parametrize('y', [0, 0.2, 0.25, 0.5, 1])
+@pytest.mark.parametrize('z1', [-0.2, 0, 0.2, 0.25, 0.5, 1])
+def test_from_zyz_exponents(z0: float, y: float, z1: float) -> None:
+    q = cirq.q(0)
+    phxz = cirq.PhasedXZGate.from_zyz_exponents(z0, y, z1)
+    zyz = cirq.Circuit(cirq.Z(q) ** z0, cirq.Y(q) ** y, cirq.Z(q) ** z1)
+    cirq.testing.assert_allclose_up_to_global_phase(
+        cirq.unitary(phxz), cirq.unitary(zyz), atol=1e-8
+    )
+
+
 def test_canonicalization():
     def f(x, z, a):
         return cirq.PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)

cirq/ops/qid_util.py

@@ -19,18 +19,15 @@ if TYPE_CHECKING:
 
 
 @overload
-def q(__x: int) -> 'cirq.LineQubit':
-    ...
+def q(__x: int) -> 'cirq.LineQubit': ...
 
 
 @overload
-def q(__row: int, __col: int) -> 'cirq.GridQubit':
-    ...
+def q(__row: int, __col: int) -> 'cirq.GridQubit': ...
 
 
 @overload
-def q(__name: str) -> 'cirq.NamedQubit':
-    ...
+def q(__name: str) -> 'cirq.NamedQubit': ...
 
 
 def q(*args: Union[int, str]) -> Union['cirq.LineQubit', 'cirq.GridQubit', 'cirq.NamedQubit']:
@@ -44,8 +41,7 @@ def q(*args: Union[int, str]) -> Union['cirq.LineQubit', 'cirq.GridQubit', 'cirq
     >>> cirq.q("foo") == cirq.NamedQubit("foo")
     True
 
-    Note that arguments should be treated as positional only, even
-    though this is only enforceable in python 3.8 or later.
+    Note that arguments should be treated as positional only.
 
     Args:
         *args: One or two ints, or a single str, as described above.

cirq/ops/qubit_manager.py

@@ -14,7 +14,7 @@
 
 import abc
 import dataclasses
-from typing import Iterable, List, TYPE_CHECKING
+from typing import Iterable, List, TYPE_CHECKING, Tuple
 from cirq.ops import raw_types
 
 if TYPE_CHECKING:
@@ -41,16 +41,19 @@ class _BaseAncillaQid(raw_types.Qid):
     dim: int = 2
     prefix: str = ''
 
-    def _comparison_key(self) -> int:
-        return self.id
+    def _comparison_key(self) -> Tuple[str, int]:
+        return self.prefix, self.id
 
     @property
     def dimension(self) -> int:
         return self.dim
 
+    def with_dimension(self, dimension: int) -> '_BaseAncillaQid':
+        return dataclasses.replace(self, dim=dimension)
+
     def __repr__(self) -> str:
         dim_str = f', dim={self.dim}' if self.dim != 2 else ''
-        prefix_str = f', prefix={self.prefix}' if self.prefix != '' else ''
+        prefix_str = f', prefix={self.prefix!r}' if self.prefix != '' else ''
         return f"cirq.ops.{type(self).__name__}({self.id}{dim_str}{prefix_str})"
 
 

cirq/ops/qubit_manager_test.py

@@ -27,12 +27,27 @@ def test_clean_qubits():
     q = cqi.CleanQubit(2, dim=3)
     assert q.id == 2
     assert q.dimension == 3
+    assert q.with_dimension(4) == cqi.CleanQubit(2, dim=4)
     assert str(q) == '_c(2) (d=3)'
     assert repr(q) == 'cirq.ops.CleanQubit(2, dim=3)'
 
+    q = cqi.CleanQubit(3, dim=4, prefix="a")
+    assert str(q) == 'a_c(3) (d=4)'
+    assert repr(q) == "cirq.ops.CleanQubit(3, dim=4, prefix='a')"
+
     assert cqi.CleanQubit(1) < cqi.CleanQubit(2)
 
 
+def test_ancilla_qubits_prefix():
+    assert cqi.CleanQubit(1, prefix="1") != cqi.CleanQubit(1, prefix="2")
+    assert cqi.CleanQubit(1, prefix="1") < cqi.CleanQubit(1, prefix="2")
+    assert cqi.CleanQubit(1, prefix="1") < cqi.CleanQubit(2, prefix="1")
+    assert cqi.BorrowableQubit(1, prefix="1") != cqi.BorrowableQubit(1, prefix="2")
+    assert cqi.BorrowableQubit(1, prefix="1") < cqi.BorrowableQubit(1, prefix="2")
+    assert cqi.BorrowableQubit(1, prefix="1") < cqi.BorrowableQubit(2, prefix="1")
+    assert cqi.CleanQubit(1, prefix="1") != cqi.BorrowableQubit(1, prefix="1")
+
+
 def test_borrow_qubits():
     q = cqi.BorrowableQubit(10)
     assert q.id == 10
@@ -43,9 +58,14 @@ def test_borrow_qubits():
     q = cqi.BorrowableQubit(20, dim=4)
     assert q.id == 20
     assert q.dimension == 4
+    assert q.with_dimension(10) == cqi.BorrowableQubit(20, dim=10)
     assert str(q) == '_b(20) (d=4)'
     assert repr(q) == 'cirq.ops.BorrowableQubit(20, dim=4)'
 
+    q = cqi.BorrowableQubit(30, dim=4, prefix="a")
+    assert str(q) == 'a_b(30) (d=4)'
+    assert repr(q) == "cirq.ops.BorrowableQubit(30, dim=4, prefix='a')"
+
     assert cqi.BorrowableQubit(1) < cqi.BorrowableQubit(2)
 
 

cirq/ops/raw_types.py

@@ -230,7 +230,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         Returns: a `cirq.Operation` which is this gate applied to the given
             qubits.
         """
-        return ops.gate_operation.GateOperation(self, list(qubits))
+        return ops.gate_operation.GateOperation(self, qubits)
 
     def on_each(self, *targets: Union[Qid, Iterable[Any]]) -> List['cirq.Operation']:
         """Returns a list of operations applying the gate to all targets.
@@ -921,7 +921,7 @@ class TaggedOperation(Operation):
         # 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] + str(list(self._tags)),
+                sub_op_info.wire_symbols[0] + f"[{', '.join(map(str, self._tags))}]",
             ) + sub_op_info.wire_symbols[1:]
         return sub_op_info
 
@@ -1032,6 +1032,9 @@ class _InverseCompositeGate(Gate):
     def __repr__(self) -> str:
         return f'({self._original!r}**-1)'
 
+    def __str__(self) -> str:
+        return f'{self._original!s}†'
+
 
 def _validate_qid_shape(val: Any, qubits: Sequence['cirq.Qid']) -> None:
     """Helper function to validate qubits for gates and operations.