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_iteration(self):
"""Test iteration methods."""
labels = ['+III', '+IXI', '-IYY', '+YIZ', '-ZIZ', '+XYZ', '-III']
stab = StabilizerTable.from_labels(labels)
with self.subTest(msg='enumerate'):
for idx, i in enumerate(stab):
self.assertEqual(i, StabilizerTable(labels[idx]))
with self.subTest(msg='iter'):
for idx, i in enumerate(iter(stab)):
self.assertEqual(i, StabilizerTable(labels[idx]))
with self.subTest(msg='zip'):
for label, i in zip(labels, stab):
self.assertEqual(i, StabilizerTable(label))
with self.subTest(msg='label_iter'):
for idx, i in enumerate(stab.label_iter()):
self.assertEqual(i, labels[idx])
with self.subTest(msg='matrix_iter (dense)'):
for idx, i in enumerate(stab.matrix_iter()):
self.assertTrue(np.all(i == stab_mat(labels[idx])))
with self.subTest(msg='matrix_iter (sparse)'):
for idx, i in enumerate(stab.matrix_iter(sparse=True)):
self.assertTrue(isinstance(i, csr_matrix))
self.assertTrue(np.all(i.toarray() == stab_mat(labels[idx])))
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_iteration(self):
"""Test iteration methods."""
labels = ["+III", "+IXI", "-IYY", "+YIZ", "-ZIZ", "+XYZ", "-III"]
stab = StabilizerTable.from_labels(labels)
with self.subTest(msg="enumerate"):
for idx, i in enumerate(stab):
self.assertEqual(i, StabilizerTable(labels[idx]))
with self.subTest(msg="iter"):
for idx, i in enumerate(iter(stab)):
self.assertEqual(i, StabilizerTable(labels[idx]))
with self.subTest(msg="zip"):
for label, i in zip(labels, stab):
self.assertEqual(i, StabilizerTable(label))
with self.subTest(msg="label_iter"):
for idx, i in enumerate(stab.label_iter()):
self.assertEqual(i, labels[idx])
with self.subTest(msg="matrix_iter (dense)"):
for idx, i in enumerate(stab.matrix_iter()):
self.assertTrue(np.all(i == stab_mat(labels[idx])))
with self.subTest(msg="matrix_iter (sparse)"):
for idx, i in enumerate(stab.matrix_iter(sparse=True)):
self.assertTrue(isinstance(i, csr_matrix))
self.assertTrue(np.all(i.toarray() == stab_mat(labels[idx])))
def test_table_init(self):
"""Test StabilizerTable initialization."""
with self.subTest(msg='StabilizerTable'):
target = StabilizerTable.from_labels(['XI', 'IX', 'IZ'])
value = StabilizerTable(target)
self.assertEqual(value, target)
with self.subTest(msg='StabilizerTable no copy'):
target = StabilizerTable.from_labels(['XI', 'IX', 'IZ'])
value = StabilizerTable(target)
value[0] = 'II'
self.assertEqual(value, target)
def test_vector_init(self):
"""Test vector initialization."""
with self.subTest(msg="bool vector"):
target = np.array([False, False, False, False])
value = StabilizerTable(target)._array
self.assertTrue(np.all(value == target))
with self.subTest(msg="bool vector no copy"):
target = np.array([False, True, True, False])
value = StabilizerTable(target)._array
value[0, 0] = not value[0, 0]
self.assertTrue(np.all(value == target))
def test_table_init(self):
"""Test StabilizerTable initialization."""
with self.subTest(msg="StabilizerTable"):
target = StabilizerTable.from_labels(["XI", "IX", "IZ"])
value = StabilizerTable(target)
self.assertEqual(value, target)
with self.subTest(msg="StabilizerTable no copy"):
target = StabilizerTable.from_labels(["XI", "IX", "IZ"])
value = StabilizerTable(target)
value[0] = "II"
self.assertEqual(value, target)
def test_size_property(self):
"""Test size property"""
with self.subTest(msg="size"):
for j in range(1, 10):
shape = (j, 8)
stab = StabilizerTable(np.zeros(shape))
self.assertEqual(stab.size, j)
def test_num_qubits_property(self):
"""Test num_qubits property"""
with self.subTest(msg="num_qubits"):
for j in range(1, 10):
shape = (5, 2 * j)
stab = StabilizerTable(np.zeros(shape))
self.assertEqual(stab.num_qubits, j)
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_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_from_labels_2q(self):
"""Test 2-qubit from_labels method."""
labels = ['II', '-YY', '+XZ']
array = np.array(
[[False, False, False, False], [True, True, True, True],
[False, True, True, False]],
dtype=np.bool)
phase = np.array([False, True, False])
target = StabilizerTable(array, phase)
value = StabilizerTable.from_labels(labels)
self.assertEqual(target, value)
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_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_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_from_labels_5q(self):
"""Test 5-qubit from_labels method."""
labels = ['IIIII', '-XXXXX', 'YYYYY', 'ZZZZZ']
array = np.array([
10 * [False], 5 * [True] + 5 * [False], 10 * [True],
5 * [False] + 5 * [True]
],
dtype=np.bool)
phase = np.array([False, True, False, False])
target = StabilizerTable(array, phase)
value = StabilizerTable.from_labels(labels)
self.assertEqual(target, value)
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_from_labels_1q(self):
"""Test 1-qubit from_labels method."""
labels = [
'I', 'X', 'Y', 'Z', '+I', '+X', '+Y', '+Z', '-I', '-X', '-Y', '-Z'
]
array = np.vstack(3 * [
np.array(
[[False, False], [True, False], [True, True], [False, True]],
dtype=np.bool)
])
phase = np.array(8 * [False] + 4 * [True], dtype=np.bool)
target = StabilizerTable(array, phase)
value = StabilizerTable.from_labels(labels)
self.assertEqual(target, value)
def test_from_labels_5q(self):
"""Test 5-qubit from_labels method."""
labels = ["IIIII", "-XXXXX", "YYYYY", "ZZZZZ"]
array = np.array(
[
10 * [False], 5 * [True] + 5 * [False], 10 * [True],
5 * [False] + 5 * [True]
],
dtype=bool,
)
phase = np.array([False, True, False, False])
target = StabilizerTable(array, phase)
value = StabilizerTable.from_labels(labels)
self.assertEqual(target, value)
def test_from_labels_1q(self):
"""Test 1-qubit from_labels method."""
labels = [
"I", "X", "Y", "Z", "+I", "+X", "+Y", "+Z", "-I", "-X", "-Y", "-Z"
]
array = np.vstack(3 * [
np.array(
[[False, False], [True, False], [True, True], [False, True]],
dtype=bool)
])
phase = np.array(8 * [False] + 4 * [True], dtype=bool)
target = StabilizerTable(array, phase)
value = StabilizerTable.from_labels(labels)
self.assertEqual(target, value)
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_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_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 set_array():
stab = StabilizerTable("XXX")
stab.array = np.eye(4)
return stab
def test_shape_property(self):
"""Test shape property"""
shape = (3, 8)
stab = StabilizerTable(np.zeros(shape))
self.assertEqual(stab.shape, shape)