def test_operate_h_y(self):
"""test 'operate' (h-y)
"""
pp = PauliProduct(pauli_str="Y")
qc = QCirc().h(0).operate(pp=pp).measure(qid=[0], cid=[0])
qs = QState(qubit_num=1).h(0).operate(pp=pp)
value = evaluate(qc, qs)
self.assertEqual(value < EPS, True)
def test_operate_controlled_xyz(self):
"""test 'operate' (xyz)
"""
pp = PauliProduct(pauli_str="XYZ", qid=[1, 2, 3])
qc = QCirc().operate(pp=pp, ctrl=0).measure(qid=[0, 1, 2, 3],
cid=[0, 1, 2, 3])
qs = QState(qubit_num=4).operate(pp=pp, ctrl=0)
value = evaluate(qc, qs)
self.assertEqual(value < EPS, True)
def test_operate_x(self):
"""test 'operate' (x)
"""
qs_expect = QStateGpu(qubit_num=1)
qs_actual = QStateGpu(qubit_num=1)
pp = PauliProduct(pauli_str="X")
qs_expect.x(0)
qs_actual.operate(pp=pp)
ans = equal_qstates(qs_expect, qs_actual)
self.assertEqual(ans, True)
def test_operate_controlled_xyz(self):
"""test 'operate' (controlled_xyz)
"""
qs_expect = QStateGpu(qubit_num=4)
qs_actual = QStateGpu(qubit_num=4)
pp = PauliProduct(pauli_str="XYZ", qid=[2, 0, 1])
qs_expect.cx(3, 2).cy(3, 0).cz(3, 1)
qs_actual.operate(pp=pp, ctrl=3)
ans = equal_qstates(qs_expect, qs_actual)
self.assertEqual(ans, True)
def test_operate_h_z(self):
"""test 'operate' (z followed by h)
"""
qs_expect = QStateGpu(qubit_num=1).h(0)
qs_actual = QStateGpu(qubit_num=1).h(0)
pp = PauliProduct(pauli_str="Z")
qs_expect.z(0)
qs_actual.operate(pp=pp)
ans = equal_qstates(qs_expect, qs_actual)
self.assertEqual(ans, True)
def test_operate_xyz(self):
"""test 'operate' (xyz)
"""
qs_expect = QStateGpu(qubit_num=3)
qs_actual = QStateGpu(qubit_num=3)
pp = PauliProduct(pauli_str="XYZ", qid=[2, 0, 1])
qs_expect.x(2).y(0).z(1)
qs_actual.operate(pp=pp)
ans = equal_qstates(qs_expect, qs_actual)
self.assertEqual(ans, True)
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_h_z(self):
"""test 'operate' (Z followed by h)
"""
bk = Backend(product='qlazy', device='stabilizer_simulator')
qc = QCirc().h(0).z(0)
res = bk.run(qcirc=qc, out_state=True)
expect = res.stabilizer.get_str()
pp = PauliProduct(pauli_str="Z")
qc = QCirc().h(0).operate(pp=pp)
res = bk.run(qcirc=qc, out_state=True)
actual = res.stabilizer.get_str()
self.assertEqual(expect, actual)
def test_operate_controlled_xyz(self):
"""test 'operate' (controlled_xyz)
"""
bk = Backend(product='qlazy', device='stabilizer_simulator')
qc = QCirc().cx(3, 2).cy(3, 0).cz(3, 1)
res = bk.run(qcirc=qc, out_state=True)
expect = res.stabilizer.get_str()
pp = PauliProduct(pauli_str="XYZ", qid=[2, 0, 1])
qc = QCirc().operate(pp=pp, ctrl=3)
res = bk.run(qcirc=qc, out_state=True)
actual = res.stabilizer.get_str()
self.assertEqual(expect, actual)
def set_register(self, dat_left, dat_rignt, bnd, anc):
self.__dat = {'left': dat_left, 'right': dat_right}
self.__bnd = bnd
self.__anc = anc
self.__x_stab = {
'left': [
PauliProduct(pauli_str='XXX',
qid=[dat_left[0], dat_left[1], dat_left[2]]),
PauliProduct(pauli_str='XXX',
qid=[dat_left[2], dat_left[3], dat_left[4]])
],
'right': [
PauliProduct(pauli_str='XXX',
qid=[dat_right[0], dat_right[1], dat_right[2]]),
PauliProduct(pauli_str='XXX',
qid=[dat_right[2], dat_right[3], dat_right[4]])
],
'bnd': [
PauliProduct(pauli_str='XXX',
qid=[dat_left[1], dat_right[0], bnd[0]]),
PauliProduct(pauli_str='XXX',
qid=[bnd[0], dat_left[4], dat_right[3]])
]
}
return self
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_operate_xyz(self):
"""test 'operate' (xyz)
"""
bk = Backend(product='qlazy', device='qstate_gpu_simulator')
qc = QCirc().x(2).y(0).z(1)
res = bk.run(qcirc=qc, out_state=True)
expect = res.qstate.amp
pp = PauliProduct(pauli_str="XYZ", qid=[2, 0, 1])
qc = QCirc().operate(pp=pp)
res = bk.run(qcirc=qc, out_state=True)
actual = res.qstate.amp
ans = equal_vectors(actual, expect)
self.assertEqual(ans, True)
def test_operate_h_z(self):
"""test 'operate' (Z followed by h)
"""
bk = Backend(product='qulacs', device='gpu_simulator')
qc = QCirc().h(0).z(0)
res = bk.run(qcirc=qc, out_state=True)
expect = res.qstate.amp
pp = PauliProduct(pauli_str="Z")
qc = QCirc().h(0).operate(pp=pp)
res = bk.run(qcirc=qc, out_state=True)
actual = res.qstate.amp
ans = equal_vectors(actual, expect)
self.assertEqual(ans,True)
def test_operate_controlled_xyz(self):
"""test 'operate' (controlled_xyz)
"""
bk = Backend(product='qulacs', device='gpu_simulator')
qc = QCirc().cx(3,2).cy(3,0).cz(3,1)
res = bk.run(qcirc=qc, out_state=True)
expect = res.qstate.amp
pp = PauliProduct(pauli_str="XYZ", qid=[2,0,1])
qc = QCirc().operate(pp=pp, ctrl=3)
res = bk.run(qcirc=qc, out_state=True)
actual = res.qstate.amp
ans = equal_vectors(actual, expect)
self.assertEqual(ans,True)
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 set_register(self, dat, anc):
self.__dat = dat
self.__anc = anc
self.__x_stab = [PauliProduct(pauli_str='XXX', qid=[dat[0], dat[1], dat[2]]),
PauliProduct(pauli_str='XXX', qid=[dat[2], dat[3], dat[4]])]
self.__z_stab = [PauliProduct(pauli_str='ZZZ', qid=[dat[0], dat[2], dat[3]]),
PauliProduct(pauli_str='ZZZ', qid=[dat[1], dat[2], dat[4]])]
self.__lx = PauliProduct(pauli_str='XX', qid=[dat[0], dat[3]])
self.__lz = PauliProduct(pauli_str='ZZ', qid=[dat[0], dat[1]])
return self
def test_init_X_qid(self):
"""test '__init__' (pauli_str="X", qid=[1])
"""
pp = PauliProduct(pauli_str="X", qid=[1])
ans = equal_list(pp.pauli_list, ['X']) and equal_list(pp.qid, [1])
self.assertEqual(ans, True)
def set_register(self, dat_cnt, dat_int, dat_tar, bnd_cnt, bnd_tar, anc):
self.__dat = {'cnt': dat_cnt, 'int': dat_int, 'tar': dat_tar}
self.__bnd = {'cnt': bnd_cnt, 'tar': bnd_tar}
self.__anc = anc
self.__x_stab = {'cnt': [PauliProduct(pauli_str='XXX', qid=[dat_cnt[0], dat_cnt[1], dat_cnt[2]]),
PauliProduct(pauli_str='XXX', qid=[dat_cnt[2], dat_cnt[3], dat_cnt[4]])],
'int': [PauliProduct(pauli_str='XXX', qid=[dat_int[0], dat_int[1], dat_int[2]]),
PauliProduct(pauli_str='XXX', qid=[dat_int[2], dat_int[3], dat_int[4]])],
'tar': [PauliProduct(pauli_str='XXX', qid=[dat_tar[0], dat_tar[1], dat_tar[2]]),
PauliProduct(pauli_str='XXX', qid=[dat_tar[2], dat_tar[3], dat_tar[4]])],
'bnd_tar': [PauliProduct(pauli_str='XXX', qid=[dat_int[1], dat_tar[0], bnd_tar[0]]),
PauliProduct(pauli_str='XXX', qid=[bnd_tar[0], dat_int[4], dat_tar[3]])]}
self.__z_stab = {'cnt': [PauliProduct(pauli_str='ZZZ', qid=[dat_cnt[0], dat_cnt[2], dat_cnt[3]]),
PauliProduct(pauli_str='ZZZ', qid=[dat_cnt[1], dat_cnt[2], dat_cnt[4]])],
'int': [PauliProduct(pauli_str='ZZZ', qid=[dat_int[0], dat_int[2], dat_int[3]]),
PauliProduct(pauli_str='ZZZ', qid=[dat_int[1], dat_int[2], dat_int[4]])],
'tar': [PauliProduct(pauli_str='ZZZ', qid=[dat_tar[0], dat_tar[2], dat_tar[3]]),
PauliProduct(pauli_str='ZZZ', qid=[dat_tar[1], dat_tar[2], dat_tar[4]])],
'bnd_cnt': [PauliProduct(pauli_str='ZZZ', qid=[dat_cnt[0], bnd_cnt[0], dat_int[3]]),
PauliProduct(pauli_str='ZZZ', qid=[dat_cnt[1], bnd_cnt[0], dat_int[4]])]}
self.__lx = PauliProduct(pauli_str='XXXX', qid=[dat_int[0], dat_int[3], dat_cnt[0], dat_cnt[3]])
self.__lz = PauliProduct(pauli_str='ZZZZ', qid=[dat_int[0], dat_int[1], dat_tar[0], dat_tar[1]])
return self
def test_print(self):
"""test '__str__' (pauli_str="XZZIX", qid=[3,1,4,10,5])
"""
pp = PauliProduct(pauli_str="XZZIX", qid=[3, 1, 4, 10, 5])
self.assertEqual(pp.__str__(), "Z(1) X(3) Z(4) X(5)")
def test_init_I(self):
"""test '__init__' (pauli_str="I")
"""
pp = PauliProduct(pauli_str="I")
ans = equal_list(pp.pauli_list, ['I']) and equal_list(pp.qid, [0])
self.assertEqual(ans, True)