Interacting with Neutral Atom Hardware

get_device_capabilities(capabilities_file=nothing)

Generates a DeviceCapabilities struct from either an explicitly provided path to a capabilities JSON file or using the default JSON provided in "lib/BloqadeSchema/config/capabilities-qpu1-mock.json".

By default, the units for capabilities JSON file are specified by the "lib/BloqadeSchema/config/capabilities-qpu1-mock-units.json" file this function gives a DeviceCapabilities struct with non-SI base (e.g. μm, μs) units.

See also get_device_capabilities_SI

julia> get_device_capabilities()
BloqadeSchema.DeviceCapabilities(BloqadeSchema.TaskCapabilities(1, 1000), BloqadeSchema.LatticeCapabilities(BloqadeSchema.LatticeAreaCapabilities(75.0, 76.0), BloqadeSchema.LatticeGeometryCapabilities(4.0, 4.0, 0.1, 256), 256), BloqadeSchema.RydbergCapabilities(5.42e6, BloqadeSchema.RydbergGlobalCapabilities(0.0, 15.8, 0.0004, 250.0, -125.0, 125.0, 2.0e-7, 2500.0, -99.0, 99.0, 5.0e-7, 0.0, 4.0, 0.001, 0.05), nothing))

get_device_capabilities_SI(capabilities_file=nothing)

Generates a DeviceCapabilities struct from either an explicitly provided path to a capabilities JSON file or using the default JSON provided in "lib/BloqadeSchema/config/capabilities-qpu1-mock.json".

The values returned are in Base SI units: m, s, rad/s, etc.

julia> get_device_capabilities_SI()
BloqadeSchema.DeviceCapabilities(BloqadeSchema.TaskCapabilities(1, 1000), BloqadeSchema.LatticeCapabilities(BloqadeSchema.LatticeAreaCapabilities(7.5e-5, 7.6e-5), BloqadeSchema.LatticeGeometryCapabilities(4.0e-6, 4.0e-6, 1.0e-7, 256), 256), BloqadeSchema.RydbergCapabilities(5.42e-24, BloqadeSchema.RydbergGlobalCapabilities(0.0, 1.58e7, 400.0, 2.5e14, -1.25e8, 1.25e8, 0.2, 2.5e15, -99.0, 99.0, 5.0e-7, 0.0, 4.0e-6, 1.0e-9, 5.0e-8), nothing))

hardware_transform_Ω(Ω,device_capabilities::DeviceCapabilities=get_device_capabilities())

Given the device_capabilities of the machine and a Rabi frequency (Ω) Waveform, return a transformed Ω capable of being implemented by the machine along with the error between the original ($A$) and transformed ($B$) waveforms calculated as $\Vert A - B\Vert_1$. If the waveform durations are different, the shorter waveform is padded with zeros for values to make the durations equal in error calculation.

Logs/Warnings/Exceptions

Exceptions are thrown if Ω is:

• Not of type BloqadWaveforms.Waveform
• Not present (nothing was passed in)
• Not a global drive (e.g.: Vector of Waveforms, localized Ω is not supported)
• the maximum slope allowed for the waveform from device_capabilities is set to infinity
• the minimum time step allowed for the waveform from device_capabilities is set to zero

Debug logs are issued if the following are encountered in Ω:

• duration may be rounded due to time resolution from device_capabilities
• the initial waveform does not start/end in zero for its value
• the values in the waveform exceed device_capabilities supported values, and must be clipped

Examples

julia> wf = sinusoidal(duration=2, amplitude=1.3*π);

julia> hardware_transform_Ω(wf)
(Waveform(_, 2.0), 2.632451578170084)

hardware_transform_ϕ(ϕ,device_capabilities::DeviceCapabilities=get_device_capabilities())

Given the device_capabilities of the machine and a phase Waveform, return a transformed ϕ capable of being implemented by the machine along with the error between the original ($A$) and transformed ($B$) waveforms calculated as $\Vert A - B\Vert_1$. If the waveform durations are different, the shorter waveform is padded with zeros for values to make the durations equal in error calculation.

