cirq-core 1.1.0.dev20221219200817__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/protocols/json_test_data/Points.repr

@@ -1 +1,4 @@
-cirq.Points('a', [0, 0.4])
+[
+    cirq.Points('a', [0, 0.4]),
+    cirq.Points('amp', [0, 1], metadata='used to turn amp on or off'),
+]

cirq/protocols/json_test_data/Result.repr_inward

@@ -1 +1 @@
-[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[True, True, False, True, False], [False, True, True, False, False], [True, False, True, False, True]], dtype=bool)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8), 'n': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)})]
+[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[True, True, False, True, False], [False, True, True, False, False], [True, False, True, False, True]], dtype=np.dtype('bool'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8), 'n': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)})]

cirq/protocols/json_test_data/ResultDict.repr

@@ -1 +1 @@
-[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[True, True, False, True, False]], [[False, True, True, False, False]], [[True, False, True, False, True]]], dtype=bool)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[1, 1, 0, 1, 0]], [[0, 1, 1, 0, 0]], [[1, 0, 1, 0, 1]]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[1, 1, 0, 1, 0]], [[0, 1, 1, 0, 0]], [[1, 0, 1, 0, 1]]], dtype=np.uint8), 'n': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int64)})]
+[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[True, True, False, True, False]], [[False, True, True, False, False]], [[True, False, True, False, True]]], dtype=np.dtype('bool'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[1, 1, 0, 1, 0]], [[0, 1, 1, 0, 0]], [[1, 0, 1, 0, 1]]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.uint64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), records={'m': np.array([[[1, 1, 0, 1, 0]], [[0, 1, 1, 0, 0]], [[1, 0, 1, 0, 1]]], dtype=np.uint8), 'n': np.array([[[0, 1, 2]], [[3, 4, 5]], [[6, 7, 8]]], dtype=np.int64)})]

cirq/protocols/json_test_data/ResultDict.repr_inward

@@ -1 +1 @@
-[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[True, True, False, True, False], [False, True, True, False, False], [True, False, True, False, True]], dtype=bool)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8), 'n': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)})]
+[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[True, True, False, True, False], [False, True, True, False, False], [True, False, True, False, True]], dtype=np.dtype('bool'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8), 'n': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)})]

cirq/protocols/json_test_data/TrialResult.repr_inward

