def test_hadamard_loop(printFlag=False, parallel=False):
lp = 1 # loop size
ms = 5
me = 5
for n in range(ms, me + 1):
ts = 5.0 # target second
lc = lp # loop counter
ss = 0.0 # sum sec
for l in range(lc):
# print(n)
p = '0' * n
# print(p)
q = Qubit(p)
# print(q)
h = H(0)
for i in range(1, n):
h = H(i) * h
print(h)
executor = CythonExecutor(parallel=parallel)
start = time.time()
r = qapply(h * q, executor=executor)
elapsed_time = time.time() - start
ss += elapsed_time
if printFlag:
print(r)
print("elapsed_time:\t{0},\t{1} [sec]".format(n, elapsed_time))
print("average:\t{0}x{1},\t{2} [sec]".format(n, lc, ss / lc))
assert ss / lc < ts
def test_ex4():
if not mpl:
skip("matplotlib not installed")
else:
from sympy.physics.quantum.circuitplot import CircuitPlot
c = CircuitPlot(SWAP(0,2)*H(0)* CGate((0,),S(1)) *H(1)*CGate((0,),T(2))\
*CGate((1,),S(2))*H(2),3,labels=labeller(3,'j'))
assert c.ngates == 7
assert c.nqubits == 3
assert c.labels == ['j_2', 'j_1', 'j_0']
def test_gate_simp():
"""Test gate_simp."""
e = H(0) * X(1) * H(0)**2 * CNOT(0, 1) * X(1)**3 * X(0) * Z(3)**2 * S(4)**3
assert gate_simp(e) == H(0) * CNOT(0, 1) * S(4) * X(0) * Z(4)
assert gate_simp(X(0) * X(0)) == 1
assert gate_simp(Y(0) * Y(0)) == 1
assert gate_simp(Z(0) * Z(0)) == 1
assert gate_simp(H(0) * H(0)) == 1
assert gate_simp(T(0) * T(0)) == S(0)
assert gate_simp(S(0) * S(0)) == Z(0)
assert gate_simp(Integer(1)) == Integer(1)
assert gate_simp(X(0)**2 + Y(0)**2) == Integer(2)
def test_UGate_OneQubitGate_combo():
v, w, f, g = symbols('v w f g')
uMat1 = ImmutableMatrix([[v, w], [f, g]])
cMat1 = Matrix([[v, w + 1, 0, 0], [f + 1, g, 0, 0], [0, 0, v, w + 1], [0, 0, f + 1, g]])
u1 = X(0) + UGate(0, uMat1)
assert represent(u1, nqubits=2) == cMat1
uMat2 = ImmutableMatrix([[1/sqrt(2), 1/sqrt(2)], [I/sqrt(2), -I/sqrt(2)]])
cMat2_1 = Matrix([[Rational(1,2) + I/2, Rational(1, 2) - I/2], [Rational(1, 2) - I/2, Rational(1, 2) + I/2]])
cMat2_2 = Matrix([[1, 0], [0, I]])
u2 = UGate(0, uMat2)
assert represent(H(0)*u2, nqubits=1) == cMat2_1
assert represent(u2*H(0), nqubits=1) == cMat2_2
def test_is_scalar_sparse_matrix():
np = import_module('numpy')
if not np:
skip("numpy not installed.")
scipy = import_module('scipy', import_kwargs={'fromlist': ['sparse']})
if not scipy:
skip("scipy not installed.")
numqubits = 2
id_only = False
id_gate = (IdentityGate(1), )
assert is_scalar_sparse_matrix(id_gate, numqubits, id_only) is True
x0 = X(0)
xx_circuit = (x0, x0)
assert is_scalar_sparse_matrix(xx_circuit, numqubits, id_only) is True
x1 = X(1)
y1 = Y(1)
xy_circuit = (x1, y1)
assert is_scalar_sparse_matrix(xy_circuit, numqubits, id_only) is False
z1 = Z(1)
xyz_circuit = (x1, y1, z1)
assert is_scalar_sparse_matrix(xyz_circuit, numqubits, id_only) is True
cnot = CNOT(1, 0)
cnot_circuit = (cnot, cnot)
assert is_scalar_sparse_matrix(cnot_circuit, numqubits, id_only) is True
h = H(0)
hh_circuit = (h, h)
assert is_scalar_sparse_matrix(hh_circuit, numqubits, id_only) is True
# NOTE:
# The elements of the sparse matrix for the following circuit
# is actually 1.0000000000000002+0.0j.
h1 = H(1)
xhzh_circuit = (x1, h1, z1, h1)
assert is_scalar_sparse_matrix(xhzh_circuit, numqubits, id_only) is True
id_only = True
assert is_scalar_sparse_matrix(xhzh_circuit, numqubits, id_only) is True
assert is_scalar_sparse_matrix(xyz_circuit, numqubits, id_only) is False
assert is_scalar_sparse_matrix(cnot_circuit, numqubits, id_only) is True
assert is_scalar_sparse_matrix(hh_circuit, numqubits, id_only) is True
def test_is_scalar_nonsparse_matrix():
numqubits = 2
id_only = False
id_gate = (IdentityGate(1), )
actual = is_scalar_nonsparse_matrix(id_gate, numqubits, id_only)
assert actual is True
x0 = X(0)
xx_circuit = (x0, x0)
actual = is_scalar_nonsparse_matrix(xx_circuit, numqubits, id_only)
assert actual is True
x1 = X(1)
y1 = Y(1)
xy_circuit = (x1, y1)
actual = is_scalar_nonsparse_matrix(xy_circuit, numqubits, id_only)
assert actual is False
z1 = Z(1)
xyz_circuit = (x1, y1, z1)
actual = is_scalar_nonsparse_matrix(xyz_circuit, numqubits, id_only)
assert actual is True
cnot = CNOT(1, 0)
cnot_circuit = (cnot, cnot)
actual = is_scalar_nonsparse_matrix(cnot_circuit, numqubits, id_only)
assert actual is True
h = H(0)
hh_circuit = (h, h)
actual = is_scalar_nonsparse_matrix(hh_circuit, numqubits, id_only)
assert actual is True
h1 = H(1)
xhzh_circuit = (x1, h1, z1, h1)
actual = is_scalar_nonsparse_matrix(xhzh_circuit, numqubits, id_only)
assert actual is True
id_only = True
actual = is_scalar_nonsparse_matrix(xhzh_circuit, numqubits, id_only)
assert actual is True
actual = is_scalar_nonsparse_matrix(xyz_circuit, numqubits, id_only)
assert actual is False
actual = is_scalar_nonsparse_matrix(cnot_circuit, numqubits, id_only)
assert actual is True
actual = is_scalar_nonsparse_matrix(hh_circuit, numqubits, id_only)
assert actual is True
def test_qasm_ex1_methodcalls():
q = Qasm()
q.qubit("q_0")
q.qubit("q_1")
q.h("q_0")
q.cnot("q_0", "q_1")
assert q.get_circuit() == CNOT(1, 0) * H(1)
def test_qasm_ex1_methodcalls():
q = Qasm()
q.qubit('q_0')
q.qubit('q_1')
q.h('q_0')
q.cnot('q_0', 'q_1')
assert q.get_circuit() == CNOT(1, 0) * H(1)
def test_random_reduce():
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
cnot = CNOT(1, 0)
cgate_z = CGate((0,), Z(1))
gate_list = [x, y, z]
ids = list(bfs_identity_search(gate_list, 1, max_depth=4))
circuit = (x, y, h, z, cnot)
assert random_reduce(circuit, []) == circuit
assert random_reduce(circuit, ids) == circuit
seq = [2, 11, 9, 3, 5]
circuit = (x, y, z, x, y, h)
assert random_reduce(circuit, ids, seed=seq) == (x, y, h)
circuit = (x, x, y, y, z, z)
assert random_reduce(circuit, ids, seed=seq) == (x, x, y, y)
seq = [14, 13, 0]
assert random_reduce(circuit, ids, seed=seq) == (y, y, z, z)
gate_list = [x, y, z, h, cnot, cgate_z]
ids = list(bfs_identity_search(gate_list, 2, max_depth=4))
seq = [25]
circuit = (x, y, z, y, h, y, h, cgate_z, h, cnot)
expected = (x, y, z, cgate_z, h, cnot)
assert random_reduce(circuit, ids, seed=seq) == expected
circuit = Mul(*circuit)
assert random_reduce(circuit, ids, seed=seq) == expected
def test_random_insert():
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
cnot = CNOT(1, 0)
cgate_z = CGate((0,), Z(1))
choices = [(x, x)]
circuit = (y, y)
loc, choice = 0, 0
actual = random_insert(circuit, choices, seed=[loc, choice])
assert actual == (x, x, y, y)
circuit = (x, y, z, h)
choices = [(h, h), (x, y, z)]
expected = (x, x, y, z, y, z, h)
loc, choice = 1, 1
actual = random_insert(circuit, choices, seed=[loc, choice])
assert actual == expected
gate_list = [x, y, z, h, cnot, cgate_z]
ids = list(bfs_identity_search(gate_list, 2, max_depth=4))
eq_ids = flatten_ids(ids)
circuit = (x, y, h, cnot, cgate_z)
expected = (x, z, x, z, x, y, h, cnot, cgate_z)
loc, choice = 1, 30
actual = random_insert(circuit, eq_ids, seed=[loc, choice])
assert actual == expected
circuit = Mul(*circuit)
actual = random_insert(circuit, eq_ids, seed=[loc, choice])
assert actual == expected
def test_qasm_ex2():
q = Qasm(
"qubit q_0",
"qubit q_1",
"qubit q_2",
"h q_1",
"cnot q_1,q_2",
"cnot q_0,q_1",
"h q_0",
"measure q_1",
"measure q_0",
"c-x q_1,q_2",
"c-z q_0,q_2",
)
assert q.get_circuit() == CGate(2, Z(0)) * CGate(1, X(0)) * Mz(2) * Mz(1) * H(
2
) * CNOT(2, 1) * CNOT(1, 0) * H(1)
def test_find_subcircuit():
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
x1 = X(1)
y1 = Y(1)
i0 = Symbol('i0')
x_i0 = X(i0)
y_i0 = Y(i0)
z_i0 = Z(i0)
h_i0 = H(i0)
circuit = (x, y, z)
assert find_subcircuit(circuit, (x,)) == 0
assert find_subcircuit(circuit, (x1,)) == -1
assert find_subcircuit(circuit, (y,)) == 1
assert find_subcircuit(circuit, (h,)) == -1
assert find_subcircuit(circuit, Mul(x, h)) == -1
assert find_subcircuit(circuit, Mul(x, y, z)) == 0
assert find_subcircuit(circuit, Mul(y, z)) == 1
assert find_subcircuit(Mul(*circuit), (x, y, z, h)) == -1
assert find_subcircuit(Mul(*circuit), (z, y, x)) == -1
assert find_subcircuit(circuit, (x,), start=2, end=1) == -1
circuit = (x, y, x, y, z)
assert find_subcircuit(Mul(*circuit), Mul(x, y, z)) == 2
assert find_subcircuit(circuit, (x,), start=1) == 2
assert find_subcircuit(circuit, (x, y), start=1, end=2) == -1
assert find_subcircuit(Mul(*circuit), (x, y), start=1, end=3) == -1
assert find_subcircuit(circuit, (x, y), start=1, end=4) == 2
assert find_subcircuit(circuit, (x, y), start=2, end=4) == 2
circuit = (x, y, z, x1, x, y, z, h, x, y, x1,
x, y, z, h, y1, h)
assert find_subcircuit(circuit, (x, y, z, h, y1)) == 11
circuit = (x, y, x_i0, y_i0, z_i0, z)
assert find_subcircuit(circuit, (x_i0, y_i0, z_i0)) == 2
circuit = (x_i0, y_i0, z_i0, x_i0, y_i0, h_i0)
subcircuit = (x_i0, y_i0, z_i0)
result = find_subcircuit(circuit, subcircuit)
assert result == 0
def test_qasm_readqasm():
qasm_lines = """\
qubit q_0
qubit q_1
h q_0
cnot q_0,q_1
"""
q = read_qasm(qasm_lines)
assert q.get_circuit() == CNOT(1, 0) * H(1)
def test_gate_sort():
"""Test gate_sort."""
for g in (X, Y, Z, H, S, T):
assert gate_sort(g(2) * g(1) * g(0)) == g(0) * g(1) * g(2)
e = gate_sort(X(1) * H(0)**2 * CNOT(0, 1) * X(1) * X(0))
assert e == H(0)**2 * CNOT(0, 1) * X(0) * X(1)**2
assert gate_sort(Z(0) * X(0)) == -X(0) * Z(0)
assert gate_sort(Z(0) * X(0)**2) == X(0)**2 * Z(0)
assert gate_sort(Y(0) * H(0)) == -H(0) * Y(0)
assert gate_sort(Y(0) * X(0)) == -X(0) * Y(0)
assert gate_sort(Z(0) * Y(0)) == -Y(0) * Z(0)
assert gate_sort(T(0) * S(0)) == S(0) * T(0)
assert gate_sort(Z(0) * S(0)) == S(0) * Z(0)
assert gate_sort(Z(0) * T(0)) == T(0) * Z(0)
assert gate_sort(Z(0) * CNOT(0, 1)) == CNOT(0, 1) * Z(0)
assert gate_sort(S(0) * CNOT(0, 1)) == CNOT(0, 1) * S(0)
assert gate_sort(T(0) * CNOT(0, 1)) == CNOT(0, 1) * T(0)
assert gate_sort(X(1) * CNOT(0, 1)) == CNOT(0, 1) * X(1)
def main():
psi = superposition_basis(2)
psi
# Dense coding demo:
# Assume Alice has the left QBit in psi
print(
"An even superposition of 2 qubits. Assume Alice has the left QBit.")
pprint(psi)
# The corresponding gates applied to Alice's QBit are:
# Identity Gate (1), Not Gate (X), Z Gate (Z), Z Gate and Not Gate (ZX)
# Then there's the controlled not gate (with Alice's as control):CNOT(1, 0)
# And the Hadamard gate applied to Alice's Qbit: H(1)
# To Send Bob the message |0>|0>
print("To Send Bob the message |00>.")
circuit = H(1) * CNOT(1, 0)
result = qapply(circuit * psi)
result
pprint(result)
# To send Bob the message |0>|1>
print("To Send Bob the message |01>.")
circuit = H(1) * CNOT(1, 0) * X(1)
result = qapply(circuit * psi)
result
pprint(result)
# To send Bob the message |1>|0>
print("To Send Bob the message |10>.")
circuit = H(1) * CNOT(1, 0) * Z(1)
result = qapply(circuit * psi)
result
pprint(result)
# To send Bob the message |1>|1>
print("To Send Bob the message |11>.")
circuit = H(1) * CNOT(1, 0) * Z(1) * X(1)
result = qapply(circuit * psi)
result
pprint(result)
def test_ex1():
if not mpl:
skip("matplotlib not installed")
else:
from sympy.physics.quantum.circuitplot import CircuitPlot
c = CircuitPlot(CNOT(1, 0) * H(1), 2, labels=labeller(2))
assert c.ngates == 2
assert c.nqubits == 2
assert c.labels == ['q_1', 'q_0']
def test_random_reduce():
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
cnot = CNOT(1, 0)
cgate_z = CGate((0, ), Z(1))
seed = 1
gate_list = [x, y, z]
ids = list(bfs_identity_search(gate_list, 1, max_depth=4))
circuit = (x, y, h, z, cnot)
assert random_reduce(circuit, []) == circuit
assert random_reduce(circuit, ids) == circuit
circuit = (x, y, z, x, y, h)
# seed = 1, indices to attempt removal: 2, 11, 9, 3
# removed id: y, z, x
actual = random_reduce(circuit, ids, seed=seed)
assert actual == (x, y, h)
circuit = (x, x, y, y, z, z)
# seed = 1, indices to attempt removal: 2, 11, 9
# removed id: y, y
actual = random_reduce(circuit, ids, seed=seed)
assert actual == (x, x, z, z)
seed = 2
# seed = 2, indices: 14, 13, 0
# removed id: z, z
actual = random_reduce(circuit, ids, seed=seed)
assert random_reduce(circuit, ids, seed=seed) == (x, x, y, y)
gate_list = [x, y, z, h, cnot, cgate_z]
ids = list(bfs_identity_search(gate_list, 2, max_depth=4))
circuit = (x, y, z, y, h, y, h, cgate_z, h, cnot)
expected = (x, y, z, y, h, y)
# seed = 2, indices: 30, 29, 1, 2, 23, 19, 17, 7, 14, 13, 12, 3, 8
# 7, 13, 16, 15, 8, 6, 3
# removed id: h, cgate_z, h, cnot
actual = random_reduce(circuit, ids, seed=seed)
assert actual == expected
circuit = Mul(*(x, y, z, y, h, y, h, cgate_z, h, cnot))
expected = (x, y, z, y, h, y)
# seed = 2, indices: 30, 29, 1, 2, 23, 19, 17, 7, 14, 13, 12, 3, 8
# 7, 13, 16, 15, 8, 6, 3
# removed id: h, cgate_z, h, cnot
actual = random_reduce(circuit, ids, seed=seed)
assert actual == expected
def test_replace_subcircuit():
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
cnot = CNOT(1, 0)
cgate_z = CGate((0,), Z(1))
# Standard cases
circuit = (z, y, x, x)
remove = (z, y, x)
assert replace_subcircuit(circuit, Mul(*remove)) == (x,)
assert replace_subcircuit(circuit, remove + (x,)) == ()
assert replace_subcircuit(circuit, remove, pos=1) == circuit
assert replace_subcircuit(circuit, remove, pos=0) == (x,)
assert replace_subcircuit(circuit, (x, x), pos=2) == (z, y)
assert replace_subcircuit(circuit, (h,)) == circuit
circuit = (x, y, x, y, z)
remove = (x, y, z)
assert replace_subcircuit(Mul(*circuit), Mul(*remove)) == (x, y)
remove = (x, y, x, y)
assert replace_subcircuit(circuit, remove) == (z,)
circuit = (x, h, cgate_z, h, cnot)
remove = (x, h, cgate_z)
assert replace_subcircuit(circuit, Mul(*remove), pos=-1) == (h, cnot)
assert replace_subcircuit(circuit, remove, pos=1) == circuit
remove = (h, h)
assert replace_subcircuit(circuit, remove) == circuit
remove = (h, cgate_z, h, cnot)
assert replace_subcircuit(circuit, remove) == (x,)
replace = (h, x)
actual = replace_subcircuit(circuit, remove,
replace=replace)
assert actual == (x, h, x)
circuit = (x, y, h, x, y, z)
remove = (x, y)
replace = (cnot, cgate_z)
actual = replace_subcircuit(circuit, remove,
replace=Mul(*replace))
assert actual == (cnot, cgate_z, h, x, y, z)
actual = replace_subcircuit(circuit, remove,
replace=replace, pos=1)
assert actual == (x, y, h, cnot, cgate_z, z)
def test_random_insert():
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
cnot = CNOT(1, 0)
cgate_z = CGate((0, ), Z(1))
seed = 1
choices = [(x, x)]
circuit = (y, y)
# insert location: 0;
actual = random_insert(circuit, choices, seed=seed)
assert actual == (x, x, y, y)
seed = 8
circuit = (x, y, z, h)
choices = [(h, h), (x, y, z)]
expected = (x, x, y, z, y, z, h)
# insert location: 1; circuit choice: 1
actual = random_insert(circuit, choices, seed=seed)
assert actual == expected
gate_list = [x, y, z, h, cnot, cgate_z]
ids = list(bfs_identity_search(gate_list, 2, max_depth=4))
collapse_eq_ids = lambda acc, an_id: acc + list(an_id.equivalent_ids)
eq_ids = reduce(collapse_eq_ids, ids, [])
circuit = (x, y, h, cnot, cgate_z)
expected = (x, y, z, y, z, y, h, cnot, cgate_z)
# insert location: 1; circuit choice: 30
actual = random_insert(circuit, eq_ids, seed=seed)
assert actual == expected
circuit = Mul(*(x, y, h, cnot, cgate_z))
expected = (x, y, z, y, z, y, h, cnot, cgate_z)
# insert location: 1; circuit choice: 30
actual = random_insert(circuit, eq_ids, seed=seed)
assert actual == expected
def test_kmp_table():
word = ('a', 'b', 'c', 'd', 'a', 'b', 'd')
expected_table = [-1, 0, 0, 0, 0, 1, 2]
assert expected_table == kmp_table(word)
word = ('P', 'A', 'R', 'T', 'I', 'C', 'I', 'P', 'A', 'T', 'E', ' ',
'I', 'N', ' ', 'P', 'A', 'R', 'A', 'C', 'H', 'U', 'T', 'E')
expected_table = [-1, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0,
0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 0]
assert expected_table == kmp_table(word)
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
word = (x, y, y, x, z)
expected_table = [-1, 0, 0, 0, 1]
assert expected_table == kmp_table(word)
word = (x, x, y, h, z)
expected_table = [-1, 0, 1, 0, 0]
assert expected_table == kmp_table(word)
def test_qasm_ex1():
q = Qasm('qubit q0', 'qubit q1', 'h q0', 'cnot q0,q1')
assert q.get_circuit() == CNOT(1, 0) * H(1)
def h(self, arg):
self.circuit.append(H(self.index(arg)))
def test_convert_to_symbolic_indices():
(x, y, z, h) = create_gate_sequence()
i0 = Symbol('i0')
exp_map = {i0: Integer(0)}
actual, act_map, sndx, gen = convert_to_symbolic_indices((x,))
assert actual == (X(i0),)
assert act_map == exp_map
expected = (X(i0), Y(i0), Z(i0), H(i0))
exp_map = {i0: Integer(0)}
actual, act_map, sndx, gen = convert_to_symbolic_indices((x, y, z, h))
assert actual == expected
assert exp_map == act_map
(x1, y1, z1, h1) = create_gate_sequence(1)
i1 = Symbol('i1')
expected = (X(i0), Y(i0), Z(i0), H(i0))
exp_map = {i0: Integer(1)}
actual, act_map, sndx, gen = convert_to_symbolic_indices((x1, y1, z1, h1))
assert actual == expected
assert act_map == exp_map
expected = (X(i0), Y(i0), Z(i0), H(i0), X(i1), Y(i1), Z(i1), H(i1))
exp_map = {i0: Integer(0), i1: Integer(1)}
actual, act_map, sndx, gen = convert_to_symbolic_indices((x, y, z, h,
x1, y1, z1, h1))
assert actual == expected
assert act_map == exp_map
exp_map = {i0: Integer(1), i1: Integer(0)}
actual, act_map, sndx, gen = convert_to_symbolic_indices(Mul(x1, y1,
z1, h1, x, y, z, h))
assert actual == expected
assert act_map == exp_map
expected = (X(i0), X(i1), Y(i0), Y(i1), Z(i0), Z(i1), H(i0), H(i1))
exp_map = {i0: Integer(0), i1: Integer(1)}
actual, act_map, sndx, gen = convert_to_symbolic_indices(Mul(x, x1,
y, y1, z, z1, h, h1))
assert actual == expected
assert act_map == exp_map
exp_map = {i0: Integer(1), i1: Integer(0)}
actual, act_map, sndx, gen = convert_to_symbolic_indices((x1, x, y1, y,
z1, z, h1, h))
assert actual == expected
assert act_map == exp_map
cnot_10 = CNOT(1, 0)
cnot_01 = CNOT(0, 1)
cgate_z_10 = CGate(1, Z(0))
cgate_z_01 = CGate(0, Z(1))
expected = (X(i0), X(i1), Y(i0), Y(i1), Z(i0), Z(i1),
H(i0), H(i1), CNOT(i1, i0), CNOT(i0, i1),
CGate(i1, Z(i0)), CGate(i0, Z(i1)))
exp_map = {i0: Integer(0), i1: Integer(1)}
args = (x, x1, y, y1, z, z1, h, h1, cnot_10, cnot_01,
cgate_z_10, cgate_z_01)
actual, act_map, sndx, gen = convert_to_symbolic_indices(args)
assert actual == expected
assert act_map == exp_map
args = (x1, x, y1, y, z1, z, h1, h, cnot_10, cnot_01,
cgate_z_10, cgate_z_01)
expected = (X(i0), X(i1), Y(i0), Y(i1), Z(i0), Z(i1),
H(i0), H(i1), CNOT(i0, i1), CNOT(i1, i0),
CGate(i0, Z(i1)), CGate(i1, Z(i0)))
exp_map = {i0: Integer(1), i1: Integer(0)}
actual, act_map, sndx, gen = convert_to_symbolic_indices(args)
assert actual == expected
assert act_map == exp_map
args = (cnot_10, h, cgate_z_01, h)
expected = (CNOT(i0, i1), H(i1), CGate(i1, Z(i0)), H(i1))
exp_map = {i0: Integer(1), i1: Integer(0)}
actual, act_map, sndx, gen = convert_to_symbolic_indices(args)
assert actual == expected
assert act_map == exp_map
args = (cnot_01, h1, cgate_z_10, h1)
exp_map = {i0: Integer(0), i1: Integer(1)}
actual, act_map, sndx, gen = convert_to_symbolic_indices(args)
assert actual == expected
assert act_map == exp_map
args = (cnot_10, h1, cgate_z_01, h1)
expected = (CNOT(i0, i1), H(i0), CGate(i1, Z(i0)), H(i0))
exp_map = {i0: Integer(1), i1: Integer(0)}
actual, act_map, sndx, gen = convert_to_symbolic_indices(args)
assert actual == expected
assert act_map == exp_map
i2 = Symbol('i2')
ccgate_z = CGate(0, CGate(1, Z(2)))
ccgate_x = CGate(1, CGate(2, X(0)))
args = (ccgate_z, ccgate_x)
expected = (CGate(i0, CGate(i1, Z(i2))), CGate(i1, CGate(i2, X(i0))))
exp_map = {i0: Integer(0), i1: Integer(1), i2: Integer(2)}
actual, act_map, sndx, gen = convert_to_symbolic_indices(args)
assert actual == expected
assert act_map == exp_map
ndx_map = {i0: Integer(0)}
index_gen = numbered_symbols(prefix='i', start=1)
actual, act_map, sndx, gen = convert_to_symbolic_indices(args,
qubit_map=ndx_map,
start=i0,
gen=index_gen)
assert actual == expected
assert act_map == exp_map
i3 = Symbol('i3')
cgate_x0_c321 = CGate((3, 2, 1), X(0))
exp_map = {i0: Integer(3), i1: Integer(2),
i2: Integer(1), i3: Integer(0)}
expected = (CGate((i0, i1, i2), X(i3)),)
args = (cgate_x0_c321,)
actual, act_map, sndx, gen = convert_to_symbolic_indices(args)
assert actual == expected
assert act_map == exp_map
def get_sym_op(name, qid_tuple, params=None):
""" return the sympy version for the gate
Args:
name (str): gate name
qid_tuple (tuple): the ids of the qubits being operated on
params (list): optional parameter lists, which may be needed by the U gates.
Returns:
object: (the sympy representation of) the gate being applied to the qubits
Raises:
Exception: if an unsupported operation is seen
"""
the_gate = None
if name == 'ID':
the_gate = IdentityGate(*qid_tuple) # de-tuple means unpacking
elif name == 'X':
the_gate = X(*qid_tuple)
elif name == 'Y':
the_gate = Y(*qid_tuple)
elif name == 'Z':
the_gate = Z(*qid_tuple)
elif name == 'H':
the_gate = H(*qid_tuple)
elif name == 'S':
the_gate = S(*qid_tuple)
elif name == 'SDG':
the_gate = SDGGate(*qid_tuple)
elif name == 'T':
the_gate = T(*qid_tuple)
elif name == 'TDG':
the_gate = TDGGate(*qid_tuple)
elif name == 'CX' or name == 'CNOT':
the_gate = CNOT(*qid_tuple)
elif name == 'CY':
the_gate = CGate(qid_tuple[0], Y(qid_tuple[1])) # qid_tuple: control target
elif name == 'CZ':
the_gate = CGate(qid_tuple[0], Z(qid_tuple[1])) # qid_tuple: control target
elif name == 'CCX' or name == 'CCNOT' or name == 'TOFFOLI':
the_gate = CGate((qid_tuple[0], qid_tuple[1]), X(qid_tuple[2]))
if the_gate is not None:
return the_gate
# U gate, CU gate or measure gate handled below
if name.startswith('U') or name.startswith('CU'):
parameters = params
if len(parameters) == 1: # [theta=0, phi=0, lambda]
parameters.insert(0, 0.0)
parameters.insert(0, 0.0)
elif len(parameters) == 2: # [theta=pi/2, phi, lambda]
parameters.insert(0, pi/2)
elif len(parameters) == 3: # [theta, phi, lambda]
pass
else:
raise Exception('U gate must carry 1, 2 or 3 parameters!')
if name.startswith('U'):
ugate = UGateGeneric(*qid_tuple)
u_mat = compute_ugate_matrix(parameters)
ugate.set_target_matrix(u_matrix=u_mat)
return ugate
elif name.startswith('CU'): # additional treatment for CU1, CU2, CU3
ugate = UGateGeneric(*qid_tuple)
u_mat = compute_ugate_matrix(parameters)
ugate.set_target_matrix(u_matrix=u_mat)
return CGate(qid_tuple[0], ugate)
elif name == "MEASURE":
return None
# if the control flow comes here, alarm!
raise Exception('Not supported')
def create_gate_sequence(qubit=0):
gates = (X(qubit), Y(qubit), Z(qubit), H(qubit))
return gates
def test_qasm_prod():
assert prod([1, 2, 3]) == 6
assert prod([H(0), X(1)]) == H(0) * X(1)
def test_qasm_ex2():
q = Qasm('qubit q_0', 'qubit q_1', 'qubit q_2', 'h q_1', 'cnot q_1,q_2',
'cnot q_0,q_1', 'h q_0', 'measure q_1', 'measure q_0',
'c-x q_1,q_2', 'c-z q_0,q_2')
assert q.get_circuit() == CGate(2, Z(0)) * CGate(
1, X(0)) * Mz(2) * Mz(1) * H(2) * CNOT(2, 1) * CNOT(1, 0) * H(1)
def test_kmp_table():
word = ("a", "b", "c", "d", "a", "b", "d")
expected_table = [-1, 0, 0, 0, 0, 1, 2]
assert expected_table == kmp_table(word)
word = (
"P",
"A",
"R",
"T",
"I",
"C",
"I",
"P",
"A",
"T",
"E",
" ",
"I",
"N",
" ",
"P",
"A",
"R",
"A",
"C",
"H",
"U",
"T",
"E",
)
expected_table = [
-1,
0,
0,
0,
0,
0,
0,
0,
1,
2,
0,
0,
0,
0,
0,
0,
1,
2,
3,
0,
0,
0,
0,
0,
]
assert expected_table == kmp_table(word)
x = X(0)
y = Y(0)
z = Z(0)
h = H(0)
word = (x, y, y, x, z)
expected_table = [-1, 0, 0, 0, 1]
assert expected_table == kmp_table(word)
word = (x, x, y, h, z)
expected_table = [-1, 0, 1, 0, 0]
assert expected_table == kmp_table(word)
# In[25]: represent(X(1), nqubits=2) # In[26]: represent(Y(0), nqubits=1) # In[27]: represent(Z(0), nqubits=1) # In[28]: represent(H(0), nqubits=1) # In[29]: represent(S(0), nqubits=1) # In[30]: represent(T(0), nqubits=1) # ## 1量子ゲートの演算 # # 実際にゲートを作用させてみます。そのためにはqapplyというメソッドを利用します。式を定義してから実際に関数を作用させる形を取ります。$\left| 0\right>$に対してXゲートを作用させます。 # In[31]:
def test_dagger():
lhs = Dagger(Qubit(0)) * Dagger(H(0))
rhs = Dagger(Qubit(1)) / sqrt(2) + Dagger(Qubit(0)) / sqrt(2)
assert qapply(lhs, dagger=True) == rhs
