cuquantum.densitymat.Operator

class cuquantum.densitymat.Operator(hilbert_space_dims, *terms)

Operator representing a collection of OperatorTerm objects.

The action of an Operator maps a State to another State. An Operator acts on an instance of State through its compute method after its prepare method is called on the same instance of State.

Parameters

• hilbert_space_dims – Hilbert space dimensions of the physical system.

• terms – A sequence of tuples specifying each term. Each tuple can consist of a single element (OperatorTerm), two elements (OperatorTerm and coefficient), three elements (OperatorTerm, coefficient and duality) or four elements (OperatorTerm, coefficient, duality and batch size). If less than four elements are given, the remaining ones will be set to their default values (coefficient=1, duality=False, batch_size=1).

Methods

__add__(other: Operator) → Operator

Return a new Operator equal to the sum of this Operator with another Operator.

__iadd__(other: Union[Operator, OperatorTerm]) → None

Inplace add another Operator or OperatorTerm into this Operator.

__init__(hilbert_space_dims: Sequence[int], *terms: Union[Tuple[OperatorTerm], Tuple[OperatorTerm, Union[numbers.Number, numpy.ndarray, cupy.ndarray, Callback, Tuple[numbers.Number, Callback], Tuple[Union[numpy.ndarray, cupy.ndarray], Callback]]], Tuple[OperatorTerm, Union[numbers.Number, numpy.ndarray, cupy.ndarray, Callback, Tuple[numbers.Number, Callback], Tuple[Union[numpy.ndarray, cupy.ndarray], Callback]], bool], Tuple[OperatorTerm, Union[numbers.Number, numpy.ndarray, cupy.ndarray, Callback, Tuple[numbers.Number, Callback], Tuple[Union[numpy.ndarray, cupy.ndarray], Callback]], bool, int]]) → None

Initialize an operator representing a collection of OperatorTerm objects.

__mul__(factor: Union[numbers.Number, numpy.ndarray, cupy.ndarray, Callback, Tuple[numbers.Number, Callback], Tuple[Union[numpy.ndarray, cupy.ndarray], Callback]]) → Operator

Return a new Operator equal to this Operator multiplied by a scalar or a batch of scalars on the left.

__rmul__(scalar) → Operator

Return a new Operator equal to this Operator multiplied by a scalar on the right.

__sub__(other: Operator) → Operator

Return the difference of this Operator with another Operator.

append(term: OperatorTerm, coeff: Union[numbers.Number, numpy.ndarray, cupy.ndarray, Callback, Tuple[numbers.Number, Callback], Tuple[Union[numpy.ndarray, cupy.ndarray], Callback]] = 1.0, duality: bool = False, batch_size: Optional[int] = 1) → None

Append an OperatorTerm to this Operator.

Parameters

• term – The OperatorTerm to be appended.

• coeff – The coefficient associated with this OperatorTerm.

• duality – Whether the elementary operators in term are applied on ket modes (False) or bra modes (True).

• batch_size – Batch size associated with the operator term.

compute_action(t: float, params: Optional[Union[numpy.ndarray, cupy.ndarray, Sequence[float]]], state_in: State, state_out: State) → None

Compute the action of this Operator on an input state and accumulate into the output state.

Parameters

• t – Time argument to be passed to all callback functions.

• params – Additional arguments to be passed to all callback functions. The element type is required to be float (i.e “float64” for arrays). If batched operators or coefficients are used, they need to be passed as 2-dimensional the last dimension of which is the batch size. To avoid copy of the argument array, it can be passed as a fortran-contiguous cp.ndarray.

• state – The input quantum state to which the Operator is to be applied.

• state_out – The output quantum state to which the action is to be accumulated. Defaults to state.

compute_action_gradient_backward(t: float, params: Union[numpy.ndarray, cupy.ndarray, Sequence[float]], state_in: State, state_out_adj: State, state_in_adj: State) → cupy.ndarray

Compute the action gradient of this Operator through backward differentiation. The input to the backward pass is the output state adjoint state_out_adj and this call overwrites state_in_adj with the result of the backward pass.

Parameters

• t – Time argument to be passed to all callback functions.

• params – Additional arguments to be passed to all callback functions. The element type is required to be float (i.e “float64” for arrays). If batched operators or coefficients are used, they need to be passed as 2-dimensional the last dimension of which is the batch size. To avoid copy of the argument array, it can be passed as a fortran-contiguous cp.ndarray.

• state_in – The input quantum state to which the Operator is to be applied.

• state_out_adj – The adjoint of the output quantum state.

• state_in_adj – The adjoint of the input quantum state. Note that this state will be overwritten with the output of the backward pass of the gradient computation.

Returns

Gradients with respect to the callback arguments.

compute_expectation(t: float, params: Optional[Union[numpy.ndarray, cupy.ndarray, Sequence[float]]], state: State, out: Optional[cupy.ndarray] = None) → cupy.ndarray

Compute the expectation value of this Operator on a state.

Parameters

• t – Time argument to be passed to all callback functions.

• params – Additional arguments to be passed to all callback functions. The element type is required to be float (i.e “float64” for arrays). If batched operators or coefficients are used, they need to be passed as 2-dimensional the last dimension of which is the batch size. To avoid copy of the argument array, it can be passed as a fortran-contiguous cp.ndarray.

• state – The quantum state on which the expectation value is evaluated.

Returns

The computed expectation value wrapped in a cupy.ndarray.

Note

Currently, this method executes in blocking manner, returning the expectation value only after the computation is finished.

dual() → Operator

Return a shallow copy of this Operator with flipped duality for each term.

prepare_action(ctx: WorkStream, state: State, state_out: Optional[State] = None, compute_type: Optional[str] = None) → None

Prepare the action of this Operator on an input state and accumulate into the output state.

Parameters

• ctx – Library context, which contains workspace, stream and other configuration information.

• state – The input quantum state to which the Operator is to be applied.

• state_out – The output quantum state to which the action is to be accumulated. Defaults to state.

• compute_type – The CUDA compute type to be used by the computation.

Attention

The compute_type argument is currently not used and will default to the data type.

prepare_action_gradient_backward(ctx: WorkStream, state_in: State, state_out_adj: Optional[State] = None, compute_type: Optional[str] = None) → None

Prepare the evaluation of the operator action gradient of this Operator.

Parameters

• ctx – Library context, which contains workspace, stream and other configuration information.

• state_in – The input quantum state to which the Operator is to be applied.

• state_out_adj – The output quantum state adjoint with respect to which the gradient is evaluated. Defaults to state_in.

• compute_type – The CUDA compute type to be used by the computation.

Attention

The compute_type argument is currently not used and will default to the data type.

prepare_expectation(ctx: WorkStream, state: State, compute_type: Optional[str] = None) → None

Prepare the computation of an expectation value of this Operator on a state.

Parameters

• ctx – Library context, which contains workspace, stream and other configuration information.

• state – The quantum state on which the expectation value is evaluated.

• compute_type – The CUDA compute type to be used by the computation.

Attention

The compute_type argument is currently not used and will default to the data type.

Attributes

dtype

Data type of this Operator.

hilbert_space_dims

Hilbert space dimension of this Operator.