Logs/Warnings/Exceptions

Exceptions are thrown if ϕ is:

• Not of type BloqadWaveforms.Waveform
• Not present (nothing was passed in)
• Not a global drive (e.g.: Vector of Waveforms, localized ϕ is not supported)
• the maximum slope allowed for the waveform from device_capabilities is set to infinity
• the minimum time step allowed for the waveform from device_capabilities is set to zero

Debug logs are issued if the following are encountered in ϕ:

• duration may be rounded due to time resolution from device_capabilities
• the initial waveform does not start/end in zero for its value
• the values in the waveform exceed device_capabilities supported values, and must be clipped

Examples

julia> wf = sinusoidal(duration=2, amplitude=1.3*π);

julia> hardware_transform_ϕ(wf)
(Waveform(_, 2.0), 0.5386117854062276)

hardware_transform_Δ(Δ,device_capabilities::DeviceCapabilities=get_device_capabilities())

Given the device_capabilities of the machine and a detuning waveform Δ, return a transformed Δ capable of being implemented by the machine along with the error between the original ($A$) and transformed ($B$) waveforms calculated as $\Vert A - B\Vert_1$. If the waveform durations are different, the shorter waveform is padded with zeros for values to make the durations equal in error calculation.

Logs/Warnings/Exceptions

Exceptions are thrown if Δ is:

• Not of type BloqadWaveforms.Waveform
• Not present (nothing was passed in)
• Not a global drive (e.g. Vector of Waveforms, localized Δ is not supported)
• the maximum slope allowed for the waveform from device_capabilities is set to infinity
• the minimum time step allowed for the waveform from device_capabilities is set to zero

Debug logs are issued if the following are encountered in Δ:

• duration may be rounded due to time resolution from device_capabilities
• the initial waveform does not start/end in zero for its value
• the values in the waveform exceed device_capabilities supported values, and must be clipped

Examples

julia> wf = sinusoidal(duration=2, amplitude=1.3*π);

julia> hardware_transform_Δ(wf)
(Waveform(_, 2.0), 0.06492452289703464)

hardware_transform_atoms(atoms,device_capabilities::DeviceCapabilities=get_device_capabilities())

Given the constraints of the hardware from device_capabilities (specifically the position resolution) and an iterable containing the atom positions atoms, returns a Tuple containing the adjusted atom positions the machine is capable of resolving and the mean squared error between the desired atom positions and newly generated ones.

Note that other constraints such as the maximum width, height, and minimum supported spacings are not taken into account in adjusting the atoms. This may result in the validation function failing and requiring user intervention to modify the atom positions such that they satisfy the other constraints.

Examples

julia> atom_positions = ((1.12,), (2.01,), (3.01,));

julia> hardware_transform_atoms(atom_positions) # by default, calls get_device_capabilities()
([(1.1,), (2.0,), (3.0,)], 0.013333333333333197)

hardware_transform(h::BloqadeExpr.RydbergHamiltonian;device_capabilities::DeviceCapabilities=get_device_capabilities())

Given the constraints of the hardware via device_capabilities, transforms h into one the machine is capable of executing as well as:

• The mean squared error between original positions of the atoms and the transformed ones
• The 1-norm of the difference between the original and transformed waveforms

which are all stored in a HardwareTransformInfo struct.

hardware_transform expects that ALL waveforms h can have specified (Ω, Δ, ϕ) are explicitly defined. If there is a waveform that is not being used, a BloqadeWaveforms.constant waveform should be created with value zero to indicate non-use.

Note that not all atom position constraints are accounted for, such as the maximum lattice width, lattice height, and minimum supported spacings. Only position resolution is automatically accounted for. This may result in the validation function failing and requiring user intervention to modify the atom positions such that they satisfy the other constraints.

Logs/Warnings/Exceptions

Debug logs are always emitted containing the error (defined as the 1-norm of the difference between the original waveform and the transformed waveform) across all waveforms (Ω, Δ, ϕ) as well as the Mean Squared Error between the original atom positions and the adjusted atom positions.

