Operator

class pulser.backend.Operator

Bases: ABC, Generic[ArgScalarType, ReturnScalarType, StateType]

Base class enforcing an API for quantum operator.

Each backend will implement its own type of state and the methods below.

Methods

`apply_to`	Apply the operator to a state.
`expect`	Compute the expectation value of self on the given state.
`from_operator`	Creates a new operator of this type from another operator.
`from_operator_repr`	Create an operator from the operator representation.

Signatures

abstract apply_to(state, /)

Apply the operator to a state.

Parameters:: state (TypeVar(StateType, bound= State)) – The state to apply this operator to.
Return type:: TypeVar(StateType, bound= State)
Returns:: The resulting state.

abstract expect(state, /)

Compute the expectation value of self on the given state.

Parameters:: state (TypeVar(StateType, bound= State)) – The state with which to compute.
Return type:: TypeVar(ReturnScalarType)
Returns:: The expectation value.

classmethod from_operator(operator)

Creates a new operator of this type from another operator.

By default, the operator is converted through its abstract representation, which is only possible if it was created via from_operator_repr(). If the operator is already an instance of this type, a shallow copy of it is returned instead, so it does not need to be serializable.

Subclasses can override this method to support other conversions (e.g. directly from an operator type they know).

Parameters:: operator (Operator) – The operator to convert.
Return type:: TypeVar(OperatorType, bound= Operator)
Returns:: A new operator of this type, equivalent to the given one.
Raises:: TypeError – If the operator can’t be converted to this type.

classmethod from_operator_repr(*, eigenstates, n_qudits, operations)

Create an operator from the operator representation.

Only operators constructed with this method are allowed in remote backend.

The full operator representation (FullOp) is a weigthed sum of tensor operators (TensorOp), written as a sequence of coefficient and tensor operator pairs, ie

FullOp = Sequence[tuple[ScalarType, TensorOp]]

Each TensorOp is itself a sequence of qudit operators (QuditOp) applied to mutually exclusive sets of qudits (represented by their indices), ie

TensorOp = Sequence[tuple[QuditOp, Collection[int]]]

Qudits without an associated QuditOp are applied the identity operator.

Finally, each QuditOp is represented as weighted sum of pre-defined single-qudit operators. It is given as a mapping between a string representation of the single-qudit operator and its respective coefficient, ie

QuditOp = Mapping[str, ScalarType]

By default, it identifies strings "ij" as single-qudit operators, where i and j are eigenstates that denote |i><j|.

Parameters:

eigenstates (Sequence[Literal['u', 'd', 'r', 'g', 'h', 'x'] | Literal['0', '1']]) – The eigenstates to use.
n_qudits (int) – How many qudits there are in the system.
operations (Sequence[tuple[TypeVar(ArgScalarType), Sequence[tuple[Mapping[str, TypeVar(ArgScalarType)], Collection[int]]]]]) – The full operator representation.

Return type:

TypeVar(OperatorType, bound= Operator)

Returns:

The constructed operator.

Examples

>>> eigenstates = ("r", "g")
>>> n_qudits = 4
>>> # define X,Y,Z
>>> X = {"gr": 1.0, "rg": 1.0}
>>> Y = {"gr": 1.0j, "rg": -1.0j}
>>> Z = {"rr": 1.0, "gg": -1.0}
>>> # build for example 0.5*X0Y1X2Z3 - j0.2*Z1Y3 + (-0.1+j4.0)*X2
>>> operations = [
>>>     (
>>>         0.5,
>>>         [
>>>             (X, [0, 2]), # acts on qudit 0 and 2
>>>             (Y, [1]),
>>>             (Z, [3]),
>>>         ],
>>>     ),
>>>     (
>>>         -0.2j,
>>>         [
>>>             (Z, [1]),
>>>             (Y, [3]),
>>>         ],
>>>     ),
>>>     (
>>>         -0.1 + 4.0j,
>>>         [
>>>             (X, [2]),
>>>         ],
>>>     ),
>>> ]
>>> config_class = your_pulser_backend.config_type
>>> operator_class = config_class.operator_type
>>> op = operator_class.from_operator_repr(
>>>     eigenstates=eigenstates,
>>>     n_qudits=n_qudits,
>>>     operations=operations
>>> )