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 _bloch_multivector_data(state):
"""Return list of Bloch vectors for each qubit
Args:
state (DensityMatrix or Statevector): an N-qubit state.
Returns:
list: list of Bloch vectors (x, y, z) for each qubit.
Raises:
VisualizationError: if input is not an N-qubit state.
"""
rho = DensityMatrix(state)
num = rho.num_qubits
if num is None:
raise VisualizationError("Input is not a multi-qubit quantum state.")
pauli_singles = PauliTable.from_labels(['X', 'Y', 'Z'])
bloch_data = []
for i in range(num):
if num > 1:
paulis = PauliTable(np.zeros((3, 2 * (num - 1)),
dtype=bool)).insert(i,
pauli_singles,
qubit=True)
else:
paulis = pauli_singles
bloch_state = [
np.real(np.trace(np.dot(mat, rho.data)))
for mat in paulis.matrix_iter()
]
bloch_data.append(bloch_state)
return bloch_data
def test_weight_order_2q(self):
"""Test 2-qubit pauli_basis function with weight=True."""
labels = [
'II', 'IX', 'IY', 'IZ', 'XI', 'YI', 'ZI', 'XX', 'XY', 'XZ', 'YX',
'YY', 'YZ', 'ZX', 'ZY', 'ZZ'
]
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(2, weight=True), target)
def test_standard_order_2q(self):
"""Test 2-qubit pauli_basis function."""
labels = [
'II', 'IX', 'IY', 'IZ', 'XI', 'XX', 'XY', 'XZ', 'YI', 'YX', 'YY',
'YZ', 'ZI', 'ZX', 'ZY', 'ZZ'
]
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(2), target)
def test_weight_order_3q(self):
"""Test 3-qubit pauli_basis function with weight=True."""
labels = ['III', 'IIX', 'IIY', 'IIZ', 'IXI', 'IYI', 'IZI', 'XII', 'YII', 'ZII',
'IXX', 'IXY', 'IXZ', 'IYX', 'IYY', 'IYZ', 'IZX', 'IZY', 'IZZ',
'XIX', 'XIY', 'XIZ', 'XXI', 'XYI', 'XZI',
'YIX', 'YIY', 'YIZ', 'YXI', 'YYI', 'YZI',
'ZIX', 'ZIY', 'ZIZ', 'ZXI', 'ZYI', 'ZZI',
'XXX', 'XXY', 'XXZ', 'XYX', 'XYY', 'XYZ', 'XZX', 'XZY', 'XZZ',
'YXX', 'YXY', 'YXZ', 'YYX', 'YYY', 'YYZ', 'YZX', 'YZY', 'YZZ',
'ZXX', 'ZXY', 'ZXZ', 'ZYX', 'ZYY', 'ZYZ', 'ZZX', 'ZZY', 'ZZZ']
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(3, weight=True), target)
def test_weight_order_2q(self):
"""Test 2-qubit pauli_basis function with weight=True."""
labels = [
"II",
"IX",
"IY",
"IZ",
"XI",
"YI",
"ZI",
"XX",
"XY",
"XZ",
"YX",
"YY",
"YZ",
"ZX",
"ZY",
"ZZ",
]
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(2, weight=True), target)
def test_standard_order_2q(self):
"""Test 2-qubit pauli_basis function."""
labels = [
"II",
"IX",
"IY",
"IZ",
"XI",
"XX",
"XY",
"XZ",
"YI",
"YX",
"YY",
"YZ",
"ZI",
"ZX",
"ZY",
"ZZ",
]
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(2), target)
def test_weight_order_1q(self):
"""Test 1-qubit pauli_basis function with weight=True."""
labels = ['I', 'X', 'Y', 'Z']
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(1, weight=True), target)
def test_standard_order_1q(self):
"""Test 1-qubit pauli_basis function."""
labels = ['I', 'X', 'Y', 'Z']
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(1), target)
def test_standard_order_3q(self):
"""Test 3-qubit pauli_basis function."""
labels = [
"III",
"IIX",
"IIY",
"IIZ",
"IXI",
"IXX",
"IXY",
"IXZ",
"IYI",
"IYX",
"IYY",
"IYZ",
"IZI",
"IZX",
"IZY",
"IZZ",
"XII",
"XIX",
"XIY",
"XIZ",
"XXI",
"XXX",
"XXY",
"XXZ",
"XYI",
"XYX",
"XYY",
"XYZ",
"XZI",
"XZX",
"XZY",
"XZZ",
"YII",
"YIX",
"YIY",
"YIZ",
"YXI",
"YXX",
"YXY",
"YXZ",
"YYI",
"YYX",
"YYY",
"YYZ",
"YZI",
"YZX",
"YZY",
"YZZ",
"ZII",
"ZIX",
"ZIY",
"ZIZ",
"ZXI",
"ZXX",
"ZXY",
"ZXZ",
"ZYI",
"ZYX",
"ZYY",
"ZYZ",
"ZZI",
"ZZX",
"ZZY",
"ZZZ",
]
target = PauliTable.from_labels(labels)
self.assertEqual(pauli_basis(3), target)