The debug logs/warnings from constituent functions hardware_transform_Ω, hardware_transform_Δ, hardware_transform_ϕ are also emitted should the waveforms in h cause them to.

See also hardware_transform_atoms, hardware_transform_Ω, hardware_transform_Δ, hardware_transform_ϕ.

Examples

julia> atom_positions = AtomList([(1.12,), (2.01,), (3.01,)]);

julia> Δ = Ω = ϕ = sinusoidal(duration=2, amplitude=1.3*π);

julia> h = rydberg_h(atom_positions; Ω=Ω,Δ=Δ,ϕ=ϕ)
nqubits: 3
+
├─ [+] ∑ 2π ⋅ 8.627e5.0/|x_i-x_j|^6 n_i n_j
├─ [+] Ω(t) ⋅∑ e^{ϕ(t) ⋅ im} |0⟩⟨1| + e^{-ϕ(t) ⋅ im} |1⟩⟨0|
└─ [-] Δ(t) ⋅ ∑ n_i


julia> hardware_transform(h)
(nqubits: 3
+
├─ [+] ∑ 2π ⋅ 8.627e5.0/|x_i-x_j|^6 n_i n_j
├─ [+] Ω(t) ⋅∑ e^{ϕ(t) ⋅ im} |0⟩⟨1| + e^{-ϕ(t) ⋅ im} |1⟩⟨0|
└─ [-] Δ(t) ⋅ ∑ n_i
, BloqadeSchema.HardwareTransformInfo(0.5386117854062276, 2.632451578170084, 0.06492452289703464, (Δ = Waveform(_, 2), δ = nothing, Δi = 1.0), 0.013333333333333197))

struct HardwareTransformInfo <: QuEraSchema

Contains the calculated differences (error) betwen the original and transformed waveforms and atoms from invoking hardware_transform on a BloqadeExpr.RydbergHamiltonian.

Fields

• ϕ_error: Error between the original laser phase waveform ($A$) and transformed one ($B$) waveforms calculated as $\Vert A - B\Vert_1$.
• Ω_error: Error between the original Rabi frequency waveform ($A$) and transformed one ($B$) waveforms calculated as $\Vert A - B\Vert_1$.
• Δ_error: Error between the global detuning waveform ($A$) and transformed one ($B$) waveforms calculated as $\Vert A - B\Vert_1$.
• Δ_mask: Decoupling of local detuning field inferred from the detuning value specified in Δ.

• mse_atoms: Mean Squared Error between original atom positions and transformed ones.

validate(H::BloqadeExpr.RydbergHamiltonian;device_capabilities::DeviceCapabilities=get_device_capabilities())

Checks if H is capable of being represented as part of the internal schema as well as if it falls in the capabilities of what the machine can do via device_capabilities.

Returns ValidationViolations with each field containing a set of strings indicating which constraints were violated for which part of H.

Violations include:

Waveform Type

• ϕ is not of type PiecewiseConstantWaveform
• Ω and Δ are not of type PiecewiseLinearWaveform

Atom Position

• Number of qubits requested exceeds what is supported by the device
• Atom positions exceed position resolution supported by the device
• The total width/height of the atom arrangement exceeds what is supported by the device
• The radial spacing between atoms is smaller than what is supported by the device
• The vertical row spacing between atoms is smaller than what is supported by the device

General Waveform Constraints (apply to Ω, Δ, ϕ)

• duration exceeds device supported duration
• duration is smaller than device supported minimum time step
• smallest time step is smaller than supported smallest time step
• value is smaller than smallest supported value
• value is larger than largest supported value

Ω Waveform specific constraints

• Slope exceeds largest supported slope
• Start and end values are not equal to 0.0 rad/μs

Δ Waveform specific constraints

• Slope exceeds largest supported slope

ϕ Waveform specific constraints

• start value is not equal to 0.0 rad/μs

Logs/Warnings/Exceptions

The following exceptions can be thrown:

• ϕ is not of type PiecewiseConstantWaveform
• Ω and Δ are not of type PiecewiseLinearWaveform

Examples

julia> Δ = Ω = ϕ = sinusoidal(duration=2, amplitude=1.3*π);

