def test_chop_all(self): """Test that chop returns an identity operator with coeff 0 if all coeffs are chopped.""" eps = 1e-10 op = SparsePauliOp(["X", "Z"], coeffs=[eps, eps]) simplified = op.chop(tol=eps) expected = SparsePauliOp(["I"], coeffs=[0.0]) self.assertEqual(simplified, expected)
def to_list(self): """Test to_operator method.""" labels = ["XI", "YZ", "YY", "ZZ"] coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12] op = SparsePauliOp(labels, coeffs) target = list(zip(labels, coeffs)) self.assertEqual(op.to_list(), target)
def test_label_iter(self): """Test SparsePauliOp label_iter method.""" labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"] coeffs = np.array([1, 2, 3, 4, 5, 6]) op = SparsePauliOp(labels, coeffs) for idx, i in enumerate(op.label_iter()): self.assertEqual(i, (labels[idx], coeffs[idx]))
def to_list(self): """Test to_operator method.""" labels = ['XI', 'YZ', 'YY', 'ZZ'] coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12] op = SparsePauliOp(PauliTable.from_labels(labels), coeffs) target = list(zip(labels, coeffs)) self.assertEqual(op.to_list(), target)
def test_matrix_iter_sparse(self): """Test SparsePauliOp sparse matrix_iter method.""" labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"] coeffs = np.array([1, 2, 3, 4, 5, 6]) op = SparsePauliOp(labels, coeffs) for idx, i in enumerate(op.matrix_iter(sparse=True)): np.testing.assert_array_equal(i.toarray(), coeffs[idx] * pauli_mat(labels[idx]))
def test_iter(self): """Test iter with SparsePauliOp.""" labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"] coeffs = np.array([1, 2, 3, 4, 5, 6]) op = SparsePauliOp(labels, coeffs) for idx, i in enumerate(iter(op)): self.assertEqual(i, SparsePauliOp(labels[idx], coeffs[[idx]]))
def test_from_index_list_same_index(self): """Test from_list via Pauli + number of qubits raises correctly, if indices duplicate.""" with self.assertRaises(QiskitError): _ = SparsePauliOp.from_sparse_list([("ZZ", [0, 0], 1)], 2) with self.assertRaises(QiskitError): _ = SparsePauliOp.from_sparse_list([("ZI", [0, 0], 1)], 2) with self.assertRaises(QiskitError): _ = SparsePauliOp.from_sparse_list([("IZ", [0, 0], 1)], 2)
def test_enumerate(self): """Test enumerate with SparsePauliOp.""" labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"] coeffs = np.array([1, 2, 3, 4, 5, 6]) table = PauliTable.from_labels(labels) op = SparsePauliOp(table, coeffs) for idx, i in enumerate(op): self.assertEqual(i, SparsePauliOp(labels[idx], coeffs[[idx]]))
def test_label_iter(self): """Test PauliTable label_iter method.""" labels = ['III', 'IXI', 'IYY', 'YIZ', 'XYZ', 'III'] coeffs = np.array([1, 2, 3, 4, 5, 6]) table = PauliTable.from_labels(labels) op = SparsePauliOp(table, coeffs) for idx, i in enumerate(op.label_iter()): self.assertEqual(i, (labels[idx], coeffs[idx]))
def test_iter(self): """Test iter with PauliTable.""" labels = ['III', 'IXI', 'IYY', 'YIZ', 'XYZ', 'III'] coeffs = np.array([1, 2, 3, 4, 5, 6]) table = PauliTable.from_labels(labels) op = SparsePauliOp(table, coeffs) for idx, i in enumerate(iter(op)): self.assertEqual(i, SparsePauliOp(labels[idx], coeffs[[idx]]))
def test_matrix_iter(self): """Test PauliTable dense matrix_iter method.""" labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"] coeffs = np.array([1, 2, 3, 4, 5, 6]) table = PauliTable.from_labels(labels) op = SparsePauliOp(table, coeffs) for idx, i in enumerate(op.matrix_iter()): self.assertTrue( np.array_equal(i, coeffs[idx] * pauli_mat(labels[idx])))
def to_operator(self): """Test to_operator method.""" labels = ["XI", "YZ", "YY", "ZZ"] coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12] spp_op = SparsePauliOp(labels, coeffs) target = Operator(np.zeros((4, 4), dtype=complex)) for coeff, label in zip(coeffs, labels): target = target + Operator(coeff * pauli_mat(label)) self.assertEqual(spp_op.to_operator(), target)
def to_matrix(self): """Test to_matrix method.""" labels = ["XI", "YZ", "YY", "ZZ"] coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12] spp_op = SparsePauliOp(labels, coeffs) target = np.zeros((4, 4), dtype=complex) for coeff, label in zip(coeffs, labels): target += coeff * pauli_mat(label) np.testing.assert_array_equal(spp_op.to_matrix(), target)
def test_matrix_iter_sparse(self): """Test PauliTable sparse matrix_iter method.""" labels = ['III', 'IXI', 'IYY', 'YIZ', 'XYZ', 'III'] coeffs = np.array([1, 2, 3, 4, 5, 6]) table = PauliTable.from_labels(labels) op = SparsePauliOp(table, coeffs) for idx, i in enumerate(op.matrix_iter(sparse=True)): self.assertTrue( np.array_equal(i.toarray(), coeffs[idx] * pauli_mat(labels[idx])))
def to_operator(self): """Test to_operator method.""" labels = ['XI', 'YZ', 'YY', 'ZZ'] coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12] spp_op = SparsePauliOp(PauliTable.from_labels(labels), coeffs) target = Operator(np.zeros((4, 4), dtype=complex)) for coeff, label in zip(coeffs, labels): target = target + Operator(coeff * pauli_mat(label)) self.assertEqual(spp_op.to_operator(), target)
def to_matrix(self): """Test to_matrix method.""" labels = ['XI', 'YZ', 'YY', 'ZZ'] coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12] spp_op = SparsePauliOp(PauliTable.from_labels(labels), coeffs) target = np.zeros((4, 4), dtype=complex) for coeff, label in zip(coeffs, labels): target += coeff * pauli_mat(label) self.assertTrue(np.array_equal(spp_op.to_matrix(), target))
def test_chop(self): """Test chop, which individually truncates real and imaginary parts of the coeffs.""" eps = 1e-10 op = SparsePauliOp( ["XYZ", "ZII", "ZII", "YZY"], coeffs=[eps + 1j * eps, 1 + 1j * eps, eps + 1j, 1 + 1j]) simplified = op.chop(tol=eps) expected_coeffs = [1, 1j, 1 + 1j] expected_paulis = ["ZII", "ZII", "YZY"] self.assertListEqual(simplified.coeffs.tolist(), expected_coeffs) self.assertListEqual(simplified.paulis.to_labels(), expected_paulis)
def test_simplify(self): """Test simplify method""" coeffs = [3 + 1j, -3 - 1j, 0, 4, -5, 2.2, -1.1j] labels = ["IXI", "IXI", "ZZZ", "III", "III", "XXX", "XXX"] spp_op = SparsePauliOp.from_list(zip(labels, coeffs)) simplified_op = spp_op.simplify() target_coeffs = [-1, 2.2 - 1.1j] target_labels = ["III", "XXX"] target_op = SparsePauliOp.from_list(zip(target_labels, target_coeffs)) self.assertEqual(simplified_op, target_op) np.testing.assert_array_equal(simplified_op.paulis.phase, np.zeros(simplified_op.size))
def test_simplify(self): """Test simplify method""" coeffs = [3 + 1j, -3 - 1j, 0, 4, -5, 2.2, -1.1j] labels = ['IXI', 'IXI', 'ZZZ', 'III', 'III', 'XXX', 'XXX'] value = SparsePauliOp( PauliTable.from_labels(labels), coeffs).simplify() target_coeffs = [-1, 2.2 - 1.1j] target_labels = ['III', 'XXX'] target = SparsePauliOp( PauliTable.from_labels(target_labels), target_coeffs) self.assertEqual(value, target)
def test_pauli_table_init(self): """Test PauliTable initialization.""" labels = ['I', 'X', 'Y', 'Z'] table = PauliTable.from_labels(labels) with self.subTest(msg='no coeffs'): spp_op = SparsePauliOp(table) self.assertTrue(np.array_equal(spp_op.coeffs, np.ones(len(labels)))) self.assertEqual(spp_op.table, table) with self.subTest(msg='no coeffs'): coeffs = [1, 2, 3, 4] spp_op = SparsePauliOp(table, coeffs) self.assertTrue(np.array_equal(spp_op.coeffs, coeffs)) self.assertEqual(spp_op.table, table)
def test_eq_equiv(self): """Test __eq__ and equiv methods with some specific cases.""" with self.subTest("shuffled"): spp_op1 = SparsePauliOp.from_list([("X", 1), ("Y", 2)]) spp_op2 = SparsePauliOp.from_list([("Y", 2), ("X", 1)]) self.assertNotEqual(spp_op1, spp_op2) self.assertTrue(spp_op1.equiv(spp_op2)) with self.subTest("w/ zero"): spp_op1 = SparsePauliOp.from_list([("X", 1), ("Y", 1)]) spp_op2 = SparsePauliOp.from_list([("X", 1), ("Y", 1), ("Z", 0)]) self.assertNotEqual(spp_op1, spp_op2) self.assertTrue(spp_op1.equiv(spp_op2))
def test_pauli_table_init(self): """Test PauliTable initialization.""" labels = ["I", "X", "Y", "Z"] table = PauliTable.from_labels(labels) paulis = PauliList(labels) with self.subTest(msg="no coeffs"): spp_op = SparsePauliOp(table) np.testing.assert_array_equal(spp_op.coeffs, np.ones(len(labels))) self.assertEqual(spp_op.paulis, paulis) with self.subTest(msg="no coeffs"): coeffs = [1, 2, 3, 4] spp_op = SparsePauliOp(table, coeffs) np.testing.assert_array_equal(spp_op.coeffs, coeffs) self.assertEqual(spp_op.paulis, paulis)
def test_from_zip(self): """Test from_list method for zipped input.""" labels = ['XXZ', 'IXI', 'YZZ', 'III'] coeffs = [3.0, 5.5, -1j, 23.3333] spp_op = SparsePauliOp.from_list(zip(labels, coeffs)) self.assertTrue(np.array_equal(spp_op.coeffs, coeffs)) self.assertEqual(spp_op.table, PauliTable.from_labels(labels))
def test_str_init(self): """Test PauliTable initialization.""" for label in ['IZ', 'XI', 'YX', 'ZZ']: table = PauliTable(label) spp_op = SparsePauliOp(label) self.assertEqual(spp_op.table, table) self.assertTrue(np.array_equal(spp_op.coeffs, [1]))
def random_spp_op(self, num_qubits, num_terms): """Generate a pseudo-random SparsePauliOp""" coeffs = (self.RNG.uniform(-1, 1, size=num_terms) + 1j * self.RNG.uniform(-1, 1, size=num_terms)) labels = [''.join(self.RNG.choice(['I', 'X', 'Y', 'Z'], size=num_qubits)) for _ in range(num_terms)] return SparsePauliOp(PauliTable.from_labels(labels), coeffs)
def _pauli_id(n_qubits: int, coeff=None) -> SparsePauliOp: """Return the identity for `SparsePauliOp` on `n_qubits` qubits.""" if coeff is None: coeff = complex(1.0) return SparsePauliOp( Pauli((np.zeros(n_qubits, dtype=bool), np.zeros(n_qubits, dtype=bool))), [coeff])
def test_from_zip(self): """Test from_list method for zipped input.""" labels = ["XXZ", "IXI", "YZZ", "III"] coeffs = [3.0, 5.5, -1j, 23.3333] spp_op = SparsePauliOp.from_list(zip(labels, coeffs)) np.testing.assert_array_equal(spp_op.coeffs, coeffs) self.assertEqual(spp_op.paulis, PauliList(labels))
def test_str_init(self): """Test PauliTable initialization.""" for label in ["IZ", "XI", "YX", "ZZ"]: table = PauliTable(label) spp_op = SparsePauliOp(label) self.assertEqual(spp_op.table, table) self.assertTrue(np.array_equal(spp_op.coeffs, [1]))
def test_pauli_list_init(self): """Test PauliList initialization.""" labels = ["I", "X", "Y", "-Z", "iZ", "-iX"] paulis = PauliList(labels) with self.subTest(msg="no coeffs"): spp_op = SparsePauliOp(paulis) np.testing.assert_array_equal(spp_op.coeffs, [1, 1, 1, -1, 1j, -1j]) paulis.phase = 0 self.assertEqual(spp_op.paulis, paulis) paulis = PauliList(labels) with self.subTest(msg="with coeffs"): coeffs = [1, 2, 3, 4, 5, 6] spp_op = SparsePauliOp(paulis, coeffs) np.testing.assert_array_equal(spp_op.coeffs, [1, 2, 3, -4, 5j, -6j]) paulis.phase = 0 self.assertEqual(spp_op.paulis, paulis)
def test_str_init(self): """Test str initialization.""" for label in ["IZ", "XI", "YX", "ZZ"]: pauli_list = PauliList(label) spp_op = SparsePauliOp(label) self.assertEqual(spp_op.paulis, pauli_list) np.testing.assert_array_equal(spp_op.coeffs, [1])