dot(coeffs, ops, pauli=False, grouping_type=None, method='rlf')[source]

Returns the dot product between the coeffs vector and the ops list of operators.

This function returns the following linear combination: \(\sum_{k} c_k O_k\), where \(c_k\) and \(O_k\) are the elements inside the coeffs and ops arguments, respectively.

  • coeffs (Sequence[float, Callable]) – sequence containing the coefficients of the linear combination

  • ops (Sequence[Operator, PauliWord, PauliSentence]) – sequence containing the operators of the linear combination. Can also be PauliWord or PauliSentence instances.

  • pauli (bool, optional) – If True, a PauliSentence operator is used to represent the linear combination. If False, a Sum operator is returned. Defaults to False. Note that when ops consists solely of PauliWord and PauliSentence instances, the function still returns a PennyLane operator when pauli=False.

  • grouping_type (str) – The type of binary relation between Pauli words used to compute the grouping. Can be 'qwc', 'commuting', or 'anticommuting'. Note that if pauli=True, the grouping will be ignored.

  • method (str) – The graph coloring heuristic to use in solving minimum clique cover for grouping, which can be 'lf' (Largest First) or 'rlf' (Recursive Largest First). This keyword argument is ignored if grouping_type is None.


ValueError – if the number of coefficients and operators does not match or if they are empty


operator describing the linear combination

Return type

Operator or ParametrizedHamiltonian


If grouping is requested, the computed groupings are stored as a list of list of indices in Sum.grouping_indices. The indices refer to the operators and coefficients returned by Sum.terms(), not Sum.operands, as these are not guaranteed to be equivalent.


>>> coeffs = np.array([1.1, 2.2])
>>> ops = [qml.X(0), qml.Y(0)]
>>> qml.dot(coeffs, ops)
1.1 * X(0) + 2.2 * Y(0)
>>> qml.dot(coeffs, ops, pauli=True)
1.1 * X(0)
+ 2.2 * Y(0)

Note that additions of the same operator are not executed by default.

>>> qml.dot([1., 1.], [qml.X(0), qml.X(0)])
X(0) + X(0)

You can obtain a cleaner version by simplifying the resulting expression.

>>> qml.dot([1., 1.], [qml.X(0), qml.X(0)]).simplify()
2.0 * X(0)

pauli=True can be used to construct a more efficient, simplified version of the operator. Note that it returns a PauliSentence, which is not an Operator. This specialized representation can be converted to an operator:

>>> qml.dot([1, 2], [qml.X(0), qml.X(0)], pauli=True).operation()
3.0 * X(0)

Using pauli=True and then converting the result to an Operator is much faster than using pauli=False, but it only works for pauli words (see is_pauli_word()).

If any of the parameters listed in coeffs are callables, the resulting dot product will be a ParametrizedHamiltonian:

>>> coeffs = [lambda p, t: p * jnp.sin(t) for _ in range(2)]
>>> ops = [qml.X(0), qml.Y(0)]
>>> qml.dot(coeffs, ops)
    <lambda>(params_0, t) * X(0)
  + <lambda>(params_1, t) * Y(0)

Grouping information can be collected during construction using the grouping_type and method keyword arguments. For example:

import pennylane as qml

a = qml.X(0)
b = qml.prod(qml.X(0), qml.X(1))
c = qml.Z(0)
obs = [a, b, c]
coeffs = [1.0, 2.0, 3.0]

op = qml.dot(coeffs, obs, grouping_type="qwc")
>>> op.grouping_indices
((2,), (0, 1))

grouping_type can be "qwc" (qubit-wise commuting), "commuting", or "anticommuting", and method can be "rlf" or "lf". To see more details about how these affect grouping, see Pauli Graph Colouring and group_observables().


Using PennyLane

Release news