julia> h = rydberg_h(atom_positions; Ω=Ω,Δ=Δ,ϕ=ϕ)

julia> transformed_h, _ = transform(h); # transform returns error info

julia> validate(transformed_h) # constrained by default value of `device_capabilities` argument
The following validation violations occurred:

1. positions 2 => (2.0, 0.0) and 3 => (3.0, 0.0) are a distance of 1.0 μm apart which is below minimum value of 4.0 μm
2. positions 1 => (1.1, 0.0) and 2 => (2.0, 0.0) are a distance of 0.8999999999999999 μm apart which is below minimum value of 4.0 μm
3. positions 1 => (1.1, 0.0) and 3 => (3.0, 0.0) are a distance of 1.9 μm apart which is below minimum value of 4.0 μm

to_json(h::AbstractBlock; kw...)
to_json(h::BloqadeExpr.RydbergHamiltonian,params::SchemaTranslationParams)

Converts h and associated params into a JSON object. If params is not explicitly provided as a SchemaTranslationParams instance, it is automatically built from nshots and device_capabilities.

Validation is performed to ensure h is capable of being run on the machine. This can cause an exception to be thrown should any violations be caught. Refer to Logs/Warnings/Exceptions below.

Logs/Warnings/Exceptions

A ValidationException can be thrown which wraps a ValidationViolations instance.

ValidationViolations contains any constraint violations detected from to_schema

Violations include:

Waveform Type

• ϕ is not of type PiecewiseConstantWaveform
• Ω and Δ are not of type PiecewiseLinearWaveform

Atom Position

• Number of qubits requested exceeds what is supported by the device
• Atom positions exceed position resolution supported by the device
• The total width/height of the atom arrangement exceeds what is supported by the device
• The radial spacing between atoms is smaller than what is supported by the device
• The vertical row spacing between atoms is smaller than what is supported by the device

General Waveform Constraints (apply to Ω, Δ, ϕ)

• duration exceeds device supported duration
• duration is smaller than device supported minimum time step
• smallest time step is smaller than supported smallest time step
• value is smaller than smallest supported value
• value is larger than largest supported value

Ω Waveform specific constraints

• Slope exceeds largest supported slope
• Start and end values are not equal to 0.0 rad/μs

Δ Waveform specific constraints

• Slope exceeds largest supported slope

ϕ Waveform specific constraints

• start value is not equal to 0.0 rad/μs

Miscellaneous Violations

• Number of shots is below minimum supported
• Number of shots exceeds maximum supported

Examples

julia> Ω = BloqadeWaveforms.piecewise_constant(; clocks=[0, 2, 4, 6, 7], values=[5, 3, 4, 6]);

julia> Δ = BloqadeWaveforms.piecewise_linear(; clocks=[0.0, 0.6, 2.1, 2.2], values=[-10.1, -10.1, 10.1, 10.1]);

julia> ϕ = BloqadeWaveforms.piecewise_linear(; clocks=[0, 5], values=[33, 0]);

julia> atoms = [(0, 0), (1, 3), (4, 2), (6, 3), (0, 5), (2, 5)];

julia> block = BloqadeExpr.rydberg_h(atoms; Δ=Δ, Ω=Ω, ϕ=ϕ);

julia> BloqadeSchema.to_json(block; n_shots=10)
"{"nshots":10,"lattice":{"sites":[[0.0,0.0],[1.0,3.0],[4.0,2.0],[6.0,3.0],[0.0,5.0],[2.0,5.0]],"filling":[1,1,1,1,1,1]},"effective_hamiltonian":{"rydberg":{"rabi_frequency_amplitude":{"global":{"times":[0.0,-18.0,2.0,-6.0,4.0,-14.0,7.0],"values":[5.0,5.0,3.0,3.0,4.0,4.0,6.0]}},"rabi_frequency_phase":{"global":{"times":[0.0,5.0],"values":[33.0,0.0]}},"detuning":{"global":{"times":[0.0,0.6,2.1,2.2],"values":[-10.1,-10.1,10.1,10.1]}}}}}"

