Example #1
0
def test_metadata_correct():
    qubits = cirq.GridQubit.rect(2, 3, left=1, top=1)
    pairs = [
        (qubits[0], qubits[1]),
        (qubits[0], qubits[3]),
        (qubits[1], qubits[4]),
        (qubits[4], qubits[5]),
    ]
    device_proto = cgdk.create_device_proto_for_qubits(
        qubits=qubits, pairs=pairs, gate_sets=[cg.FSIM_GATESET])
    device = cgdk.SerializableDevice.from_proto(device_proto,
                                                gate_sets=[cg.FSIM_GATESET])
    assert device.metadata.qubit_pairs == frozenset(
        {frozenset(p)
         for p in pairs})
    assert device.metadata.gateset == cirq.Gateset(
        cirq.FSimGate,
        cirq.ISwapPowGate,
        cirq.CZPowGate,
        cirq.PhasedXPowGate,
        cirq.XPowGate,
        cirq.YPowGate,
        cirq.ZPowGate,
        cirq.PhasedXZGate,
        cirq.MeasurementGate,
        cirq.WaitGate,
        cirq.GlobalPhaseGate,
    )
def test_create_device_proto_for_irregular_grid():
    qubits = cirq.GridQubit.rect(2, 2)
    pairs = [
        (cirq.GridQubit(0, 0), cirq.GridQubit(0, 1)),
        (cirq.GridQubit(0, 0), cirq.GridQubit(1, 0)),
        (cirq.GridQubit(1, 0), cirq.GridQubit(1, 1)),
    ]
    proto = known_devices.create_device_proto_for_qubits(qubits, pairs)
    assert (str(proto) == """\
valid_qubits: "0_0"
valid_qubits: "0_1"
valid_qubits: "1_0"
valid_qubits: "1_1"
valid_targets {
  name: "meas_targets"
  target_ordering: SUBSET_PERMUTATION
}
valid_targets {
  name: "2_qubit_targets"
  target_ordering: SYMMETRIC
  targets {
    ids: "0_0"
    ids: "0_1"
  }
  targets {
    ids: "0_0"
    ids: "1_0"
  }
  targets {
    ids: "1_0"
    ids: "1_1"
  }
}
""")
def test_str_with_grid_qubits():
    # Deprecations: cirq_google.SerializableDevice, well-known cirq_google SerializableGateSets
    # (e.g. cirq_google.SYC_GATESET) and
    # cirq_google.devices.known_devices.create_device_proto_for_qubits
    with cirq.testing.assert_deprecated(
            'Use cirq_google.GridDevice',
            'SerializableGateSet',
            'create_device_specification_proto()` can be used',
            deadline='v0.16',
            count=5,
    ):
        qubits = cirq.GridQubit.rect(2, 3, left=1, top=1)
        device_proto = cgdk.create_device_proto_for_qubits(
            qubits=qubits,
            pairs=[
                (qubits[0], qubits[1]),
                (qubits[0], qubits[3]),
                (qubits[1], qubits[4]),
                (qubits[4], qubits[5]),
            ],
            gate_sets=[cg.FSIM_GATESET],
        )
        device = cg.SerializableDevice.from_proto(device_proto,
                                                  gate_sets=[cg.FSIM_GATESET])
        assert str(device) == textwrap.dedent("""\
            q(1, 1)───q(1, 2)   q(1, 3)
            │         │
            │         │
            q(2, 1)   q(2, 2)───q(2, 3)""")
Example #4
0
def test_str_with_grid_qubits():
    qubits = cirq.GridQubit.rect(2, 3, left=1, top=1)
    device_proto = cgdk.create_device_proto_for_qubits(
        qubits=qubits,
        pairs=[
            (qubits[0], qubits[1]),
            (qubits[0], qubits[3]),
            (qubits[1], qubits[4]),
            (qubits[4], qubits[5]),
        ],
        gate_sets=[cg.FSIM_GATESET],
    )
    device = cgdk.SerializableDevice.from_proto(device_proto,
                                                gate_sets=[cg.FSIM_GATESET])
    assert str(device) == textwrap.dedent("""\
        q(1, 1)───q(1, 2)   q(1, 3)
        │         │
        │         │
        q(2, 1)   q(2, 2)───q(2, 3)""")
def test_metadata_correct():
    # Deprecations: cirq_google.SerializableDevice, well-known cirq_google SerializableGateSets
    # (e.g. cirq_google.SYC_GATESET) and
    # cirq_google.devices.known_devices.create_device_proto_for_qubits
    with cirq.testing.assert_deprecated(
            'Use cirq_google.GridDevice',
            'SerializableGateSet',
            'create_device_specification_proto()` can be used',
            deadline='v0.16',
            count=5,
    ):
        qubits = cirq.GridQubit.rect(2, 3, left=1, top=1)
        pairs = [
            (qubits[0], qubits[1]),
            (qubits[0], qubits[3]),
            (qubits[1], qubits[4]),
            (qubits[4], qubits[5]),
        ]
        device_proto = cgdk.create_device_proto_for_qubits(
            qubits=qubits, pairs=pairs, gate_sets=[cg.FSIM_GATESET])

        device = cg.SerializableDevice.from_proto(device_proto,
                                                  gate_sets=[cg.FSIM_GATESET])
        assert device.metadata.qubit_pairs == frozenset(
            {frozenset(p)
             for p in pairs})
        assert device.metadata.gateset == cirq.Gateset(
            cirq.FSimGate,
            cirq.ISwapPowGate,
            cirq.CZPowGate,
            cirq.PhasedXPowGate,
            cirq.XPowGate,
            cirq.YPowGate,
            cirq.ZPowGate,
            cirq.PhasedXZGate,
            cirq.MeasurementGate,
            cirq.WaitGate,
            cirq.GlobalPhaseGate,
        )
