def test_add():
first_addend = ccgd.UndirectedHypergraph(labelled_edges={('a', 'b'): None})
second_addend = ccgd.UndirectedHypergraph(
labelled_edges={('c', 'b'): None})
graph_sum = first_addend + second_addend
assert sorted(first_addend.vertices) == list('ab')
assert sorted(second_addend.vertices) == list('bc')
assert sorted(graph_sum.vertices) == list('abc')
assert sorted(first_addend.edges) == [frozenset('ab')]
assert sorted(second_addend.edges) == [frozenset('bc')]
assert set(graph_sum.edges) == set(frozenset(e) for e in ('ab', 'bc'))
def test_is_undirected_device_graph():
assert not ccgd.is_undirected_device_graph('abc')
graph = ccgd.UndirectedHypergraph()
assert ccgd.is_undirected_device_graph(graph)
a, b, c, d, e = cirq.LineQubit.range(5)
graph.add_edge((a, b))
assert ccgd.is_undirected_device_graph(graph)
graph.add_edge((b, c), ccgd.UnconstrainedUndirectedGraphDeviceEdge)
assert ccgd.is_undirected_device_graph(graph)
graph.add_edge((d, e), 'abc')
assert not ccgd.is_undirected_device_graph(graph)
graph = ccgd.UndirectedHypergraph(vertices=(0, 1))
assert not ccgd.is_undirected_device_graph(graph)
def test_eq(vertices, edges):
vertices = set(vertices).union(*edges)
graph_initialized = ccgd.UndirectedHypergraph(vertices=vertices,
labelled_edges=edges)
graph_added_parallel = ccgd.UndirectedHypergraph()
graph_added_parallel.add_vertices(vertices)
graph_added_parallel.add_edges(edges)
graph_added_sequential = ccgd.UndirectedHypergraph()
for vertex in vertices:
graph_added_sequential.add_vertex(vertex)
for edge, label in edges.items():
graph_added_sequential.add_edge(edge, label)
assert graph_initialized == graph_added_parallel == graph_added_sequential
def test_hypergraph():
vertices = range(4)
graph = ccgd.UndirectedHypergraph(vertices=vertices)
assert graph.vertices == tuple(vertices)
edges = [(0, 1), (2, 3)]
graph = ccgd.UndirectedHypergraph(
labelled_edges={edge: str(edge)
for edge in edges})
assert graph.vertices == tuple(vertices)
graph.remove_vertex(0)
assert graph.vertices == (1, 2, 3)
assert graph.edges == (frozenset((2, 3)), )
graph.remove_vertices((1, 3))
assert graph.vertices == (2, )
assert graph.edges == ()
def test_qubit_set():
a, b, c, d = cirq.LineQubit.range(4)
device_graph = ccgd.UndirectedHypergraph(labelled_edges={
(a, b): None,
(c, d): None
})
device = ccgd.UndirectedGraphDevice(device_graph=device_graph)
assert device.qubit_set() == {a, b, c, d}
def test_qubit_set_deprecated():
a, b, c, d = cirq.LineQubit.range(4)
device_graph = ccgd.UndirectedHypergraph(labelled_edges={
(a, b): None,
(c, d): None
})
device = ccgd.UndirectedGraphDevice(device_graph=device_graph)
with cirq.testing.assert_deprecated('qubit_set', deadline='v0.15'):
assert device.qubit_set() == {a, b, c, d}
def test_graph_device_copy_and_add():
a, b, c, d, e, f = cirq.LineQubit.range(6)
device_graph = ccgd.UndirectedHypergraph(labelled_edges={(a, b): None, (c, d): None})
crosstalk_graph = ccgd.UndirectedHypergraph(
labelled_edges={(frozenset((a, b)), frozenset((c, d))): None}
)
device = ccgd.UndirectedGraphDevice(device_graph=device_graph, crosstalk_graph=crosstalk_graph)
device_graph_addend = ccgd.UndirectedHypergraph(labelled_edges={(a, b): None, (e, f): None})
crosstalk_graph_addend = ccgd.UndirectedHypergraph(
labelled_edges={(frozenset((a, b)), frozenset((e, f))): None}
)
device_addend = ccgd.UndirectedGraphDevice(
device_graph=device_graph_addend, crosstalk_graph=crosstalk_graph_addend
)
device_sum = device + device_addend
device_copy = device.__copy__()
device_copy += device_addend
assert device != device_copy
assert device_copy == device_sum
def test_qid_pairs_deprecated():
a, b, c, d = cirq.LineQubit.range(4)
device_graph = ccgd.UndirectedHypergraph(labelled_edges={
(a, b): None,
(c, d): None
})
device = ccgd.UndirectedGraphDevice(device_graph=device_graph)
with cirq.testing.assert_deprecated('device.metadata',
deadline='v0.15',
count=1):
assert len(device.qid_pairs()) == 2
def test_is_crosstalk_graph():
a, b, c, d, e, f = cirq.LineQubit.range(6)
assert not ccgd.is_crosstalk_graph('abc')
graph = ccgd.UndirectedHypergraph()
graph.add_vertex('abc')
assert not ccgd.is_crosstalk_graph(graph)
graph = ccgd.UndirectedHypergraph()
graph.add_edge((frozenset((a, b)), frozenset((c, d))), 'abc')
assert not ccgd.is_crosstalk_graph(graph)
graph = ccgd.UndirectedHypergraph()
graph.add_edge((frozenset((a, b)), frozenset((c, d))), None)
graph.add_edge((frozenset((e, f)), frozenset((c, d))), lambda _: None)
assert ccgd.is_crosstalk_graph(graph)
graph = ccgd.UndirectedHypergraph()
graph.add_edge((frozenset((a, b)), frozenset((c, d))), 'abc')
assert not ccgd.is_crosstalk_graph(graph)
graph = ccgd.UndirectedHypergraph()
graph.add_edge((frozenset((a, b)), ), None)
assert not ccgd.is_crosstalk_graph(graph)
graph = ccgd.UndirectedHypergraph()
graph.add_edge((frozenset((0, 1)), frozenset((2, 3))), None)
assert not ccgd.is_crosstalk_graph(graph)
def test_graph_device():
one_qubit_duration = cirq.Duration(picos=10)
two_qubit_duration = cirq.Duration(picos=1)
one_qubit_edge = ccgd.FixedDurationUndirectedGraphDeviceEdge(
one_qubit_duration)
two_qubit_edge = ccgd.FixedDurationUndirectedGraphDeviceEdge(
two_qubit_duration)
empty_device = ccgd.UndirectedGraphDevice()
assert not empty_device.qubits
assert not empty_device.edges
n_qubits = 4
qubits = cirq.LineQubit.range(n_qubits)
edges = {(cirq.LineQubit(i), cirq.LineQubit((i + 1) % n_qubits)):
two_qubit_edge
for i in range(n_qubits)}
edges.update({(cirq.LineQubit(i), ): one_qubit_edge
for i in range(n_qubits)})
device_graph = ccgd.UndirectedHypergraph(labelled_edges=edges)
def not_cnots(first_op, second_op):
if all(
isinstance(op, cirq.GateOperation) and op.gate == cirq.CNOT
for op in (first_op, second_op)):
raise ValueError('Simultaneous CNOTs')
assert ccgd.is_undirected_device_graph(device_graph)
with pytest.raises(TypeError):
ccgd.UndirectedGraphDevice('abc')
constraint_edges = {
(frozenset(cirq.LineQubit.range(2)),
frozenset(cirq.LineQubit.range(2, 4))):
None,
(frozenset(cirq.LineQubit.range(1, 3)),
frozenset((cirq.LineQubit(0), cirq.LineQubit(3)))):
not_cnots
}
crosstalk_graph = ccgd.UndirectedHypergraph(
labelled_edges=constraint_edges)
assert ccgd.is_crosstalk_graph(crosstalk_graph)
with pytest.raises(TypeError):
ccgd.UndirectedGraphDevice(device_graph, crosstalk_graph='abc')
graph_device = ccgd.UndirectedGraphDevice(device_graph)
assert graph_device.crosstalk_graph == ccgd.UndirectedHypergraph()
graph_device = ccgd.UndirectedGraphDevice(device_graph,
crosstalk_graph=crosstalk_graph)
assert sorted(graph_device.edges) == sorted(device_graph.edges)
assert graph_device.qubits == tuple(qubits)
assert graph_device.device_graph == device_graph
assert graph_device.labelled_edges == device_graph.labelled_edges
assert graph_device.duration_of(cirq.X(qubits[2])) == one_qubit_duration
assert (graph_device.duration_of(
cirq.CNOT(*qubits[:2])) == two_qubit_duration)
with pytest.raises(KeyError):
graph_device.duration_of(cirq.CNOT(qubits[0], qubits[2]))
with pytest.raises(ValueError):
graph_device.validate_operation(cirq.CNOT(qubits[0], qubits[2]))
with pytest.raises(AttributeError):
graph_device.validate_operation(list((2, 3)))
moment = cirq.Moment([cirq.CNOT(*qubits[:2]), cirq.CNOT(*qubits[2:])])
with pytest.raises(ValueError):
graph_device.validate_moment(moment)
moment = cirq.Moment(
[cirq.CNOT(qubits[0], qubits[3]),
cirq.CZ(qubits[1], qubits[2])])
graph_device.validate_moment(moment)
moment = cirq.Moment(
[cirq.CNOT(qubits[0], qubits[3]),
cirq.CNOT(qubits[1], qubits[2])])
with pytest.raises(ValueError):
graph_device.validate_moment(moment)
def test_iadd():
graph = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
addend = ccgd.UndirectedHypergraph(labelled_edges={(1, 2): None})
graph += addend
assert set(graph.edges) == set(frozenset(e) for e in ((0, 1), (1, 2)))
assert sorted(graph.vertices) == [0, 1, 2]
def test_copy():
graph_original = ccgd.UndirectedHypergraph(labelled_edges={(0, 1): None})
graph_copy = graph_original.__copy__()
assert graph_copy == graph_original
graph_original.add_edge((1, 2))
assert graph_copy != graph_original
def test_update_edge_label():
edge = frozenset(range(3))
graph = ccgd.UndirectedHypergraph(labelled_edges={edge: 'a'})
assert graph.labelled_edges[edge] == 'a'
graph.add_edge(edge, 'b')
assert graph.labelled_edges[edge] == 'b'
def test_qid_pairs():
a, b, c, d = cirq.LineQubit.range(4)
device_graph = ccgd.UndirectedHypergraph(labelled_edges={(a, b): None, (c, d): None})
device = ccgd.UndirectedGraphDevice(device_graph=device_graph)
assert len(device.qid_pairs()) == 2
