CompilationTargetGateset support in GridDeviceMetadata

Author: verult

cirq-core/cirq/devices/grid_device_metadata.py

@@ -18,6 +18,7 @@
     Optional,
     FrozenSet,
     Iterable,
+    Sequence,
     Tuple,
     Dict,
 )
@@ -40,6 +41,7 @@ def __init__(
         gateset: 'cirq.Gateset',
         gate_durations: Optional[Dict['cirq.GateFamily', 'cirq.Duration']] = None,
         all_qubits: Optional[Iterable['cirq.Qid']] = None,
+        compilation_target_gatesets: Optional[Iterable['cirq.CompilationTargetGateset']] = None,
     ):
         """Create a GridDeviceMetadata object.
 
@@ -60,6 +62,10 @@ def __init__(
             all_qubits: Optional iterable specifying all qubits
                 found on the device. If None, all_qubits will
                 be inferred from the entries in qubit_pairs.
+            compilation_target_gatesets: A collection of valid
+                `cirq.CompilationTargetGateset`s which can be used to
+                transform circuits into ones that consist of only
+                operations in `gateset`.
 
         Raises:
             ValueError: if the union of GateFamily keys in gate_durations
@@ -102,6 +108,9 @@ def __init__(
         self._qubit_pairs = frozenset(edge_set)
         self._gateset = gateset
         self._isolated_qubits = all_qubits.difference(node_set)
+        self._compilation_target_gatesets = (
+            () if compilation_target_gatesets is None else tuple(compilation_target_gatesets)
+        )
 
         if gate_durations is not None:
             working_gatefamilies = frozenset(gate_durations.keys())
@@ -131,6 +140,11 @@ def gateset(self) -> 'cirq.Gateset':
         """Returns the `cirq.Gateset` of supported gates on this device."""
         return self._gateset
 
+    @property
+    def compilation_target_gatesets(self) -> Tuple['cirq.CompilationTargetGateset', ...]:
+        """Returns a sequence of valid `cirq.CompilationTargetGateset`s for this device."""
+        return self._compilation_target_gatesets
+
     @property
     def gate_durations(self) -> Optional[Dict['cirq.GateFamily', 'cirq.Duration']]:
         """Get a dictionary mapping from gateset to duration for gates."""
@@ -146,27 +160,46 @@ def _value_equality_values_(self):
             self._gateset,
             tuple(duration_equality),
             tuple(sorted(self.qubit_set)),
+            frozenset(self._compilation_target_gatesets),
         )
 
     def __repr__(self) -> str:
         return (
             f'cirq.GridDeviceMetadata({repr(self._qubit_pairs)},'
             f' {repr(self._gateset)}, {repr(self._gate_durations)},'
-            f' {repr(self.qubit_set)})'
+            f' {repr(self.qubit_set)}, {repr(self._compilation_target_gatesets)})'
         )
 
     def _json_dict_(self):
         duration_payload = None
         if self._gate_durations is not None:
             duration_payload = sorted(self._gate_durations.items(), key=lambda x: repr(x[0]))
 
-        return {
+        jd = {
             'qubit_pairs': sorted(list(self._qubit_pairs)),
             'gateset': self._gateset,
             'gate_durations': duration_payload,
             'all_qubits': sorted(list(self.qubit_set)),
         }
+        if len(self._compilation_target_gatesets) > 0:
+            jd['compilation_target_gatesets'] = list(self._compilation_target_gatesets)
+
+        return jd
 
     @classmethod
-    def _from_json_dict_(cls, qubit_pairs, gateset, gate_durations, all_qubits, **kwargs):
-        return cls(qubit_pairs, gateset, dict(gate_durations), all_qubits)
+    def _from_json_dict_(
+        cls,
+        qubit_pairs,
+        gateset,
+        gate_durations,
+        all_qubits,
+        compilation_target_gatesets=None,
+        **kwargs,
+    ):
+        return cls(
+            qubit_pairs,
+            gateset,
+            None if gate_durations is None else dict(gate_durations),
+            all_qubits,
+            compilation_target_gatesets,
+        )

cirq-core/cirq/devices/grid_device_metadata_test.py

@@ -23,7 +23,13 @@ def test_griddevice_metadata():
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
     isolated_qubits = [cirq.GridQubit(9, 9), cirq.GridQubit(10, 10)]
     gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)
-    metadata = cirq.GridDeviceMetadata(qubit_pairs, gateset, all_qubits=qubits + isolated_qubits)
+    target_gatesets = (cirq.CZTargetGateset(),)
+    metadata = cirq.GridDeviceMetadata(
+        qubit_pairs,
+        gateset,
+        all_qubits=qubits + isolated_qubits,
+        compilation_target_gatesets=target_gatesets,
+    )
     expected_pairings = frozenset(
         {
             (cirq.GridQubit(0, 0), cirq.GridQubit(0, 1)),
@@ -45,6 +51,7 @@ def test_griddevice_metadata():
     assert metadata.nx_graph.nodes() == expected_graph.nodes()
     assert metadata.gate_durations is None
     assert metadata.isolated_qubits == frozenset(isolated_qubits)
+    assert metadata.compilation_target_gatesets == target_gatesets
 
 
 def test_griddevice_metadata_bad_durations():
@@ -80,35 +87,58 @@ def test_griddevice_self_loop():
 def test_griddevice_json_load():
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
-    gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate)
+    gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)
     duration = {
         cirq.GateFamily(cirq.XPowGate): cirq.Duration(nanos=1),
         cirq.GateFamily(cirq.YPowGate): cirq.Duration(picos=2),
         cirq.GateFamily(cirq.ZPowGate): cirq.Duration(picos=3),
+        cirq.GateFamily(cirq.CZ): cirq.Duration(nanos=4),
     }
     isolated_qubits = [cirq.GridQubit(9, 9), cirq.GridQubit(10, 10)]
+    target_gatesets = [cirq.CZTargetGateset()]
     metadata = cirq.GridDeviceMetadata(
-        qubit_pairs, gateset, gate_durations=duration, all_qubits=qubits + isolated_qubits
+        qubit_pairs,
+        gateset,
+        gate_durations=duration,
+        all_qubits=qubits + isolated_qubits,
+        compilation_target_gatesets=target_gatesets,
     )
     rep_str = cirq.to_json(metadata)
     assert metadata == cirq.read_json(json_text=rep_str)
 
 
+def test_griddevice_json_load_with_defaults():
+    qubits = cirq.GridQubit.rect(2, 3)
+    qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
+    gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)
+
+    # Don't set parameters with default values
+    metadata = cirq.GridDeviceMetadata(qubit_pairs, gateset)
+    rep_str = cirq.to_json(metadata)
+
+    assert metadata == cirq.read_json(json_text=rep_str)
+
+
 def test_griddevice_metadata_equality():
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
-    gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate)
+    gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ, cirq.SQRT_ISWAP)
     duration = {
         cirq.GateFamily(cirq.XPowGate): cirq.Duration(nanos=1),
         cirq.GateFamily(cirq.YPowGate): cirq.Duration(picos=3),
         cirq.GateFamily(cirq.ZPowGate): cirq.Duration(picos=2),
+        cirq.GateFamily(cirq.CZ): cirq.Duration(nanos=4),
+        cirq.GateFamily(cirq.SQRT_ISWAP): cirq.Duration(nanos=5),
     }
     duration2 = {
         cirq.GateFamily(cirq.XPowGate): cirq.Duration(nanos=10),
         cirq.GateFamily(cirq.YPowGate): cirq.Duration(picos=13),
         cirq.GateFamily(cirq.ZPowGate): cirq.Duration(picos=12),
+        cirq.GateFamily(cirq.CZ): cirq.Duration(nanos=14),
+        cirq.GateFamily(cirq.SQRT_ISWAP): cirq.Duration(nanos=15),
     }
     isolated_qubits = [cirq.GridQubit(9, 9)]
+    target_gatesets = [cirq.CZTargetGateset(), cirq.SqrtIswapTargetGateset()]
     metadata = cirq.GridDeviceMetadata(qubit_pairs, gateset, gate_durations=duration)
     metadata2 = cirq.GridDeviceMetadata(qubit_pairs[:2], gateset, gate_durations=duration)
     metadata3 = cirq.GridDeviceMetadata(qubit_pairs, gateset, gate_durations=None)
@@ -117,28 +147,47 @@ def test_griddevice_metadata_equality():
     metadata6 = cirq.GridDeviceMetadata(
         qubit_pairs, gateset, gate_durations=duration, all_qubits=qubits + isolated_qubits
     )
+    metadata7 = cirq.GridDeviceMetadata(
+        qubit_pairs, gateset, compilation_target_gatesets=target_gatesets
+    )
+    metadata8 = cirq.GridDeviceMetadata(
+        qubit_pairs, gateset, compilation_target_gatesets=target_gatesets[::-1]
+    )
+    metadata9 = cirq.GridDeviceMetadata(
+        qubit_pairs, gateset, compilation_target_gatesets=tuple(target_gatesets)
+    )
+    metadata10 = cirq.GridDeviceMetadata(
+        qubit_pairs, gateset, compilation_target_gatesets=set(target_gatesets)
+    )
 
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(metadata)
     eq.add_equality_group(metadata2)
     eq.add_equality_group(metadata3)
     eq.add_equality_group(metadata4)
     eq.add_equality_group(metadata6)
+    eq.add_equality_group(metadata7, metadata8, metadata9, metadata10)
 
     assert metadata == metadata5
 
 
 def test_repr():
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
-    gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate)
+    gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)
     duration = {
         cirq.GateFamily(cirq.XPowGate): cirq.Duration(nanos=1),
         cirq.GateFamily(cirq.YPowGate): cirq.Duration(picos=3),
         cirq.GateFamily(cirq.ZPowGate): cirq.Duration(picos=2),
+        cirq.GateFamily(cirq.CZ): cirq.Duration(nanos=4),
     }
     isolated_qubits = [cirq.GridQubit(9, 9)]
+    target_gatesets = [cirq.CZTargetGateset()]
     metadata = cirq.GridDeviceMetadata(
-        qubit_pairs, gateset, gate_durations=duration, all_qubits=qubits + isolated_qubits
+        qubit_pairs,
+        gateset,
+        gate_durations=duration,
+        all_qubits=qubits + isolated_qubits,
+        compilation_target_gatesets=target_gatesets,
     )
     cirq.testing.assert_equivalent_repr(metadata)