def test_equality():
a = ops.QubitId()
b = ops.QubitId()
c = ops.QubitId()
d = ops.QubitId()
eq = EqualsTester()
# Default is empty. Iterables get frozen into tuples.
eq.add_equality_group(Moment(),
Moment([]), Moment(()))
eq.add_equality_group(
Moment([ops.X(d)]), Moment((ops.X(d),)))
# Equality depends on gate and qubits.
eq.add_equality_group(Moment([ops.X(a)]))
eq.add_equality_group(Moment([ops.X(b)]))
eq.add_equality_group(Moment([ops.Y(a)]))
# Equality depends on order.
eq.add_equality_group(Moment([ops.X(a), ops.X(b)]))
eq.add_equality_group(Moment([ops.X(b), ops.X(a)]))
# Two qubit gates.
eq.make_equality_pair(lambda: Moment([ops.CZ(c, d)]))
eq.make_equality_pair(lambda: Moment([ops.CZ(a, c)]))
eq.make_equality_pair(lambda: Moment([ops.CZ(a, b), ops.CZ(c, d)]))
eq.make_equality_pair(lambda: Moment([ops.CZ(a, c), ops.CZ(b, d)]))
def test_qubits():
a = ops.QubitId()
b = ops.QubitId()
assert Moment([ops.X(a), ops.X(b)]).qubits == {a , b}
assert Moment([ops.X(a)]).qubits == {a}
assert Moment([ops.CZ(a, b)]).qubits == {a, b}
def test_depolarizer_different_gate():
q1 = ops.QubitId()
q2 = ops.QubitId()
cnot = Job(circuits.Circuit([
circuits.Moment([ops.CNOT(q1, q2)]),
]))
allerrors = DepolarizerChannel(
probability=1.0,
depolarizing_gates=[xmon_gates.ExpZGate(),
xmon_gates.ExpWGate()])
p0 = Symbol(DepolarizerChannel._parameter_name + '0')
p1 = Symbol(DepolarizerChannel._parameter_name + '1')
p2 = Symbol(DepolarizerChannel._parameter_name + '2')
p3 = Symbol(DepolarizerChannel._parameter_name + '3')
error_sweep = (Points(p0.name, [1.0]) + Points(p1.name, [1.0]) +
Points(p2.name, [1.0]) + Points(p3.name, [1.0]))
cnot_then_z = Job(
circuits.Circuit([
circuits.Moment([ops.CNOT(q1, q2)]),
circuits.Moment([
xmon_gates.ExpZGate(half_turns=p0).on(q1),
xmon_gates.ExpZGate(half_turns=p1).on(q2)
]),
circuits.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_copy():
a = ops.QubitId()
b = ops.QubitId()
original = Moment([ops.CZ(a, b)])
copy = original.__copy__()
assert original == copy
assert id(original) != id(copy)
def test_controlled_op_to_gates_omits_negligible_global_phase():
qc = ops.QubitId()
qt = ops.QubitId()
operations = decompositions.controlled_op_to_native_gates(
control=qc, target=qt, operation=ops.H.matrix(), tolerance=0.0001)
assert operations == [ops.Y(qt)**-0.25, ops.CZ(qc, qt), ops.Y(qt)**0.25]
def test_operates_on():
a = ops.QubitId()
b = ops.QubitId()
c = ops.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([ops.X(a)]).operates_on([])
assert Moment([ops.X(a)]).operates_on([a])
assert not Moment([ops.X(a)]).operates_on([b])
assert Moment([ops.X(a)]).operates_on([a, b])
# Two-qubit operation case.
assert not Moment([ops.CZ(a, b)]).operates_on([])
assert Moment([ops.CZ(a, b)]).operates_on([a])
assert Moment([ops.CZ(a, b)]).operates_on([b])
assert Moment([ops.CZ(a, b)]).operates_on([a, b])
assert not Moment([ops.CZ(a, b)]).operates_on([c])
assert Moment([ops.CZ(a, b)]).operates_on([a, c])
assert Moment([ops.CZ(a, b)]).operates_on([a, b, c])
# Multiple operations case.
assert not Moment([ops.X(a), ops.X(b)]).operates_on([])
assert Moment([ops.X(a), ops.X(b)]).operates_on([a])
assert Moment([ops.X(a), ops.X(b)]).operates_on([b])
assert Moment([ops.X(a), ops.X(b)]).operates_on([a, b])
assert not Moment([ops.X(a), ops.X(b)]).operates_on([c])
assert Moment([ops.X(a), ops.X(b)]).operates_on([a, c])
assert Moment([ops.X(a), ops.X(b)]).operates_on([a, b, c])
def test_trivial_parity_interaction_corner_case():
q0 = ops.QubitId()
q1 = ops.QubitId()
nearPi4 = np.pi / 4 * 0.99
tolerance = 1e-2
circuit = circuits.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 = ops.QubitId()
qt = ops.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_clears_paired_cnot():
q0 = ops.QubitId()
q1 = ops.QubitId()
assert_optimizes(
before=circuits.Circuit([
circuits.Moment([ops.CNOT(q0, q1)]),
circuits.Moment([ops.CNOT(q0, q1)]),
]),
after=circuits.Circuit())
def test_cnots_separated_by_single_gates_correct():
q0 = ops.QubitId()
q1 = ops.QubitId()
assert_optimization_not_broken(
circuits.Circuit.from_ops(
ops.CNOT(q0, q1),
ops.H(q1),
ops.CNOT(q0, q1),
))
def test_depolarizer_no_errors():
q1 = ops.QubitId()
q2 = ops.QubitId()
cnot = Job(circuits.Circuit([
circuits.Moment([ops.CNOT(q1, q2)]),
]))
noerrors = DepolarizerChannel(probability=0.0)
assert noerrors.transform_job(cnot) == cnot
def test_with_operation():
a = ops.QubitId()
b = ops.QubitId()
assert Moment().with_operation(ops.X(a)) == Moment([ops.X(a)])
assert (Moment([ops.X(a)]).with_operation(ops.X(b)) ==
Moment([ops.X(a), ops.X(b)]))
with pytest.raises(ValueError):
_ = Moment([ops.X(a)]).with_operation(ops.X(a))
def test_ignores_2qubit_target():
m = MergeRotations(0.000001)
q = ops.QubitId()
q2 = ops.QubitId()
c = circuits.Circuit([
circuits.Moment([ops.CZ(q, q2)]),
])
m.optimization_at(c, 0, c.operation_at(q, 0))
assert c == circuits.Circuit([circuits.Moment([ops.CZ(q, q2)])])
def test_drop():
q1 = ops.QubitId()
q2 = ops.QubitId()
assert_optimizes(before=circuits.Circuit([
circuits.Moment(),
circuits.Moment(),
circuits.Moment([ops.CNOT(q1, q2)]),
circuits.Moment(),
]),
after=circuits.Circuit([
circuits.Moment([ops.CNOT(q1, q2)]),
]))
def test_clears_known_empties_even_at_zero_tolerance():
m = circuits.DropNegligible(0.001)
q = ops.QubitId()
q2 = ops.QubitId()
c = circuits.Circuit.from_ops(
ops.Z(q)**0,
ops.Y(q)**0.0000001,
ops.X(q)**-0.0000001,
ops.CZ(q, q2)**0)
m.optimize_circuit(c)
assert c == circuits.Circuit([circuits.Moment()] * 4)
def test_two_to_native_equivalent_and_bounded_for_known_and_random(
max_partial_cz_depth, max_full_cz_depth, effect):
q0 = ops.QubitId()
q1 = ops.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_controlled_op_to_gates_concrete_case():
qc = ops.QubitId()
qt = ops.QubitId()
operations = decompositions.controlled_op_to_native_gates(
control=qc,
target=qt,
operation=np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5),
tolerance=0.0001)
assert operations == [
ops.Y(qt)**-0.5,
ops.CZ(qc, qt)**1.5,
ops.Z(qc)**0.25,
ops.Y(qt)**0.5
]
def test_ignores_czs_separated_by_outer_cz():
q00 = ops.QubitId()
q01 = ops.QubitId()
q10 = ops.QubitId()
assert_optimizes(
before=circuits.Circuit([
circuits.Moment([ops.CZ(q00, q01)]),
circuits.Moment([ops.CZ(q00, q10)]),
circuits.Moment([ops.CZ(q00, q01)]),
]),
after=circuits.Circuit([
circuits.Moment([ops.CZ(q00, q01)]),
circuits.Moment([ops.CZ(q00, q10)]),
circuits.Moment([ops.CZ(q00, q01)]),
]))
def test_query_point_operation_exclusive():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op = ScheduledOperation(zero, Duration(), ops.H(q))
schedule = 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_query_point_operation_inclusive():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op = ScheduledOperation(zero, Duration(), ops.H(q))
schedule = Schedule(device=UnconstrainedDevice, scheduled_operations=[op])
def query(t, d=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_query_overlapping_operations_inclusive():
q = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
op1 = ScheduledOperation(zero, 2 * ps, ops.H(q))
op2 = ScheduledOperation(zero + ps, 2 * ps, ops.H(q))
schedule = Schedule(device=UnconstrainedDevice,
scheduled_operations=[op2, op1])
def query(t, d=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_ignores_czs_separated_by_parameterized():
q0 = ops.QubitId()
q1 = ops.QubitId()
assert_optimizes(
before=circuits.Circuit([
circuits.Moment([ops.CZ(q0, q1)]),
circuits.Moment([ExpZGate(
half_turns=Symbol('boo'))(q0)]),
circuits.Moment([ops.CZ(q0, q1)]),
]),
after=circuits.Circuit([
circuits.Moment([ops.CZ(q0, q1)]),
circuits.Moment([ExpZGate(
half_turns=Symbol('boo'))(q0)]),
circuits.Moment([ops.CZ(q0, q1)]),
]))
def test_without_operations_touching():
a = ops.QubitId()
b = ops.QubitId()
c = ops.QubitId()
# Empty case.
assert Moment().without_operations_touching([]) == Moment()
assert Moment().without_operations_touching([a]) == Moment()
assert Moment().without_operations_touching([a, b]) == Moment()
# One-qubit operation case.
assert (Moment([ops.X(a)]).without_operations_touching([]) ==
Moment([ops.X(a)]))
assert (Moment([ops.X(a)]).without_operations_touching([a]) ==
Moment())
assert (Moment([ops.X(a)]).without_operations_touching([b]) ==
Moment([ops.X(a)]))
# Two-qubit operation case.
assert (Moment([ops.CZ(a, b)]).without_operations_touching([]) ==
Moment([ops.CZ(a, b)]))
assert (Moment([ops.CZ(a, b)]).without_operations_touching([a]) ==
Moment())
assert (Moment([ops.CZ(a, b)]).without_operations_touching([b]) ==
Moment())
assert (Moment([ops.CZ(a, b)]).without_operations_touching([c]) ==
Moment([ops.CZ(a, b)]))
# Multiple operation case.
assert (Moment([ops.CZ(a, b),
ops.X(c)]).without_operations_touching([]) ==
Moment([ops.CZ(a, b), ops.X(c)]))
assert (Moment([ops.CZ(a, b),
ops.X(c)]).without_operations_touching([a]) ==
Moment([ops.X(c)]))
assert (Moment([ops.CZ(a, b),
ops.X(c)]).without_operations_touching([b]) ==
Moment([ops.X(c)]))
assert (Moment([ops.CZ(a, b),
ops.X(c)]).without_operations_touching([c]) ==
Moment([ops.CZ(a, b)]))
assert (Moment([ops.CZ(a, b),
ops.X(c)]).without_operations_touching([a, b]) ==
Moment([ops.X(c)]))
assert (Moment([ops.CZ(a, b),
ops.X(c)]).without_operations_touching([a, c]) ==
Moment())
def test_stopped_at_2qubit():
m = MergeRotations(0.000001)
q = ops.QubitId()
q2 = ops.QubitId()
c = circuits.Circuit([
circuits.Moment([ops.Z(q)]),
circuits.Moment([ops.H(q)]),
circuits.Moment([ops.X(q)]),
circuits.Moment([ops.H(q)]),
circuits.Moment([ops.CZ(q, q2)]),
circuits.Moment([ops.H(q)]),
])
assert (m.optimization_at(c, 0, c.operation_at(
q, 0)) == circuits.PointOptimizationSummary(clear_span=4,
clear_qubits=[q],
new_operations=[]))
def test_leaves_singleton():
m = MergeRotations(0.000001)
q = ops.QubitId()
c = circuits.Circuit([circuits.Moment([ops.X(q)])])
m.optimization_at(c, 0, c.operation_at(q, 0))
assert c == circuits.Circuit([circuits.Moment([ops.X(q)])])
def test_leaves_big():
m = circuits.DropNegligible(0.001)
q = ops.QubitId()
c = circuits.Circuit([circuits.Moment([ops.Z(q)**0.1])])
assert m.optimization_at(c, 0, c.operation_at(q, 0)) is None
d = circuits.Circuit(c.moments)
m.optimize_circuit(d)
assert d == c
def test_include():
q0 = ops.QubitId()
q1 = ops.QubitId()
zero = Timestamp(picos=0)
ps = Duration(picos=1)
schedule = Schedule(device=UnconstrainedDevice)
op0 = ScheduledOperation(zero, ps, ops.H(q0))
schedule.include(op0)
with pytest.raises(ValueError):
schedule.include(ScheduledOperation(zero, ps, ops.H(q0)))
schedule.include(ScheduledOperation(zero + 0.5 * ps, ps, ops.H(q0)))
op1 = ScheduledOperation(zero + 2 * ps, ps, ops.H(q0))
schedule.include(op1)
op2 = ScheduledOperation(zero + 0.5 * ps, ps, ops.H(q1))
schedule.include(op2)
assert schedule.query(time=zero, duration=ps * 10) == [op0, op2, op1]
def test_removes_identity_sequence():
q = ops.QubitId()
assert_optimizes(before=circuits.Circuit([
circuits.Moment([ops.Z(q)]),
circuits.Moment([ops.H(q)]),
circuits.Moment([ops.X(q)]),
circuits.Moment([ops.H(q)]),
]),
after=circuits.Circuit())
def test_inefficient_circuit_correct():
t = 0.1
v = 0.11
q0 = ops.QubitId()
q1 = ops.QubitId()
assert_optimization_not_broken(
circuits.Circuit.from_ops(
ops.H(q1),
ops.CNOT(q0, q1),
ops.H(q1),
ops.CNOT(q0, q1),
ops.CNOT(q1, q0),
ops.H(q0),
ops.CNOT(q0, q1),
ops.Z(q0)**t, ops.Z(q1)**-t,
ops.CNOT(q0, q1),
ops.H(q0), ops.Z(q1)**v,
ops.CNOT(q0, q1),
ops.Z(q0)**-v, ops.Z(q1)**-v,
))
def test_validation():
a = ops.QubitId()
b = ops.QubitId()
c = ops.QubitId()
d = ops.QubitId()
_ = Moment([])
_ = Moment([ops.X(a)])
_ = Moment([ops.CZ(a, b)])
_ = Moment([ops.CZ(b, d)])
_ = Moment([ops.CZ(a, b), ops.CZ(c, d)])
_ = Moment([ops.CZ(a, c), ops.CZ(b, d)])
_ = Moment([ops.CZ(a, c), ops.X(b)])
with pytest.raises(ValueError):
_ = Moment([ops.X(a), ops.X(a)])
with pytest.raises(ValueError):
_ = Moment([ops.CZ(a, c), ops.X(c)])
with pytest.raises(ValueError):
_ = Moment([ops.CZ(a, c), ops.CZ(c, d)])
