qml.dot

dot(coeffs, ops, pauli=False)

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.

Parameters

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

• ops (Sequence[Operator]) – sequence containing the operators of the linear combination

• 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.

Raises

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

Returns

operator describing the linear combination

Return type

Operator or ParametrizedHamiltonian

Example

>>> 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)
)

code/api/pennylane.dot

 

Download Python script

 

Download Notebook

 

View on GitHub