qp.pauli.PauliSentence

class PauliSentence[source]

Bases: dict

Dictionary representing a linear combination of Pauli words, with the keys as PauliWord instances and the values correspond to coefficients.

Note

An empty PauliSentence will be treated as the additive identity (i.e 0 * Identity()). Its matrix is the all-zero matrix (trivially the \(1\times 1\) zero matrix when no wire_order is passed to PauliSentence({}).to_mat()).

Examples

>>> ps = PauliSentence({
...     PauliWord({0:'X', 1:'Y'}): 1.23,
...     PauliWord({2:'Z', 0:'Y'}): -0.45j
... })
>>> ps
1.23 * X(0) @ Y(1)
+ (-0-0.45j) * Z(2) @ Y(0)

Combining Pauli words automatically results in Pauli sentences that can be used to construct more complicated operators.

>>> w1 = PauliWord({0:"X", 1:"Y"})
>>> w2 = PauliWord({1:"X", 2:"Z"})
>>> ps = 0.5 * w1 - 1.5 * w2 + 2
>>> ps + PauliWord({3:"Z"}) - 1
0.5 * X(0) @ Y(1)
+ -1.5 * X(1) @ Z(2)
+ 1 * I
+ 1.0 * Z(3)

Note that while the empty PauliWord PauliWord({}) respresents the identity, the empty PauliSentence represents 0

>>> PauliSentence({})
0 * I

We can compute commutators using the PauliSentence.commutator() method

>>> op1 = PauliWord({0:"X", 1:"X"})
>>> op2 = PauliWord({0:"Y"}) + PauliWord({1:"Y"})
>>> op1.commutator(op2)
2j * Z(0) @ X(1)
+ 2j * X(0) @ Z(1)

Or, alternatively, use commutator().

>>> qp.commutator(op1, op2, pauli=True)
2j * Z(0) @ X(1)
+ 2j * X(0) @ Z(1)

Note that we need to specify pauli=True as commutator() returns PennyLane operators by default.

pauli_rep

Trivial pauli_rep

wires

Track wires of the PauliSentence.

pauli_rep

Trivial pauli_rep

wires

Track wires of the PauliSentence.

commutator(other)

Compute commutator between a PauliSentence \(P\) and other operator \(O\)

dot(vector[, wire_order])

Computes the matrix-vector product of the Pauli sentence with a state vector.

map_wires(wire_map)

Return a new PauliSentence with the wires mapped.

operation([wire_order])

Returns a native PennyLane Operation representing the PauliSentence.

prune([tol])

Remove any PauliWord with coefficients less than the threshold tolerance.

simplify([tol])

Remove any PauliWord with coefficients less than the threshold tolerance.

to_mat([wire_order, format, buffer_size])

Returns the matrix representation.

trace()

Return the normalized trace of the PauliSentence instance

commutator(other)[source]

Compute commutator between a PauliSentence \(P\) and other operator \(O\)

\[[P, O] = P O - O P\]

When the other operator is a PauliWord or PauliSentence, this method is faster than computing P @ O - O @ P. It is what is being used in commutator() when setting pauli=True.

Parameters:

other (Union[Operator, PauliWord, PauliSentence]) – Second operator

Returns:

The commutator result in form of a PauliSentence instances.

Return type:

~PauliSentence

Examples

You can compute commutators between PauliSentence instances.

>>> pw1 = PauliWord({0:"X"})
>>> pw2 = PauliWord({1:"X"})
>>> ps1 = PauliSentence({pw1: 1., pw2: 2.})
>>> ps2 = PauliSentence({pw1: 0.5j, pw2: 1j})
>>> ps1.commutator(ps2)
0 * I

You can also compute the commutator with other operator types if they have a Pauli representation.

>>> ps1.commutator(qp.Y(0))
2j * Z(0)
dot(vector, wire_order=None)[source]

Computes the matrix-vector product of the Pauli sentence with a state vector. See pauli_sparse_matrices.md for the technical details.

map_wires(wire_map)[source]

Return a new PauliSentence with the wires mapped.

operation(wire_order=())[source]

Returns a native PennyLane Operation representing the PauliSentence.

prune(tol=1e-08)[source]

Remove any PauliWord with coefficients less than the threshold tolerance.

Examples

>>> ps = PauliSentence({
...     PauliWord({0:'X', 1:'Y'}): 0,
...     PauliWord({2:'Z', 0:'Y'}): -0.45j
... })
>>> ps
0 * X(0) @ Y(1)
+ (-0-0.45j) * Z(2) @ Y(0)
>>> ps.prune()
>>> ps
(-0-0.45j) * Z(2) @ Y(0)
simplify(tol=1e-08)[source]

Remove any PauliWord with coefficients less than the threshold tolerance.

This method mutates the PauliSentence in place, and does not return anything.

See also

prune()

Warning

The simplify method is deprecated and will be removed in v0.47. Please use the prune() method instead.

to_mat(wire_order=None, format='dense', buffer_size=None)[source]

Returns the matrix representation.

Keyword Arguments:
  • wire_order (iterable or None) – The order of qubits in the tensor product.

  • format (str) – The format of the matrix. It is “dense” by default. Use “csr” for sparse.

  • buffer_size (int or None) – The maximum allowed memory in bytes to store intermediate results in the calculation of sparse matrices. It defaults to 2 ** 30 bytes that make 1GB of memory. In general, larger buffers allow faster computations.

Returns:

Matrix representation of the Pauli sentence.

Return type:

(Union[NumpyArray, ScipySparseArray])

Raises:

ValueError – Can’t get the matrix of an empty PauliSentence.

trace()[source]

Return the normalized trace of the PauliSentence instance

\[\frac{1}{2^n} \text{tr}\left( P \right).\]

The normalized trace does not scale with the number of qubits \(n\).

>>> PauliSentence({PauliWord({0:"I", 1:"I"}): 0.5}).trace()
0.5
>>> PauliSentence({PauliWord({}): 0.5}).trace()
0.5