qml.generator

generator(op, format='prefactor')[source]

Returns the generator of an operation.

Parameters
  • op (Operator or Callable) – A single operator, or a function that applies a single quantum operation.

  • format (str) – The format to return the generator in. Must be one of 'prefactor', 'observable', or 'hamiltonian'. See below for more details.

Returns

The returned generator, with format/type dependent on the format argument.

  • "prefactor": Return the generator as (obs, prefactor) (representing \(G=p \hat{O}\)), where:

  • "observable": Return the generator as a single observable as directly defined by op. Returned generators may be any type of observable, including Hermitian, Tensor, SparseHamiltonian, or Hamiltonian.

  • "hamiltonian": Similar to "observable", however the returned observable will always be converted into Hamiltonian regardless of how op encodes the generator.

Return type

Observable or tuple[Observable, float]

Example

Given an operation, qml.generator returns the generator representation:

>>> op = qml.CRX(0.6, wires=[0, 1])
>>> qml.generator(op)
(Projector([1], wires=[0]) @ PauliX(wires=[1]), -0.5)

It can also be used in a functional form:

>>> qml.generator(qml.CRX)(0.6, wires=[0, 1])
(Projector([1], wires=[0]) @ PauliX(wires=[1]), -0.5)

By default, generator will return the generator in the format of (obs, prefactor), corresponding to \(G=p \hat{O}\), where the observable \(\hat{O}\) will always be given in tensor product form, or as a dense/sparse matrix.

By using the format argument, the returned generator representation can be altered:

>>> op = qml.RX(0.2, wires=0)
>>> qml.generator(op, format="prefactor")  # output will always be (prefactor, obs)
(PauliX(wires=[0]), -0.5)
>>> qml.generator(op, format="hamiltonian")  # output will always be a Hamiltonian
<Hamiltonian: terms=1, wires=[0]>
>>> qml.generator(qml.PhaseShift(0.1, wires=0), format="observable")  # ouput will be a simplified obs where possible
Projector([1], wires=[0])