def test_init_2(self):
"""test '__new__' (gene_num < qubit_num)
"""
sb = Stabilizer(gene_num=2, qubit_num=3)
actual = sb.get_str()
expect = " III\n III\n"
self.assertEqual(actual, expect)
def test_init_4(self):
"""test '__new__' (seed)
"""
sb = Stabilizer(gene_num=3, qubit_num=3, seed=123)
actual = sb.get_str()
expect = " III\n III\n III\n"
self.assertEqual(actual, expect)
def test_reset_1(self):
"""test 'reset'
"""
sb = Stabilizer(gene_num=4, qubit_num=3)
sb.set_all('Y').reset()
actual = sb.get_str()
expect = " III\n III\n III\n III\n"
self.assertEqual(actual, expect)
def test_set_pauli_fac_2(self):
"""test 'set_pauli_fac'
"""
sb = Stabilizer(gene_num=3, qubit_num=4)
sb.set_all('Z').set_pauli_op(1, 0, 'Y').set_pauli_op(1, 2, 'Y')
actual = sb.set_pauli_fac(1, '-i').get_str()
expect = " ZIII\n-iYZYI\n IIZI\n"
self.assertEqual(actual, expect)
def test_set_all_6(self):
"""test 'set_all' (gene_num = qubit_num, 'I')
"""
sb = Stabilizer(qubit_num=3)
sb.set_all('I')
actual = sb.get_str()
expect = " III\n III\n III\n"
self.assertEqual(actual, expect)
def test_set_all_3(self):
"""test 'set_all' (gene_num > qubit_num, 'X')
"""
sb = Stabilizer(gene_num=3, qubit_num=2)
sb.set_all('X')
actual = sb.get_str()
expect = " XI\n IX\n II\n"
self.assertEqual(actual, expect)
def test_inheritance_2(self):
"""test 'inheritance_2'
"""
sb_expect = Stabilizer(qubit_num=2).set_all('Z')
sb_expect.h(0).cx(0, 1).x(0)
sb_actual = MyStabilizer(qubit_num=2).set_all('Z').clone()
sb_actual.bell(0, 1).x(0)
str_expect = sb_expect.get_str()
str_actual = sb_actual.get_str()
self.assertEqual(str_expect, str_actual)
def test_init_pp(self):
"""test '__new__' (seed)
"""
gene_str_list = [
"IIIXXXX", "IXXIIXX", "XIXIXIX", "IIIZZZZ", "IZZIIZZ", "ZIZIZIZ"
]
gene_list = [
PauliProduct(pauli_str=gene_str, qid=[0, 2, 4, 6, 8, 7, 5])
for gene_str in gene_str_list
]
sb = Stabilizer(pp_list=gene_list)
actual = sb.get_str()
expect = " IIIIIXXXX\n IIXIXXIXI\n XIIIXXIIX\n IIIIIZZZZ\n IIZIZZIZI\n ZIIIZZIIZ\n"
self.assertEqual(actual, expect)
def test_get_pauli_fac_2(self):
"""test 'get_pauli_fac'
"""
sb = Stabilizer(gene_num=3, qubit_num=4)
sb.set_all('Y').set_pauli_op(1, 2, 'Y')
sb.set_pauli_fac(1, '-i')
actual = sb.get_pauli_fac(1)
expect = -1j
self.assertEqual(actual, expect)
def test_cx_15(self):
"""test 'CX' (input:ZY)
"""
sb = Stabilizer(gene_num=1, qubit_num=2)
sb.set_pauli_op(0, 0, 'Z').set_pauli_op(0, 1, 'Y')
sb.cx(0, 1)
actual = sb.get_str()
expect = " IY\n"
self.assertEqual(actual, expect)
def test_cy_16(self):
"""test 'CY' (input:ZZ)
"""
sb = Stabilizer(gene_num=1, qubit_num=2)
sb.set_pauli_op(0, 0, 'Z').set_pauli_op(0, 1, 'Z')
sb.cy(0, 1)
actual = sb.get_str()
expect = " IZ\n"
self.assertEqual(actual, expect)
def test_s_dg_4(self):
"""test 'S+' (input:I)
"""
sb = Stabilizer(gene_num=1, qubit_num=1)
sb.set_pauli_op(0, 0, 'I')
sb.s_dg(0)
actual = sb.get_str()
expect = " I\n"
self.assertEqual(actual, expect)
def test_z_1(self):
"""test 'Z' (input:X)
"""
sb = Stabilizer(gene_num=1, qubit_num=1)
sb.set_pauli_op(0, 0, 'X')
sb.z(0)
actual = sb.get_str()
expect = " -X\n"
self.assertEqual(actual, expect)
def test_s_3(self):
"""test 'S' (input:Z)
"""
sb = Stabilizer(gene_num=1, qubit_num=1)
sb.set_pauli_op(0, 0, 'Z')
sb.s(0)
actual = sb.get_str()
expect = " Z\n"
self.assertEqual(actual, expect)
def test_h_2(self):
"""test 'H' (input:Y)
"""
sb = Stabilizer(gene_num=1, qubit_num=1)
sb.set_pauli_op(0, 0, 'Y')
sb.h(0)
actual = sb.get_str()
expect = " -Y\n"
self.assertEqual(actual, expect)
def test_cz_13(self):
"""test 'CZ' (input:YZ)
"""
sb = Stabilizer(gene_num=1, qubit_num=2)
sb.set_pauli_op(0, 0, 'Y').set_pauli_op(0, 1, 'Z')
sb.cz(0, 1)
actual = sb.get_str()
expect = " YI\n"
self.assertEqual(actual, expect)
def test_my_1(self):
"""test 'my'
"""
sb = Stabilizer(gene_num=2, qubit_num=2)
sb.set_all('Z')
sb.h(0).cx(0, 1)
md = sb.my(qid=[0, 1], shots=10)
frq = md.frequency
lst = md.last
ans = ((lst == '01' or lst == '10') and (frq['01'] + frq['10'] == 10))
self.assertEqual(ans, True)
def test_mx_2(self):
"""test 'mx'
"""
sb = Stabilizer(gene_num=3, qubit_num=3)
sb.set_all('Z')
sb.h(0).cx(0, 1).cx(0, 2)
md = sb.mx(qid=[0, 1, 2], shots=10)
frq = md.frequency
lst = md.last
ans = ((lst == '000' or lst == '011' or lst == '101' or lst == '110')
and (frq['000'] + frq['011'] + frq['101'] + frq['110'] == 10))
self.assertEqual(ans, True)
def test_reset_1(self):
"""test 'clone'
"""
sb = Stabilizer(gene_num=4, qubit_num=3)
sb.set_all('Y')
sb_clone = sb.clone()
actual = sb_clone.get_str()
expect = sb.get_str()
self.assertEqual(actual, expect)
def test_operate_h_z(self):
"""test 'operate' (Z followed by h)
"""
sb_expect = Stabilizer(gene_num=1,
qubit_num=1).set_pauli_op(0, 0, 'Z').h(0).z(0)
expect = sb_expect.get_str()
pp = PauliProduct(pauli_str="Z")
sb_actual = Stabilizer(gene_num=1, qubit_num=1).set_pauli_op(
0, 0, 'Z').h(0).operate(pp=pp)
actual = sb_actual.get_str()
self.assertEqual(actual, expect)
def test_operate_xyz(self):
"""test 'operate' (xyz)
"""
sb_expect = Stabilizer(gene_num=3,
qubit_num=3).set_all('Z').x(2).y(0).z(1)
expect = sb_expect.get_str()
pp = PauliProduct(pauli_str="XYZ", qid=[2, 0, 1])
sb_actual = Stabilizer(gene_num=3,
qubit_num=3).set_all('Z').operate(pp=pp)
actual = sb_actual.get_str()
self.assertEqual(actual, expect)
def test_operate_controlled_xyz(self):
"""test 'operate' (controlled_xyz)
"""
sb_expect = Stabilizer(gene_num=4,
qubit_num=4).set_all('Z').cx(3,
2).cy(3,
0).cz(3, 1)
expect = sb_expect.get_str()
pp = PauliProduct(pauli_str="XYZ", qid=[2, 0, 1])
sb_actual = Stabilizer(gene_num=4,
qubit_num=4).set_all('Z').operate(pp=pp, ctrl=3)
actual = sb_actual.get_str()
self.assertEqual(actual, expect)
def test_set_pauli_op_1(self):
"""test 'set_pauli_op'
"""
sb = Stabilizer(gene_num=4, qubit_num=3)
sb.set_pauli_op(0, 0, 'X').set_pauli_op(0, 1,
'Y').set_pauli_op(0, 2, 'Z')
sb.set_pauli_op(1, 0, 'Y').set_pauli_op(1, 1,
'Z').set_pauli_op(1, 2, 'X')
sb.set_pauli_op(2, 0, 'Z').set_pauli_op(2, 1,
'X').set_pauli_op(2, 2, 'Y')
sb.set_pauli_op(3, 0, 'I').set_pauli_op(3, 1,
'I').set_pauli_op(3, 2, 'I')
actual = sb.get_str()
expect = " XYZ\n YZX\n ZXY\n III\n"
self.assertEqual(actual, expect)
def test_get_pauli_op_2(self):
"""test 'get_pauli_op'
"""
sb = Stabilizer(gene_num=4, qubit_num=3)
sb.set_pauli_op(0, 0, 'X').set_pauli_op(0, 1,
'Y').set_pauli_op(0, 2, 'Z')
sb.set_pauli_op(1, 0, 'Y').set_pauli_op(1, 1,
'Z').set_pauli_op(1, 2, 'X')
sb.set_pauli_op(2, 0, 'Z').set_pauli_op(2, 1,
'X').set_pauli_op(2, 2, 'Y')
sb.set_pauli_op(3, 0, 'I').set_pauli_op(3, 1,
'I').set_pauli_op(3, 2, 'I')
sb.set_pauli_fac(0, '+1').set_pauli_fac(1, '-1')
sb.set_pauli_fac(2, '+i').set_pauli_fac(3, '-i')
actual = sb.get_pauli_op(3, 2)
expect = "I"
self.assertEqual(actual, expect)
def test_measure(self):
"""test 'measure'
"""
sb = Stabilizer(qubit_num=4).set_all('Z').x(1).x(2)
mval = sb.measure(qid=[0, 1, 2, 3])
self.assertEqual(mval, '0110')
mval_1 = sb_tmp.m(qid=chain).last
mval = (str(sum([int(s) for s in list(mval_0)]) % 2) +
str(sum([int(s) for s in list(mval_1)]) % 2))
mval_list.append(mval)
return Counter(mval_list)
if __name__ == '__main__':
lattice_row = 4
lattice_col = 6
lattice = create_lattice(lattice_row, lattice_col)
# make vacuum state
qubit_num = (2 * lattice_row + 1) * (2 * lattice_col + 1)
sb = Stabilizer(qubit_num=qubit_num)
initialize(sb, lattice)
# logical qubit #1
d_pos_A = [2, 1]
d_pos_B = [2, 2]
d_path = [[2, 2], [2, 3], [2, 4]]
create_move_defect_d(sb, d_pos_A, d_pos_B, d_path, lattice)
# logical qubit #0
p_pos_A = [0, 0]
p_pos_B = [0, 1]
# p_path = [[0,1],[0,2]]
p_path = [[0, 1], [0, 2], [1, 2], [2, 2], [3, 2], [3, 3], [3, 4], [3, 5],
[2, 5], [1, 5], [0, 5], [0, 4], [0, 3], [0, 2]]
create_move_defect_p(sb, p_pos_A, p_pos_B, p_path, lattice)
def operate_logical_cnot(lq, shots=5):
# set lattice
lattice_row, lattice_col = 7, 8
lattice = create_lattice(lattice_row, lattice_col)
# make vacuum state
qubit_num = (2 * lattice_row + 1) * (2 * lattice_col + 1)
sb = Stabilizer(qubit_num=qubit_num, gene_num=qubit_num+1)
initialize(sb, lattice)
# set logical qubit #0
p0_pos_A, p0_pos_B = [0,0], [0,1]
p0_path = [[0,1],[0,2]]
move_defect(sb, p0_pos_A, p0_pos_B, p0_path, 'p', lattice, create=True)
if lq[0] == '-': operate_logical_Z(sb, 0, lattice)
# set logical qubit #1
d1_pos_A, d1_pos_B = [2,5], [3,5]
d1_path = [[3,5],[4,5],[5,5]]
move_defect(sb, d1_pos_A, d1_pos_B, d1_path, 'd', lattice, create=True)
# set logical qubit #2
p2_pos_A, p2_pos_B = [0,7], [1,7]
p2_path = [[1,7],[2,7],[3,7]]
move_defect(sb, p2_pos_A, p2_pos_B, p2_path, 'p', lattice, create=True)
# set logical qubit #3
p3_pos_A, p3_pos_B = [6,0], [6,1]
p3_path = [[6,1],[6,2]]
move_defect(sb, p3_pos_A, p3_pos_B, p3_path, 'p', lattice, create=True)
if lq[1] == '-': operate_logical_Z(sb, 3, lattice)
# braid logical qubit #0
p0_pos_A, p0_pos_B = [0,0], [0,2]
p0_path = [[0,2],[1,2],[2,2],[3,2],[3,3],[3,4],[3,5],[3,6],
[2,6],[1,6],[0,6],[0,5],[0,4],[0,3],[0,2]]
move_defect(sb, p0_pos_A, p0_pos_B, p0_path, 'p', lattice)
# braid logical qubit #2
p2_pos_A, p2_pos_B = [0,7], [3,7]
p2_path = [[3,7],[3,6],[3,5],[3,4],[3,3],[4,3],[5,3],
[6,3],[6,4],[6,5],[6,6],[6,7],[5,7],[4,7],[3,7]]
move_defect(sb, p2_pos_A, p2_pos_B, p2_path, 'p', lattice)
# braid and annihilate logical qubit #3
p3_pos_A, p3_pos_B = [6,0], [6,2]
p3_path = [[6,2],[6,3],[6,4],[6,5],[6,6],[5,6],[4,6],[3,6],
[3,5],[3,4],[3,3],[3,2],[4,2],[5,2],[6,2],[6,1]]
mval_p = move_defect(sb, p3_pos_A, p3_pos_B, p3_path, 'p', lattice, annihilate=True)
# braid and annihilate logical qubit #1
d1_pos_A, d1_pos_B = [2,5], [5,5]
d1_path = [[5,5],[4,5],[3,5]]
mval_d = move_defect(sb, d1_pos_A, d1_pos_B, d1_path, 'd', lattice, annihilate=True)
if mval_p == '1':
operate_logical_Z(sb, 0, lattice)
operate_logical_Z(sb, 2, lattice)
# measure logical qubits: #0 and #2
chain_0 = get_chain(get_path([0,0],[0,2]), 'p', lattice)
chain_2 = get_chain(get_path([0,7],[3,7]), 'p', lattice)
freq = measure_logical_X(sb, chain_0, chain_2, shots=shots)
print("Input('{0:}') == [CNOT] ==> {1:}".format(lq, freq))