@@ -1 +1 @@
-[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[True, True, False, True, False], [False, True, True, False, False], [True, False, True, False, True]], dtype=np.bool)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint8)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint16)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint32)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.uint64)}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.uint8), 'n': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int64)})]
+[cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[True, True, False, True, False], [False, True, True, False, False], [True, False, True, False, True]], dtype=np.dtype('bool'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.dtype('uint8'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('int8'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('int16'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('int32'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('int64'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('uint8'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('uint16'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('uint32'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('uint64'))}), cirq.ResultDict(params=cirq.ParamResolver({sympy.Symbol('a'): 0.5}), measurements={'m': np.array([[1, 1, 0, 1, 0], [0, 1, 1, 0, 0], [1, 0, 1, 0, 1]], dtype=np.dtype('uint8')), 'n': np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.dtype('int64'))})]

cirq/protocols/json_test_data/XPowGate.json

@@ -1,5 +1,13 @@
-{
-  "cirq_type": "XPowGate",
-  "exponent": 0.123,
-  "global_shift": 0.0
-}
+[
+  {
+    "cirq_type": "XPowGate",
+    "exponent": 0.123,
+    "global_shift": 0.0
+  },
+  {
+    "cirq_type": "XPowGate",
+    "exponent": 0.123,
+    "global_shift": 0.0,
+    "dimension": 3
+  }
+]

cirq/protocols/json_test_data/XPowGate.repr

@@ -1 +1 @@
-(cirq.X**0.123)
+[(cirq.X**0.123), cirq.XPowGate(exponent=0.123, dimension=3)]

cirq/protocols/json_test_data/ZPowGate.json

@@ -1,5 +1,13 @@
-{
-  "cirq_type": "ZPowGate",
-  "exponent": 0.789,
-  "global_shift": 0.0
-}
+[
+  {
+    "cirq_type": "ZPowGate",
+    "exponent": 0.789,
+    "global_shift": 0.0
+  },
+  {
+    "cirq_type": "ZPowGate",
+    "exponent": 0.789,
+    "global_shift": 0.0,
+    "dimension": 3
+  }
+]

cirq/protocols/json_test_data/ZPowGate.repr

@@ -1 +1 @@
-(cirq.Z**0.789)
+[(cirq.Z**0.789), cirq.ZPowGate(exponent=0.789, dimension=3)]

cirq/protocols/json_test_data/ZipLongest.json

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

cirq/protocols/json_test_data/ZipLongest.repr

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

cirq/protocols/json_test_data/spec.py

@@ -81,6 +81,7 @@ TestSpec = ModuleJsonTestSpec(
         'MEASUREMENT_KEY_SEPARATOR',
         'PointOptimizer',
         # Transformers
+        'DecompositionContext',
         'TransformerLogger',
         'TransformerContext',
         # Routing utilities

cirq/protocols/kraus_protocol.py

@@ -164,13 +164,12 @@ def kraus(
 
     if kraus_getter is None and unitary_getter is None and mixture_getter is None:
         raise TypeError(
-            "object of type '{}' has no _kraus_ or _mixture_ or "
-            "_unitary_ method.".format(type(val))
+            f"object of type '{type(val)}' has no _kraus_ or _mixture_ or _unitary_ method."
         )
 
     raise TypeError(
-        "object of type '{}' does have a _kraus_, _mixture_ or "
-        "_unitary_ method, but it returned NotImplemented.".format(type(val))
+        f"object of type '{type(val)}' does have a _kraus_, _mixture_ or "
+        "_unitary_ method, but it returned NotImplemented."
     )
 
 

cirq/protocols/measurement_key_protocol.py

@@ -316,7 +316,9 @@ def with_key_path_prefix(val: Any, prefix: Tuple[str, ...]):
 
 
 def with_rescoped_keys(
-    val: Any, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey'] = None
+    val: Any,
+    path: Tuple[str, ...],
+    bindable_keys: Optional[FrozenSet['cirq.MeasurementKey']] = None,
 ):
     """Rescopes any measurement and control keys to the provided path, given the existing keys.
 

cirq/protocols/mixture_protocol.py

@@ -11,6 +11,7 @@
 # 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.
+
 """Protocol for objects that are mixtures (probabilistic combinations)."""
 from typing import Any, Sequence, Tuple, Union
 
@@ -103,8 +104,8 @@ def mixture(
         raise TypeError(f"object of type '{type(val)}' has no _mixture_ or _unitary_ method.")
 
     raise TypeError(
-        "object of type '{}' does have a _mixture_ or _unitary_ "
-        "method, but it returned NotImplemented.".format(type(val))
+        f"object of type '{type(val)}' does have a _mixture_ or _unitary_ "
+        "method, but it returned NotImplemented."
     )
 
 

cirq/protocols/phase_protocol.py

@@ -30,7 +30,7 @@ class SupportsPhase(Protocol):
     """An effect that can be phased around the Z axis of target qubits."""
 
     @doc_private
-    def _phase_by_(self: Any, phase_turns: float, qubit_index: int):
+    def _phase_by_(self, phase_turns: float, qubit_index: int):
         """Returns a phased version of the effect.
 
         Specifically, returns an object with matrix P U P^-1 (up to global
@@ -88,6 +88,6 @@ def phase_by(
     if getter is None:
         raise TypeError(f"object of type '{type(val)}' has no _phase_by_ method.")
     raise TypeError(
-        "object of type '{}' does have a _phase_by_ method, "
-        "but it returned NotImplemented.".format(type(val))
+        f"object of type '{type(val)}' does have a _phase_by_ method, "
+        "but it returned NotImplemented."
     )

cirq/protocols/pow_protocol.py

@@ -94,8 +94,7 @@ def pow(val: Any, exponent: Any, default: Any = RaiseTypeErrorIfNotProvided) ->
     if raiser is None:
         raise TypeError(f"object of type '{type(val)}' has no __pow__ method.")
     raise TypeError(
-        "object of type '{}' does have a __pow__ method, "
-        "but it returned NotImplemented.".format(type(val))
+        f"object of type '{type(val)}' does have a __pow__ method, but it returned NotImplemented."
     )
 
 

cirq/protocols/qasm.py

@@ -36,8 +36,8 @@ class QasmArgs(string.Formatter):
         self,
         precision: int = 10,
         version: str = '2.0',
-        qubit_id_map: Dict['cirq.Qid', str] = None,
-        meas_key_id_map: Dict[str, str] = None,
+        qubit_id_map: Optional[Dict['cirq.Qid', str]] = None,
+        meas_key_id_map: Optional[Dict[str, str]] = None,
     ) -> None:
         """Inits QasmArgs.
 
@@ -172,8 +172,8 @@ def qasm(
     if method is None:
         raise TypeError(f"object of type '{type(val)}' has no _qasm_ method.")
     raise TypeError(
-        "object of type '{}' does have a _qasm_ method, "
-        "but it returned NotImplemented or None.".format(type(val))
+        f"object of type '{type(val)}' does have a _qasm_ method, "
+        "but it returned NotImplemented or None."
     )
 
 

cirq/protocols/qid_shape_protocol.py

@@ -123,13 +123,13 @@ def qid_shape(
 
     if getter is not None:
         raise TypeError(
-            "object of type '{}' does have a _qid_shape_ method, "
-            "but it returned NotImplemented.".format(type(val))
+            f"object of type '{type(val)}' does have a _qid_shape_ method, "
+            "but it returned NotImplemented."
         )
     if num_getter is not None:
         raise TypeError(
-            "object of type '{}' does have a _num_qubits_ method, "
-            "but it returned NotImplemented.".format(type(val))
+            f"object of type '{type(val)}' does have a _num_qubits_ method, "
+            "but it returned NotImplemented."
         )
     raise TypeError(f"object of type '{type(val)}' has no _num_qubits_ or _qid_shape_ methods.")
 
@@ -178,12 +178,12 @@ def num_qubits(
 
     if num_getter is not None:
         raise TypeError(
-            "object of type '{}' does have a _num_qubits_ method, "
-            "but it returned NotImplemented.".format(type(val))
+            f"object of type '{type(val)}' does have a _num_qubits_ method, "
+            "but it returned NotImplemented."
         )
     if getter is not None:
         raise TypeError(
-            "object of type '{}' does have a _qid_shape_ method, "
-            "but it returned NotImplemented.".format(type(val))
+            f"object of type '{type(val)}' does have a _qid_shape_ method, "
+            "but it returned NotImplemented."
         )
     raise TypeError(f"object of type '{type(val)}' has no _num_qubits_ or _qid_shape_ methods.")

cirq/protocols/resolve_parameters.py

@@ -14,6 +14,7 @@
 
 import numbers
 from typing import AbstractSet, Any, cast, TYPE_CHECKING, TypeVar
+from typing_extensions import Self
 
 import sympy
 from typing_extensions import Protocol
@@ -33,13 +34,13 @@ class SupportsParameterization(Protocol):
     via a ParamResolver"""
 
     @doc_private
-    def _is_parameterized_(self: Any) -> bool:
+    def _is_parameterized_(self) -> bool:
         """Whether the object is parameterized by any Symbols that require
         resolution. Returns True if the object has any unresolved Symbols
         and False otherwise."""
 
     @doc_private
-    def _parameter_names_(self: Any) -> AbstractSet[str]:
+    def _parameter_names_(self) -> AbstractSet[str]:
         """Returns a collection of string names of parameters that require
         resolution. If _is_parameterized_ is False, the collection is empty.
         The converse is not necessarily true, because some objects may report
@@ -48,7 +49,7 @@ class SupportsParameterization(Protocol):
         """
 
     @doc_private
-    def _resolve_parameters_(self: T, resolver: 'cirq.ParamResolver', recursive: bool) -> T:
+    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> Self:
         """Resolve the parameters in the effect."""
 
 
@@ -177,6 +178,10 @@ def resolve_parameters(
     if isinstance(val, (list, tuple)):
         return cast(T, type(val)(resolve_parameters(e, param_resolver, recursive) for e in val))
 
+    is_parameterized = getattr(val, '_is_parameterized_', None)
+    if is_parameterized is not None and not is_parameterized():
+        return val
+
     getter = getattr(val, '_resolve_parameters_', None)
     if getter is None:
         result = NotImplemented

cirq/protocols/resolve_parameters_test.py

@@ -35,7 +35,7 @@ def test_resolve_parameters(resolve_fn):
             self.parameter = var
 
         def _is_parameterized_(self) -> bool:
-            return self.parameter == 0
+            return self.parameter != 0
 
         def _resolve_parameters_(self, resolver: ParamResolver, recursive: bool):
             self.parameter = resolver.value_of(self.parameter, recursive)
@@ -43,8 +43,8 @@ def test_resolve_parameters(resolve_fn):
 
     assert not cirq.is_parameterized(NoMethod())
     assert not cirq.is_parameterized(ReturnsNotImplemented())
-    assert not cirq.is_parameterized(SimpleParameterSwitch('a'))
-    assert cirq.is_parameterized(SimpleParameterSwitch(0))
+    assert cirq.is_parameterized(SimpleParameterSwitch('a'))
+    assert not cirq.is_parameterized(SimpleParameterSwitch(0))
 
     ni = ReturnsNotImplemented()
     d = {'a': 0}

cirq/protocols/unitary_protocol.py

@@ -17,7 +17,6 @@ from typing import Any, TypeVar, Union, Optional
 import numpy as np
 from typing_extensions import Protocol
 
-from cirq import qis
 from cirq._doc import doc_private
 from cirq.protocols import qid_shape_protocol
 from cirq.protocols.apply_unitary_protocol import ApplyUnitaryArgs, apply_unitaries
@@ -128,8 +127,8 @@ def unitary(
         "cirq.unitary failed. "
         "Value doesn't have a (non-parameterized) unitary effect.\n"
         "\n"
-        "type: {}\n"
-        "value: {!r}\n"
+        f"type: {type(val)}\n"
+        f"value: {val!r}\n"
         "\n"
         "The value failed to satisfy any of the following criteria:\n"
         "- A `_unitary_(self)` method that returned a value "
@@ -137,7 +136,7 @@ def unitary(
         "- A `_decompose_(self)` method that returned a "
         "list of unitary operations.\n"
         "- An `_apply_unitary_(self, args) method that returned a value "
-        "besides None or NotImplemented.".format(type(val), val)
+        "besides None or NotImplemented."
     )
 
 
@@ -162,9 +161,7 @@ def _strat_unitary_from_apply_unitary(val: Any) -> Optional[np.ndarray]:
         return NotImplemented
 
     # Apply unitary effect to an identity matrix.
-    state = qis.eye_tensor(val_qid_shape, dtype=np.complex128)
-    buffer = np.empty_like(state)
-    result = method(ApplyUnitaryArgs(state, buffer, range(len(val_qid_shape))))
+    result = method(ApplyUnitaryArgs.for_unitary(qid_shape=val_qid_shape))
 
     if result is NotImplemented or result is None:
         return result
@@ -179,15 +176,26 @@ def _strat_unitary_from_decompose(val: Any) -> Optional[np.ndarray]:
     if operations is None:
         return NotImplemented
 
+    all_qubits = frozenset(q for op in operations for q in op.qubits)
+    work_qubits = frozenset(qubits)
+    ancillas = tuple(sorted(all_qubits.difference(work_qubits)))
+
+    ordered_qubits = ancillas + tuple(qubits)
+    val_qid_shape = qid_shape_protocol.qid_shape(ancillas) + val_qid_shape
+
     # Apply sub-operations' unitary effects to an identity matrix.
-    state = qis.eye_tensor(val_qid_shape, dtype=np.complex128)
-    buffer = np.empty_like(state)
     result = apply_unitaries(
-        operations, qubits, ApplyUnitaryArgs(state, buffer, range(len(val_qid_shape))), None
+        operations, ordered_qubits, ApplyUnitaryArgs.for_unitary(qid_shape=val_qid_shape), None
     )
 
     # Package result.
     if result is None:
         return None
+
     state_len = np.prod(val_qid_shape, dtype=np.int64)
-    return result.reshape((state_len, state_len))
+    result = result.reshape((state_len, state_len))
+    # Assuming borrowable qubits are restored to their original state and
+    # clean qubits restord to the zero state then the desired unitary is
+    # the upper left square.
+    work_state_len = np.prod(val_qid_shape[len(ancillas) :], dtype=np.int64)
+    return result[:work_state_len, :work_state_len]

cirq/protocols/unitary_protocol_test.py

@@ -17,6 +17,7 @@ import numpy as np
 import pytest
 
 import cirq
+from cirq import testing
 
 m0: np.ndarray = np.array([])
 # yapf: disable
@@ -188,6 +189,42 @@ def test_has_unitary():
     assert not cirq.has_unitary(FullyImplemented(False))
 
 
+def _test_gate_that_allocates_qubits(gate):
+    from cirq.protocols.unitary_protocol import _strat_unitary_from_decompose
+
+    op = gate.on(*cirq.LineQubit.range(cirq.num_qubits(gate)))
+    moment = cirq.Moment(op)
+    circuit = cirq.FrozenCircuit(op)
+    circuit_op = cirq.CircuitOperation(circuit)
+    for val in [gate, op, moment, circuit, circuit_op]:
+        unitary_from_strat = _strat_unitary_from_decompose(val)
+        assert unitary_from_strat is not None
+        np.testing.assert_allclose(unitary_from_strat, gate.narrow_unitary())
+
+
+@pytest.mark.parametrize('theta', np.linspace(0, 2 * np.pi, 10))
+@pytest.mark.parametrize('phase_state', [0, 1])
+@pytest.mark.parametrize('target_bitsize', [1, 2, 3])
+@pytest.mark.parametrize('ancilla_bitsize', [1, 4])
+def test_decompose_gate_that_allocates_clean_qubits(
+    theta: float, phase_state: int, target_bitsize: int, ancilla_bitsize: int
+):
+
+    gate = testing.PhaseUsingCleanAncilla(theta, phase_state, target_bitsize, ancilla_bitsize)
+    _test_gate_that_allocates_qubits(gate)
+
+
+@pytest.mark.parametrize('phase_state', [0, 1])
+@pytest.mark.parametrize('target_bitsize', [1, 2, 3])
+@pytest.mark.parametrize('ancilla_bitsize', [1, 4])
+def test_decompose_gate_that_allocates_dirty_qubits(
+    phase_state: int, target_bitsize: int, ancilla_bitsize: int
+):
+
+    gate = testing.PhaseUsingDirtyAncilla(phase_state, target_bitsize, ancilla_bitsize)
+    _test_gate_that_allocates_qubits(gate)
+
+
 def test_decompose_and_get_unitary():
     from cirq.protocols.unitary_protocol import _strat_unitary_from_decompose
 

cirq/qis/channels.py

@@ -51,7 +51,7 @@ def kraus_to_choi(kraus_operators: Sequence[np.ndarray]) -> np.ndarray:
     """
     d = np.prod(kraus_operators[0].shape, dtype=np.int64)
     choi_rank = len(kraus_operators)
-    k = np.reshape(kraus_operators, (choi_rank, d))
+    k = np.reshape(np.asarray(kraus_operators), (choi_rank, d))
     return np.einsum('bi,bj->ij', k, k.conj())
 
 

cirq/qis/clifford_tableau.py

@@ -164,7 +164,7 @@ class CliffordTableau(StabilizerState):
     def _reconstruct_rs(self, rs: Optional[np.ndarray]) -> np.ndarray:
         if rs is None:
             new_rs = np.zeros(2 * self.n + 1, dtype=bool)
-            for (i, val) in enumerate(
+            for i, val in enumerate(
                 big_endian_int_to_digits(self.initial_state, digit_count=self.n, base=2)
             ):
                 new_rs[self.n + i] = bool(val)
@@ -203,7 +203,6 @@ class CliffordTableau(StabilizerState):
         return new_xs
 
     def _reconstruct_zs(self, zs: Optional[np.ndarray]) -> np.ndarray:
-
         if zs is None:
             new_zs = np.zeros((2 * self.n + 1, self.n), dtype=bool)
             for i in range(self.n):
@@ -338,11 +337,11 @@ class CliffordTableau(StabilizerState):
 
                 for k in range(self.n):
                     if self.xs[i, k] & (not self.zs[i, k]):
-                        string += 'X%d' % k
+                        string += f'X{k}'
                     elif (not self.xs[i, k]) & self.zs[i, k]:
-                        string += 'Z%d' % k
+                        string += f'Z{k}'
                     elif self.xs[i, k] & self.zs[i, k]:
-                        string += 'Y%d' % k
+                        string += f'Y{k}'
                     else:
                         string += '  '
 

cirq/qis/quantum_state_representation.py

@@ -13,7 +13,9 @@
 # limitations under the License.
 
 import abc
-from typing import List, Sequence, Tuple, TYPE_CHECKING, TypeVar
+from typing import List, Sequence, Tuple, TYPE_CHECKING
+from typing_extensions import Self
+
 import numpy as np
 
 from cirq import value
@@ -21,12 +23,10 @@ from cirq import value
 if TYPE_CHECKING:
     import cirq
 
-TSelf = TypeVar('TSelf', bound='QuantumStateRepresentation')
-
 
 class QuantumStateRepresentation(metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def copy(self: TSelf, deep_copy_buffers: bool = True) -> TSelf:
+    def copy(self, deep_copy_buffers: bool = True) -> Self:
         """Creates a copy of the object.
         Args:
             deep_copy_buffers: If True, buffers will also be deep-copied.
@@ -71,17 +71,15 @@ class QuantumStateRepresentation(metaclass=abc.ABCMeta):
             measurements.append(state.measure(axes, prng))
         return np.array(measurements, dtype=np.uint8)
 
-    def kron(self: TSelf, other: TSelf) -> TSelf:
+    def kron(self, other: Self) -> Self:
         """Joins two state spaces together."""
         raise NotImplementedError()
 
-    def factor(
-        self: TSelf, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple[TSelf, TSelf]:
+    def factor(self, axes: Sequence[int], *, validate=True, atol=1e-07) -> Tuple[Self, Self]:
         """Splits two state spaces after a measurement or reset."""
         raise NotImplementedError()
 
-    def reindex(self: TSelf, axes: Sequence[int]) -> TSelf:
+    def reindex(self, axes: Sequence[int]) -> Self:
         """Physically reindexes the state by the new basis.
         Args:
             axes: The desired axis order.

cirq/qis/states.py

@@ -11,6 +11,7 @@
 # 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.
+
 """Classes and methods for quantum states."""
 
 from typing import Any, cast, Iterable, List, Optional, Sequence, Set, TYPE_CHECKING, Tuple, Union
@@ -714,10 +715,21 @@ def dirac_notation(
     Returns:
         A pretty string consisting of a sum of computational basis kets
         and non-zero floats of the specified accuracy.
+
+    Raises:
+        ValueError: If there is a shape mismatch between state_vector and qid_shape.
+            Otherwise, when qid_shape is not mentioned and length of state_vector
+            is not a power of 2.
     """
     if qid_shape is None:
         qid_shape = (2,) * (len(state_vector).bit_length() - 1)
 
+    if len(state_vector) != np.prod(qid_shape, dtype=np.int64):
+        raise ValueError(
+            'state_vector has incorrect size. '
+            f'Expected {np.prod(qid_shape, dtype=np.int64)} but was {len(state_vector)}.'
+        )
+
     digit_separator = '' if max(qid_shape, default=0) < 10 else ','
     perm_list = [
         digit_separator.join(seq)
@@ -808,8 +820,8 @@ def to_valid_state_vector(
         num_qubits = len(qid_shape)
     if num_qubits != len(qid_shape):
         raise ValueError(
-            'num_qubits != len(qid_shape). num_qubits is <{!r}>. '
-            'qid_shape is <{!r}>.'.format(num_qubits, qid_shape)
+            f'num_qubits != len(qid_shape). num_qubits is <{num_qubits!r}>. '
+            f'qid_shape is <{qid_shape!r}>.'
         )
 
     if isinstance(state_rep, np.ndarray):
@@ -821,7 +833,6 @@ def to_valid_state_vector(
 def _qudit_values_to_state_tensor(
     *, state_vector: np.ndarray, qid_shape: Tuple[int, ...], dtype: Optional['DTypeLike']
 ) -> np.ndarray:
-
     for i in range(len(qid_shape)):
         s = state_vector[i]
         q = qid_shape[i]
@@ -871,15 +882,12 @@ def validate_normalized_state_vector(
     """
     if dtype and state_vector.dtype != dtype:
         raise ValueError(
-            'state_vector has invalid dtype. Expected {} but was {}'.format(
-                dtype, state_vector.dtype
-            )
+            f'state_vector has invalid dtype. Expected {dtype} but was {state_vector.dtype}'
         )
     if state_vector.size != np.prod(qid_shape, dtype=np.int64):
         raise ValueError(
-            'state_vector has incorrect size. Expected {} but was {}.'.format(
-                np.prod(qid_shape, dtype=np.int64), state_vector.size
-            )
+            'state_vector has incorrect size. '
+            f'Expected {np.prod(qid_shape, dtype=np.int64)} but was {state_vector.size}.'
         )
     norm = np.sum(np.abs(state_vector) ** 2)
     if not np.isclose(norm, 1, atol=atol):
@@ -904,8 +912,8 @@ def validate_qid_shape(
         qid_shape = (2,) * (size.bit_length() - 1)
     if size != np.prod(qid_shape, dtype=np.int64):
         raise ValueError(
-            'state_vector.size ({}) is not a power of two or is not a product '
-            'of the qid shape {!r}.'.format(size, qid_shape)
+            f'state_vector.size ({size}) is not a power of two or is not a product '
+            f'of the qid shape {qid_shape!r}.'
         )
     return qid_shape
 
@@ -1031,8 +1039,8 @@ def _qid_shape_from_args(
         return (2,) * num_qubits
     if len(qid_shape) != num_qubits:
         raise ValueError(
-            'num_qubits != len(qid_shape). num_qubits was {!r}. '
-            'qid_shape was {!r}.'.format(num_qubits, qid_shape)
+            f'num_qubits != len(qid_shape). num_qubits was {num_qubits!r}. '
+            f'qid_shape was {qid_shape!r}.'
         )
     return qid_shape