def raises_array():
stab[inds] = StabilizerTable.from_labels(["+YY", "-ZZ", "+XX"])
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_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)
def test_compose_qargs(self):
"""Test compose and dot methods with qargs."""
# Dot product with qargs
stab1 = StabilizerTable.from_labels(["III", "-XXX", "YYY", "-ZZZ"])
# 1-qubit qargs
stab2 = StabilizerTable("-Z")
with self.subTest(msg="dot 1-qubit qargs=[0]"):
target = StabilizerTable.from_labels(["-IIZ", "XXY", "YYX", "ZZI"])
value = stab1.dot(stab2, qargs=[0])
self.assertEqual(value, target)
with self.subTest(msg="compose 1-qubit qargs=[0]"):
target = StabilizerTable.from_labels(
["-IIZ", "-XXY", "-YYX", "ZZI"])
value = stab1.compose(stab2, qargs=[0])
self.assertEqual(value, target)
with self.subTest(msg="dot 1-qubit qargs=[1]"):
target = StabilizerTable.from_labels(["-IZI", "XYX", "YXY", "ZIZ"])
value = stab1.dot(stab2, qargs=[1])
self.assertEqual(value, target)
with self.subTest(msg="compose 1-qubit qargs=[1]"):
value = stab1.compose(stab2, qargs=[1])
target = StabilizerTable.from_labels(
["-IZI", "-XYX", "-YXY", "ZIZ"])
self.assertEqual(value, target)
target = StabilizerTable.from_labels(["ZII", "YXX"])
with self.subTest(msg="dot 1-qubit qargs=[2]"):
value = stab1.dot(stab2, qargs=[2])
target = StabilizerTable.from_labels(["-ZII", "YXX", "XYY", "IZZ"])
self.assertEqual(value, target)
with self.subTest(msg="compose 1-qubit qargs=[2]"):
value = stab1.compose(stab2, qargs=[2])
target = StabilizerTable.from_labels(
["-ZII", "-YXX", "-XYY", "IZZ"])
self.assertEqual(value, target)
# 2-qubit qargs
stab2 = StabilizerTable("-ZY")
with self.subTest(msg="dot 2-qubit qargs=[0, 1]"):
value = stab1.dot(stab2, qargs=[0, 1])
target = StabilizerTable.from_labels(
["-IZY", "-XYZ", "-YXI", "ZIX"])
self.assertEqual(value, target)
with self.subTest(msg="compose 2-qubit qargs=[0, 1]"):
value = stab1.compose(stab2, qargs=[0, 1])
target = StabilizerTable.from_labels(
["-IZY", "-XYZ", "YXI", "-ZIX"])
self.assertEqual(value, target)
target = StabilizerTable.from_labels(["YIZ", "ZXY"])
with self.subTest(msg="dot 2-qubit qargs=[2, 0]"):
value = stab1.dot(stab2, qargs=[2, 0])
target = StabilizerTable.from_labels(
["-YIZ", "-ZXY", "-IYX", "XZI"])
self.assertEqual(value, target)
with self.subTest(msg="compose 2-qubit qargs=[2, 0]"):
value = stab1.compose(stab2, qargs=[2, 0])
target = StabilizerTable.from_labels(
["-YIZ", "-ZXY", "IYX", "-XZI"])
self.assertEqual(value, target)
# 3-qubit qargs
stab2 = StabilizerTable("-XYZ")
target = StabilizerTable.from_labels(["XYZ", "IZY"])
with self.subTest(msg="dot 3-qubit qargs=None"):
value = stab1.dot(stab2, qargs=[0, 1, 2])
target = StabilizerTable.from_labels(
["-XYZ", "-IZY", "-ZIX", "-YXI"])
self.assertEqual(value, target)
with self.subTest(msg="dot 3-qubit qargs=[0, 1, 2]"):
value = stab1.dot(stab2, qargs=[0, 1, 2])
target = StabilizerTable.from_labels(
["-XYZ", "-IZY", "-ZIX", "-YXI"])
self.assertEqual(value, target)
with self.subTest(msg="dot 3-qubit qargs=[2, 1, 0]"):
value = stab1.dot(stab2, qargs=[2, 1, 0])
target = StabilizerTable.from_labels(
["-ZYX", "-YZI", "-XIZ", "-IXY"])
self.assertEqual(value, target)
with self.subTest(msg="compose 3-qubit qargs=[2, 1, 0]"):
value = stab1.compose(stab2, qargs=[2, 1, 0])
target = StabilizerTable.from_labels(
["-ZYX", "-YZI", "-XIZ", "-IXY"])
self.assertEqual(value, target)
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
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
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_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_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_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_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='single row from str ({})'.format(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='single row from StabilizerTable ({})'.format(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='multiple-rows from StabilizerTable ({})'.format(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_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_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_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 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=f"single-column single-val from str {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=
f"single-column single-val from StabilizerTable {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_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_compose_qargs(self):
"""Test compose and dot methods with qargs."""
# Dot product with qargs
stab1 = StabilizerTable.from_labels(['III', '-XXX', 'YYY', '-ZZZ'])
# 1-qubit qargs
stab2 = StabilizerTable('-Z')
with self.subTest(msg='dot 1-qubit qargs=[0]'):
target = StabilizerTable.from_labels(['-IIZ', 'XXY', 'YYX', 'ZZI'])
value = stab1.dot(stab2, qargs=[0])
self.assertEqual(value, target)
with self.subTest(msg='compose 1-qubit qargs=[0]'):
target = StabilizerTable.from_labels(
['-IIZ', '-XXY', '-YYX', 'ZZI'])
value = stab1.compose(stab2, qargs=[0])
self.assertEqual(value, target)
with self.subTest(msg='dot 1-qubit qargs=[1]'):
target = StabilizerTable.from_labels(['-IZI', 'XYX', 'YXY', 'ZIZ'])
value = stab1.dot(stab2, qargs=[1])
self.assertEqual(value, target)
with self.subTest(msg='compose 1-qubit qargs=[1]'):
value = stab1.compose(stab2, qargs=[1])
target = StabilizerTable.from_labels(
['-IZI', '-XYX', '-YXY', 'ZIZ'])
self.assertEqual(value, target)
target = StabilizerTable.from_labels(['ZII', 'YXX'])
with self.subTest(msg='dot 1-qubit qargs=[2]'):
value = stab1.dot(stab2, qargs=[2])
target = StabilizerTable.from_labels(['-ZII', 'YXX', 'XYY', 'IZZ'])
self.assertEqual(value, target)
with self.subTest(msg='compose 1-qubit qargs=[2]'):
value = stab1.compose(stab2, qargs=[2])
target = StabilizerTable.from_labels(
['-ZII', '-YXX', '-XYY', 'IZZ'])
self.assertEqual(value, target)
# 2-qubit qargs
stab2 = StabilizerTable('-ZY')
with self.subTest(msg='dot 2-qubit qargs=[0, 1]'):
value = stab1.dot(stab2, qargs=[0, 1])
target = StabilizerTable.from_labels(
['-IZY', '-XYZ', '-YXI', 'ZIX'])
self.assertEqual(value, target)
with self.subTest(msg='compose 2-qubit qargs=[0, 1]'):
value = stab1.compose(stab2, qargs=[0, 1])
target = StabilizerTable.from_labels(
['-IZY', '-XYZ', 'YXI', '-ZIX'])
self.assertEqual(value, target)
target = StabilizerTable.from_labels(['YIZ', 'ZXY'])
with self.subTest(msg='dot 2-qubit qargs=[2, 0]'):
value = stab1.dot(stab2, qargs=[2, 0])
target = StabilizerTable.from_labels(
['-YIZ', '-ZXY', '-IYX', 'XZI'])
self.assertEqual(value, target)
with self.subTest(msg='compose 2-qubit qargs=[2, 0]'):
value = stab1.compose(stab2, qargs=[2, 0])
target = StabilizerTable.from_labels(
['-YIZ', '-ZXY', 'IYX', '-XZI'])
self.assertEqual(value, target)
# 3-qubit qargs
stab2 = StabilizerTable('-XYZ')
target = StabilizerTable.from_labels(['XYZ', 'IZY'])
with self.subTest(msg='dot 3-qubit qargs=None'):
value = stab1.dot(stab2, qargs=[0, 1, 2])
target = StabilizerTable.from_labels(
['-XYZ', '-IZY', '-ZIX', '-YXI'])
self.assertEqual(value, target)
with self.subTest(msg='dot 3-qubit qargs=[0, 1, 2]'):
value = stab1.dot(stab2, qargs=[0, 1, 2])
target = StabilizerTable.from_labels(
['-XYZ', '-IZY', '-ZIX', '-YXI'])
self.assertEqual(value, target)
with self.subTest(msg='dot 3-qubit qargs=[2, 1, 0]'):
value = stab1.dot(stab2, qargs=[2, 1, 0])
target = StabilizerTable.from_labels(
['-ZYX', '-YZI', '-XIZ', '-IXY'])
self.assertEqual(value, target)
with self.subTest(msg='compose 3-qubit qargs=[2, 1, 0]'):
value = stab1.compose(stab2, qargs=[2, 1, 0])
target = StabilizerTable.from_labels(
['-ZYX', '-YZI', '-XIZ', '-IXY'])
self.assertEqual(value, target)
