def test_copy():
a = cirq.QubitId()
b = cirq.QubitId()
original = Moment([cirq.CZ(a, b)])
copy = original.__copy__()
assert original == copy
assert id(original) != id(copy)
def test_depolarizer_different_gate():
q1 = cirq.QubitId()
q2 = cirq.QubitId()
cnot = Job(cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
]))
allerrors = DepolarizerChannel(probability=1.0, depolarizing_gates=
[xmon_gates.ExpZGate(),
xmon_gates.ExpWGate()])
p0 = cirq.Symbol(DepolarizerChannel._parameter_name + '0')
p1 = cirq.Symbol(DepolarizerChannel._parameter_name + '1')
p2 = cirq.Symbol(DepolarizerChannel._parameter_name + '2')
p3 = cirq.Symbol(DepolarizerChannel._parameter_name + '3')
error_sweep = (cirq.Points(p0.name, [1.0]) + cirq.Points(p1.name, [1.0])
+ cirq.Points(p2.name, [1.0]) + cirq.Points(p3.name, [1.0]))
cnot_then_z = Job(
cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
cirq.Moment([xmon_gates.ExpZGate(half_turns=p0).on(q1),
xmon_gates.ExpZGate(half_turns=p1).on(q2)]),
cirq.Moment([xmon_gates.ExpWGate(half_turns=p2).on(q1),
xmon_gates.ExpWGate(half_turns=p3).on(q2)])
]),
cnot.sweep * error_sweep)
assert allerrors.transform_job(cnot) == cnot_then_z
def test_equality():
a = cirq.QubitId()
b = cirq.QubitId()
eq = cirq.testing.EqualsTester()
# Default is empty. Iterables get listed.
eq.add_equality_group(Circuit(), Circuit([]), Circuit(()))
eq.add_equality_group(Circuit([Moment()]), Circuit((Moment(), )))
# Equality depends on structure and contents.
eq.add_equality_group(Circuit([Moment([cirq.X(a)])]))
eq.add_equality_group(Circuit([Moment([cirq.X(b)])]))
eq.add_equality_group(Circuit([Moment([cirq.X(a)]), Moment([cirq.X(b)])]))
eq.add_equality_group(Circuit([Moment([cirq.X(a), cirq.X(b)])]))
# Big case.
eq.add_equality_group(
Circuit([
Moment([cirq.H(a), cirq.H(b)]),
Moment([cirq.CZ(a, b)]),
Moment([cirq.H(b)]),
]))
eq.add_equality_group(
Circuit([
Moment([cirq.H(a)]),
Moment([cirq.CNOT(a, b)]),
]))
def test_insert_inline_near_start():
a = cirq.QubitId()
b = cirq.QubitId()
c = Circuit([
Moment(),
Moment(),
])
c.insert(1, cirq.X(a), strategy=InsertStrategy.INLINE)
assert c == Circuit([
Moment([cirq.X(a)]),
Moment(),
])
c.insert(1, cirq.Y(a), strategy=InsertStrategy.INLINE)
assert c == Circuit([
Moment([cirq.X(a)]),
Moment([cirq.Y(a)]),
Moment(),
])
c.insert(0, cirq.Z(b), strategy=InsertStrategy.INLINE)
assert c == Circuit([
Moment([cirq.Z(b)]),
Moment([cirq.X(a)]),
Moment([cirq.Y(a)]),
Moment(),
])
def test_operation_eq():
g1 = cirq.Gate()
g2 = cirq.Gate()
r1 = [cirq.QubitId()]
r2 = [cirq.QubitId()]
r12 = r1 + r2
r21 = r2 + r1
eq = cirq.testing.EqualsTester()
eq.make_equality_pair(lambda: cirq.Operation(g1, r1))
eq.make_equality_pair(lambda: cirq.Operation(g2, r1))
eq.make_equality_pair(lambda: cirq.Operation(g1, r2))
eq.make_equality_pair(lambda: cirq.Operation(g1, r12))
eq.make_equality_pair(lambda: cirq.Operation(g1, r21))
eq.add_equality_group(cirq.Operation(cirq.CZ, r21),
cirq.Operation(cirq.CZ, r12))
# Interchangeable subsets.
class PairGate(cirq.Gate, cirq.InterchangeableQubitsGate):
def qubit_index_to_equivalence_group_key(self, index: int):
return index // 2
p = PairGate()
a0, a1, b0, b1, c0 = cirq.LineQubit.range(5)
eq.add_equality_group(p(a0, a1, b0, b1), p(a1, a0, b1, b0))
eq.add_equality_group(p(b0, b1, a0, a1))
eq.add_equality_group(p(a0, a1, b0, b1, c0), p(a1, a0, b1, b0, c0))
eq.add_equality_group(p(a0, b0, a1, b1, c0))
eq.add_equality_group(p(a0, c0, b0, b1, a1))
eq.add_equality_group(p(b0, a1, a0, b1, c0))
def test_append_strategies():
a = cirq.QubitId()
b = cirq.QubitId()
stream = [cirq.X(a), cirq.CZ(a, b), cirq.X(b), cirq.X(b), cirq.X(a)]
c = Circuit()
c.append(stream, InsertStrategy.NEW)
assert c == Circuit([
Moment([cirq.X(a)]),
Moment([cirq.CZ(a, b)]),
Moment([cirq.X(b)]),
Moment([cirq.X(b)]),
Moment([cirq.X(a)]),
])
c = Circuit()
c.append(stream, InsertStrategy.INLINE)
assert c == Circuit([
Moment([cirq.X(a)]),
Moment([cirq.CZ(a, b)]),
Moment([cirq.X(b)]),
Moment([cirq.X(b), cirq.X(a)]),
])
c = Circuit()
c.append(stream, InsertStrategy.EARLIEST)
assert c == Circuit([
Moment([cirq.X(a)]),
Moment([cirq.CZ(a, b)]),
Moment([cirq.X(b), cirq.X(a)]),
Moment([cirq.X(b)]),
])
def test_concatenate():
a = cirq.QubitId()
b = cirq.QubitId()
c = Circuit()
d = Circuit([Moment([cirq.X(b)])])
e = Circuit([Moment([cirq.X(a), cirq.X(b)])])
assert c + d == Circuit([Moment([cirq.X(b)])])
assert d + c == Circuit([Moment([cirq.X(b)])])
assert e + d == Circuit(
[Moment([cirq.X(a), cirq.X(b)]),
Moment([cirq.X(b)])])
d += c
assert d == Circuit([Moment([cirq.X(b)])])
c += d
assert c == Circuit([Moment([cirq.X(b)])])
f = e + d
f += e
assert f == Circuit([
Moment([cirq.X(a), cirq.X(b)]),
Moment([cirq.X(b)]),
Moment([cirq.X(a), cirq.X(b)])
])
with pytest.raises(TypeError):
_ = c + 'a'
with pytest.raises(TypeError):
c += 'a'
def test_controlled_op_to_gates_omits_negligible_global_phase():
qc = cirq.QubitId()
qt = cirq.QubitId()
operations = decompositions.controlled_op_to_native_gates(
control=qc, target=qt, operation=cirq.H.matrix(), tolerance=0.0001)
assert operations == [cirq.Y(qt)**-0.25, cirq.CZ(qc, qt), cirq.Y(qt)**0.25]
def test_operates_on():
a = cirq.QubitId()
b = cirq.QubitId()
c = cirq.QubitId()
# Empty case.
assert not Moment().operates_on([])
assert not Moment().operates_on([a])
assert not Moment().operates_on([b])
assert not Moment().operates_on([a, b])
# One-qubit operation case.
assert not Moment([cirq.X(a)]).operates_on([])
assert Moment([cirq.X(a)]).operates_on([a])
assert not Moment([cirq.X(a)]).operates_on([b])
assert Moment([cirq.X(a)]).operates_on([a, b])
# Two-qubit operation case.
assert not Moment([cirq.CZ(a, b)]).operates_on([])
assert Moment([cirq.CZ(a, b)]).operates_on([a])
assert Moment([cirq.CZ(a, b)]).operates_on([b])
assert Moment([cirq.CZ(a, b)]).operates_on([a, b])
assert not Moment([cirq.CZ(a, b)]).operates_on([c])
assert Moment([cirq.CZ(a, b)]).operates_on([a, c])
assert Moment([cirq.CZ(a, b)]).operates_on([a, b, c])
# Multiple operations case.
assert not Moment([cirq.X(a), cirq.X(b)]).operates_on([])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([b])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, b])
assert not Moment([cirq.X(a), cirq.X(b)]).operates_on([c])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, c])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, b, c])
def test_equality():
a = cirq.QubitId()
b = cirq.QubitId()
c = cirq.QubitId()
d = cirq.QubitId()
eq = cirq.testing.EqualsTester()
# Default is empty. Iterables get frozen into tuples.
eq.add_equality_group(Moment(), Moment([]), Moment(()))
eq.add_equality_group(Moment([cirq.X(d)]), Moment((cirq.X(d), )))
# Equality depends on gate and qubits.
eq.add_equality_group(Moment([cirq.X(a)]))
eq.add_equality_group(Moment([cirq.X(b)]))
eq.add_equality_group(Moment([cirq.Y(a)]))
# Equality depends on order.
eq.add_equality_group(Moment([cirq.X(a), cirq.X(b)]))
eq.add_equality_group(Moment([cirq.X(b), cirq.X(a)]))
# Two qubit gates.
eq.make_equality_group(lambda: Moment([cirq.CZ(c, d)]))
eq.make_equality_group(lambda: Moment([cirq.CZ(a, c)]))
eq.make_equality_group(lambda: Moment([cirq.CZ(a, b), cirq.CZ(c, d)]))
eq.make_equality_group(lambda: Moment([cirq.CZ(a, c), cirq.CZ(b, d)]))
def test_qubits():
a = cirq.QubitId()
b = cirq.QubitId()
assert Moment([cirq.X(a), cirq.X(b)]).qubits == {a, b}
assert Moment([cirq.X(a)]).qubits == {a}
assert Moment([cirq.CZ(a, b)]).qubits == {a, b}
def test_trivial_parity_interaction_corner_case():
q0 = cirq.QubitId()
q1 = cirq.QubitId()
nearPi4 = np.pi / 4 * 0.99
tolerance = 1e-2
circuit = cirq.Circuit.from_ops(
decompositions._parity_interaction(q0, q1, -nearPi4, tolerance))
assert len(circuit) == 2
def test_controlled_op_to_gates_equivalent_on_known_and_random(mat):
qc = cirq.QubitId()
qt = cirq.QubitId()
operations = decompositions.controlled_op_to_native_gates(
control=qc, target=qt, operation=mat)
actual_effect = _operations_to_matrix(operations, (qc, qt))
intended_effect = linalg.kron_with_controls(linalg.CONTROL_TAG, mat)
assert linalg.allclose_up_to_global_phase(actual_effect, intended_effect)
def test_depolarizer_no_errors():
q1 = cirq.QubitId()
q2 = cirq.QubitId()
cnot = Job(cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
]))
no_errors = DepolarizerChannel(probability=0.0)
assert no_errors.transform_job(cnot) == cnot
def test_controlled_op_to_operations_omits_negligible_global_phase():
qc = cirq.QubitId()
qt = cirq.QubitId()
operations = cirq.controlled_op_to_operations(control=qc,
target=qt,
operation=cirq.unitary(
cirq.H),
tolerance=0.0001)
assert operations == [cirq.Y(qt)**-0.25, cirq.CZ(qc, qt), cirq.Y(qt)**0.25]
def test_ignores_2qubit_target():
m = cirq.google.MergeRotations(0.000001)
q = cirq.QubitId()
q2 = cirq.QubitId()
c = cirq.Circuit([
cirq.Moment([cirq.CZ(q, q2)]),
])
m.optimization_at(c, 0, c.operation_at(q, 0))
assert c == cirq.Circuit([cirq.Moment([cirq.CZ(q, q2)])])
def test_with_operation():
a = cirq.QubitId()
b = cirq.QubitId()
assert Moment().with_operation(cirq.X(a)) == Moment([cirq.X(a)])
assert (Moment([cirq.X(a)]).with_operation(cirq.X(b)) == Moment(
[cirq.X(a), cirq.X(b)]))
with pytest.raises(ValueError):
_ = Moment([cirq.X(a)]).with_operation(cirq.X(a))
def test_ignores_2qubit_target():
m = cirq.MergeSingleQubitGates()
q = cirq.QubitId()
q2 = cirq.QubitId()
c = cirq.Circuit([
cirq.Moment([cirq.CZ(q, q2)]),
])
m.optimization_at(c, 0, c.operation_at(q, 0))
assert c == cirq.Circuit([cirq.Moment([cirq.CZ(q, q2)])])
def test_drop():
q1 = cirq.QubitId()
q2 = cirq.QubitId()
assert_optimizes(before=cirq.Circuit([
cirq.Moment(),
cirq.Moment(),
cirq.Moment([cirq.CNOT(q1, q2)]),
cirq.Moment(),
]),
after=cirq.Circuit([
cirq.Moment([cirq.CNOT(q1, q2)]),
]))
def test_clear_operations_touching():
a = cirq.QubitId()
b = cirq.QubitId()
c = Circuit()
c.clear_operations_touching([a, b], range(10))
assert c == Circuit()
c = Circuit([
Moment(),
Moment([cirq.X(a), cirq.X(b)]),
Moment([cirq.X(a)]),
Moment([cirq.X(a)]),
Moment([cirq.CZ(a, b)]),
Moment(),
Moment([cirq.X(b)]),
Moment(),
])
c.clear_operations_touching([a], [1, 3, 4, 6, 7])
assert c == Circuit([
Moment(),
Moment([cirq.X(b)]),
Moment([cirq.X(a)]),
Moment(),
Moment(),
Moment(),
Moment([cirq.X(b)]),
Moment(),
])
c = Circuit([
Moment(),
Moment([cirq.X(a), cirq.X(b)]),
Moment([cirq.X(a)]),
Moment([cirq.X(a)]),
Moment([cirq.CZ(a, b)]),
Moment(),
Moment([cirq.X(b)]),
Moment(),
])
c.clear_operations_touching([a, b], [1, 3, 4, 6, 7])
assert c == Circuit([
Moment(),
Moment(),
Moment([cirq.X(a)]),
Moment(),
Moment(),
Moment(),
Moment(),
Moment(),
])
def test_two_to_native_equivalent_and_bounded_for_known_and_random(
max_partial_cz_depth, max_full_cz_depth, effect):
q0 = cirq.QubitId()
q1 = cirq.QubitId()
operations_with_partial = decompositions.two_qubit_matrix_to_native_gates(
q0, q1, effect, True)
operations_with_full = decompositions.two_qubit_matrix_to_native_gates(
q0, q1, effect, False)
assert_ops_implement_unitary(q0, q1, operations_with_partial, effect)
assert_ops_implement_unitary(q0, q1, operations_with_full, effect)
assert_cz_depth_below(operations_with_partial, max_partial_cz_depth, False)
assert_cz_depth_below(operations_with_full, max_full_cz_depth, True)
def test_query_point_operation_inclusive():
q = cirq.QubitId()
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op = cirq.ScheduledOperation(zero, cirq.Duration(), cirq.H(q))
schedule = cirq.Schedule(device=UnconstrainedDevice,
scheduled_operations=[op])
def query(t, d=cirq.Duration(), qubits=None):
return schedule.query(time=t,
duration=d,
qubits=qubits,
include_query_end_time=True,
include_op_end_times=True)
assert query(zero) == [op]
assert query(zero + ps) == []
assert query(zero - ps) == []
assert query(zero, qubits=[]) == []
assert query(zero, qubits=[q]) == [op]
assert query(zero, ps) == [op]
assert query(zero - 0.5 * ps, ps) == [op]
assert query(zero - ps, ps) == [op]
assert query(zero - 2 * ps, ps) == []
assert query(zero - ps, 3 * ps) == [op]
assert query(zero + ps, ps) == []
def test_multiply():
a = cirq.QubitId()
c = Circuit()
d = Circuit([Moment([cirq.X(a)])])
assert c * 0 == Circuit()
assert d * 0 == Circuit()
assert d * 2 == Circuit([Moment([cirq.X(a)]), Moment([cirq.X(a)])])
assert 1 * c == Circuit()
assert -1 * d == Circuit()
assert 1 * d == Circuit([Moment([cirq.X(a)])])
d *= 3
assert d == Circuit(
[Moment([cirq.X(a)]),
Moment([cirq.X(a)]),
Moment([cirq.X(a)])])
with pytest.raises(TypeError):
_ = c * 'a'
with pytest.raises(TypeError):
_ = 'a' * c
with pytest.raises(TypeError):
c *= 'a'
def test_prev_moment_operating_on_distance():
a = cirq.QubitId()
c = Circuit([
Moment(),
Moment([cirq.X(a)]),
Moment(),
Moment(),
Moment(),
Moment(),
])
assert c.prev_moment_operating_on([a], max_distance=4) is None
assert c.prev_moment_operating_on([a], 6, max_distance=4) is None
assert c.prev_moment_operating_on([a], 5, max_distance=3) is None
assert c.prev_moment_operating_on([a], 4, max_distance=2) is None
assert c.prev_moment_operating_on([a], 3, max_distance=1) is None
assert c.prev_moment_operating_on([a], 2, max_distance=0) is None
assert c.prev_moment_operating_on([a], 1, max_distance=0) is None
assert c.prev_moment_operating_on([a], 0, max_distance=0) is None
assert c.prev_moment_operating_on([a], 6, max_distance=5) == 1
assert c.prev_moment_operating_on([a], 5, max_distance=4) == 1
assert c.prev_moment_operating_on([a], 4, max_distance=3) == 1
assert c.prev_moment_operating_on([a], 3, max_distance=2) == 1
assert c.prev_moment_operating_on([a], 2, max_distance=1) == 1
assert c.prev_moment_operating_on([a], 6, max_distance=10) == 1
assert c.prev_moment_operating_on([a], 6, max_distance=100) == 1
assert c.prev_moment_operating_on([a], 13, max_distance=500) == 1
# Huge max distances should be handled quickly due to capping.
assert c.prev_moment_operating_on([a], 1, max_distance=10**100) is None
def test_query_overlapping_operations_inclusive():
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])
def query(t, d=cirq.Duration(), qubits=None):
return schedule.query(time=t,
duration=d,
qubits=qubits,
include_query_end_time=True,
include_op_end_times=True)
assert query(zero - 0.5 * ps, ps) == [op1]
assert query(zero - 0.5 * ps, 2 * ps) == [op1, op2]
assert query(zero, ps) == [op1, op2]
assert query(zero + 0.5 * ps, ps) == [op1, op2]
assert query(zero + ps, ps) == [op1, op2]
assert query(zero + 1.5 * ps, ps) == [op1, op2]
assert query(zero + 2.0 * ps, ps) == [op1, op2]
assert query(zero + 2.5 * ps, ps) == [op2]
assert query(zero + 3.0 * ps, ps) == [op2]
assert query(zero + 3.5 * ps, ps) == []
def test_query_point_operation_exclusive():
q = cirq.QubitId()
zero = cirq.Timestamp(picos=0)
ps = cirq.Duration(picos=1)
op = cirq.ScheduledOperation(zero, cirq.Duration(), cirq.H(q))
schedule = cirq.Schedule(device=UnconstrainedDevice,
scheduled_operations=[op])
assert schedule.query(time=zero,
include_query_end_time=False,
include_op_end_times=False) == []
assert schedule.query(time=zero + ps,
include_query_end_time=False,
include_op_end_times=False) == []
assert schedule.query(time=zero - ps,
include_query_end_time=False,
include_op_end_times=False) == []
assert schedule.query(time=zero) == []
assert schedule.query(time=zero + ps) == []
assert schedule.query(time=zero - ps) == []
assert schedule.query(time=zero, qubits=[]) == []
assert schedule.query(time=zero, qubits=[q]) == []
assert schedule.query(time=zero, duration=ps) == []
assert schedule.query(time=zero - 0.5 * ps, duration=ps) == [op]
assert schedule.query(time=zero - ps, duration=ps) == []
assert schedule.query(time=zero - 2 * ps, duration=ps) == []
assert schedule.query(time=zero - ps, duration=3 * ps) == [op]
assert schedule.query(time=zero + ps, duration=ps) == []
def test_stopped_at_2qubit():
m = cirq.google.MergeRotations(0.000001)
q = cirq.QubitId()
q2 = cirq.QubitId()
c = cirq.Circuit([
cirq.Moment([cirq.Z(q)]),
cirq.Moment([cirq.H(q)]),
cirq.Moment([cirq.X(q)]),
cirq.Moment([cirq.H(q)]),
cirq.Moment([cirq.CZ(q, q2)]),
cirq.Moment([cirq.H(q)]),
])
assert (m.optimization_at(c, 0, c.operation_at(
q, 0)) == cirq.PointOptimizationSummary(clear_span=4,
clear_qubits=[q],
new_operations=[]))
def test_leaves_singleton():
m = cirq.google.MergeRotations(0.000001)
q = cirq.QubitId()
c = cirq.Circuit([cirq.Moment([cirq.X(q)])])
m.optimization_at(c, 0, c.operation_at(q, 0))
assert c == cirq.Circuit([cirq.Moment([cirq.X(q)])])
def test_container_methods():
a = cirq.QubitId()
b = cirq.QubitId()
c = Circuit([
Moment([cirq.H(a), cirq.H(b)]),
Moment([cirq.CZ(a, b)]),
Moment([cirq.H(b)]),
])
assert list(c) == list(c.moments)
# __iter__
assert list(iter(c)) == list(c.moments)
# __reversed__ for free.
assert list(reversed(c)) == list(reversed(c.moments))
# __contains__ for free.
assert Moment([cirq.H(b)]) in c
assert len(c) == 3
def test_leaves_singleton():
m = cirq.MergeSingleQubitGates()
q = cirq.QubitId()
c = cirq.Circuit([cirq.Moment([cirq.X(q)])])
m.optimization_at(c, 0, c.operation_at(q, 0))
assert c == cirq.Circuit([cirq.Moment([cirq.X(q)])])
