Using PennyLane

Release news

Development

API

Internals

  1. Docs
  2. qml.pauli
  3. qml.pauli.pauli_decompose

qml.pauli.pauli_decompose

pauli_decompose(H, hide_identity=False, wire_order=None, pauli=False, check_hermitian=True)[source]

Decomposes a Hermitian matrix into a linear combination of Pauli operators.

Parameters:

  • H (tensor_like[complex]) – a Hermitian matrix of dimension \(2^n\times 2^n\).

  • hide_identity (bool) – does not include the Identity observable within the tensor products of the decomposition if True.

  • wire_order (list[Union[int, str]]) – the ordered list of wires with respect to which the operator is represented as a matrix.

  • pauli (bool) – return a PauliSentence instance if True.

  • check_hermitian (bool) – check if the provided matrix is Hermitian if True.

Returns:

the matrix decomposed as a linear combination of Pauli operators, returned either as a LinearCombination or PauliSentence instance.

Return type:

Union[LinearCombination, PauliSentence]

Example:

We can use this function to compute the Pauli operator decomposition of an arbitrary Hermitian matrix:

>>> import pennylane as qml
>>> import numpy as np
>>> A = np.array(
... [[-2, -2+1j, -2, -2], [-2-1j,  0,  0, -1], [-2,  0, -2, -1], [-2, -1, -1,  0]])
>>> H = qml.pauli_decompose(A)
>>> import pprint
>>> pprint.pprint(H)
(
    -1.0 * (I(0) @ I(1))
  + -1.5 * (I(0) @ X(1))
  + -0.5 * (I(0) @ Y(1))
  + -1.0 * (I(0) @ Z(1))
  + -1.5 * (X(0) @ I(1))
  + -1.0 * (X(0) @ X(1))
  + -0.5 * (X(0) @ Z(1))
  + 1.0 * (Y(0) @ Y(1))
  + -0.5 * (Z(0) @ X(1))
  + -0.5 * (Z(0) @ Y(1))
)

We can return a PauliSentence instance by using the keyword argument pauli=True:

>>> ps = qml.pauli_decompose(A, pauli=True)
>>> print(ps)
-1.0 * I
+ -1.5 * X(1)
+ -0.5 * Y(1)
+ -1.0 * Z(1)
+ -1.5 * X(0)
+ -1.0 * X(0) @ X(1)
+ -0.5 * X(0) @ Z(1)
+ 1.0 * Y(0) @ Y(1)
+ -0.5 * Z(0) @ X(1)
+ -0.5 * Z(0) @ Y(1)

By default the wires are numbered [0, 1, …, n], but we can also set custom wires using the wire_order argument:

>>> ps = qml.pauli_decompose(A, pauli=True, wire_order=['a', 'b'])
>>> print(ps)
-1.0 * I
+ -1.5 * X(b)
+ -0.5 * Y(b)
+ -1.0 * Z(b)
+ -1.5 * X(a)
+ -1.0 * X(a) @ X(b)
+ -0.5 * X(a) @ Z(b)
+ 1.0 * Y(a) @ Y(b)
+ -0.5 * Z(a) @ X(b)
+ -0.5 * Z(a) @ Y(b)

This method internally uses a generalized decomposition routine to convert the matrix to a weighted sum of Pauli words acting on \(n\) qubits in time \(O(n 4^n)\). The input matrix is written as a quantum state in the computational basis following the channel-state duality. A Bell basis transformation is then performed using the Walsh-Hadamard transform, after which coefficients for each of the \(4^n\) Pauli words are computed while accounting for the phase from each PauliY term occurring in the word.

Previous
Next