def test_phase_property(self): """Test phase property""" with self.subTest(msg="phase"): phase = np.array([False, True, True, False]) array = np.eye(4, dtype=bool) stab = StabilizerTable(array, phase) self.assertTrue(np.all(stab.phase == phase)) with self.subTest(msg="set phase"): phase = np.array([False, True, True, False]) array = np.eye(4, dtype=bool) stab = StabilizerTable(array) stab.phase = phase self.assertTrue(np.all(stab.phase == phase)) with self.subTest(msg="set phase raises"): phase = np.array([False, True, False]) array = np.eye(4, dtype=bool) stab = StabilizerTable(array) def set_phase_raise(): """Raise exception""" stab.phase = phase self.assertRaises(ValueError, set_phase_raise)
def test_pauli_property(self): """Test pauli property""" with self.subTest(msg='pauli'): phase = np.array([False, True, True, False]) array = np.eye(4, dtype=bool) stab = StabilizerTable(array, phase) pauli = PauliTable(array) self.assertEqual(stab.pauli, pauli) with self.subTest(msg='set pauli'): phase = np.array([False, True, True, False]) array = np.zeros((4, 4), dtype=bool) stab = StabilizerTable(array, phase) pauli = PauliTable(np.eye(4, dtype=bool)) stab.pauli = pauli self.assertTrue(np.all(stab.array == pauli.array)) self.assertTrue(np.all(stab.phase == phase)) with self.subTest(msg='set pauli'): phase = np.array([False, True, True, False]) array = np.zeros((4, 4), dtype=bool) stab = StabilizerTable(array, phase) pauli = PauliTable(np.eye(4, dtype=bool)[1:]) def set_pauli_raise(): """Raise exception""" stab.pauli = pauli self.assertRaises(ValueError, set_pauli_raise)
def test_to_matrix_5q_sparse(self): """Test 5-qubit to_matrix method w/ sparse=True.""" labels = ['-XXXYY', 'IXIZY', '-ZYXIX', '+ZXIYZ'] targets = [stab_mat(i) for i in labels] values = StabilizerTable.from_labels( labels).to_matrix(sparse=True) for mat, targ in zip(values, targets): self.assertTrue(isinstance(mat, csr_matrix)) self.assertTrue(np.all(targ == mat.toarray()))
def test_array_init(self): """Test array initialization.""" with self.subTest(msg='bool array'): target = np.array([[False, False], [True, True]]) value = StabilizerTable(target)._array self.assertTrue(np.all(value == target)) with self.subTest(msg='bool array no copy'): target = np.array([[False, True], [True, True]]) value = StabilizerTable(target)._array value[0, 0] = not value[0, 0] self.assertTrue(np.all(value == target)) with self.subTest(msg='bool array raises'): array = np.array([[False, False, False], [True, True, True]]) self.assertRaises(QiskitError, StabilizerTable, array)
def test_tensor(self): """Test tensor and expand methods.""" labels1 = ['-XX', 'YY'] labels2 = ['III', '-ZZZ'] stab1 = StabilizerTable.from_labels(labels1) stab2 = StabilizerTable.from_labels(labels2) with self.subTest(msg='tensor'): target = StabilizerTable.from_labels( ['-XXIII', 'XXZZZ', 'YYIII', '-YYZZZ']) value = stab1.tensor(stab2) self.assertEqual(value, target) with self.subTest(msg='expand'): target = StabilizerTable.from_labels( ['-IIIXX', 'ZZZXX', 'IIIYY', '-ZZZYY']) value = stab1.expand(stab2) self.assertEqual(value, target)
def test_to_labels_1q_array(self): """Test 1-qubit to_labels method w/ array=True.""" array = np.vstack(2 * [ np.array( [[False, False], [True, False], [True, True], [False, True]], dtype=np.bool) ]) phase = np.array(4 * [False] + 4 * [True], dtype=np.bool) value = StabilizerTable(array, phase).to_labels(array=True) target = np.array(['+I', '+X', '+Y', '+Z', '-I', '-X', '-Y', '-Z']) self.assertTrue(np.all(value == target))
def test_to_labels_1q(self): """Test 1-qubit to_labels method.""" array = np.vstack(2 * [ np.array( [[False, False], [True, False], [True, True], [False, True]], dtype=np.bool) ]) phase = np.array(4 * [False] + 4 * [True], dtype=np.bool) value = StabilizerTable(array, phase).to_labels() target = ['+I', '+X', '+Y', '+Z', '-I', '-X', '-Y', '-Z'] self.assertEqual(value, target)
def test_to_labels_1q(self): """Test 1-qubit to_labels method.""" array = np.vstack(2 * [ np.array( [[False, False], [True, False], [True, True], [False, True]], dtype=bool) ]) phase = np.array(4 * [False] + 4 * [True], dtype=bool) value = StabilizerTable(array, phase).to_labels() target = ["+I", "+X", "+Y", "+Z", "-I", "-X", "-Y", "-Z"] self.assertEqual(value, target)
def test_to_labels_1q_array(self): """Test 1-qubit to_labels method w/ array=True.""" array = np.vstack(2 * [ np.array( [[False, False], [True, False], [True, True], [False, True]], dtype=bool) ]) phase = np.array(4 * [False] + 4 * [True], dtype=bool) value = StabilizerTable(array, phase).to_labels(array=True) target = np.array(["+I", "+X", "+Y", "+Z", "-I", "-X", "-Y", "-Z"]) self.assertTrue(np.all(value == target))
def test_unique(self): """Test unique method.""" with self.subTest(msg='1 qubit'): labels = [ 'X', 'Z', '-I', '-X', 'X', 'I', 'Y', '-I', '-X', '-Z', 'Z', 'X', 'I' ] unique = ['X', 'Z', '-I', '-X', 'I', 'Y', '-Z'] target = StabilizerTable.from_labels(unique) value = StabilizerTable.from_labels(labels).unique() self.assertEqual(target, value) with self.subTest(msg='2 qubit'): labels = [ 'XX', 'IX', '-XX', 'XX', '-IZ', 'II', 'IZ', 'ZI', 'YX', 'YX', 'ZZ', 'IX', 'XI' ] unique = [ 'XX', 'IX', '-XX', '-IZ', 'II', 'IZ', 'ZI', 'YX', 'ZZ', 'XI' ] target = StabilizerTable.from_labels(unique) value = StabilizerTable.from_labels(labels).unique() self.assertEqual(target, value) with self.subTest(msg='10 qubit'): labels = [ 10 * 'X', '-' + 10 * 'X', '-' + 10 * 'X', 10 * 'I', 10 * 'X' ] unique = [10 * 'X', '-' + 10 * 'X', 10 * 'I'] target = StabilizerTable.from_labels(unique) value = StabilizerTable.from_labels(labels).unique() self.assertEqual(target, value)
def test_z_property(self): """Test Z property""" with self.subTest(msg='Z'): stab = StabilizerTable.from_labels(['XI', 'IZ', 'YY']) array = np.array([[False, False], [True, False], [True, True]], dtype=np.bool) self.assertTrue(np.all(stab.Z == array)) with self.subTest(msg='set Z'): stab = StabilizerTable.from_labels(['XI', 'IZ']) val = np.array([[False, False], [True, True]], dtype=np.bool) stab.Z = val self.assertEqual(stab, StabilizerTable.from_labels(['XI', 'ZZ'])) with self.subTest(msg='set Z raises'): def set_z(): stab = StabilizerTable.from_labels(['XI', 'IZ']) val = np.array([[False, False, False], [True, True, True]], dtype=np.bool) stab.Z = val return stab self.assertRaises(Exception, set_z)
def test_z_property(self): """Test Z property""" with self.subTest(msg="Z"): stab = StabilizerTable.from_labels(["XI", "IZ", "YY"]) array = np.array([[False, False], [True, False], [True, True]], dtype=bool) self.assertTrue(np.all(stab.Z == array)) with self.subTest(msg="set Z"): stab = StabilizerTable.from_labels(["XI", "IZ"]) val = np.array([[False, False], [True, True]], dtype=bool) stab.Z = val self.assertEqual(stab, StabilizerTable.from_labels(["XI", "ZZ"])) with self.subTest(msg="set Z raises"): def set_z(): stab = StabilizerTable.from_labels(["XI", "IZ"]) val = np.array([[False, False, False], [True, True, True]], dtype=bool) stab.Z = val return stab self.assertRaises(Exception, set_z)
def test_array_property(self): """Test array property""" with self.subTest(msg="array"): stab = StabilizerTable("II") array = np.zeros([2, 4], dtype=bool) self.assertTrue(np.all(stab.array == array)) with self.subTest(msg="set array"): def set_array(): stab = StabilizerTable("XXX") stab.array = np.eye(4) return stab self.assertRaises(Exception, set_array)
def test_string_init(self): """Test string initialization.""" with self.subTest(msg='str init "I"'): value = StabilizerTable("I")._array target = np.array([[False, False]], dtype=bool) self.assertTrue(np.all(np.array(value == target))) with self.subTest(msg='str init "X"'): value = StabilizerTable("X")._array target = np.array([[True, False]], dtype=bool) self.assertTrue(np.all(np.array(value == target))) with self.subTest(msg='str init "Y"'): value = StabilizerTable("Y")._array target = np.array([[True, True]], dtype=bool) self.assertTrue(np.all(np.array(value == target))) with self.subTest(msg='str init "Z"'): value = StabilizerTable("Z")._array target = np.array([[False, True]], dtype=bool) self.assertTrue(np.all(np.array(value == target))) with self.subTest(msg='str init "IX"'): value = StabilizerTable("IX")._array target = np.array([[True, False, False, False]], dtype=bool) self.assertTrue(np.all(np.array(value == target))) with self.subTest(msg='str init "XI"'): value = StabilizerTable("XI")._array target = np.array([[False, True, False, False]], dtype=bool) self.assertTrue(np.all(np.array(value == target))) with self.subTest(msg='str init "YZ"'): value = StabilizerTable("YZ")._array target = np.array([[False, True, True, True]], dtype=bool) self.assertTrue(np.all(np.array(value == target))) with self.subTest(msg='str init "XIZ"'): value = StabilizerTable("XIZ")._array target = np.array([[False, False, True, True, False, False]], dtype=bool) self.assertTrue(np.all(np.array(value == target)))
def test_setitem_methods(self): """Test __setitem__ method.""" with self.subTest(msg="__setitem__ single"): labels = ["+XI", "IY"] stab = StabilizerTable.from_labels(["+XI", "IY"]) stab[0] = "+II" self.assertEqual(stab[0], StabilizerTable("+II")) stab[1] = "-XX" self.assertEqual(stab[1], StabilizerTable("-XX")) def raises_single(): # Wrong size Pauli stab[0] = "+XXX" self.assertRaises(Exception, raises_single) with self.subTest(msg="__setitem__ array"): labels = np.array(["+XI", "-IY", "+IZ"]) stab = StabilizerTable.from_labels(labels) target = StabilizerTable.from_labels(["+II", "-ZZ"]) inds = [2, 0] stab[inds] = target self.assertEqual(stab[inds], target) def raises_array(): stab[inds] = StabilizerTable.from_labels(["+YY", "-ZZ", "+XX"]) self.assertRaises(Exception, raises_array) with self.subTest(msg="__setitem__ slice"): labels = np.array(5 * ["+III"]) stab = StabilizerTable.from_labels(labels) target = StabilizerTable.from_labels(5 * ["-XXX"]) stab[:] = target self.assertEqual(stab[:], target) target = StabilizerTable.from_labels(2 * ["+ZZZ"]) stab[1:3] = target self.assertEqual(stab[1:3], target)
def test_setitem_methods(self): """Test __setitem__ method.""" with self.subTest(msg='__setitem__ single'): labels = ['+XI', 'IY'] stab = StabilizerTable.from_labels(['+XI', 'IY']) stab[0] = '+II' self.assertEqual(stab[0], StabilizerTable('+II')) stab[1] = '-XX' self.assertEqual(stab[1], StabilizerTable('-XX')) def raises_single(): # Wrong size Pauli stab[0] = '+XXX' self.assertRaises(Exception, raises_single) with self.subTest(msg='__setitem__ array'): labels = np.array(['+XI', '-IY', '+IZ']) stab = StabilizerTable.from_labels(labels) target = StabilizerTable.from_labels(['+II', '-ZZ']) inds = [2, 0] stab[inds] = target self.assertEqual(stab[inds], target) def raises_array(): stab[inds] = StabilizerTable.from_labels(['+YY', '-ZZ', '+XX']) self.assertRaises(Exception, raises_array) with self.subTest(msg='__setitem__ slice'): labels = np.array(5 * ['+III']) stab = StabilizerTable.from_labels(labels) target = StabilizerTable.from_labels(5 * ['-XXX']) stab[:] = target self.assertEqual(stab[:], target) target = StabilizerTable.from_labels(2 * ['+ZZZ']) stab[1:3] = target self.assertEqual(stab[1:3], target)
def test_getitem_methods(self): """Test __getitem__ method.""" with self.subTest(msg='__getitem__ single'): labels = ['+XI', '-IY'] stab = StabilizerTable.from_labels(labels) self.assertEqual(stab[0], StabilizerTable(labels[0])) self.assertEqual(stab[1], StabilizerTable(labels[1])) with self.subTest(msg='__getitem__ array'): labels = np.array(['+XI', '-IY', '+IZ', '-XY', '+ZX']) stab = StabilizerTable.from_labels(labels) inds = [0, 3] self.assertEqual(stab[inds], StabilizerTable.from_labels(labels[inds])) inds = np.array([4, 1]) self.assertEqual(stab[inds], StabilizerTable.from_labels(labels[inds])) with self.subTest(msg='__getitem__ slice'): labels = np.array(['+XI', '-IY', '+IZ', '-XY', '+ZX']) stab = StabilizerTable.from_labels(labels) self.assertEqual(stab[:], stab) self.assertEqual(stab[1:3], StabilizerTable.from_labels(labels[1:3]))
def test_getitem_methods(self): """Test __getitem__ method.""" with self.subTest(msg="__getitem__ single"): labels = ["+XI", "-IY"] stab = StabilizerTable.from_labels(labels) self.assertEqual(stab[0], StabilizerTable(labels[0])) self.assertEqual(stab[1], StabilizerTable(labels[1])) with self.subTest(msg="__getitem__ array"): labels = np.array(["+XI", "-IY", "+IZ", "-XY", "+ZX"]) stab = StabilizerTable.from_labels(labels) inds = [0, 3] self.assertEqual(stab[inds], StabilizerTable.from_labels(labels[inds])) inds = np.array([4, 1]) self.assertEqual(stab[inds], StabilizerTable.from_labels(labels[inds])) with self.subTest(msg="__getitem__ slice"): labels = np.array(["+XI", "-IY", "+IZ", "-XY", "+ZX"]) stab = StabilizerTable.from_labels(labels) self.assertEqual(stab[:], stab) self.assertEqual(stab[1:3], StabilizerTable.from_labels(labels[1:3]))
def test_unique(self): """Test unique method.""" with self.subTest(msg="1 qubit"): labels = [ "X", "Z", "-I", "-X", "X", "I", "Y", "-I", "-X", "-Z", "Z", "X", "I" ] unique = ["X", "Z", "-I", "-X", "I", "Y", "-Z"] target = StabilizerTable.from_labels(unique) value = StabilizerTable.from_labels(labels).unique() self.assertEqual(target, value) with self.subTest(msg="2 qubit"): labels = [ "XX", "IX", "-XX", "XX", "-IZ", "II", "IZ", "ZI", "YX", "YX", "ZZ", "IX", "XI", ] unique = [ "XX", "IX", "-XX", "-IZ", "II", "IZ", "ZI", "YX", "ZZ", "XI" ] target = StabilizerTable.from_labels(unique) value = StabilizerTable.from_labels(labels).unique() self.assertEqual(target, value) with self.subTest(msg="10 qubit"): labels = [ 10 * "X", "-" + 10 * "X", "-" + 10 * "X", 10 * "I", 10 * "X" ] unique = [10 * "X", "-" + 10 * "X", 10 * "I"] target = StabilizerTable.from_labels(unique) value = StabilizerTable.from_labels(labels).unique() self.assertEqual(target, value)
def test_add_qargs(self): """Test add method with qargs.""" stab1 = StabilizerTable.from_labels(['+IIII', '-YYYY']) stab2 = StabilizerTable.from_labels(['-XY', '+YZ']) with self.subTest(msg='qargs=[0, 1]'): target = StabilizerTable.from_labels( ['+IIII', '-YYYY', '-IIXY', '+IIYZ']) self.assertEqual(stab1 + stab2([0, 1]), target) with self.subTest(msg='qargs=[0, 3]'): target = StabilizerTable.from_labels( ['+IIII', '-YYYY', '-XIIY', '+YIIZ']) self.assertEqual(stab1 + stab2([0, 3]), target) with self.subTest(msg='qargs=[2, 1]'): target = StabilizerTable.from_labels( ['+IIII', '-YYYY', '-IYXI', '+IZYI']) self.assertEqual(stab1 + stab2([2, 1]), target) with self.subTest(msg='qargs=[3, 1]'): target = StabilizerTable.from_labels( ['+IIII', '-YYYY', '-YIXI', '+ZIYI']) self.assertEqual(stab1 + stab2([3, 1]), target)
def test_add_qargs(self): """Test add method with qargs.""" stab1 = StabilizerTable.from_labels(["+IIII", "-YYYY"]) stab2 = StabilizerTable.from_labels(["-XY", "+YZ"]) with self.subTest(msg="qargs=[0, 1]"): target = StabilizerTable.from_labels( ["+IIII", "-YYYY", "-IIXY", "+IIYZ"]) self.assertEqual(stab1 + stab2([0, 1]), target) with self.subTest(msg="qargs=[0, 3]"): target = StabilizerTable.from_labels( ["+IIII", "-YYYY", "-XIIY", "+YIIZ"]) self.assertEqual(stab1 + stab2([0, 3]), target) with self.subTest(msg="qargs=[2, 1]"): target = StabilizerTable.from_labels( ["+IIII", "-YYYY", "-IYXI", "+IZYI"]) self.assertEqual(stab1 + stab2([2, 1]), target) with self.subTest(msg="qargs=[3, 1]"): target = StabilizerTable.from_labels( ["+IIII", "-YYYY", "-YIXI", "+ZIYI"]) self.assertEqual(stab1 + stab2([3, 1]), target)
def test_sort(self): """Test sort method.""" with self.subTest(msg="1 qubit"): unsrt = ["X", "-Z", "I", "Y", "-X", "Z"] srt = ["I", "X", "-X", "Y", "-Z", "Z"] target = StabilizerTable.from_labels(srt) value = StabilizerTable.from_labels(unsrt).sort() self.assertEqual(target, value) with self.subTest(msg="1 qubit weight order"): unsrt = ["X", "-Z", "I", "Y", "-X", "Z"] srt = ["I", "X", "-X", "Y", "-Z", "Z"] target = StabilizerTable.from_labels(srt) value = StabilizerTable.from_labels(unsrt).sort(weight=True) self.assertEqual(target, value) with self.subTest(msg="2 qubit standard order"): srt_p = [ "II", "IX", "IY", "XI", "XX", "XY", "XZ", "YI", "YX", "YY", "YZ", "ZI", "ZX", "ZY", "ZZ", ] srt_m = ["-" + i for i in srt_p] unsrt_p = srt_p.copy() np.random.shuffle(unsrt_p) unsrt_m = srt_m.copy() np.random.shuffle(unsrt_m) # Sort with + cases all first in shuffled list srt = [val for pair in zip(srt_p, srt_m) for val in pair] unsrt = unsrt_p + unsrt_m target = StabilizerTable.from_labels(srt) value = StabilizerTable.from_labels(unsrt).sort() self.assertEqual(target, value) # Sort with - cases all first in shuffled list srt = [val for pair in zip(srt_m, srt_p) for val in pair] unsrt = unsrt_m + unsrt_p target = StabilizerTable.from_labels(srt) value = StabilizerTable.from_labels(unsrt).sort() self.assertEqual(target, value) with self.subTest(msg="2 qubit weight order"): srt_p = [ "II", "IX", "IY", "IZ", "XI", "YI", "ZI", "XX", "XY", "XZ", "YX", "YY", "YZ", "ZX", "ZY", "ZZ", ] srt_m = ["-" + i for i in srt_p] unsrt_p = srt_p.copy() np.random.shuffle(unsrt_p) unsrt_m = srt_m.copy() np.random.shuffle(unsrt_m) # Sort with + cases all first in shuffled list srt = [val for pair in zip(srt_p, srt_m) for val in pair] unsrt = unsrt_p + unsrt_m target = StabilizerTable.from_labels(srt) value = StabilizerTable.from_labels(unsrt).sort(weight=True) self.assertEqual(target, value) # Sort with - cases all first in shuffled list srt = [val for pair in zip(srt_m, srt_p) for val in pair] unsrt = unsrt_m + unsrt_p target = StabilizerTable.from_labels(srt) value = StabilizerTable.from_labels(unsrt).sort(weight=True) self.assertEqual(target, value)
def test_labels_round_trip_array(self): """Test from_labels and to_labels round trip w/ array=True.""" labels = ["+III", "-IXZ", "-XYI", "+ZZZ"] target = np.array(labels) value = StabilizerTable.from_labels(labels).to_labels(array=True) self.assertTrue(np.all(value == target))
def test_labels_round_trip(self): """Test from_labels and to_labels round trip.""" target = ["+III", "-IXZ", "-XYI", "+ZZZ"] value = StabilizerTable.from_labels(target).to_labels() self.assertEqual(value, target)
def raises_array(): stab[inds] = StabilizerTable.from_labels(["+YY", "-ZZ", "+XX"])
def test_delete(self): """Test delete method.""" with self.subTest(msg="single row"): for j in range(1, 6): stab = StabilizerTable.from_labels([j * "X", "-" + j * "Y"]) self.assertEqual(stab.delete(0), StabilizerTable("-" + j * "Y")) self.assertEqual(stab.delete(1), StabilizerTable(j * "X")) with self.subTest(msg="multiple rows"): for j in range(1, 6): stab = StabilizerTable.from_labels( [j * "X", "-" + j * "Y", j * "Z"]) self.assertEqual(stab.delete([0, 2]), StabilizerTable("-" + j * "Y")) self.assertEqual(stab.delete([1, 2]), StabilizerTable(j * "X")) self.assertEqual(stab.delete([0, 1]), StabilizerTable(j * "Z")) with self.subTest(msg="single qubit"): stab = StabilizerTable.from_labels(["IIX", "IYI", "ZII"]) value = stab.delete(0, qubit=True) target = StabilizerTable.from_labels(["II", "IY", "ZI"]) self.assertEqual(value, target) value = stab.delete(1, qubit=True) target = StabilizerTable.from_labels(["IX", "II", "ZI"]) self.assertEqual(value, target) value = stab.delete(2, qubit=True) target = StabilizerTable.from_labels(["IX", "YI", "II"]) self.assertEqual(value, target) with self.subTest(msg="multiple qubits"): stab = StabilizerTable.from_labels(["IIX", "IYI", "ZII"]) value = stab.delete([0, 1], qubit=True) target = StabilizerTable.from_labels(["I", "I", "Z"]) self.assertEqual(value, target) value = stab.delete([1, 2], qubit=True) target = StabilizerTable.from_labels(["X", "I", "I"]) self.assertEqual(value, target) value = stab.delete([0, 2], qubit=True) target = StabilizerTable.from_labels(["I", "Y", "I"]) self.assertEqual(value, target)
def test_insert(self): """Test insert method.""" # Insert single row for j in range(1, 10): l_px = j * "X" l_mi = "-" + j * "I" stab = StabilizerTable(l_px) target0 = StabilizerTable.from_labels([l_mi, l_px]) target1 = StabilizerTable.from_labels([l_px, l_mi]) with self.subTest(msg=f"single row from str ({j})"): value0 = stab.insert(0, l_mi) self.assertEqual(value0, target0) value1 = stab.insert(1, l_mi) self.assertEqual(value1, target1) with self.subTest(msg=f"single row from StabilizerTable ({j})"): value0 = stab.insert(0, StabilizerTable(l_mi)) self.assertEqual(value0, target0) value1 = stab.insert(1, StabilizerTable(l_mi)) self.assertEqual(value1, target1) # Insert multiple rows for j in range(1, 10): stab = StabilizerTable(j * "X") insert = StabilizerTable.from_labels( ["-" + j * "I", j * "Y", "-" + j * "Z"]) target0 = insert + stab target1 = stab + insert with self.subTest(msg=f"multiple-rows from StabilizerTable ({j})"): value0 = stab.insert(0, insert) self.assertEqual(value0, target0) value1 = stab.insert(1, insert) self.assertEqual(value1, target1) # Insert single column stab = StabilizerTable.from_labels(["X", "Y", "Z"]) for sgn in ["+", "-"]: for i in ["I", "X", "Y", "Z"]: target0 = StabilizerTable.from_labels( [sgn + "X" + i, sgn + "Y" + i, sgn + "Z" + i]) target1 = StabilizerTable.from_labels( [sgn + i + "X", sgn + i + "Y", sgn + i + "Z"]) with self.subTest(msg="single-column single-val from str" " {}".format(sgn + i)): value = stab.insert(0, sgn + i, qubit=True) self.assertEqual(value, target0) value = stab.insert(1, sgn + i, qubit=True) self.assertEqual(value, target1) with self.subTest(msg="single-column single-val from" " StabilizerTable {}".format(sgn + i)): value = stab.insert(0, StabilizerTable(sgn + i), qubit=True) self.assertEqual(value, target0) value = stab.insert(1, StabilizerTable(sgn + i), qubit=True) self.assertEqual(value, target1) # Insert single column with multiple values stab = StabilizerTable.from_labels(["X", "Y", "Z"]) for i in [("I", "X", "Y"), ("X", "Y", "Z"), ("Y", "Z", "I")]: target0 = StabilizerTable.from_labels( ["X" + i[0], "Y" + i[1], "Z" + i[2]]) target1 = StabilizerTable.from_labels( [i[0] + "X", i[1] + "Y", i[2] + "Z"]) with self.subTest( msg="single-column multiple-vals from StabilizerTable"): value = stab.insert(0, StabilizerTable.from_labels(i), qubit=True) self.assertEqual(value, target0) value = stab.insert(1, StabilizerTable.from_labels(i), qubit=True) self.assertEqual(value, target1) with self.subTest(msg="single-column multiple-vals from array"): value = stab.insert(0, StabilizerTable.from_labels(i).array, qubit=True) self.assertEqual(value, target0) value = stab.insert(1, StabilizerTable.from_labels(i).array, qubit=True) self.assertEqual(value, target1) # Insert multiple columns from single stab = StabilizerTable.from_labels(["X", "Y", "Z"]) for j in range(1, 5): for i in [j * "I", j * "X", j * "Y", j * "Z"]: target0 = StabilizerTable.from_labels( ["X" + i, "Y" + i, "Z" + i]) target1 = StabilizerTable.from_labels( [i + "X", i + "Y", i + "Z"]) with self.subTest(msg="multiple-columns single-val from str"): value = stab.insert(0, i, qubit=True) self.assertEqual(value, target0) value = stab.insert(1, i, qubit=True) self.assertEqual(value, target1) with self.subTest( msg="multiple-columns single-val from StabilizerTable"): value = stab.insert(0, StabilizerTable(i), qubit=True) self.assertEqual(value, target0) value = stab.insert(1, StabilizerTable(i), qubit=True) self.assertEqual(value, target1) with self.subTest(msg="multiple-columns single-val from array"): value = stab.insert(0, StabilizerTable(i).array, qubit=True) self.assertEqual(value, target0) value = stab.insert(1, StabilizerTable(i).array, qubit=True) self.assertEqual(value, target1) # Insert multiple columns multiple row values stab = StabilizerTable.from_labels(["X", "Y", "Z"]) for j in range(1, 5): for i in [ (j * "I", j * "X", j * "Y"), (j * "X", j * "Z", j * "Y"), (j * "Y", j * "Z", j * "I"), ]: target0 = StabilizerTable.from_labels( ["X" + i[0], "Y" + i[1], "Z" + i[2]]) target1 = StabilizerTable.from_labels( [i[0] + "X", i[1] + "Y", i[2] + "Z"]) with self.subTest( msg="multiple-column multiple-vals from StabilizerTable" ): value = stab.insert(0, StabilizerTable.from_labels(i), qubit=True) self.assertEqual(value, target0) value = stab.insert(1, StabilizerTable.from_labels(i), qubit=True) self.assertEqual(value, target1) with self.subTest( msg="multiple-column multiple-vals from array"): value = stab.insert(0, StabilizerTable.from_labels(i).array, qubit=True) self.assertEqual(value, target0) value = stab.insert(1, StabilizerTable.from_labels(i).array, qubit=True) self.assertEqual(value, target1)
def test_eq(self): """Test __eq__ method.""" stab1 = StabilizerTable.from_labels(["II", "XI"]) stab2 = StabilizerTable.from_labels(["XI", "II"]) self.assertEqual(stab1, stab1) self.assertNotEqual(stab1, stab2)
def test_compose(self): """Test compose and dot methods.""" # Test single qubit Pauli dot products stab = StabilizerTable.from_labels(["I", "X", "Y", "Z"]) # Test single qubit Pauli dot products stab = StabilizerTable.from_labels( ["I", "X", "Y", "Z", "-I", "-X", "-Y", "-Z"]) with self.subTest(msg="dot single I"): value = stab.compose("I") target = StabilizerTable.from_labels( ["I", "X", "Y", "Z", "-I", "-X", "-Y", "-Z"]) self.assertEqual(target, value) with self.subTest(msg="dot single -I"): value = stab.compose("-I") target = StabilizerTable.from_labels( ["-I", "-X", "-Y", "-Z", "I", "X", "Y", "Z"]) self.assertEqual(target, value) with self.subTest(msg="dot single I"): value = stab.dot("I") target = StabilizerTable.from_labels( ["I", "X", "Y", "Z", "-I", "-X", "-Y", "-Z"]) self.assertEqual(target, value) with self.subTest(msg="dot single -I"): value = stab.dot("-I") target = StabilizerTable.from_labels( ["-I", "-X", "-Y", "-Z", "I", "X", "Y", "Z"]) self.assertEqual(target, value) with self.subTest(msg="compose single X"): value = stab.compose("X") target = StabilizerTable.from_labels( ["X", "I", "-Z", "Y", "-X", "-I", "Z", "-Y"]) self.assertEqual(target, value) with self.subTest(msg="compose single -X"): value = stab.compose("-X") target = StabilizerTable.from_labels( ["-X", "-I", "Z", "-Y", "X", "I", "-Z", "Y"]) self.assertEqual(target, value) with self.subTest(msg="dot single X"): value = stab.dot("X") target = StabilizerTable.from_labels( ["X", "I", "Z", "-Y", "-X", "-I", "-Z", "Y"]) self.assertEqual(target, value) with self.subTest(msg="dot single -X"): value = stab.dot("-X") target = StabilizerTable.from_labels( ["-X", "-I", "-Z", "Y", "X", "I", "Z", "-Y"]) self.assertEqual(target, value) with self.subTest(msg="compose single Y"): value = stab.compose("Y") target = StabilizerTable.from_labels( ["Y", "Z", "-I", "-X", "-Y", "-Z", "I", "X"]) self.assertEqual(target, value) with self.subTest(msg="compose single -Y"): value = stab.compose("-Y") target = StabilizerTable.from_labels( ["-Y", "-Z", "I", "X", "Y", "Z", "-I", "-X"]) self.assertEqual(target, value) with self.subTest(msg="dot single Y"): value = stab.dot("Y") target = StabilizerTable.from_labels( ["Y", "-Z", "-I", "X", "-Y", "Z", "I", "-X"]) self.assertEqual(target, value) with self.subTest(msg="dot single -Y"): value = stab.dot("-Y") target = StabilizerTable.from_labels( ["-Y", "Z", "I", "-X", "Y", "-Z", "-I", "X"]) self.assertEqual(target, value) with self.subTest(msg="compose single Z"): value = stab.compose("Z") target = StabilizerTable.from_labels( ["Z", "-Y", "X", "I", "-Z", "Y", "-X", "-I"]) self.assertEqual(target, value) with self.subTest(msg="compose single -Z"): value = stab.compose("-Z") target = StabilizerTable.from_labels( ["-Z", "Y", "-X", "-I", "Z", "-Y", "X", "I"]) self.assertEqual(target, value) with self.subTest(msg="dot single Z"): value = stab.dot("Z") target = StabilizerTable.from_labels( ["Z", "Y", "-X", "I", "-Z", "-Y", "X", "-I"]) self.assertEqual(target, value) with self.subTest(msg="dot single -Z"): value = stab.dot("-Z") target = StabilizerTable.from_labels( ["-Z", "-Y", "X", "-I", "Z", "Y", "-X", "I"]) self.assertEqual(target, value)
def test_len_methods(self): """Test __len__ method.""" for j in range(1, 10): labels = j * ["XX"] stab = StabilizerTable.from_labels(labels) self.assertEqual(len(stab), j)