def test_create_device_proto_for_irregular_grid():
    qubits = cirq.GridQubit.rect(2, 2)
    pairs = [
        (cirq.GridQubit(0, 0), cirq.GridQubit(0, 1)),
        (cirq.GridQubit(0, 0), cirq.GridQubit(1, 0)),
        (cirq.GridQubit(1, 0), cirq.GridQubit(1, 1)),
    ]
    with cirq.testing.assert_deprecated(
            'create_device_specification_proto()` can be used',
            deadline='v0.16',
            count=1):
        proto = known_devices.create_device_proto_for_qubits(qubits, pairs)
        assert (str(proto) == """\
valid_qubits: "0_0"
valid_qubits: "0_1"
valid_qubits: "1_0"
valid_qubits: "1_1"
valid_targets {
  name: "meas_targets"
  target_ordering: SUBSET_PERMUTATION
}
valid_targets {
  name: "2_qubit_targets"
  target_ordering: SYMMETRIC
  targets {
    ids: "0_0"
    ids: "0_1"
  }
  targets {
    ids: "0_0"
    ids: "1_0"
  }
  targets {
    ids: "1_0"
    ids: "1_1"
  }
}
""")
def test_to_proto_backward_compatibility():
    # Deprecations: cirq_google.SerializableGateSet and
    # cirq_google.device.known_devices.create_device_proto_for_qubits()
    with cirq.testing.assert_deprecated(
            'SerializableGateSet',
            'create_device_specification_proto()` can be used',
            deadline='v0.16',
            count=None,
    ):
        device_info, _ = _create_device_spec_with_horizontal_couplings()

        # The set of gates in gate_durations are consistent with what's generated in
        # _create_device_spec_with_horizontal_couplings()
        base_duration = cirq.Duration(picos=1_000)
        gate_durations = {
            cirq.GateFamily(cirq_google.SYC):
            base_duration * 0,
            cirq.GateFamily(cirq.SQRT_ISWAP):
            base_duration * 1,
            cirq.GateFamily(cirq.SQRT_ISWAP_INV):
            base_duration * 2,
            cirq.GateFamily(cirq.CZ):
            base_duration * 3,
            cirq.GateFamily(cirq.ops.phased_x_z_gate.PhasedXZGate):
            base_duration * 4,
            cirq.GateFamily(cirq.ops.common_gates.ZPowGate,
                            tags_to_ignore=[cirq_google.PhysicalZTag()]):
            base_duration * 5,
            cirq.GateFamily(cirq.ops.common_gates.ZPowGate,
                            tags_to_accept=[cirq_google.PhysicalZTag()]):
            base_duration * 6,
            cirq.GateFamily(cirq_google.experimental.ops.coupler_pulse.CouplerPulse):
            base_duration * 7,
            cirq.GateFamily(cirq.ops.measurement_gate.MeasurementGate):
            base_duration * 8,
            cirq.GateFamily(cirq.ops.wait_gate.WaitGate):
            base_duration * 9,
        }

        # Serialize the old way
        spec = known_devices.create_device_proto_for_qubits(
            device_info.grid_qubits,
            device_info.qubit_pairs,
            [cirq_google.FSIM_GATESET],
            known_devices._SYCAMORE_DURATIONS_PICOS,
        )

        # Serialize the new way
        grid_device.create_device_specification_proto(
            qubits=device_info.grid_qubits,
            pairs=device_info.qubit_pairs,
            gateset=cirq.Gateset(*gate_durations.keys()),
            gate_durations=gate_durations,
            out=spec,
        )

        with cirq.testing.assert_deprecated('Use cirq_google.GridDevice',
                                            deadline='v0.16',
                                            count=None):
            # Deserialize both ways
            serializable_dev = cirq_google.SerializableDevice.from_proto(
                spec, [cirq_google.FSIM_GATESET])
            grid_dev = cirq_google.GridDevice.from_proto(spec)

            assert serializable_dev.metadata.qubit_set == grid_dev.metadata.qubit_set
            assert serializable_dev.metadata.qubit_pairs == grid_dev.metadata.qubit_pairs

            assert serializable_dev.metadata.gateset == cirq.Gateset(
                cirq.FSimGate,
                cirq.ISwapPowGate,
                cirq.CZPowGate,
                cirq.PhasedXPowGate,
                cirq.XPowGate,
                cirq.YPowGate,
                cirq.ZPowGate,
                cirq.PhasedXZGate,
                cirq.MeasurementGate,
                cirq.WaitGate,
                cirq.GlobalPhaseGate,
            )

            assert grid_dev.metadata.gateset == device_info.expected_gateset
            assert (tuple(grid_dev.metadata.compilation_target_gatesets) ==
                    device_info.expected_target_gatesets)

            assert grid_dev.metadata.gate_durations == device_info.expected_gate_durations