def test_protocols():
t = sympy.Symbol('t')
p = cirq.WaitGate(cirq.Duration(millis=5 * t))
c = cirq.WaitGate(cirq.Duration(millis=2))
q = cirq.LineQubit(0)
cirq.testing.assert_implements_consistent_protocols(cirq.WaitGate(0).on(q))
cirq.testing.assert_implements_consistent_protocols(c.on(q))
cirq.testing.assert_implements_consistent_protocols(p.on(q))
assert cirq.has_unitary(p)
assert cirq.has_unitary(c)
assert cirq.is_parameterized(p)
assert not cirq.is_parameterized(c)
assert cirq.resolve_parameters(p, {'t': 2}) == cirq.WaitGate(
cirq.Duration(millis=10))
assert cirq.resolve_parameters(c, {'t': 2}) == c
assert cirq.trace_distance_bound(p) == 0
assert cirq.trace_distance_bound(c) == 0
assert cirq.inverse(c) == c
assert cirq.inverse(p) == p
assert cirq.decompose(c.on(q)) == []
assert cirq.decompose(p.on(q)) == []
def test_init_timedelta():
d = ion_device(3, use_timedelta=True)
ms = 1000*cirq.Duration(nanos=1)
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
q2 = cirq.LineQubit(2)
assert d.qubits == {q0, q1, q2}
assert d.duration_of(cirq.Z(q0)) == 10 * ms
assert d.duration_of(cirq.measure(q0)) == 100 * ms
assert d.duration_of(cirq.measure(q0, q1)) == 100 * ms
assert d.duration_of(cirq.ops.XX(q0, q1)) == 200 * ms
with pytest.raises(ValueError):
_ = d.duration_of(cirq.SingleQubitGate().on(q0))
def test_sudden_decay_results():
class _SuddenDecay(cirq.NoiseModel):
def noisy_moment(self, moment, system_qubits):
duration = max((op.gate.duration for op in moment.operations
if isinstance(op.gate, cirq.WaitGate)),
default=cirq.Duration())
if duration > cirq.Duration(nanos=500):
yield cirq.amplitude_damp(1).on_each(system_qubits)
yield moment
results = cirq.experiments.t2_decay(
sampler=cirq.DensityMatrixSimulator(noise=_SuddenDecay()),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=500,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1))
assert (results.expectation_pauli_y['value'][0:2] == -1).all()
assert (results.expectation_pauli_y['value'][2:] < 0.20).all()
# X Should be approximately zero
assert (abs(results.expectation_pauli_x['value']) < 0.20).all()
def test_xmon_device_eq():
eq = cirq.testing.EqualsTester()
eq.make_equality_group(lambda: square_device(3, 3))
eq.make_equality_group(
lambda: square_device(3, 3, holes=[cirq.GridQubit(1, 1)]))
eq.make_equality_group(lambda: cg.XmonDevice(cirq.Duration(
nanos=1), cirq.Duration(nanos=2), cirq.Duration(nanos=3), []))
eq.make_equality_group(lambda: cg.XmonDevice(cirq.Duration(
nanos=1), cirq.Duration(nanos=1), cirq.Duration(nanos=1), []))
def test_custom_delay_sweep(experiment_type):
pulses = [1] if experiment_type == t2.ExperimentType.CPMG else None
results = t2.t2_decay(
sampler=cirq.DensityMatrixSimulator(noise=cirq.amplitude_damp(1)),
qubit=cirq.GridQubit(0, 0),
num_points=4,
repetitions=10,
min_delay=cirq.Duration(nanos=100),
max_delay=cirq.Duration(micros=1),
experiment_type=experiment_type,
num_pulses=pulses,
delay_sweep=cirq.Points('delay_ns', [1.0, 10.0, 100.0, 1000.0, 10000.0]),
)
assert results == cirq.experiments.T2DecayResult(
x_basis_data=pd.DataFrame(
columns=['delay_ns', 0, 1],
index=range(5),
data=[
[1.0, 10, 0],
[10.0, 10, 0],
[100.0, 10, 0],
[1000.0, 10, 0],
[10000.0, 10, 0],
],
),
y_basis_data=pd.DataFrame(
columns=['delay_ns', 0, 1],
index=range(5),
data=[
[1.0, 10, 0],
[10.0, 10, 0],
[100.0, 10, 0],
[1000.0, 10, 0],
[10000.0, 10, 0],
],
),
)
def test_sycamore_circuitop_device():
# Deprecations: cirq_google.SerializableDevice, cirq_google.SerializableGateSets class,
# well-known cirq_google SerializableGateSets (e.g. cirq_google.SYC_GATESET), and
# cirq_google.devices.known_devices.create_device_proto_from_diagram
with cirq.testing.assert_deprecated(
'Use cirq_google.GridDevice',
'SerializableGateSet',
'no longer be available',
deadline='v0.16',
count=7,
):
circuitop_gateset = cirq_google.SerializableGateSet(
gate_set_name='circuitop_gateset',
serializers=[cgc.CIRCUIT_OP_SERIALIZER],
deserializers=[cgc.CIRCUIT_OP_DESERIALIZER],
)
gateset_list = [
cirq_google.SQRT_ISWAP_GATESET, cirq_google.SYC_GATESET,
circuitop_gateset
]
circuitop_proto = cirq_google.devices.known_devices.create_device_proto_from_diagram(
known_devices._SYCAMORE23_GRID, gateset_list,
known_devices._SYCAMORE_DURATIONS_PICOS)
device = cirq_google.SerializableDevice.from_proto(
proto=circuitop_proto, gate_sets=gateset_list)
q0 = cirq.GridQubit(5, 3)
q1 = cirq.GridQubit(5, 4)
syc = cirq.FSimGate(theta=np.pi / 2, phi=np.pi / 6)(q0, q1)
sqrt_iswap = cirq.FSimGate(theta=np.pi / 4, phi=0)(q0, q1)
circuit_op = cirq.CircuitOperation(cirq.FrozenCircuit(syc, sqrt_iswap))
device.validate_operation(syc)
device.validate_operation(sqrt_iswap)
device.validate_operation(circuit_op)
assert device.duration_of(syc) == cirq.Duration(nanos=12)
assert device.duration_of(sqrt_iswap) == cirq.Duration(nanos=32)
# CircuitOperations don't have a set duration.
assert device.duration_of(circuit_op) == cirq.Duration(nanos=0)
def test_prepare_characterization_for_operations(options_cls):
options, cls = options_cls
q00 = cirq.GridQubit(0, 0)
q01 = cirq.GridQubit(0, 1)
q10 = cirq.GridQubit(1, 0)
q11 = cirq.GridQubit(1, 1)
q20 = cirq.GridQubit(2, 0)
q21 = cirq.GridQubit(2, 1)
# Prepare characterizations for a single circuit.
circuit_1 = cirq.Circuit([
[cirq.X(q00), cirq.Y(q11)],
[SQRT_ISWAP_GATE.on(q00, q01),
SQRT_ISWAP_GATE.on(q10, q11)],
[cirq.WaitGate(duration=cirq.Duration(micros=5.0)).on(q01)],
])
requests_1 = workflow.prepare_characterization_for_operations(
circuit_1, options=options)
assert requests_1 == [
cls(pairs=((q10, q11), ), gate=SQRT_ISWAP_GATE, options=options),
cls(pairs=((q00, q01), ), gate=SQRT_ISWAP_GATE, options=options),
]
# Prepare characterizations for a list of circuits.
circuit_2 = cirq.Circuit([
[SQRT_ISWAP_GATE.on(q00, q01),
SQRT_ISWAP_GATE.on(q10, q11)],
[SQRT_ISWAP_GATE.on(q00, q10),
SQRT_ISWAP_GATE.on(q01, q11)],
[SQRT_ISWAP_GATE.on(q10, q20),
SQRT_ISWAP_GATE.on(q11, q21)],
])
requests_2 = workflow.prepare_characterization_for_operations(
[circuit_1, circuit_2], options=options)
# The order of moments originates from HALF_GRID_STAGGERED_PATTERN.
assert requests_2 == [
cls(pairs=((q00, q10), (q11, q21)),
gate=SQRT_ISWAP_GATE,
options=options),
cls(pairs=((q01, q11), (q10, q20)),
gate=SQRT_ISWAP_GATE,
options=options),
cls(pairs=((q10, q11), ), gate=SQRT_ISWAP_GATE, options=options),
cls(pairs=((q00, q01), ), gate=SQRT_ISWAP_GATE, options=options),
]
def test_exclude():
q = cirq.QubitId()
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op = cirq.ScheduledOperation(zero, ps, cirq.H(q))
schedule = cirq.Schedule(device=UnconstrainedDevice,
scheduled_operations=[op])
assert not schedule.exclude(
cirq.ScheduledOperation(zero + ps, ps, cirq.H(q)))
assert not schedule.exclude(cirq.ScheduledOperation(zero, ps, cirq.X(q)))
assert schedule.query(time=zero, duration=ps * 10) == [op]
assert schedule.exclude(cirq.ScheduledOperation(zero, ps, cirq.H(q)))
assert schedule.query(time=zero, duration=ps * 10) == []
assert not schedule.exclude(cirq.ScheduledOperation(zero, ps, cirq.H(q)))
def test_exclude():
q = cirq.NamedQubit('q')
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op = cirq.ScheduledOperation(zero, ps, cirq.H(q))
schedule = cirq.Schedule(device=UNCONSTRAINED_DEVICE,
scheduled_operations=[op])
assert not schedule.exclude(
cirq.ScheduledOperation(zero + ps, ps, cirq.H(q)))
assert not schedule.exclude(cirq.ScheduledOperation(zero, ps, cirq.X(q)))
assert schedule.query(time=zero, duration=ps * 10) == [op]
assert schedule.exclude(cirq.ScheduledOperation(zero, ps, cirq.H(q)))
assert schedule.query(time=zero, duration=ps * 10) == []
assert not schedule.exclude(cirq.ScheduledOperation(zero, ps, cirq.H(q)))
def test_init_errors():
line = cirq.LineQubit.range(3)
us = cirq.Duration(nanos=10**3)
ms = cirq.Duration(nanos=10**6)
with pytest.raises(ValueError, match="Unsupported qubit type"):
_ = neutral_atoms.NeutralAtomDevice(
measurement_duration=50 * ms,
gate_duration=100 * us,
control_radius=1.5,
max_parallel_z=3,
max_parallel_xy=3,
max_parallel_c=3,
qubits=line,
)
with pytest.raises(ValueError, match="max_parallel_c must be less"):
_ = neutral_atoms.NeutralAtomDevice(
measurement_duration=50 * ms,
gate_duration=100 * us,
control_radius=1.5,
max_parallel_z=3,
max_parallel_xy=3,
max_parallel_c=4,
qubits=[cirq.GridQubit(0, 0)],
)
def test_init():
d = square_device(2, 2, holes=[cirq.GridQubit(1, 1)])
ns = cirq.Duration(nanos=1)
q00 = cirq.GridQubit(0, 0)
q01 = cirq.GridQubit(0, 1)
q10 = cirq.GridQubit(1, 0)
assert d.qubits == {q00, q01, q10}
assert d.duration_of(cg.ExpZGate().on(q00)) == 0 * ns
assert d.duration_of(cirq.measure(q00)) == ns
assert d.duration_of(cirq.measure(q00, q01)) == ns
assert d.duration_of(cg.ExpWGate().on(q00)) == 2 * ns
assert d.duration_of(cg.Exp11Gate().on(q00, q01)) == 3 * ns
with pytest.raises(ValueError):
_ = d.duration_of(cirq.Gate().on(q00))
def test_find_measurements_simple_schedule():
schedule = cirq.Schedule(
device=cirq.UNCONSTRAINED_DEVICE,
scheduled_operations=[
cirq.ScheduledOperation(
time=cirq.Timestamp(picos=10_000),
duration=cirq.Duration(nanos=1000),
operation=cirq.measure(q(0, 0), q(0, 1), q(0, 2), key='k'),
),
],
)
measurements = v2.find_measurements(schedule)
assert len(measurements) == 1
m = measurements[0]
_check_measurement(m, 'k', [q(0, 0), q(0, 1), q(0, 2)], 10_000)
def __init__(
self,
duration: cirq.DURATION_LIKE,
target_set: Set[Tuple[cirq.Qid, ...]],
number_of_qubits: int,
is_permutation: bool,
can_serialize_predicate: Callable[[cirq.Operation], bool] = lambda x: True,
):
self.duration = cirq.Duration(duration)
self.target_set = target_set
self.is_permutation = is_permutation
self.number_of_qubits = number_of_qubits
self.can_serialize_predicate = can_serialize_predicate
# Compute the set of all qubits in all target sets.
self.flattened_qubits = {q for qubit_tuple in target_set for q in qubit_tuple}
def test_plot_does_not_raise_error():
class _TimeDependentDecay(cirq.NoiseModel):
def noisy_moment(self, moment, system_qubits):
duration = max((op.gate.duration for op in moment.operations
if isinstance(op.gate, cirq.WaitGate)),
default=cirq.Duration(nanos=1))
yield cirq.amplitude_damp(
1 - 0.99**duration.total_nanos()).on_each(system_qubits)
yield moment
results = cirq.experiments.t1_decay(
sampler=cirq.DensityMatrixSimulator(noise=_TimeDependentDecay()),
qubit=cirq.GridQubit(0, 0),
num_points=3,
repetitions=10,
max_delay=cirq.Duration(nanos=500))
results.plot()
def test_proto_with_waitgate():
wait_gateset = cg.serializable_gate_set.SerializableGateSet(
gate_set_name='wait_gateset',
serializers=[cgc.WAIT_GATE_SERIALIZER],
deserializers=[cgc.WAIT_GATE_DESERIALIZER],
)
wait_proto = cg.devices.known_devices.create_device_proto_from_diagram(
"aa\naa",
[wait_gateset],
)
wait_device = cg.SerializableDevice.from_proto(proto=wait_proto,
gate_sets=[wait_gateset])
q0 = cirq.GridQubit(1, 1)
wait_op = cirq.WaitGate(duration=cirq.Duration(nanos=25))(q0)
wait_device.validate_operation(wait_op)
assert str(wait_proto) == """\
def get_aqt_device(num_qubits: int) -> Tuple[AQTDevice, List[cirq.LineQubit]]:
"""Returns an AQT ion device
Args:
num_qubits: number of qubits
Returns:
A tuple of IonDevice and qubit_list
"""
qubit_list = cirq.LineQubit.range(num_qubits)
us = 1000 * cirq.Duration(nanos=1)
ion_device = AQTDevice(
measurement_duration=100 * us,
twoq_gates_duration=200 * us,
oneq_gates_duration=10 * us,
qubits=qubit_list,
)
return ion_device, qubit_list
def test_query_overlapping_operations_exclusive():
q = cirq.QubitId()
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op1 = cirq.ScheduledOperation(zero, 2 * ps, cirq.H(q))
op2 = cirq.ScheduledOperation(zero + ps, 2 * ps, cirq.H(q))
schedule = cirq.Schedule(device=UnconstrainedDevice,
scheduled_operations=[op2, op1])
assert schedule.query(time=zero - 0.5 * ps, duration=ps) == [op1]
assert schedule.query(time=zero - 0.5 * ps, duration=2 * ps) == [op1, op2]
assert schedule.query(time=zero, duration=ps) == [op1]
assert schedule.query(time=zero + 0.5 * ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + 1.5 * ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + 2.0 * ps, duration=ps) == [op2]
assert schedule.query(time=zero + 2.5 * ps, duration=ps) == [op2]
assert schedule.query(time=zero + 3.0 * ps, duration=ps) == []
assert schedule.query(time=zero + 3.5 * ps, duration=ps) == []
def test_unitary():
q = cirq.NamedQubit('q')
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op = cirq.ScheduledOperation(zero, ps, cirq.H(q))
schedule = cirq.Schedule(device=UNCONSTRAINED_DEVICE,
scheduled_operations=[op])
cirq.testing.assert_has_consistent_apply_unitary(schedule, qubit_count=1)
np.testing.assert_allclose(cirq.unitary(schedule), cirq.unitary(cirq.H))
assert cirq.has_unitary(schedule)
schedule2 = cirq.Schedule(device=UNCONSTRAINED_DEVICE,
scheduled_operations=[
cirq.ScheduledOperation(
zero, ps,
cirq.depolarize(0.5).on(q))
])
assert not cirq.has_unitary(schedule2)
def test_query_overlapping_operations_exclusive():
q = cirq.NamedQubit('q')
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op1 = cirq.ScheduledOperation(zero, 2 * ps, cirq.H(q))
op2 = cirq.ScheduledOperation(zero + ps, 2 * ps, cirq.H(q))
schedule = cirq.Schedule(device=UNCONSTRAINED_DEVICE,
scheduled_operations=[op2, op1])
assert schedule.query(time=zero - 0.5 * ps, duration=ps) == [op1]
assert schedule.query(time=zero - 0.5 * ps, duration=2 * ps) == [op1, op2]
assert schedule.query(time=zero, duration=ps) == [op1]
assert schedule.query(time=zero + 0.5 * ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + 1.5 * ps, duration=ps) == [op1, op2]
assert schedule.query(time=zero + 2.0 * ps, duration=ps) == [op2]
assert schedule.query(time=zero + 2.5 * ps, duration=ps) == [op2]
assert schedule.query(time=zero + 3.0 * ps, duration=ps) == []
assert schedule.query(time=zero + 3.5 * ps, duration=ps) == []
def test_convert_to_ion_circuit():
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
us = cirq.Duration(nanos=1000)
with cirq.testing.assert_deprecated("cirq_aqt.aqt_device.AQTDevice",
deadline='v0.16',
count=2):
ion_device = cirq.IonDevice(us, us, us, [q0, q1])
with cirq.testing.assert_deprecated("cirq_aqt.aqt_device.AQTTargetGateset",
deadline='v0.16',
count=None):
convert_to_ion_gates = cirq.ion.ConvertToIonGates()
clifford_circuit_1 = cirq.Circuit()
clifford_circuit_1.append(
[cirq.X(q0), cirq.H(q1),
cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_1 = convert_to_ion_gates.convert_circuit(clifford_circuit_1)
ion_circuit_1_using_device = ion_device.decompose_circuit(
clifford_circuit_1)
ion_device.validate_circuit(ion_circuit_1)
ion_device.validate_circuit(ion_circuit_1_using_device)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_1, ion_circuit_1, atol=1e-6)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_1, ion_circuit_1_using_device, atol=1e-6)
clifford_circuit_2 = cirq.Circuit()
clifford_circuit_2.append(
[cirq.X(q0),
cirq.CNOT(q1, q0),
cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_2 = convert_to_ion_gates.convert_circuit(clifford_circuit_2)
ion_circuit_2_using_device = ion_device.decompose_circuit(
clifford_circuit_2)
ion_device.validate_circuit(ion_circuit_2)
ion_device.validate_circuit(ion_circuit_2_using_device)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_2, ion_circuit_2, atol=1e-6)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_2, ion_circuit_2_using_device, atol=1e-6)
def test_include():
q0 = cirq.NamedQubit('q0')
q1 = cirq.NamedQubit('q1')
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
schedule = cirq.Schedule(device=UNCONSTRAINED_DEVICE)
op0 = cirq.ScheduledOperation(zero, ps, cirq.H(q0))
schedule.include(op0)
with pytest.raises(ValueError):
schedule.include(cirq.ScheduledOperation(zero, ps, cirq.H(q0)))
with pytest.raises(ValueError):
schedule.include(
cirq.ScheduledOperation(zero + 0.5 * ps, ps, cirq.H(q0)))
op1 = cirq.ScheduledOperation(zero + 2 * ps, ps, cirq.H(q0))
schedule.include(op1)
op2 = cirq.ScheduledOperation(zero + 0.5 * ps, ps, cirq.H(q1))
schedule.include(op2)
assert schedule.query(time=zero, duration=ps * 10) == [op0, op2, op1]
def test_include():
q0 = cirq.QubitId()
q1 = cirq.QubitId()
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
schedule = cirq.Schedule(device=UnconstrainedDevice)
op0 = cirq.ScheduledOperation(zero, ps, cirq.H(q0))
schedule.include(op0)
with pytest.raises(ValueError):
schedule.include(cirq.ScheduledOperation(zero, ps, cirq.H(q0)))
with pytest.raises(ValueError):
schedule.include(
cirq.ScheduledOperation(zero + 0.5 * ps, ps, cirq.H(q0)))
op1 = cirq.ScheduledOperation(zero + 2 * ps, ps, cirq.H(q0))
schedule.include(op1)
op2 = cirq.ScheduledOperation(zero + 0.5 * ps, ps, cirq.H(q1))
schedule.include(op2)
assert schedule.query(time=zero, duration=ps * 10) == [op0, op2, op1]
def test_to_proto():
device_info, expected_spec = _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,
}
spec = 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,
)
assert text_format.MessageToString(spec) == text_format.MessageToString(
expected_spec)
def test_prepare_characterization_for_moments(options_cls):
options, cls = options_cls
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[SQRT_ISWAP_GATE.on(a, b),
SQRT_ISWAP_GATE.on(c, d)],
[SQRT_ISWAP_GATE.on(b, c)],
[cirq.WaitGate(duration=cirq.Duration(micros=5.0)).on(b)],
])
circuit_with_calibration, requests = workflow.prepare_characterization_for_moments(
circuit, options=options)
assert requests == [
cls(pairs=((a, b), (c, d)), gate=SQRT_ISWAP_GATE, options=options),
cls(pairs=((b, c), ), gate=SQRT_ISWAP_GATE, options=options),
]
assert circuit_with_calibration.circuit == circuit
assert circuit_with_calibration.moment_to_calibration == [None, 0, 1, None]
def test_convert_to_ion_circuit():
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
us = cirq.Duration(nanos=1000)
ion_device = cirq.IonDevice(us, us, us, [q0, q1])
clifford_circuit_1 = cirq.Circuit()
clifford_circuit_1.append([cirq.X(q0), cirq.H(q1), cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_1 = cirq.ion.ConvertToIonGates().convert_circuit(clifford_circuit_1)
ion_device.validate_circuit(ion_circuit_1)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_1, ion_circuit_1, atol=1e-6
)
clifford_circuit_2 = cirq.Circuit()
clifford_circuit_2.append([cirq.X(q0), cirq.CNOT(q1, q0), cirq.ms(np.pi / 4).on(q0, q1)])
ion_circuit_2 = cirq.ion.ConvertToIonGates().convert_circuit(clifford_circuit_2)
ion_device.validate_circuit(ion_circuit_2)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
clifford_circuit_2, ion_circuit_2, atol=1e-6
)
def test_slice_operations():
q0 = cirq.QubitId()
q1 = cirq.QubitId()
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op1 = cirq.ScheduledOperation(zero, ps, cirq.H(q0))
op2 = cirq.ScheduledOperation(zero + 2 * ps, 2 * ps, cirq.CZ(q0, q1))
op3 = cirq.ScheduledOperation(zero + 10 * ps, ps, cirq.H(q1))
schedule = cirq.Schedule(device=UnconstrainedDevice,
scheduled_operations=[op1, op2, op3])
assert schedule[zero] == [op1]
assert schedule[zero + ps * 0.5] == [op1]
assert schedule[zero:zero] == []
assert schedule[zero + ps * 0.5:zero + ps * 0.5] == [op1]
assert schedule[zero:zero + ps] == [op1]
assert schedule[zero:zero + 2 * ps] == [op1]
assert schedule[zero:zero + 2.1 * ps] == [op1, op2]
assert schedule[zero:zero + 20 * ps] == [op1, op2, op3]
assert schedule[zero + 2.5 * ps:zero + 20 * ps] == [op2, op3]
assert schedule[zero + 5 * ps:zero + 20 * ps] == [op3]
def test_slice_operations():
q0 = cirq.NamedQubit('q0')
q1 = cirq.NamedQubit('q1')
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op1 = cirq.ScheduledOperation(zero, ps, cirq.H(q0))
op2 = cirq.ScheduledOperation(zero + 2 * ps, 2 * ps, cirq.CZ(q0, q1))
op3 = cirq.ScheduledOperation(zero + 10 * ps, ps, cirq.H(q1))
schedule = cirq.Schedule(device=UNCONSTRAINED_DEVICE,
scheduled_operations=[op1, op2, op3])
assert schedule[zero] == [op1]
assert schedule[zero + ps * 0.5] == [op1]
assert schedule[zero:zero] == []
assert schedule[zero + ps * 0.5:zero + ps * 0.5] == [op1]
assert schedule[zero:zero + ps] == [op1]
assert schedule[zero:zero + 2 * ps] == [op1]
assert schedule[zero:zero + 2.1 * ps] == [op1, op2]
assert schedule[zero:zero + 20 * ps] == [op1, op2, op3]
assert schedule[zero + 2.5 * ps:zero + 20 * ps] == [op2, op3]
assert schedule[zero + 5 * ps:zero + 20 * ps] == [op3]
def test_repr_preserves_type_information():
t = sympy.Symbol('t')
assert repr(cirq.Duration(micros=1500)) == 'cirq.Duration(micros=1500)'
assert repr(cirq.Duration(micros=1500.0)) == 'cirq.Duration(micros=1500.0)'
assert repr(cirq.Duration(millis=1.5)) == 'cirq.Duration(micros=1500.0)'
assert repr(cirq.Duration(micros=1500 * t)) == (
"cirq.Duration(micros=sympy.Mul(sympy.Integer(1500), sympy.Symbol('t')))"
)
assert repr(cirq.Duration(micros=1500.0 * t)) == (
"cirq.Duration(micros=sympy.Mul(sympy.Float('1500.0', precision=53), sympy.Symbol('t')))"
)
assert repr(cirq.Duration(millis=1.5 * t)) == (
"cirq.Duration(micros=sympy.Mul(sympy.Float('1500.0', precision=53), sympy.Symbol('t')))"
)
def test_wait_gate():
gate_set = cg.SerializableGateSet('test', [cgc.WAIT_GATE_SERIALIZER],
[cgc.WAIT_GATE_DESERIALIZER])
proto_dict = {
'gate': {
'id': 'wait'
},
'args': {
'nanos': {
'arg_value': {
'float_value': 20.0
}
}
},
'qubits': [{
'id': '1_2'
}]
}
q = cirq.GridQubit(1, 2)
op = cirq.WaitGate(cirq.Duration(nanos=20)).on(q)
assert gate_set.serialize_op_dict(op) == proto_dict
assert gate_set.deserialize_op_dict(proto_dict) == op
def test_init_timedelta():
from datetime import timedelta
timedelta_duration = timedelta(microseconds=1)
d = cg.XmonDevice(measurement_duration=timedelta_duration,
exp_w_duration=2 * timedelta_duration,
exp_11_duration=3 * timedelta_duration,
qubits=[
cirq.GridQubit(row, col) for col in range(2)
for row in range(2)
])
microsecond = cirq.Duration(nanos=1000)
q00 = cirq.GridQubit(0, 0)
q01 = cirq.GridQubit(0, 1)
q10 = cirq.GridQubit(1, 0)
q11 = cirq.GridQubit(1, 1)
assert d.qubits == {q00, q01, q10, q11}
assert d.duration_of(cirq.Z(q00)) == 0 * microsecond
assert d.duration_of(cirq.measure(q00)) == microsecond
assert d.duration_of(cirq.measure(q00, q01)) == microsecond
assert d.duration_of(cirq.X(q00)) == 2 * microsecond
assert d.duration_of(cirq.CZ(q00, q01)) == 3 * microsecond
