From f6f6ccd08d52713f5c1afe2e1e3402670aeca0dd Mon Sep 17 00:00:00 2001 From: Pete Shadbolt Date: Mon, 25 Jul 2016 01:58:52 +0100 Subject: [PATCH] Still crunching thru tests --- tests/mock.py | 3 +- tests/old/test_graph.py | 77 ---------------- tests/old/test_json.py | 24 ----- tests/old/test_layout.py | 17 ---- tests/old/test_local_complementation.py | 24 ----- tests/old/test_normalize_global_phase.py | 11 --- tests/old/test_nxgraphstate.py | 12 --- tests/test_fancy.py | 36 ++++++++ tests/test_graphstate.py | 108 ++++++++++++++++++++++- tests/test_qi.py | 13 ++- 10 files changed, 153 insertions(+), 172 deletions(-) delete mode 100644 tests/old/test_graph.py delete mode 100644 tests/old/test_json.py delete mode 100644 tests/old/test_layout.py delete mode 100644 tests/old/test_local_complementation.py delete mode 100644 tests/old/test_normalize_global_phase.py delete mode 100644 tests/old/test_nxgraphstate.py create mode 100644 tests/test_fancy.py diff --git a/tests/mock.py b/tests/mock.py index 6bf3dc3..8830b28 100644 --- a/tests/mock.py +++ b/tests/mock.py @@ -97,9 +97,10 @@ def named_node_graph(): g.act_circuit((edge, "cz") for edge in edges) return g + def simple_graph(): """ A simple graph to test with""" - edges = (0, 1), (1, 2), (2, 0), (0, 3), (100, 200) + edges = (0, 1), (1, 2), (2, 0), (0, 3), (100, 200) g = ABPWrapper([0, 1, 2, 3, 100, 200]) g.act_circuit((i, "hadamard") for i in g.node) g.act_circuit((edge, "cz") for edge in edges) diff --git a/tests/old/test_graph.py b/tests/old/test_graph.py deleted file mode 100644 index 1550281..0000000 --- a/tests/old/test_graph.py +++ /dev/null @@ -1,77 +0,0 @@ -from abp import GraphState -from abp import clifford -from demograph import demograph -import time - - -def test_graph_basic(): - """ Test that we can construct graphs, delete edges, whatever """ - g = demograph() - assert set(g.adj[0].keys()) == set([1, 2, 3]) - g.del_edge(0, 1) - assert set(g.adj[0].keys()) == set([2, 3]) - assert g.has_edge(1, 2) - assert not g.has_edge(0, 1) - - -def test_local_complementation(): - """ Test that local complementation works as expected """ - g = demograph() - g.local_complementation(0) - assert g.has_edge(0, 1) - assert g.has_edge(0, 2) - assert not g.has_edge(1, 2) - assert g.has_edge(3, 2) - assert g.has_edge(3, 1) - - # TODO: test VOP conditions - - -def test_remove_vop(): - """ Test that removing VOPs really works """ - g = demograph() - g.remove_vop(0, 1) - assert g.node[0]["vop"] == clifford.by_name["identity"] - g.remove_vop(1, 1) - assert g.node[1]["vop"] == clifford.by_name["identity"] - g.remove_vop(2, 1) - assert g.node[2]["vop"] == clifford.by_name["identity"] - g.remove_vop(0, 1) - assert g.node[0]["vop"] == clifford.by_name["identity"] - - -def test_edgelist(): - """ Test making edgelists """ - g = demograph() - el = g.edgelist() - assert (0, 3) in el - assert (0, 2) in el - assert (100, 200) in el - - -def test_stress(n = int(1e5)): - """ Testing that making a graph of ten thousand qubits takes less than half a second""" - g = GraphState(range(n+1)) - t = time.clock() - for i in xrange(n): - g.add_edge(i, i + 1) - assert time.clock() - t < .5 - - -def test_cz(): - """ Test CZ gate """ - g = GraphState([0, 1]) - g.act_local_rotation(0, clifford.by_name["hadamard"]) - g.act_local_rotation(1, clifford.by_name["hadamard"]) - g.act_local_rotation(1, clifford.by_name["py"]) - assert not g.has_edge(0, 1) - g.act_cz(0, 1) - assert g.has_edge(0, 1) - -def test_stabilizer(): - """ Test that we can generate stabilizers okay """ - g = demograph() - stab = g.to_stabilizer() - #TODO: sux - #assert len(stab.split("\n")) == g.order() - diff --git a/tests/old/test_json.py b/tests/old/test_json.py deleted file mode 100644 index a3ca6a2..0000000 --- a/tests/old/test_json.py +++ /dev/null @@ -1,24 +0,0 @@ -from abp import GraphState, fancy -from abp import clifford -from demograph import demograph -import time -import json - -def test_json_basic(): - """ Test that we can export to JSON """ - g = demograph() - js = g.to_json() - assert "adj" in js - assert "node" in js - e = GraphState() - -def test_tuple_keys(): - """ Test that we can write tuple-ish keys """ - g = fancy.GraphState() - g.add_node("string") - g.add_node((1, 2, 3)) - g.add_edge((1, 2, 3), "string") - print json.dumps(g.to_json(True)) - - - diff --git a/tests/old/test_layout.py b/tests/old/test_layout.py deleted file mode 100644 index 3a9cad5..0000000 --- a/tests/old/test_layout.py +++ /dev/null @@ -1,17 +0,0 @@ -from demograph import demograph - -#TODO - -def _test_nx_convert(): - g = demograph() - n = g.to_networkx() - assert len(g.ngbh) == len(n.edge) - assert len(g.vops) == len(n.node) - -def _test_layout(): - g = demograph() - g.layout() - assert len(g.meta) == len(g.vops) - assert "pos" in g.meta[0] - assert "x" in g.meta[0]["pos"] - diff --git a/tests/old/test_local_complementation.py b/tests/old/test_local_complementation.py deleted file mode 100644 index db0ebce..0000000 --- a/tests/old/test_local_complementation.py +++ /dev/null @@ -1,24 +0,0 @@ -from abp.fancy import GraphState -from abp import qi - -def test_local_comp(): - """ Test that local complementation works okay """ - psi = GraphState() - psi.add_node(0) - psi.add_node(1) - psi.add_node(2) - psi.add_node(3) - - for n in psi.node: - psi.act_hadamard(n) - - psi.act_cz(0, 1) - psi.act_cz(0, 3) - psi.act_cz(1, 3) - psi.act_cz(1, 2) - - before = psi.copy() - psi.local_complementation(1) - assert before.edgelist() != psi.edgelist() - assert before.to_state_vector() == psi.to_state_vector() - diff --git a/tests/old/test_normalize_global_phase.py b/tests/old/test_normalize_global_phase.py deleted file mode 100644 index 7761d15..0000000 --- a/tests/old/test_normalize_global_phase.py +++ /dev/null @@ -1,11 +0,0 @@ -from abp import clifford -from abp import qi -import numpy as np - -def test_normalize_global_phase(): - for i in range(10): - u = qi.pz - phase = np.random.uniform(0, 2*np.pi) - m = np.exp(1j*phase) * u - normalized = qi.normalize_global_phase(m) - assert np.allclose(normalized, u) diff --git a/tests/old/test_nxgraphstate.py b/tests/old/test_nxgraphstate.py deleted file mode 100644 index ab7eb88..0000000 --- a/tests/old/test_nxgraphstate.py +++ /dev/null @@ -1,12 +0,0 @@ -from abp.graphstate import GraphState -from abp.util import xyz -import networkx as nx - -def simple_test(): - g = GraphState() - g.add_node(0, position = xyz(10, 0, 0)) - g.add_node(1, position = xyz(1, 0, 0)) - g.act_hadamard(0) - g.act_hadamard(1) - g.act_cz(0, 1) - diff --git a/tests/test_fancy.py b/tests/test_fancy.py new file mode 100644 index 0000000..a6decb7 --- /dev/null +++ b/tests/test_fancy.py @@ -0,0 +1,36 @@ +import json +import networkx as nx +from abp import GraphState, fancy +from abp import clifford +from abp.util import xyz +from mock import simple_graph + +def test_json_basic(): + """ Test that we can export to JSON """ + g = simple_graph() + js = g.to_json() + assert "adj" in js + assert "node" in js + +def test_tuple_keys(): + """ Test that we can use tuple-ish keys """ + g = fancy.GraphState() + g.add_node("string") + g.add_node((1, 2, 3)) + g.add_edge((1, 2, 3), "string") + json.dumps(g.to_json(True)) + +def networkx_test(): + """ Test that fancy graph states really behave like networkx graphs """ + g = fancy.GraphState() + g.add_node(0, position = xyz(10, 0, 0)) + g.add_node(1, position = xyz(1, 0, 0)) + g.act_hadamard(0) + g.act_hadamard(1) + g.act_cz(0, 1) + g.copy() + + # TODO: more tests here! + + + diff --git a/tests/test_graphstate.py b/tests/test_graphstate.py index 382dc9d..c6abdf2 100644 --- a/tests/test_graphstate.py +++ b/tests/test_graphstate.py @@ -1,7 +1,12 @@ -from abp import GraphState +from abp import GraphState, CircuitModel, clifford from abp import clifford from mock import simple_graph -import time +import random +import numpy as np +from tqdm import tqdm + +REPEATS = 100 +DEPTH = 100 def test_graph_basic(): @@ -51,6 +56,7 @@ def test_edgelist(): def test_stress(n = int(1e5)): """ Testing that making a graph of ten thousand qubits takes less than half a second""" + import time g = GraphState(range(n+1)) t = time.clock() for i in xrange(n): @@ -74,3 +80,101 @@ def test_stabilizer(): stab = g.to_stabilizer() #TODO +def test_local_complementation(): + """ Test that local complementation works okay """ + psi = GraphState() + psi.add_node(0) + psi.add_node(1) + psi.add_node(2) + psi.add_node(3) + + for n in psi.node: + psi.act_hadamard(n) + + psi.act_cz(0, 1) + psi.act_cz(0, 3) + psi.act_cz(1, 3) + psi.act_cz(1, 2) + + old_edges = psi.edgelist() + old_state = psi.to_state_vector() + psi.local_complementation(1) + assert old_edges != psi.edgelist() + assert old_state == psi.to_state_vector() + +def test_single_qubit(): + """ A multi qubit test with Hadamards only""" + for repeat in tqdm(range(REPEATS), desc="Testing against circuit model"): + g = GraphState([0]) + c = CircuitModel(1) + + for i in range(100): + op = np.random.choice(range(24)) + g.act_local_rotation(0, op) + c.act_local_rotation(0, clifford.unitaries[op]) + + assert g.to_state_vector() == c + + +def test_hadamard_only_multiqubit(n=6): + """ A multi qubit test with Hadamards only""" + for repeat in tqdm(range(REPEATS), desc="Testing against circuit model"): + g = GraphState(range(n)) + c = CircuitModel(n) + + for i in range(n): + g.act_hadamard(i) + c.act_hadamard(i) + + assert g.to_state_vector() == c + + for i in range(100): + a, b = np.random.choice(range(n), 2, False) + g.act_cz(a, b) + c.act_cz(a, b) + + assert g.to_state_vector() == c + + +def test_all_multiqubit(n=4): + """ A multi qubit test with arbitrary local rotations """ + g = GraphState(range(n)) + c = CircuitModel(n) + for i in range(10): + qubit = np.random.randint(0, n - 1) + rotation = np.random.randint(0, 24 - 1) + g.act_local_rotation(qubit, rotation) + c.act_local_rotation(qubit, clifford.unitaries[rotation]) + + assert g.to_state_vector() == c + + for repeat in tqdm(range(REPEATS), desc="Testing against circuit model"): + a, b = np.random.choice(range(n), 2, False) + g.act_cz(a, b) + c.act_cz(a, b) + assert np.allclose(np.sum(np.abs(c.state) ** 2), 1) + assert np.allclose( + np.sum(np.abs(g.to_state_vector().state) ** 2), 1) + + assert g.to_state_vector() == c + + assert g.to_state_vector() == c + +def test_all(n=8): + """ A multi qubit test with arbitrary local rotations """ + g = GraphState(range(n)) + c = CircuitModel(n) + for repeat in tqdm(xrange(REPEATS), "Testing against circuit model"): + for step in xrange(DEPTH): + if random.random()>0.5: + qubit = np.random.randint(0, n - 1) + rotation = np.random.randint(0, 24 - 1) + g.act_local_rotation(qubit, rotation) + c.act_local_rotation(qubit, clifford.unitaries[rotation]) + else: + a, b = np.random.choice(range(n), 2, False) + g.act_cz(a, b) + c.act_cz(a, b) + assert g.to_state_vector() == c + + diff --git a/tests/test_qi.py b/tests/test_qi.py index 63b836d..7a28f74 100644 --- a/tests/test_qi.py +++ b/tests/test_qi.py @@ -92,13 +92,9 @@ def test_dumbness(): a = qi.CircuitModel(1) b = qi.CircuitModel(1) assert a == b - a.act_local_rotation(0, qi.px) - assert not (a == b) - a.act_local_rotation(0, qi.px) - assert (a == b) @@ -111,3 +107,12 @@ def test_to_state_vector_single_qubit(): g.act_local_rotation(1, "hadamard") g.act_cz(0, 1) assert np.allclose(g.to_state_vector().state, qi.bond) + +def test_normalize_global_phase(): + """ We should be able to see that two states are equivalent up to a global phase """ + for i in range(10): + u = qi.pz + phase = np.random.uniform(0, 2*np.pi) + m = np.exp(1j*phase) * u + normalized = qi.normalize_global_phase(m) + assert np.allclose(normalized, u)