qcs_sdk

Contains the ResultData and the duration of the execution.

Represents the two possible types of data returned from either the QVM or a real QPU. Each variant contains the original data returned from its respective executor.

Usage

Your usage of ResultData will depend on the types of programs you are running and where. The ResultData.to_register_map() method will attempt to build RegisterMap out of the data, where each register name is mapped to a 2-dimensional rectangular RegisterMatrix where each row represents the final values in each register index for a particular shot. This is often the desired form of the data and it is probably what you want. This transformation isn't always possible, in which case to_register_map() will return an error.

To understand why this transformation can fail, we need to understand a bit about how readout data is returned from the QVM and from a real QPU:

The QVM treats each DECLARE statement as initialzing some amount of memory. This memory works as one might expect it to. It is zero-initalized, and subsequent writes to the same region overwrite the previous value. The QVM returns memory at the end of every shot. This means we get the last value in every memory reference for each shot, which is exactly the representation we want for a RegisterMatrix. For this reason, to_register_map() should always succeed for ResultData::Qvm.

The QPU on the other hand doesn't use the same memory model as the QVM. Each memory reference (ie. "ro[0]") is more like a stream than a value in memory. Every MEASURE to a memory reference emits a new value to said stream. This means that the number of values per memory reference can vary per shot. For this reason, it's not always clear what the final value in each shot was for a particular reference. When this is the case, to_register_map() will return an error as it's impossible to build a correct RegisterMatrix from the data without knowing the intent of the program that was run. Instead, it's recommended to build the RegisterMatrix you need from the inner QPUResultData data using the knowledge of your program to choose the correct readout values for each shot.

For more information on QPU readout data, refer to the QCS Documentation.

Variants:

• qvm: Data returned from the QVM, stored as QVMResultData
• qpu: Data returned from the QPU, stored as QPUResultData

Methods (each per variant):

• is_*: if the underlying values are that type.
• as_*: if the underlying values are that type, then those values, otherwise None.
• to_*: the underlying values as that type, raises ValueError if they are not.
• from_*: wrap underlying values as this enum type.

A map of register names (ie. "ro") to a RegisterMatrix containing the values of the register.

Values in a 2-dimensional ndarray representing the final shot value in each memory reference across all shots. Each variant corresponds to the possible data types a register can contain.

Variants:

• integer: Corresponds to the Quil BIT, OCTET, or INTEGER types.
• real: Corresponds to the Quil REAL type.
• complex: Registers containing complex numbers.

Methods (each per variant):

• is_*: if the underlying values are that type.
• as_*: if the underlying values are that type, then those values, otherwise None.
• to_*: the underlying values as that type, raises ValueError if they are not.
• from_*: wrap underlying values as this enum type.

The builder interface for executing Quil programs on QVMs and QPUs.

Program execution parameters.

Note: The validity of parameters is not checked until execution.

The result of submitting a job to a QPU.

Used to retrieve the results of a job.

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access::

>>> Color.RED
<Color.RED: 1>

• value lookup:

>>> Color(1)
<Color.RED: 1>

• name lookup:

>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes -- see the documentation for details.

Values present in a register that are one of a set of variants.

Variants:

• i8: Corresponds to the Quil BIT or OCTET types.
• i16: Corresponds to the Quil INTEGER type.
• f64: Corresponds to the Quil REAL type.
• complex32: Results containing complex numbers.

Methods (each per variant):

• is_*: if the underlying values are that type.
• as_*: if the underlying values are that type, then those values, otherwise None.
• to_*: the underlying values as that type, raises ValueError if they are not.
• from_*: wrap underlying values as this enum type.

Error encountered when executing a program.

Error that may occur when building a RegisterMatrix from execution data.

Reset all caches for logging configuration within this library, allowing the most recent Python-side changes to be applied.

See https://docs.rs/pyo3-log/latest/pyo3_log/ for more information.