qiskit.opflow.list_ops.SummedOp(oplist, coeff=1.0, abelian=False)
Deprecated: A class for lazily representing sums of Operators. Often Operators cannot be efficiently added to one another, but may be manipulated further so that they can be later. This class holds logic to indicate that the Operators in
oplist are meant to be added together, and therefore if they reach a point in which they can be, such as after evaluation or conversion to matrices, they can be reduced by addition.
qiskit.opflow.list_ops.summed_op.SummedOp is deprecated as of qiskit-terra 0.24.0. It will be removed no earlier than 3 months after the release date. For code migration guidelines, visit https://qisk.it/opflow_migration (opens in a new tab).
- oplist (List (opens in a new tab)[OperatorBase]) – The Operators being summed.
- coeff (complex (opens in a new tab) |ParameterExpression) – A coefficient multiplying the operator
- abelian (bool (opens in a new tab)) – Indicates whether the Operators in
oplistare known to mutually commute.
= ' '
Whether the Operators in
oplist are known to commute with one another.
A bool indicating whether the
oplist is Abelian.
The scalar coefficient multiplying the Operator.
Return a list of the coefficients of the operators listed. Raises exception for nested Listops.
The function defining how to combine
oplist (or Numbers, or NumPy arrays) to produce the Operator’s underlying function. For example, SummedOp’s combination function is to add all of the Operators in
The combination function.
The gradient of
Return the unique instance id.
The list of
OperatorBases defining the underlying function of this Operator.
The Operators defining the ListOp
Return Operator addition of
other, overloaded by
self.oplist without checking
other is already included or not. If you want to simplify them, please use
other (OperatorBase) – An
OperatorBase with the same number of qubits as self, and in the same ‘Operator’, ‘State function’, or ‘Measurement’ category as self (i.e. the same type of underlying function).
SummedOp equivalent to the sum of self and other.
Return Operator by simplifying duplicate operators.
SummedOp([2 * X ^ Y, X ^ Y]).collapse_summands() -> SummedOp([3 * X ^ Y]).
SummedOp equivalent to self.
Check if other is equal to self.
This is not a mathematical check for equality. If
other implement the same operation but differ in the representation (e.g. different type of summands)
equals will evaluate to
other (OperatorBase) – The other operator to check for equality.
True, if other and self are equal, otherwise False.
>>> from qiskit.opflow import X, Z >>> 2 * X == X + X True >>> X + Z == Z + X True
Try collapsing list or trees of sums.
Tries to sum up duplicate operators and reduces the operators in the sum.
A collapsed version of self, if possible.
Returns the quantum circuit, representing the SummedOp. In the first step, the SummedOp is converted to MatrixOp. This is straightforward for most operators, but it is not supported for operators containing parameterized PrimitiveOps (in that case, OpflowError is raised). In the next step, the MatrixOp representation of SummedOp is converted to circuit. In most cases, if the summands themselves are unitary operators, the SummedOp itself is non-unitary and can not be converted to circuit. In that case, ExtensionError is raised in the underlying modules.
The circuit representation of the summed operator.
- OpflowError – if SummedOp can not be converted to MatrixOp (e.g. SummedOp is composed of
- parameterized PrimitiveOps**)****.** –
Returns an equivalent Operator composed of only NumPy-based primitives, such as
Returns an equivalent Operator composed of only Pauli-based primitives, such as