qml.estimator.templates.TrotterPauli

class TrotterPauli(pauli_ham, num_steps, order, wires=None)

Bases: ResourceOperator

A resource operation representing the Suzuki-Trotter product approximation for the complex matrix exponential of a Hamiltonian represented as a linear combination of tensor products of Pauli operators.

The Suzuki-Trotter product formula provides a method to approximate the matrix exponential of Hamiltonian expressed as a linear combination of terms which in general do not commute. For instance, in the Hamiltonian \(H = \Sigma^{N}_{j=0} \alpha_{j} \cdot O_{j}\), the product formula is constructed using symmetrized products of the terms in the Hamiltonian. The symmetrized products of order \(m \in [1, 2, 4, ..., 2k]\) with \(k \in \mathbb{N}\) are given by:

\[\begin{split}\begin{align} S_{1}(t) &= \Pi_{j=0}^{N} \ e^{i t \alpha_{j} O_{j}} \\ S_{2}(t) &= \Pi_{j=0}^{N} \ e^{i \frac{t}{2} \alpha_{j} O_{j}} \cdot \Pi_{j=N}^{0} \ e^{i \frac{t}{2} \alpha_{j} O_{j}} \\ &\vdots \\ S_{m}(t) &= S_{m-2}(p_{m}t)^{2} \cdot S_{m-2}((1-4p_{m})t) \cdot S_{m-2}(p_{m}t)^{2}, \end{align}\end{split}\]

where the coefficient is \(p_{m} = 1 / (4 - \sqrt[m - 1]{4})\). The \(m^{\text{th}}\) order, \(n\)-step Suzuki-Trotter approximation is then defined as:

\[e^{iHt} \approx \left [S_{m}(t / n) \right ]^{n}.\]

For more details see J. Math. Phys. 32, 400 (1991).

Parameters:

• pauli_ham (PauliHamiltonian) – the Hamiltonian to be approximately exponentiated

• num_steps (int) – number of Trotter steps to perform

• order (int) – order of the approximation, must be 1 or an even number

• wires (WiresLike | None) – the wires on which the operator acts

Raises:

• TypeError – if pauli_ham is not an instance of PauliHamiltonian

• ValueError – if num_steps is not a positive integer

• ValueError – if order is not 1 or a positive even integer

• ValueError – if the number of wires provided does not match the wires expected by the operator

Resources:

The resources are defined according to the recursive formula presented above. The number of times an operator \(e^{itO_{j}}\) is applied depends on the number of Trotter steps (n) and the order of the approximation (m) as:

\[C_{O_j} = 2 \cdot n \cdot 5^{\frac{m}{2} - 1}\]

Furthermore, because of the symmetric form of the recursive formula, the first and last terms are grouped. This reduces the counts for those terms to:

\[\begin{split}\begin{align} C_{O_{0}} &= n \cdot 5^{\frac{m}{2} - 1} + 1, \\ C_{O_{N}} &= n \cdot 5^{\frac{m}{2} - 1}. \end{align}\end{split}\]

See also

PauliHamiltonian, TrotterProduct

Example

The resources for this operation are computed using the code below.

>>> pauli_terms = {"X":10, "XX":5, "XXXX":3, "YY": 5, "ZZ":5, "Z": 2}
>>> pauli_ham = qre.PauliHamiltonian(num_qubits=10, pauli_terms=pauli_terms)
>>> num_steps, order = (1, 2)
>>> res = qre.estimate(qre.TrotterPauli(pauli_ham, num_steps, order))
>>> print(res)
--- Resources: ---
 Total wires: 10
   algorithmic wires: 10
   allocated wires: 0
     zero state: 0
     any state: 0
 Total gates : 2.844E+3
   'T': 2.640E+3,
   'CNOT': 96,
   'Z': 20,
   'S': 40,
   'Hadamard': 48

Usage Details

This example computes the resources for a Hamiltonian partitioned into commuting groups of Pauli terms. See PauliHamiltonian for more information. Note that placing the largest commuting groups at the boundaries, either the beginning or the end of the list, optimizes resource reduction. This efficiency is achieved by merging the final operation of the Trotter step i with the initial operation of step i+1 which effectively minimizes gate overhead.

>>> commuting_groups = (
...     {"X":10, "XX":5, "XXXX":3},
...     {"YY": 5, "ZZ":5},
...     {"Z": 2},
... )
>>> pauli_ham = qre.PauliHamiltonian(num_qubits=10, pauli_terms=commuting_groups)
>>> num_steps, order = (1, 2)
>>> res = qre.estimate(qre.TrotterPauli(pauli_ham, num_steps, order))
>>> print(res)
--- Resources: ---
 Total wires: 10
   algorithmic wires: 10
   allocated wires: 0
     zero state: 0
     any state: 0
 Total gates : 2.756E+3
   'T': 2.552E+3,
   'CNOT': 96,
   'Z': 20,
   'S': 40,
   'Hadamard': 48

Attributes

resource_keys
resource_params	Returns a dictionary containing the minimal information needed to compute the resources.

resource_keys = {'num_steps', 'order', 'pauli_ham'}

resource_params

Returns a dictionary containing the minimal information needed to compute the resources.

Returns:

A dictionary containing the resource parameters:

• pauli_ham (PauliHamiltonian): The Hamiltonian to be approximately exponentiated

• num_steps (int): number of Trotter steps to perform

• order (int): order of the approximation, must be 1 or even.

Return type:

dict

Methods

resource_decomp(pauli_ham, num_steps, order)	Returns a list representing the resources of the operator.
resource_rep(pauli_ham, num_steps, order)	Returns a compressed representation containing only the parameters of the Operator that are needed to compute the resources.

classmethod resource_decomp(pauli_ham, num_steps, order)

Returns a list representing the resources of the operator. Each object represents a quantum gate and the number of times it occurs in the decomposition.

Parameters:

• pauli_ham (PauliHamiltonian) – The Hamiltonian to be approximately exponentiated

• num_steps (int) – number of Trotter steps to perform

• order (int) – order of the approximation, must be 1 or even.

Resources:

The resources are defined according to the recursive formula presented above. The number of times an operator \(e^{itO_{j}}\) is applied depends on the number of Trotter steps (n) and the order of the approximation (m) as:

\[C_{O_j} = 2 \cdot n \cdot 5^{\frac{m}{2} - 1}\]

Furthermore, because of the symmetric form of the recursive formula, the first and last terms are grouped. This reduces the counts for those terms to:

\[\begin{split}\begin{align} C_{O_{0}} &= n \cdot 5^{\frac{m}{2} - 1} + 1, \\ C_{O_{N}} &= n \cdot 5^{\frac{m}{2} - 1}. \end{align}\end{split}\]

Returns:

A list of GateCount objects, where each object represents a specific quantum gate and the number of times it appears in the decomposition.

Return type:

list[GateCount]

classmethod resource_rep(pauli_ham, num_steps, order)

Returns a compressed representation containing only the parameters of the Operator that are needed to compute the resources.

Parameters:

• pauli_ham (PauliHamiltonian) – The Hamiltonian to be approximately exponentiated

• num_steps (int) – number of Trotter steps to perform

• order (int) – order of the approximation, must be 1 or even.

Returns:

the operator in a compressed representation

Return type:

CompressedResourceOp

code/api/pennylane.estimator.templates.TrotterPauli

 

Download Python script

 

Download Notebook

 

View on GitHub