to_json_no_validation(lattice::Union{Vector,Lattice};
    ϕ::Maybe{PiecewiseConstantWaveform}=nothing,
    Ω::Maybe{PiecewiseLinearWaveform}=nothing,
    Δ::Maybe{PiecewiseLinearWaveform}=nothing,
    δ::Maybe{PiecewiseLinearWaveform}=nothing,
    Δi::Maybe{Vector{Number}}=nothing,kw...)

Converts lattice, ϕ, Δ, δ, and Δi to a JSON representation of a QuEraTaskSpecification instance WITHOUT ensuring the provided values are capable of being executed on the machine (fit within the constraints of the device's capabilities)

See also to_json

to_dict(h::BloqadeExpr.RydbergHamiltonian; nshots::Int, device_capabilities::DeviceCapabilities=get_device_capabilities())
to_dict(h::BloqadeExpr.RydbergHamiltonian,params::SchemaTranslationParams)

Converts h and associated params into the dictionary representation of a QuEraTaskSpecification. If params is not explicitly provided as a SchemaTranslationParams instance, it is automatically built from nshots and device_capabilities.

Validation is performed to ensure h is capable of being run on the machine. This can cause an exception to be thrown should any violations be caught. Refer to Logs/Warnings/Exceptions below.

Logs/Warnings/Exceptions

A ValidationException can be thrown which wraps a ValidationViolations instance.

ValidationViolations contains any constraint violations detected from to_schema

Violations include:

Waveform Type

• ϕ is not of type PiecewiseConstantWaveform
• Ω and Δ are not of type PiecewiseLinearWaveform

Atom Position

• Number of qubits requested exceeds what is supported by the device
• Atom positions exceed position resolution supported by the device
• The total width/height of the atom arrangement exceeds what is supported by the device
• The radial spacing between atoms is smaller than what is supported by the device
• The vertical row spacing between atoms is smaller than what is supported by the device

General Waveform Constraints (apply to Ω, Δ, ϕ)

• duration exceeds device supported duration
• duration is smaller than device supported minimum time step
• smallest time step is smaller than supported smallest time step
• value is smaller than smallest supported value
• value is larger than largest supported value

Ω Waveform specific constraints

• Slope exceeds largest supported slope
• Start and end values are not equal to 0.0 rad/μs

Δ Waveform specific constraints

• Slope exceeds largest supported slope

ϕ Waveform specific constraints

• start value is not equal to 0.0 rad/μs

Miscellaneous Violations

• Number of shots is below minimum supported
• Number of shots exceeds maximum supported

to_schema(h::BloqadeExpr.RydbergHamiltonian; nshots::Int, device_capabilities::DeviceCapabilities=get_device_capabilities())
to_schema(h::BloqadeExpr.RydbergHamiltonian, params::SchemaTranslationParams)

Converts h to a QuEraTaskSpecification instance with params. If params is not explicitly constructed, it will be built automatically from nshots and device_capabilities.

Validation is performed to ensure h is capable of being run on the machine. This can cause an exception to be thrown should any violations be caught. Refer to Logs/Warnings/Exceptions below.

Logs/Warnings/Exceptions

If any violations of device_capabilities are detected, a ValidationException is thrown which wraps a ValidationViolations instance.

Violations include:

Waveform Type

• ϕ is not of type PiecewiseConstantWaveform
• Ω and Δ are not of type PiecewiseLinearWaveform

Atom Position

• Number of qubits requested exceeds what is supported by the device
• Atom positions exceed position resolution supported by the device
• The total width/height of the atom arrangement exceeds what is supported by the device
• The vertical row spacing between atoms is smaller than what is supported by the device
• The radial spacing between atoms is smaller than what is supported by the device

General Waveform Constraints (apply to Ω, Δ, ϕ)

• duration exceeds device supported duration
• duration is smaller than device supported minimum time step
• smallest time step is smaller than supported smallest time step
• value is smaller than smallest supported value
• value is larger than largest supported value

Ω Waveform specific constraints

• Slope exceeds largest supported slope
• Start and end values are not equal to 0.0 rad/μs

Δ Waveform specific constraints

• Slope exceeds largest supported slope

ϕ Waveform specific constraints

• start value is not equal to 0.0 rad/μs

Miscellaneous Violations

• Number of shots is below minimum supported
• Number of shots exceeds maximum supported

to_schema_no_validation(lattice::Union{Vector,Lattice};
    ϕ::Maybe{PiecewiseConstantWaveform}=nothing,
    Ω::Maybe{PiecewiseLinearWaveform}=nothing,
    Δ::Maybe{PiecewiseLinearWaveform}=nothing,
    δ::Maybe{PiecewiseLinearWaveform}=nothing,
    Δi::Maybe{Vector{Number}}=nothing, 
    nshots::Int,
    device_capabilities::DeviceCapabilities=get_device_capabilities())
to_schema_no_validation(lattice::Union{Vector,Lattice},
    ϕ::Maybe{PiecewiseConstantWaveform},
    Ω::Maybe{PiecewiseLinearWaveform},
    Δ::Maybe{PiecewiseLinearWaveform},
    δ::Maybe{PiecewiseLinearWaveform},
    Δi::Maybe{Vector{Number}}, 
    params::SchemaTranslationParams)

Converts lattice, ϕ, Δ, δ, and Δi to a QuEraTaskSpecification instance WITHOUT ensuring the provided values are capable of being executed on the machine (fit within the constraints of the device's capabilities).

If params is not already provided, it is constructed automatically from nshots::Int and device_capabilities.

See also to_schema

function to_braket_ahs_ir(local_value::BloqadeSchema.LocalField)

Converts local_value to Braket.IR.PhysicalField

function to_braket_ahs_ir(global_values::BloqadeSchema.GlobalField)

Converts global_values to Braket.IR.PhysicalField

function to_braket_ahs_ir(amplitude_or_phase::Union{BloqadeSchema.RabiFrequencyAmplitude,
BloqadeSchema.RabiFrequencyPhase})

Unwraps amplitude_or_phase to extract their global_value fields which are immediately evaluated by function to_braket_ahs_ir(global_values::BloqadeSchema.GlobalField)

function to_braket_ahs_ir(detuning::BloqadeSchema.Detuning)

Converts detuning to Braket.IR.PhysicalField's for the global_value and local_value fields of detuning. Returns the converted global_value first followed by the local_value. ``

function to_braket_ahs_ir(rydberg_hamiltonian::BloqadeSchema.RydbergHamiltonian)

Converts rydberg_hamiltonian to Braket.IR.Hamiltonian

function to_braket_ahs_ir(lattice::BloqadeSchema.Lattice)

Converts lattice to a Braket.IR.Setup instance.

function to_braket_ahs_ir(hamiltonian::BloqadeSchema.EffectiveHamiltonian)

Unwraps the BloqadeSchema.RydbergHamiltonian contained inside hamiltonian and immediately evaluates it using to_braket_ahs_ir(rydberg_hamiltonian::BloqadeSchema.RydbergHamiltonian)

function tobraketahsir(bloqadetask::BloqadeSchema.QuEraTaskSpecification)

Converts a bloqade_task into a Braket.IR.AHSProgram capable of being submitted to AWS Braket for execution on a QPU.

NOTE: BloqadeSchema.QuEraTaskSpecification contains a field nshots which does not have a corresponding field in Braket.IR.AHSProgram. This value must be fed as a keyword argument to a Braket.AwsDevice instance separately.

submit_to_braket(h::BloqadeExpr.Hamiltonian, n_shots::Int; <keyword arguments>)

Submits a BloqadeExpr.RydbergHamiltonian instance to Braket with n_shots defining the number of times the Hamiltonian should be executed.

Credentials can be passed in explicitly through an AWS.AWSCredentials struct or by passing in nothing, in which case credentials will be sought in the standard AWS locations.

Keyword Arguments

• arn="arn:aws:braket:us-east-1::device/qpu/quera/Aquila": ARN for the machine
• region="us-east-1": AWS Region machine is located in
• credentials::Union{AWSCredentials, Nothing}=nothing: AWS.AWSCredentials instance you can create to login.

Logs/Warnings/Exceptions

An AWS.NoCredentials exception is thrown containing a message string "Can't find AWS credentials!" if the credentials given are invalid.

BloqadeSchema.hardware_transform is always invoked, meaning its debug logs are also always emitted containing the difference (error) between the original waveforms in h and the newly generated ones compatible with hardware as well as the same transformation for atom positions.

submit_to_braket(h::BloqadeExpr.RydbergHamiltonian, translation_params::BloqadeSchema.SchemaTranslationParams; <keyword arguments>)

Submits a BloqadeExpr.RydbergHamiltonian instance to Braket with BloqadeSchema.SchemaTranslationParams containing the number of shots and device capabilities. Returns an AWS.AwsQuantumTask upon converting the Hamiltonian to one the hardware can execute and submitting it.

Credentials can be passed in explicitly through an AWS.AWSCredentials struct or by passing in nothing, in which case credentials will be sought in the standard AWS locations.

Keyword Arguments

• arn="arn:aws:braket:us-east-1::device/qpu/quera/Aquila": ARN for the machine
• region="us-east-1": AWS Region machine is located in
• credentials::Union{AWSCredentials, Nothing}=nothing: AWS.AWSCredentials instance you can create to login.

Logs/Warnings/Exceptions

An AWS.NoCredentials exception is thrown containing a message string "Can't find AWS credentials!" if the credentials given are invalid.

hardware_transform is always invoked internally, meaning its debug logs are also always emitted containing the difference (error) between the original waveforms in h and the newly generated ones compatible with hardware as well as the same transformation for atom positions.

sumbit_to_braket(ts:BloqadeSchema.QuEraTaskSpecification; <keyword arguments>)

Submits a BloqadeSchema.QuEraTaskSpecification instance to Braket, returning an AWS.AwsQuantumTask.

Credentials can be passed in explicitly through an AWS.AWSCredentials struct or by passing in nothing, in which case credentials will be sought in the standard AWS locations.

Keyword Arguments

• arn="arn:aws:braket:us-east-1::device/qpu/quera/Aquila": ARN for the machine
• region="us-east-1": AWS Region machine is located in
• credentials::Union{AWSCredentials, Nothing}=nothing: AWS.AWSCredentials instance you can create to login.

Logs/Warnings/Exceptions

An AWS.NoCredentials exception is thrown containing a message string "Can't find AWS credentials!" if the credentials given are invalid.

from_json(j::String)

Convert the JSON representation of a QuEraTaskSpecification instance to a QuEraTaskSpecification

from_dict(d::AbstractDict{String})

Convert the dictionary representation of a QuEraTaskSpecification instance, into a QuEraTaskSpecification.

from_schema(t::QuEraTaskSpecification)

Converts t into valid BloqadeExpr.RydbergHamiltonian instance.

execute(j::Dict)

Executes a task given as a Dict in the task specification API format, and returns a JSON string of the result

execute(j::QuEraTaskSpecification)

Executes a task given as a QuEraTaskSpecification object in the task specification API format, and returns a JSON string of the result

struct TaskOutput <: QuEraSchema

The result of executing a QuEraTaskSpecification on the machine.

Output of execute function.

Fields

• task_status_code::Int: Task Status
• shot_outputs::Vector{ShotOutput}: Contains pre- and post- shot

sequence in binary of if atoms are in Rydberg/Ground state.

struct ValidationViolations <: QuEraSchema

Stores violations of hardware constraints from the user-supplied BloqadeExpr.RydbergHamiltonian as strings in sets. This is returned by validate and to_schema.

Fields

• lattice_violations::Set: violations of hardware-supported lattice geometry
• misc_violations::Set: violations that do not fall into other categories (e.g. number of shots)
• Δ_violations::Set: violations of detuning waveform
• Ω_violations::Set: violations of Rabi frequency waveform
• ϕ_violations::Set: violations of Phase waveform
• δ_violations::Set: violations of local detuning waveforms