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

cirq/sim/state_vector_test.py

@@ -14,16 +14,24 @@
 """Tests for state_vector.py"""
 
 import itertools
-from typing import Optional
-import pytest
+from typing import Iterator, Optional
+from unittest import mock
 
 import numpy as np
+import pytest
 
 import cirq
 import cirq.testing
 from cirq import linalg
 
 
+@pytest.fixture
+def use_np_transpose(request) -> Iterator[bool]:
+    value: bool = request.param
+    with mock.patch.object(linalg, 'can_numpy_support_shape', lambda shape: value):
+        yield value
+
+
 def test_state_mixin():
     class TestClass(cirq.StateVectorMixin):
         def state_vector(self, copy: Optional[bool] = None) -> np.ndarray:
@@ -173,9 +181,10 @@ def test_sample_no_indices_repetitions():
     )
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_computational_basis(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
+    # verify patching of can_numpy_support_shape in the use_np_transpose fixture
+    assert linalg.can_numpy_support_shape([1]) is use_np_transpose
     results = []
     for x in range(8):
         initial_state = cirq.to_valid_state_vector(x, 3)
@@ -186,9 +195,8 @@ def test_measure_state_computational_basis(use_np_transpose: bool):
     assert results == expected
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_reshape(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     results = []
     for x in range(8):
         initial_state = np.reshape(cirq.to_valid_state_vector(x, 3), [2] * 3)
@@ -199,9 +207,8 @@ def test_measure_state_reshape(use_np_transpose: bool):
     assert results == expected
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_partial_indices(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     for index in range(3):
         for x in range(8):
             initial_state = cirq.to_valid_state_vector(x, 3)
@@ -210,9 +217,8 @@ def test_measure_state_partial_indices(use_np_transpose: bool):
             assert bits == [bool(1 & (x >> (2 - index)))]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_partial_indices_order(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     for x in range(8):
         initial_state = cirq.to_valid_state_vector(x, 3)
         bits, state = cirq.measure_state_vector(initial_state, [2, 1])
@@ -220,9 +226,8 @@ def test_measure_state_partial_indices_order(use_np_transpose: bool):
         assert bits == [bool(1 & (x >> 0)), bool(1 & (x >> 1))]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_partial_indices_all_orders(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     for perm in itertools.permutations([0, 1, 2]):
         for x in range(8):
             initial_state = cirq.to_valid_state_vector(x, 3)
@@ -231,9 +236,8 @@ def test_measure_state_partial_indices_all_orders(use_np_transpose: bool):
             assert bits == [bool(1 & (x >> (2 - p))) for p in perm]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_collapse(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -256,9 +260,8 @@ def test_measure_state_collapse(use_np_transpose: bool):
         assert bits == [False]
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_seed(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     n = 10
     initial_state = np.ones(2**n) / 2 ** (n / 2)
 
@@ -277,9 +280,8 @@ def test_measure_state_seed(use_np_transpose: bool):
     np.testing.assert_allclose(state1, state2)
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_out_is_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -290,9 +292,8 @@ def test_measure_state_out_is_state(use_np_transpose: bool):
     assert state is initial_state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_out_is_not_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.zeros(8, dtype=np.complex64)
     initial_state[0] = 1 / np.sqrt(2)
     initial_state[2] = 1 / np.sqrt(2)
@@ -302,18 +303,16 @@ def test_measure_state_out_is_not_state(use_np_transpose: bool):
     assert out is state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_not_power_of_two(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     with pytest.raises(ValueError, match='3'):
         _, _ = cirq.measure_state_vector(np.array([1, 0, 0]), [1])
     with pytest.raises(ValueError, match='5'):
         cirq.measure_state_vector(np.array([0, 1, 0, 0, 0]), [1])
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_index_out_of_range(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     state = cirq.to_valid_state_vector(0, 3)
     with pytest.raises(IndexError, match='-2'):
         cirq.measure_state_vector(state, [-2])
@@ -321,18 +320,16 @@ def test_measure_state_index_out_of_range(use_np_transpose: bool):
         cirq.measure_state_vector(state, [3])
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_no_indices(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = cirq.to_valid_state_vector(0, 3)
     bits, state = cirq.measure_state_vector(initial_state, [])
     assert [] == bits
     np.testing.assert_almost_equal(state, initial_state)
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_no_indices_out_is_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = cirq.to_valid_state_vector(0, 3)
     bits, state = cirq.measure_state_vector(initial_state, [], out=initial_state)
     assert [] == bits
@@ -340,9 +337,8 @@ def test_measure_state_no_indices_out_is_state(use_np_transpose: bool):
     assert state is initial_state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_no_indices_out_is_not_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = cirq.to_valid_state_vector(0, 3)
     out = np.zeros_like(initial_state)
     bits, state = cirq.measure_state_vector(initial_state, [], out=out)
@@ -352,9 +348,8 @@ def test_measure_state_no_indices_out_is_not_state(use_np_transpose: bool):
     assert out is not initial_state
 
 
-@pytest.mark.parametrize('use_np_transpose', [False, True])
+@pytest.mark.parametrize('use_np_transpose', [False, True], indirect=True)
 def test_measure_state_empty_state(use_np_transpose: bool):
-    linalg.can_numpy_support_shape = lambda s: use_np_transpose
     initial_state = np.array([1.0])
     bits, state = cirq.measure_state_vector(initial_state, [])
     assert [] == bits

cirq/study/__init__.py

@@ -15,33 +15,39 @@
 """Parameterized circuits and results."""
 
 from cirq.study.flatten_expressions import (
-    ExpressionMap,
-    flatten,
-    flatten_with_params,
-    flatten_with_sweep,
+    ExpressionMap as ExpressionMap,
+    flatten as flatten,
+    flatten_with_params as flatten_with_params,
+    flatten_with_sweep as flatten_with_sweep,
 )
 
 from cirq.study.resolver import (
-    ParamDictType,
-    ParamMappingType,
-    ParamResolver,
-    ParamResolverOrSimilarType,
+    ParamDictType as ParamDictType,
+    ParamMappingType as ParamMappingType,
+    ParamResolver as ParamResolver,
+    ParamResolverOrSimilarType as ParamResolverOrSimilarType,
 )
 
-from cirq.study.sweepable import Sweepable, to_resolvers, to_sweep, to_sweeps
+from cirq.study.sweepable import (
+    Sweepable as Sweepable,
+    to_resolvers as to_resolvers,
+    to_sweep as to_sweep,
+    to_sweeps as to_sweeps,
+)
 
 from cirq.study.sweeps import (
-    Linspace,
-    ListSweep,
-    Points,
-    Product,
-    Sweep,
-    UNIT_SWEEP,
-    UnitSweep,
-    Zip,
-    ZipLongest,
-    dict_to_product_sweep,
-    dict_to_zip_sweep,
+    Concat as Concat,
+    Linspace as Linspace,
+    ListSweep as ListSweep,
+    Points as Points,
+    Product as Product,
+    Sweep as Sweep,
+    UNIT_SWEEP as UNIT_SWEEP,
+    UnitSweep as UnitSweep,
+    Zip as Zip,
+    ZipLongest as ZipLongest,
+    dict_to_product_sweep as dict_to_product_sweep,
+    dict_to_zip_sweep as dict_to_zip_sweep,
 )
 
-from cirq.study.result import ResultDict, Result
+from cirq.study.result import ResultDict as ResultDict, Result as Result

cirq/study/flatten_expressions.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 """Resolves symbolic expressions to unique symbols."""
 
-from typing import Any, Callable, List, Optional, Tuple, Union, TYPE_CHECKING
 import numbers
+from typing import Any, Callable, List, Optional, Tuple, TYPE_CHECKING, Union
 
 import sympy
 
 from cirq import protocols
-from cirq.study import resolver, sweeps, sweepable
+from cirq.study import resolver, sweepable, sweeps
 
 if TYPE_CHECKING:
     import cirq
@@ -225,8 +225,7 @@ class _ParamFlattener(resolver.ParamResolver):
             params = param_dict if param_dict else {}
         # TODO: Support complex values for typing below.
         symbol_params: resolver.ParamDictType = {
-            _ensure_not_str(param): _ensure_not_str(val)  # type: ignore[misc]
-            for param, val in params.items()
+            _ensure_not_str(param): _ensure_not_str(val) for param, val in params.items()
         }
         super().__init__(symbol_params)
         if get_param_name is None:
@@ -270,7 +269,7 @@ class _ParamFlattener(resolver.ParamResolver):
             The unique symbol or value of the parameter as resolved by this
             resolver.
         """
-        if isinstance(value, (int, float, complex, numbers.Complex)):
+        if isinstance(value, numbers.Complex):
             return value
         if isinstance(value, str):
             value = sympy.Symbol(value)
@@ -381,7 +380,7 @@ class ExpressionMap(dict):
 
 
 def _ensure_not_str(
-    param: Union[sympy.Expr, 'cirq.TParamValComplex', str]
+    param: Union[sympy.Expr, 'cirq.TParamValComplex', str],
 ) -> Union[sympy.Expr, 'cirq.TParamValComplex']:
     if isinstance(param, str):
         return sympy.Symbol(param)

cirq/study/flatten_expressions_test.py

@@ -13,10 +13,10 @@
 # limitations under the License.
 
 import sympy
+
 import cirq
 from cirq.study import flatten_expressions
 
-
 # None of the following tests use expressions of the form
 # <constant term> - <other term> because the string of expressions containing
 # exactly two terms, one constant term and one non-constant term with a negative

cirq/study/resolver.py

@@ -19,6 +19,7 @@ from typing import Any, cast, Dict, Iterator, Mapping, Optional, TYPE_CHECKING,
 import numpy as np
 import sympy
 from sympy.core import numbers as sympy_numbers
+
 from cirq._compat import proper_repr
 from cirq._doc import document
 
@@ -43,10 +44,6 @@ _NOT_FOUND = object()
 _RECURSION_FLAG = object()
 
 
-def _is_param_resolver_or_similar_type(obj: Any):
-    return obj is None or isinstance(obj, (ParamResolver, dict))
-
-
 class ParamResolver:
     """Resolves parameters to actual values.
 
@@ -139,10 +136,10 @@ class ParamResolver:
             if isinstance(param_value, str):
                 param_value = sympy.Symbol(param_value)
             elif not isinstance(param_value, sympy.Basic):
-                return value  # type: ignore[return-value]
+                return value
             if recursive:
                 param_value = self._value_of_recursive(value)
-            return param_value  # type: ignore[return-value]
+            return param_value
 
         if not isinstance(value, sympy.Basic):
             # No known way to resolve this variable, return unchanged.
@@ -207,7 +204,7 @@ class ParamResolver:
 
         # There isn't a full evaluation for 'value' yet. Until it's ready,
         # map value to None to identify loops in component evaluation.
-        self._deep_eval_map[value] = _RECURSION_FLAG  # type: ignore
+        self._deep_eval_map[value] = _RECURSION_FLAG
 
         v = self.value_of(value, recursive=False)
         if v == value:
@@ -220,10 +217,8 @@ class ParamResolver:
         new_dict: Dict['cirq.TParamKey', Union[float, str, sympy.Symbol, sympy.Expr]] = {
             k: k for k in resolver
         }
-        new_dict.update({k: self.value_of(k, recursive) for k in self})  # type: ignore[misc]
-        new_dict.update(
-            {k: resolver.value_of(v, recursive) for k, v in new_dict.items()}  # type: ignore[misc]
-        )
+        new_dict.update({k: self.value_of(k, recursive) for k in self})
+        new_dict.update({k: resolver.value_of(v, recursive) for k, v in new_dict.items()})
         if recursive and self._param_dict:
             new_resolver = ParamResolver(cast(ParamDictType, new_dict))
             # Resolve down to single-step mappings.
@@ -246,6 +241,14 @@ class ParamResolver:
             self._param_hash = hash(frozenset(self._param_dict.items()))
         return self._param_hash
 
+    def __getstate__(self) -> Dict[str, Any]:
+        # clear cached hash value when pickling, see #6674
+        state = self.__dict__
+        if state["_param_hash"] is not None:
+            state = state.copy()
+            state["_param_hash"] = None
+        return state
+
     def __eq__(self, other):
         if not isinstance(other, ParamResolver):
             return NotImplemented

cirq/study/resolver_test.py

@@ -84,7 +84,7 @@ def _assert_consistent_resolution(v, resolved):
 
         # note: super().subs() doesn't resolve based on the param_dict properly
         # for some reason, that's why a delegate (self.symbol) is used instead
-        def subs(self, *args, **kwargs):
+        def subs(self, *args, **kwargs):  # pragma: no cover
             self.called = True
             return self.symbol.subs(*args, **kwargs)
 
@@ -93,6 +93,7 @@ def _assert_consistent_resolution(v, resolved):
     # symbol based resolution
     s = SubsAwareSymbol('a')
     assert r.value_of(s) == resolved, f"expected {resolved}, got {r.value_of(s)}"
+    assert r[s] == resolved, f"expected {resolved}, got {r.value_of(s)}"
     assert not s.called, f"For pass-through type {type(v)} sympy.subs shouldn't have been called."
     assert isinstance(
         r.value_of(s), type(resolved)
@@ -183,6 +184,14 @@ def test_recursive_evaluation():
     assert sympy.Eq(r.value_of(e), 0)
 
 
+def test_resolution_of_unknown_formulas():
+    a = sympy.Symbol('a')
+    b = sympy.Symbol('b')
+
+    r = cirq.ParamResolver({a: b - 2})
+    assert r.value_of(sympy.sin(a), recursive=False) == sympy.sin(b - 2)
+
+
 def test_unbound_recursion_halted():
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')

cirq/study/result.py

@@ -19,22 +19,22 @@ import io
 from typing import (
     Any,
     Callable,
+    cast,
     Dict,
     Iterable,
     Mapping,
     Optional,
     Sequence,
-    TYPE_CHECKING,
     Tuple,
+    TYPE_CHECKING,
     TypeVar,
     Union,
-    cast,
 )
 
 import numpy as np
 import pandas as pd
 
-from cirq import value, ops
+from cirq import ops, value
 from cirq._compat import proper_repr
 from cirq.study import resolver
 

cirq/study/sweepable.py

@@ -14,13 +14,14 @@
 
 """Defines which types are Sweepable."""
 
-from typing import Iterable, Iterator, List, Sequence, Union, cast
 import warnings
+from typing import cast, Iterable, Iterator, List, Optional, Sequence, Union
+
 from typing_extensions import Protocol
 
 from cirq._doc import document
 from cirq.study.resolver import ParamResolver, ParamResolverOrSimilarType
-from cirq.study.sweeps import ListSweep, Points, Sweep, UnitSweep, Zip, dict_to_product_sweep
+from cirq.study.sweeps import dict_to_product_sweep, ListSweep, Points, Sweep, UnitSweep, Zip
 
 SweepLike = Union[ParamResolverOrSimilarType, Sweep]
 document(SweepLike, """An object similar to an iterable of parameter resolvers.""")
@@ -44,12 +45,12 @@ def to_resolvers(sweepable: Sweepable) -> Iterator[ParamResolver]:
         yield from sweep
 
 
-def to_sweeps(sweepable: Sweepable) -> List[Sweep]:
+def to_sweeps(sweepable: Sweepable, metadata: Optional[dict] = None) -> List[Sweep]:
     """Converts a Sweepable to a list of Sweeps."""
     if sweepable is None:
         return [UnitSweep]
     if isinstance(sweepable, ParamResolver):
-        return [_resolver_to_sweep(sweepable)]
+        return [_resolver_to_sweep(sweepable, metadata)]
     if isinstance(sweepable, Sweep):
         return [sweepable]
     if isinstance(sweepable, dict):
@@ -63,16 +64,16 @@ def to_sweeps(sweepable: Sweepable) -> List[Sweep]:
                 stacklevel=2,
             )
         product_sweep = dict_to_product_sweep(sweepable)
-        return [_resolver_to_sweep(resolver) for resolver in product_sweep]
+        return [_resolver_to_sweep(resolver, metadata) for resolver in product_sweep]
     if isinstance(sweepable, Iterable) and not isinstance(sweepable, str):
-        return [sweep for item in sweepable for sweep in to_sweeps(item)]  # type: ignore[arg-type]
+        return [sweep for item in sweepable for sweep in to_sweeps(item, metadata)]
     raise TypeError(f'Unrecognized sweepable type: {type(sweepable)}.\nsweepable: {sweepable}')
 
 
 def to_sweep(
     sweep_or_resolver_list: Union[
         'Sweep', ParamResolverOrSimilarType, Iterable[ParamResolverOrSimilarType]
-    ]
+    ],
 ) -> 'Sweep':
     """Converts the argument into a ``cirq.Sweep``.
 
@@ -98,8 +99,13 @@ def to_sweep(
     raise TypeError(f'Unexpected sweep-like value: {sweep_or_resolver_list}')
 
 
-def _resolver_to_sweep(resolver: ParamResolver) -> Sweep:
+def _resolver_to_sweep(resolver: ParamResolver, metadata: Optional[dict]) -> Sweep:
     params = resolver.param_dict
     if not params:
         return UnitSweep
-    return Zip(*[Points(key, [cast(float, value)]) for key, value in params.items()])
+    return Zip(
+        *[
+            Points(key, [cast(float, value)], metadata=metadata.get(key) if metadata else None)
+            for key, value in params.items()
+        ]
+    )

cirq/study/sweepable_test.py

@@ -147,3 +147,30 @@ def test_to_sweep_resolver_list(r_list_gen):
 def test_to_sweep_type_error():
     with pytest.raises(TypeError, match='Unexpected sweep'):
         cirq.to_sweep(5)
+
+
+def test_to_sweeps_with_param_dict_appends_metadata():
+    params = {'a': 1, 'b': 2, 'c': 3}
+    unit_map = {'a': 'ns', 'b': 'ns'}
+
+    sweep = cirq.to_sweeps(params, unit_map)
+
+    assert sweep == [
+        cirq.Zip(
+            cirq.Points('a', [1], metadata='ns'),
+            cirq.Points('b', [2], metadata='ns'),
+            cirq.Points('c', [3]),
+        )
+    ]
+
+
+def test_to_sweeps_with_param_list_appends_metadata():
+    resolvers = [cirq.ParamResolver({'a': 2}), cirq.ParamResolver({'a': 1})]
+    unit_map = {'a': 'ns'}
+
+    sweeps = cirq.study.to_sweeps(resolvers, unit_map)
+
+    assert sweeps == [
+        cirq.Zip(cirq.Points('a', [2], metadata='ns')),
+        cirq.Zip(cirq.Points('a', [1], metadata='ns')),
+    ]

cirq/study/sweeps.py

@@ -11,6 +11,9 @@
 # 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.
+import abc
+import collections
+import itertools
 from typing import (
     Any,
     cast,
@@ -21,14 +24,11 @@ from typing import (
     Optional,
     overload,
     Sequence,
-    TYPE_CHECKING,
     Tuple,
+    TYPE_CHECKING,
     Union,
 )
 
-import abc
-import collections
-import itertools
 import sympy
 
 from cirq import protocols
@@ -216,7 +216,8 @@ class Product(Sweep):
     If one sweep assigns 'a' to the values 0, 1, 2, and the second sweep
     assigns 'b' to the values 2, 3, then the product is a sweep that
     assigns the tuple ('a','b') to all possible combinations of these
-    assignments: (0, 2), (1, 2), (2, 2), (0, 3), (1, 3), (2, 3).
+    assignments: (0, 2), (0, 3), (1, 2), (1, 3), (2, 2), (2, 3).
+    That is, the leftmost sweep is the outer loop in a product of sweeps.
     """
 
     def __init__(self, *factors: Sweep) -> None:
@@ -276,6 +277,63 @@ class Product(Sweep):
         return Product(*factors)
 
 
+class Concat(Sweep):
+    """Concatenates multiple to a new sweep.
+
+    All sweeps must share the same descriptors.
+
+    If one sweep assigns 'a' to the values 0, 1, 2, and another sweep assigns
+    'a' to the values 3, 4, 5, the concatenation produces a sweep assigning
+    'a' to the values 0, 1, 2, 3, 4, 5 in sequence.
+    """
+
+    def __init__(self, *sweeps: Sweep) -> None:
+        if not sweeps:
+            raise ValueError("Concat requires at least one sweep.")
+
+        # Validate consistency across sweeps
+        first_sweep = sweeps[0]
+        for sweep in sweeps[1:]:
+            if sweep.keys != first_sweep.keys:
+                raise ValueError("All sweeps must have the same descriptors.")
+
+        self.sweeps = sweeps
+
+    def __eq__(self, other):
+        if not isinstance(other, Concat):
+            return NotImplemented
+        return self.sweeps == other.sweeps
+
+    def __hash__(self):
+        return hash(tuple(self.sweeps))
+
+    @property
+    def keys(self) -> List['cirq.TParamKey']:
+        return self.sweeps[0].keys
+
+    def __len__(self) -> int:
+        return sum(len(sweep) for sweep in self.sweeps)
+
+    def param_tuples(self) -> Iterator[Params]:
+        for sweep in self.sweeps:
+            yield from sweep.param_tuples()
+
+    def __repr__(self) -> str:
+        sweeps_repr = ', '.join(repr(sweep) for sweep in self.sweeps)
+        return f'cirq.Concat({sweeps_repr})'
+
+    def __str__(self) -> str:
+        sweeps_repr = ', '.join(repr(s) for s in self.sweeps)
+        return f'Concat({sweeps_repr})'
+
+    def _json_dict_(self) -> Dict[str, Any]:
+        return protocols.obj_to_dict_helper(self, ['sweeps'])
+
+    @classmethod
+    def _from_json_dict_(cls, sweeps, **kwargs):
+        return Concat(*sweeps)
+
+
 class Zip(Sweep):
     """Zip product (direct sum) of one or more sweeps.
 
@@ -346,7 +404,7 @@ class ZipLongest(Zip):
     which uses a fixed fill value.
 
     Raises:
-        ValueError if an input sweep if completely empty.
+        ValueError if an input sweep is completely empty.
     """
 
     def __init__(self, *sweeps: Sweep) -> None:
@@ -589,10 +647,7 @@ def dict_to_product_sweep(factor_dict: ProductOrZipSweepLike) -> Product:
         Cartesian product of the sweeps.
     """
     return Product(
-        *(
-            Points(k, v if isinstance(v, Sequence) else [v])  # type: ignore
-            for k, v in factor_dict.items()
-        )
+        *(Points(k, v if isinstance(v, Sequence) else [v]) for k, v in factor_dict.items())
     )