cirq-core 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/protocols/equal_up_to_global_phase_protocol.py

@@ -14,7 +14,7 @@
 
 import numbers
 from collections.abc import Iterable
-from typing import Any, Union
+from typing import Any
 
 import numpy as np
 from typing_extensions import Protocol
@@ -28,7 +28,7 @@ class SupportsEqualUpToGlobalPhase(Protocol):
     """Object which can be compared for equality mod global phase."""
 
     @doc_private
-    def _equal_up_to_global_phase_(self, other: Any, *, atol: Union[int, float]) -> bool:
+    def _equal_up_to_global_phase_(self, other: Any, *, atol: float) -> bool:
         """Approximate comparator.
 
         Types implementing this protocol define their own logic for comparison
@@ -46,7 +46,7 @@ class SupportsEqualUpToGlobalPhase(Protocol):
         """
 
 
-def equal_up_to_global_phase(val: Any, other: Any, *, atol: Union[int, float] = 1e-8) -> bool:
+def equal_up_to_global_phase(val: Any, other: Any, *, atol: float = 1e-8) -> bool:
     """Determine whether two objects are equal up to global phase.
 
     If `val` implements a `_equal_up_to_global_phase_` method then it is

cirq/protocols/equal_up_to_global_phase_protocol_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import numpy as np
+
 import cirq
 
 
@@ -117,3 +118,9 @@ def test_equal_up_to_global_phase_eq_supported():
     # cast types
     assert cirq.equal_up_to_global_phase(A(0.1), A(0.1j), atol=1e-2)
     assert not cirq.equal_up_to_global_phase(1e-8j, B(0.0), atol=1e-10)
+
+
+def test_equal_up_to_global_phase_non_eigen_gates():
+    gate1 = cirq.PhasedXPowGate(phase_exponent=1.5, exponent=1.0)
+    gate2 = cirq.PhasedXPowGate(phase_exponent=0.5, exponent=1.0)
+    assert cirq.equal_up_to_global_phase(gate1, gate2)

cirq/protocols/has_stabilizer_effect_protocol.py

@@ -14,13 +14,13 @@
 
 from typing import Any, Optional
 
-from cirq.ops.clifford_gate import SingleQubitCliffordGate
-from cirq.ops.dense_pauli_string import DensePauliString
-from cirq._import import LazyLoader
-import cirq.protocols.unitary_protocol as unitary_protocol
+import cirq.protocols.decompose_protocol as decompose_protocol
 import cirq.protocols.has_unitary_protocol as has_unitary_protocol
 import cirq.protocols.qid_shape_protocol as qid_shape_protocol
-import cirq.protocols.decompose_protocol as decompose_protocol
+import cirq.protocols.unitary_protocol as unitary_protocol
+from cirq._import import LazyLoader
+from cirq.ops.clifford_gate import SingleQubitCliffordGate
+from cirq.ops.dense_pauli_string import DensePauliString
 
 pauli_string_decomposition = LazyLoader(
     "pauli_string_decomposition",

cirq/protocols/has_unitary_protocol.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, TypeVar, Optional
+from typing import Any, Optional, TypeVar
 
 import numpy as np
 from typing_extensions import Protocol

cirq/protocols/has_unitary_protocol_test.py

@@ -80,7 +80,8 @@ def test_via_apply_unitary():
 
     class No4:  # A non-operation non-gate.
         def _apply_unitary_(self, args):
-            assert False  # Because has_unitary doesn't understand how to call.
+            # Because has_unitary doesn't understand how to call.
+            assert False  # pragma: no cover
 
     class Yes1(EmptyOp):
         def _apply_unitary_(self, args):
@@ -155,13 +156,13 @@ def test_order():
             return True
 
         def _decompose_(self):
-            assert False
+            assert False  # pragma: no cover
 
         def _apply_unitary_(self, args):
-            assert False
+            assert False  # pragma: no cover
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     class Yes2(EmptyOp):
         def _has_unitary_(self):
@@ -171,10 +172,10 @@ def test_order():
             return []
 
         def _apply_unitary_(self, args):
-            assert False
+            assert False  # pragma: no cover
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     class Yes3(EmptyOp):
         def _has_unitary_(self):
@@ -187,7 +188,7 @@ def test_order():
             return args.target_tensor
 
         def _unitary_(self):
-            assert False
+            assert False  # pragma: no cover
 
     class Yes4(EmptyOp):
         def _has_unitary_(self):

cirq/protocols/hash_from_pickle_test.py

@@ -0,0 +1,120 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import multiprocessing
+import os
+import pathlib
+import pickle
+from collections.abc import Iterator
+from typing import Any, Hashable
+
+import pytest
+
+import cirq
+from cirq.protocols.json_serialization_test import MODULE_TEST_SPECS
+
+_EXCLUDE_JSON_FILES = (
+    # sympy - related objects
+    "cirq/protocols/json_test_data/sympy.Add.json",
+    "cirq/protocols/json_test_data/sympy.E.json",
+    "cirq/protocols/json_test_data/sympy.Equality.json",
+    "cirq/protocols/json_test_data/sympy.EulerGamma.json",
+    "cirq/protocols/json_test_data/sympy.Float.json",
+    "cirq/protocols/json_test_data/sympy.GreaterThan.json",
+    "cirq/protocols/json_test_data/sympy.Integer.json",
+    "cirq/protocols/json_test_data/sympy.LessThan.json",
+    "cirq/protocols/json_test_data/sympy.Mul.json",
+    "cirq/protocols/json_test_data/sympy.Pow.json",
+    "cirq/protocols/json_test_data/sympy.Rational.json",
+    "cirq/protocols/json_test_data/sympy.StrictGreaterThan.json",
+    "cirq/protocols/json_test_data/sympy.StrictLessThan.json",
+    "cirq/protocols/json_test_data/sympy.Symbol.json",
+    "cirq/protocols/json_test_data/sympy.Unequality.json",
+    "cirq/protocols/json_test_data/sympy.And.json",
+    "cirq/protocols/json_test_data/sympy.Not.json",
+    "cirq/protocols/json_test_data/sympy.Or.json",
+    "cirq/protocols/json_test_data/sympy.Xor.json",
+    "cirq/protocols/json_test_data/sympy.Indexed.json",
+    "cirq/protocols/json_test_data/sympy.IndexedBase.json",
+    "cirq/protocols/json_test_data/sympy.pi.json",
+    # Cirq-Rigetti is deprecated per #7058
+    # Instead of handling deprecation-in-test errors we exclude
+    # all cirq_rigetti classes here.
+    "cirq_rigetti/json_test_data/AspenQubit.json",
+    "cirq_rigetti/json_test_data/OctagonalQubit.json",
+    # RigettiQCSAspenDevice does not pickle
+    "cirq_rigetti/json_test_data/RigettiQCSAspenDevice.json",
+)
+
+
+def _is_included(json_filename: str) -> bool:
+    json_posix_path = pathlib.PurePath(json_filename).as_posix()
+    if any(json_posix_path.endswith(t) for t in _EXCLUDE_JSON_FILES):
+        return False
+    if not os.path.isfile(json_filename):
+        return False
+    return True
+
+
+@pytest.fixture(scope='module')
+def pool() -> Iterator[multiprocessing.pool.Pool]:
+    ctx = multiprocessing.get_context("spawn")
+    with ctx.Pool(1) as pool:
+        yield pool
+
+
+def _read_json(json_filename: str) -> Any:
+    obj = cirq.read_json(json_filename)
+    obj = obj[0] if isinstance(obj, list) else obj
+    # trigger possible caching of the hash value
+    if isinstance(obj, Hashable):
+        _ = hash(obj)
+    return obj
+
+
+def test_exclude_json_files_has_valid_entries() -> None:
+    """Verify _EXCLUDE_JSON_FILES has valid entries."""
+    # do not check rigetti files if not installed
+    skip_rigetti = all(m.name != "cirq_rigetti" for m in MODULE_TEST_SPECS)
+    json_file_validates = lambda f: any(
+        m.test_data_path.joinpath(os.path.basename(f)).is_file() for m in MODULE_TEST_SPECS
+    ) or (skip_rigetti and f.startswith("cirq_rigetti/"))
+    invalid_json_paths = [f for f in _EXCLUDE_JSON_FILES if not json_file_validates(f)]
+    assert invalid_json_paths == []
+
+
+@pytest.mark.parametrize(
+    'json_filename',
+    [
+        f"{abs_path}.json"
+        for m in MODULE_TEST_SPECS
+        for abs_path in m.all_test_data_keys()
+        if _is_included(f"{abs_path}.json")
+    ],
+)
+def test_hash_from_pickle(json_filename: str, pool: multiprocessing.pool.Pool):
+    obj_local = _read_json(json_filename)
+    if not isinstance(obj_local, Hashable):
+        return
+    # check if pickling works in the main process for the sake of debugging
+    obj_copy = pickle.loads(pickle.dumps(obj_local))
+    assert obj_copy == obj_local
+    assert hash(obj_copy) == hash(obj_local)
+    # Read and hash the object in a separate worker process and then
+    # send it back which requires pickling and unpickling.
+    obj_worker = pool.apply(_read_json, [json_filename])
+    assert obj_worker == obj_local
+    assert hash(obj_worker) == hash(obj_local)

cirq/protocols/inverse_protocol.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, List, overload, Tuple, TYPE_CHECKING, TypeVar, Union, Iterable
+from typing import Any, Iterable, List, overload, Tuple, TYPE_CHECKING, TypeVar, Union
 
 from cirq import ops
 

cirq/protocols/json_serialization.py

@@ -17,6 +17,7 @@ import gzip
 import json
 import numbers
 import pathlib
+from types import NotImplementedType
 from typing import (
     Any,
     Callable,
@@ -33,13 +34,13 @@ from typing import (
     Union,
 )
 
+import attrs
 import numpy as np
 import pandas as pd
 import sympy
 from typing_extensions import Protocol
 
 from cirq._doc import doc_private
-from cirq.type_workarounds import NotImplementedType
 
 ObjectFactory = Union[Type, Callable[..., Any]]
 
@@ -182,6 +183,12 @@ def dataclass_json_dict(obj: Any) -> Dict[str, Any]:
     return obj_to_dict_helper(obj, attribute_names)
 
 
+def attrs_json_dict(obj: Any) -> Dict[str, Any]:
+    """Return a dictionary suitable for `_json_dict_` from an attrs dataclass."""
+    attribute_names = [f.name for f in attrs.fields(type(obj))]
+    return obj_to_dict_helper(obj, attribute_names)
+
+
 def _json_dict_with_cirq_type(obj: Any):
     base_dict = obj._json_dict_()
     if 'cirq_type' in base_dict:
@@ -255,6 +262,12 @@ class CirqEncoder(json.JSONEncoder):
                 sympy.StrictLessThan,
                 sympy.Equality,
                 sympy.Unequality,
+                sympy.And,
+                sympy.Or,
+                sympy.Not,
+                sympy.Xor,
+                sympy.Indexed,
+                sympy.IndexedBase,
             ),
         ):
             return {'cirq_type': f'sympy.{o.__class__.__name__}', 'args': o.args}

cirq/protocols/json_serialization_test.py

@@ -24,6 +24,7 @@ import warnings
 from typing import Dict, List, Optional, Tuple, Type
 from unittest import mock
 
+import attrs
 import networkx as nx
 import numpy as np
 import pandas as pd
@@ -33,7 +34,7 @@ import sympy
 import cirq
 from cirq._compat import proper_eq
 from cirq.protocols import json_serialization
-from cirq.testing.json import ModuleJsonTestSpec, spec_for, assert_json_roundtrip_works
+from cirq.testing.json import assert_json_roundtrip_works, ModuleJsonTestSpec, spec_for
 
 REPO_ROOT = pathlib.Path(__file__).parent.parent.parent.parent
 
@@ -55,6 +56,13 @@ TESTED_MODULES: Dict[str, Optional[_ModuleDeprecation]] = {
     'non_existent_should_be_fine': None,
 }
 
+# TODO(#6706) remove after cirq_rigetti supports NumPy 2.0
+if np.__version__.startswith("2."):  # pragma: no cover
+    warnings.warn(
+        "json_serialization_test - ignoring cirq_rigetti due to incompatibility with NumPy 2.0"
+    )
+    del TESTED_MODULES["cirq_rigetti"]
+
 
 def _get_testspecs_for_modules() -> List[ModuleJsonTestSpec]:
     modules = []
@@ -76,20 +84,20 @@ def test_deprecated_cirq_type_in_json_dict():
         __module__ = 'test.noncirq.namespace'
 
         def __eq__(self, other):
-            return isinstance(other, HasOldJsonDict)
+            return isinstance(other, HasOldJsonDict)  # pragma: no cover
 
         def _json_dict_(self):
             return {'cirq_type': 'test.noncirq.namespace.HasOldJsonDict'}
 
         @classmethod
         def _from_json_dict_(cls, **kwargs):
-            return cls()
+            return cls()  # pragma: no cover
 
     with pytest.raises(ValueError, match='not a Cirq type'):
         _ = cirq.json_cirq_type(HasOldJsonDict)
 
     def custom_resolver(name):
-        if name == 'test.noncirq.namespace.HasOldJsonDict':
+        if name == 'test.noncirq.namespace.HasOldJsonDict':  # pragma: no cover
             return HasOldJsonDict
 
     test_resolvers = [custom_resolver] + cirq.DEFAULT_RESOLVERS
@@ -275,6 +283,7 @@ def test_builtins():
 def test_numpy():
     x = np.ones(1)[0]
 
+    assert_json_roundtrip_works(np.bool_(True))
     assert_json_roundtrip_works(x.astype(np.int8))
     assert_json_roundtrip_works(x.astype(np.int16))
     assert_json_roundtrip_works(x.astype(np.int32))
@@ -359,7 +368,7 @@ class SBKImpl(cirq.SerializableByKey):
 
     def __eq__(self, other):
         if not isinstance(other, SBKImpl):
-            return False
+            return False  # pragma: no cover
         return (
             self.name == other.name
             and self.data_list == other.data_list
@@ -534,7 +543,7 @@ def test_type_serialization(mod_spec: ModuleJsonTestSpec, cirq_obj_name: str, cl
         return pytest.xfail(reason="Not serializable (yet)")
 
     if cls is None:
-        pytest.skip(f'No serialization for None-mapped type: {cirq_obj_name}')
+        pytest.skip(f'No serialization for None-mapped type: {cirq_obj_name}')  # pragma: no cover
 
     try:
         typename = cirq.json_cirq_type(cls)
@@ -606,7 +615,7 @@ def _eval_repr_data_file(path: pathlib.Path, deprecation_deadline: Optional[str]
 
     for deprecation in TESTED_MODULES.values():
         if deprecation is not None and deprecation.old_name in content:
-            ctx_managers.append(deprecation.deprecation_assertion)
+            ctx_managers.append(deprecation.deprecation_assertion)  # pragma: no cover
 
     imports = {'cirq': cirq, 'pd': pd, 'sympy': sympy, 'np': np, 'datetime': datetime, 'nx': nx}
 
@@ -783,3 +792,15 @@ def test_datetime():
     assert re_pst_dt == pst_dt
     assert re_pst_dt == utc_dt
     assert re_pst_dt == re_naive_dt
+
+
+@attrs.frozen
+class _TestAttrsClas:
+    name: str
+    x: int
+
+
+def test_attrs_json_dict():
+    obj = _TestAttrsClas('test', x=123)
+    js = json_serialization.attrs_json_dict(obj)
+    assert js == {'name': 'test', 'x': 123}

cirq/protocols/json_test_data/BitMaskKeyCondition.json

@@ -0,0 +1,86 @@
+[
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "a",
+      "path": []
+    },
+    "index": 59,
+    "target_value": 0,
+    "equal_target": false,
+    "bitmask": null
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "b",
+      "path": []
+    },
+    "index": 58,
+    "target_value": 3,
+    "equal_target": false,
+    "bitmask": null
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "c",
+      "path": []
+    },
+    "index": 57,
+    "target_value": 0,
+    "equal_target": false,
+    "bitmask": 13
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "d",
+      "path": []
+    },
+    "index": 56,
+    "target_value": 12,
+    "equal_target": false,
+    "bitmask": 13
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "d",
+      "path": []
+    },
+    "index": 55,
+    "target_value": 12,
+    "equal_target": true,
+    "bitmask": 13
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "e",
+      "path": []
+    },
+    "index": 54,
+    "target_value": 11,
+    "equal_target": true,
+    "bitmask": 11
+  },
+  {
+    "cirq_type": "BitMaskKeyCondition",
+    "key": {
+      "cirq_type": "MeasurementKey",
+      "name": "e",
+      "path": []
+    },
+    "index": 53,
+    "target_value": 9,
+    "equal_target": false,
+    "bitmask": 9
+  }
+]

cirq/protocols/json_test_data/BitMaskKeyCondition.repr

@@ -0,0 +1,7 @@
+[cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='a'), index=59, target_value=0, equal_target=False, bitmask=None),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='b'), index=58, target_value=3, equal_target=False, bitmask=None),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='c'), index=57, target_value=0, equal_target=False, bitmask=13),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='d'), index=56, target_value=12, equal_target=False, bitmask=13),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='d'), index=55, target_value=12, equal_target=True, bitmask=13),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='e'), index=54, target_value=11, equal_target=True, bitmask=11),
+ cirq.BitMaskKeyCondition(key=cirq.MeasurementKey(name='e'), index=53, target_value=9, equal_target=False, bitmask=9)]

cirq/protocols/json_test_data/Concat.json

@@ -0,0 +1,19 @@
+{
+    "cirq_type": "Concat",
+    "sweeps": [
+      {
+        "cirq_type": "Linspace",
+        "key": "a",
+        "start": 0,
+        "stop": 1,
+        "length": 2
+      },
+      {
+        "cirq_type": "Linspace",
+        "key": "a",
+        "start": 0,
+        "stop": 2,
+        "length": 4
+      }
+    ]
+  }

cirq/protocols/json_test_data/Concat.repr

@@ -0,0 +1 @@
+cirq.Concat(cirq.Linspace('a', start=0, stop=1, length=2), cirq.Linspace('a', start=0, stop=2, length=4))

cirq/protocols/json_test_data/README.md

@@ -1,3 +1,5 @@
-This folder contains test data for cirq's JSON serialization functionality.
+# JSON test data for Cirq serialization tests
 
-For more information, see [`docs/dev/serialization.md`](/docs/dev/serialization.md).
+This folder contains test data for Cirq's JSON serialization functionality. For
+more information, please see
+[`docs/dev/serialization.md`](/docs/dev/serialization.md).

cirq/protocols/json_test_data/SympyCondition.json

@@ -1,17 +1,62 @@
-{
-  "cirq_type": "SympyCondition",
-  "expr":
+[
   {
-    "cirq_type": "sympy.GreaterThan",
-    "args": [
-      {
-        "cirq_type": "sympy.Symbol",
-        "name": "a"
-      },
-      {
-        "cirq_type": "sympy.Symbol",
-        "name": "b"
-      }
-    ]
+    "cirq_type": "SympyCondition",
+    "expr": {
+      "cirq_type": "sympy.GreaterThan",
+      "args": [
+        {
+          "cirq_type": "sympy.Symbol",
+          "name": "a"
+        },
+        {
+          "cirq_type": "sympy.Symbol",
+          "name": "b"
+        }
+      ]
+    }
+  },
+  {
+    "cirq_type": "SympyCondition",
+    "expr": {
+      "cirq_type": "sympy.Xor",
+      "args": [
+        {
+          "cirq_type": "sympy.Indexed",
+          "args": [
+            {
+              "cirq_type": "sympy.IndexedBase",
+              "args": [
+                {
+                  "cirq_type": "sympy.Symbol",
+                  "name": "a"
+                }
+              ]
+            },
+            {
+              "cirq_type": "sympy.Integer",
+              "i": 0
+            }
+          ]
+        },
+        {
+          "cirq_type": "sympy.Indexed",
+          "args": [
+            {
+              "cirq_type": "sympy.IndexedBase",
+              "args": [
+                {
+                  "cirq_type": "sympy.Symbol",
+                  "name": "a"
+                }
+              ]
+            },
+            {
+              "cirq_type": "sympy.Integer",
+              "i": 1
+            }
+          ]
+        }
+      ]
+    }
   }
-}
+]

cirq/protocols/json_test_data/SympyCondition.repr

@@ -1 +1,4 @@
-cirq.SympyCondition(sympy.GreaterThan(sympy.Symbol('a'), sympy.Symbol('b')))
+[
+cirq.SympyCondition(sympy.GreaterThan(sympy.Symbol('a'), sympy.Symbol('b'))),
+cirq.SympyCondition(sympy.Xor(sympy.Indexed(sympy.IndexedBase(sympy.Symbol('a')), sympy.Integer(0)), sympy.Indexed(sympy.IndexedBase(sympy.Symbol('a')), sympy.Integer(1))))
+]

cirq/protocols/json_test_data/_InverseCompositeGate.json

@@ -0,0 +1,10 @@
+{
+    "cirq_type": "_InverseCompositeGate",
+    "original": {
+        "cirq_type": "QubitPermutationGate",
+        "permutation": [
+        0,
+        1,
+        2
+    ]}
+}

cirq/protocols/json_test_data/_InverseCompositeGate.repr

@@ -0,0 +1 @@
+(cirq.QubitPermutationGate(permutation=(0, 1, 2))**-1)

cirq/protocols/json_test_data/__init__.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cirq.protocols.json_test_data.spec import TestSpec
+from cirq.protocols.json_test_data.spec import TestSpec as TestSpec

cirq/protocols/json_test_data/sympy.And.json

@@ -0,0 +1,13 @@
+{
+  "cirq_type": "sympy.And",
+  "args": [
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "s"
+    },
+    {
+      "cirq_type": "sympy.Symbol",
+      "name": "t"
+    }
+  ]
+}

cirq/protocols/json_test_data/sympy.And.repr

@@ -0,0 +1 @@
+sympy.And(sympy.Symbol('s'), sympy.Symbol('t'))

cirq/protocols/json_test_data/sympy.Indexed.json

@@ -0,0 +1,18 @@
+{
+  "cirq_type": "sympy.Indexed",
+  "args": [
+    {
+      "cirq_type": "sympy.IndexedBase",
+      "args": [
+        {
+          "cirq_type": "sympy.Symbol",
+          "name": "s"
+        }
+      ]
+    },
+    {
+      "cirq_type": "sympy.Integer",
+      "i": 1
+    }
+  ]
+}