State

class pulser.backend.State(*, eigenstates)

Bases: ABC, Generic[ArgScalarType, ReturnScalarType]

Base class enforcing an API for quantum states.

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

Attributes

eigenstates	The eigenstates that form a qudit's eigenbasis.
n_qudits	The number of qudits in the state.
qudit_dim	The dimensions (ie number of eigenstates) of a qudit.

Methods

from_state_amplitudes	Construct the state from its basis states' amplitudes.
get_basis_state_from_index	Generates a basis state combination from its index in the state.
infer_one_state	Infers the state measured as 1 from the eigenstates.
overlap	Compute the overlap between this state and another of the same type.
sample	Sample bitstrings from the state, taking into account error rates.

Signatures

classmethod from_state_amplitudes(*, eigenstates, amplitudes)

Construct the state from its basis states’ amplitudes.

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

Parameters:

• eigenstates (Sequence[Literal['u', 'd', 'r', 'g', 'h', 'x'] | Literal['0', '1']]) – The basis states (e.g., (‘r’, ‘g’)).

• amplitudes (Mapping[str, TypeVar(ArgScalarType)]) – A mapping between basis state combinations and complex amplitudes (e.g., {“rgr”: 0.5, “grg”: 0.5}).

Return type:

TypeVar(StateType, bound= State)

Returns:

The state constructed from the amplitudes.

get_basis_state_from_index(index)

Generates a basis state combination from its index in the state.

Assumes a state vector representation regardless of the actual support of the state.

Parameters:

index (int) – The position of the state in a state vector.

Return type:

str

Returns:

The basis state combination for the desired index.

infer_one_state()

Infers the state measured as 1 from the eigenstates.

Only works when the eigenstates form a known eigenbasis with a well-defined “one state”.

Return type:

Literal['u', 'd', 'r', 'g', 'h', 'x'] | Literal['0', '1']

abstract overlap(other, /)

Compute the overlap between this state and another of the same type.

Generally computes Tr[AB] for mixed states A and B, which corresponds to |<a|b>|^2 for pure states A=|a><a| and B=|b><b|.

Parameters:

other (TypeVar(StateType, bound= State)) – The other state.

Return type:

TypeVar(ReturnScalarType, bound= SupportsFloat)

Returns:

The overlap between the two states.

abstract sample(*, num_shots, one_state=None, p_false_pos=0.0, p_false_neg=0.0)

Sample bitstrings from the state, taking into account error rates.

Parameters:

• num_shots (int) – How many bitstrings to sample.

• one_state (Literal['u', 'd', 'r', 'g', 'h', 'x'] | Literal['0', '1'] | None, default: None) – The eigenstate that measures to 1. Can be left undefined if the state’s eigenstates form a known eigenbasis with a defined “one state”.

• p_false_pos (float, default: 0.0) – The rate at which a 0 is read as a 1.

• p_false_neg (float, default: 0.0) – The rate at which a 1 is read as a 0.

Return type:

Counter[str]

Returns:

The measured bitstrings, by count.

property eigenstates: tuple[Literal['u', 'd', 'r', 'g', 'h', 'x', '0', '1'], ...]

The eigenstates that form a qudit’s eigenbasis.

The order of the states should match the order in a numerical (ie state vector or density matrix) representation. For example, with eigenstates (“a”, “b”, …), “a” will be associated to eigenvector (1, 0, …), “b” to (0, 1, …) and so on.

abstract property n_qudits: int

The number of qudits in the state.

property qudit_dim: int

The dimensions (ie number of eigenstates) of a qudit.