Execution

sample

Functions:

Name	Description
`sample`	Sample a quantum program or OpenQASM circuit.

sample

sample(
    qprog: QuantumProgram,
    backend: str | None = ...,
    *,
    parameters: list[ExecutionParams],
    config: dict[str, Any] | ProviderConfig | None = ...,
    num_shots: int | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    run_via_classiq: bool = ...
) -> list[DataFrame]

sample(
    qprog: QuantumProgram,
    backend: str | None = ...,
    *,
    parameters: ExecutionParams | None = ...,
    config: dict[str, Any] | ProviderConfig | None = ...,
    num_shots: int | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    run_via_classiq: bool = ...
) -> DataFrame

sample(
    qprog: str,
    backend: str | None = ...,
    *,
    parameters: list[ExecutionParams],
    config: dict[str, Any] | ProviderConfig | None = ...,
    num_shots: int | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    run_via_classiq: bool = ...
) -> list[DataFrame]

sample(
    qprog: str,
    backend: str | None = ...,
    *,
    parameters: ExecutionParams | None = ...,
    config: dict[str, Any] | ProviderConfig | None = ...,
    num_shots: int | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    run_via_classiq: bool = ...
) -> DataFrame

sample(
    qprog: QuantumProgram | str,
    backend: str | None = None,
    *,
    parameters: (
        ExecutionParams | list[ExecutionParams] | None
    ) = None,
    config: dict[str, Any] | ProviderConfig | None = None,
    num_shots: int | None = None,
    random_seed: int | None = None,
    transpilation_option: TranspilationOption = DECOMPOSE,
    run_via_classiq: bool = False
) -> DataFrame | list[DataFrame]

Sample a quantum program or OpenQASM circuit.

Parameters:

Name	Type	Description	Default
`qprog`	`QuantumProgram \| str`	A synthesized `QuantumProgram`, or OpenQASM 2.0 / 3.0 source as a single string (for example output of `qiskit.qasm2.dumps` or `qiskit.qasm3.dumps`).	required
`backend`	`str \| None`	The hardware or simulator on which to run the quantum program. Use `"simulator"` for Classiq's default simulator, or specify a backend as `"provider/device_id"`. Use the `get_backend_details` function to see supported devices.	`None`
`parameters`	`ExecutionParams \| list[ExecutionParams] \| None`	A dictionary of parameter values, or a list of dictionaries for batch execution. Each key should be the name of a parameter in the quantum program (parameters of the `main` function), and the value should be the value to set for that parameter. Not supported when `qprog` is an OpenQASM string (use a `QuantumProgram` or bind values in QASM before calling `sample`).	`None`
`config`	`dict[str, Any] \| ProviderConfig \| None`	Provider-specific configuration, such as API keys. For full details, see the SDK reference under Providers.	`None`
`num_shots`	`int \| None`	The number of times to sample.	`None`
`random_seed`	`int \| None`	The random seed used for transpilation and simulation.	`None`
`transpilation_option`	`TranspilationOption`	Advanced configuration for hardware-specific transpilation.	`DECOMPOSE`
`run_via_classiq`	`bool`	Run via Classiq's credentials while using your allocated budget. Defaults to `False`.	`False`

Returns:

Type	Description
`DataFrame \| list[DataFrame]`	A dataframe containing the histogram, or a list of dataframes when
`DataFrame \| list[DataFrame]`	`parameters` is a list.

calculate_state_vector

calculate_state_vector(
    qprog: QuantumProgram,
    backend: str | None = ...,
    *,
    parameters: list[ExecutionParams],
    filters: dict[str, Any] | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    amplitude_threshold: float = ...
) -> list[DataFrame]

calculate_state_vector(
    qprog: QuantumProgram,
    backend: str | None = ...,
    *,
    parameters: ExecutionParams | None = ...,
    filters: dict[str, Any] | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    amplitude_threshold: float = ...
) -> DataFrame

calculate_state_vector(
    qprog: QuantumProgram,
    backend: str | None = None,
    *,
    parameters: (
        ExecutionParams | list[ExecutionParams] | None
    ) = None,
    filters: dict[str, Any] | None = None,
    random_seed: int | None = None,
    transpilation_option: TranspilationOption = DECOMPOSE,
    amplitude_threshold: float = 0.0
) -> DataFrame | list[DataFrame]

Calculate the state vector of a quantum program.

This function is only available for Classiq simulators (e.g. "classiq/simulator").

Parameters:

Name	Type	Description	Default
`qprog`	`QuantumProgram`	The quantum program to be executed.	required
`backend`	`str \| None`	The simulator on which to simulate the quantum program. Specified as `"provider/backend_name"`. Use the `get_backend_details` function to see supported backends. Only Classiq simulators are supported.	`None`
`parameters`	`ExecutionParams \| list[ExecutionParams] \| None`	A dictionary of parameter values, or a list of dictionaries for batch execution. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	`None`
`filters`	`dict[str, Any] \| None`	Only states where the variables match these values will be included in the state vector.	`None`
`random_seed`	`int \| None`	The random seed for reproducibility.	`None`
`transpilation_option`	`TranspilationOption`	Advanced configuration for hardware-specific transpilation.	`DECOMPOSE`
`amplitude_threshold`	`float`	If provided, only states whose amplitude magnitude is strictly greater than this value will be included in the result. Defaults to 0 (filters exactly zero-amplitude states).	`0.0`

Returns:

Type	Description
`DataFrame \| list[DataFrame]`	A dataframe containing the state vector, or a list of dataframes when
`DataFrame \| list[DataFrame]`	`parameters` is a list.

observe

observe(
    qprog: QuantumProgram,
    observable: SparsePauliOp,
    backend: str | None = ...,
    *,
    estimate: bool = ...,
    parameters: list[ExecutionParams],
    config: dict[str, Any] | ProviderConfig | None = ...,
    num_shots: int | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    run_via_classiq: bool = ...
) -> list[float]

observe(
    qprog: QuantumProgram,
    observable: SparsePauliOp,
    backend: str | None = ...,
    *,
    estimate: bool = ...,
    parameters: ExecutionParams | None = ...,
    config: dict[str, Any] | ProviderConfig | None = ...,
    num_shots: int | None = ...,
    random_seed: int | None = ...,
    transpilation_option: TranspilationOption = ...,
    run_via_classiq: bool = ...
) -> float

observe(
    qprog: QuantumProgram,
    observable: SparsePauliOp,
    backend: str | None = None,
    *,
    estimate: bool = True,
    parameters: (
        ExecutionParams | list[ExecutionParams] | None
    ) = None,
    config: dict[str, Any] | ProviderConfig | None = None,
    num_shots: int | None = None,
    random_seed: int | None = None,
    transpilation_option: TranspilationOption = DECOMPOSE,
    run_via_classiq: bool = False
) -> float | list[float]

Get the expectation value of the observable O with respect to the state |psi>, which is prepared by the provided quantum program.

Parameters:

Name	Type	Description	Default
`qprog`	`QuantumProgram`	The quantum program that generates the state \|psi> to be observed.	required
`observable`	`SparsePauliOp`	The observable O, a Hermitian operator defined as a `SparsePauliOp` (sum of Pauli terms).	required
`backend`	`str \| None`	The hardware or simulator on which to run the quantum program. Use `"simulator"` for Classiq's default simulator, or specify a backend as `"provider/backend_name"`. Use the `get_backend_details` function to see supported devices.	`None`
`estimate`	`bool`	Whether to estimate the expectation value by repeatedly measuring the circuit `num_shots` times, or calculate the exact expectation value using a simulated statevector. Note that the available options depend on the specified backend. Defaults to `True`.	`True`
`parameters`	`ExecutionParams \| list[ExecutionParams] \| None`	A dictionary of parameter values, or a list of dictionaries for batch execution. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	`None`
`config`	`dict[str, Any] \| ProviderConfig \| None`	Provider-specific configuration, such as API keys. For full details, see the SDK reference under Providers.	`None`
`num_shots`	`int \| None`	The number of measurement shots. Only relevant when `estimate=True`.	`None`
`random_seed`	`int \| None`	The random seed for reproducibility.	`None`
`transpilation_option`	`TranspilationOption`	Advanced configuration for hardware-specific transpilation.	`DECOMPOSE`
`run_via_classiq`	`bool`	Run via Classiq's credentials while using your allocated budget. Defaults to `False`.	`False`

Returns:

Type	Description
`float \| list[float]`	The expectation value as a float, or a list of floats when
`float \| list[float]`	`parameters` is a list.

See Also

More information about defining observables as Hamiltonians <https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians>_.

variational_minimize

variational_minimize(
    qprog: QuantumProgram,
    cost_function: SparsePauliOp | QmodExpressionCreator,
    initial_params: ExecutionParams,
    max_iteration: int,
    backend: str | None = None,
    *,
    quantile: float = 1.0,
    tolerance: float | None = None,
    config: dict[str, Any] | ProviderConfig | None = None,
    random_seed: int | None = None,
    transpilation_option: TranspilationOption = DECOMPOSE,
    run_via_classiq: bool = False
) -> list[tuple[float, ExecutionParams]]

Minimize the given cost function over the parameter values of the provided quantum program.

Parameters:

Name	Type	Description	Default
`qprog`	`QuantumProgram`	The parametric quantum program that generates the state (ansatz). Only quantum programs with exactly one execution parameter are supported.	required
`cost_function`	`SparsePauliOp \| QmodExpressionCreator`	The cost function to minimize. It can be one of the following: A quantum cost function defined by a Hamiltonian. A classical cost function represented as a callable that returns a Qmod expression. The callable should accept `QVar`s as arguments and use names matching the Model outputs.	required
`initial_params`	`ExecutionParams`	The initial parameter values for the minimization. This parameter must be of type `CReal` or `CArray`. The dictionary must contain a single key-value pair, where: The key is the name of the parameter. The value is either a float or a list of floats.	required
`max_iteration`	`int`	The maximum number of iterations for the minimization.	required
`backend`	`str \| None`	The hardware or simulator on which to run the quantum programs. Use `"simulator"` for Classiq's default simulator, or specify a backend as `"provider/backend_name"`. Use the `get_backend_details` function to see supported devices.	`None`
`quantile`	`float`	The quantile to use for cost estimation.	`1.0`
`tolerance`	`float \| None`	The tolerance for the minimization.	`None`
`config`	`dict[str, Any] \| ProviderConfig \| None`	Provider-specific configuration, such as API keys. For full details, see the SDK reference under Providers.	`None`
`random_seed`	`int \| None`	The random seed for reproducibility.	`None`
`transpilation_option`	`TranspilationOption`	Advanced configuration for hardware-specific transpilation.	`DECOMPOSE`
`run_via_classiq`	`bool`	Run via Classiq's credentials while using your allocated budget. Defaults to `False`.	`False`

Returns:

Type	Description
`list[tuple[float, ExecutionParams]]`	A list of tuples, each containing the estimated cost and the
`list[tuple[float, ExecutionParams]]`	corresponding parameters for that iteration. `cost` is a float,
`list[tuple[float, ExecutionParams]]`	and `parameters` is a dictionary matching the execution parameter
`list[tuple[float, ExecutionParams]]`	format.

See Also

The Execution Tutorial <https://docs.classiq.io/latest/getting-started/classiq_tutorial/execution_tutorial_part2/>_ has examples on using this method in variational quantum algorithms.

More information about Hamiltonians <https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians>_.

BraketConfig

Bases: ProviderConfig

Configuration specific to Amazon Braket.

Attributes:

Name	Type	Description
`braket_access_key_id`	`str \| None`	The access key id of user with full braket access
`braket_secret_access_key`	`str \| None`	The secret key assigned to the access key id for the user with full braket access.
`s3_bucket_name`	`str \| None`	The name of the S3 bucket where results and other related data will be stored. This field should contain a valid S3 bucket name under your AWS account.
`s3_folder`	`PydanticS3BucketKey \| None`	The folder path within the specified S3 bucket. This allows for organizing results and data under a specific directory within the S3 bucket.

braket_access_key_id

braket_access_key_id: str | None = Field(
    default=None,
    description="Key id assigned to user with credentials to access Braket service",
)

braket_secret_access_key

braket_secret_access_key: str | None = Field(
    default=None,
    description="Secret access key assigned to user with credentials to access Braket service",
)

s3_bucket_name

s3_bucket_name: str | None = Field(
    default=None, description="S3 Bucket Name"
)

s3_folder

s3_folder: str | None = Field(
    default=None,
    description="S3 Folder Path Within The S3 Bucket",
)

IBMConfig

Bases: ProviderConfig

Configuration specific to IBM.

Attributes:

Name	Type	Description
`access_token`	`str \| None`	The IBM Cloud access token to be used with IBM Quantum hosted backends. Defaults to `None`.
`channel`	`str`	Channel to use for IBM cloud backends. Defaults to `"ibm_cloud"`.
`instance_crn`	`str \| None`	The IBM Cloud instance CRN (Cloud Resource Name) for the IBM Quantum service.
`emulate`	`bool`	If True, run on a Classiq-hosted simulator with IBM noise derived from the backend name. Defaults to `False`.

access_token

access_token: str | None = Field(
    default=None,
    description="IBM Cloud access token to be used with IBM Quantum hosted backends.",
)

channel

channel: str = Field(
    default="ibm_cloud",
    description="Channel to use for IBM cloud backends.",
)

emulate

emulate: bool = Field(
    default=False,
    description="If True, run on a Classiq-hosted simulator with an IBM noise model.",
)

instance_crn

instance_crn: str | None = Field(
    default=None, description="IBM Cloud instance CRN."
)

IonQConfig

Bases: ProviderConfig

Configuration specific to IonQ.

Attributes: api_key (PydanticIonQApiKeyType | None): Key to access IonQ API. error_mitigation (bool): A configuration option to enable or disable error mitigation during execution. Defaults to False. emulate (bool): If True, run on IonQ simulator with noise model derived from the backend name. Defaults to False.

Attributes:

Name	Type	Description
`api_key`	`PydanticIonQApiKeyType \| None`
`emulate`	`bool`
`error_mitigation`	`bool`

api_key

api_key: PydanticIonQApiKeyType | None = Field(
    default=None, description="IonQ API key."
)

emulate

emulate: bool = Field(
    default=False,
    description="If True, run on simulator with noise model derived from backend name.",
)

error_mitigation

error_mitigation: bool = Field(
    default=False,
    description="Enable error mitigation during execution.",
)

AzureConfig

Bases: ProviderConfig

Configuration specific to Azure.

Attributes:

Name	Type	Description
`location`	`str`	Azure region. Defaults to `"East US"`.
`tenant_id`	`str \| None`	Azure Tenant ID used to identify the directory in which the application is registered.
`client_id`	`str \| None`	Azure Client ID, also known as the application ID, which is used to authenticate the application.
`client_secret`	`str \| None`	Azure Client Secret associated with the application, used for authentication.
`resource_id`	`str \| None`	Azure Resource ID, including the subscription ID, resource group, and workspace, typically used for personal resources.
`ionq_error_mitigation`	`bool`	Should use error mitigation when running on IonQ via Azure. Defaults to `False`.

client_id

client_id: str | None = Field(
    default=None, description="Azure Client ID"
)

client_secret

client_secret: str | None = Field(
    default=None, description="Azure Client Secret"
)

ionq_error_mitigation

ionq_error_mitigation: bool = Field(
    default=False,
    description="Error mitigation configuration upon running on IonQ via Azure.",
)

location

location: str = Field(
    default="East US",
    description="Azure personal resource region",
)

resource_id

resource_id: str | None = Field(
    default=None,
    description="Azure Resource ID (including Azure subscription ID, resource group and workspace), for personal resource",
)

tenant_id

tenant_id: str | None = Field(
    default=None, description="Azure Tenant ID"
)

AQTConfig

Bases: ProviderConfig

Configuration specific to AQT (Alpine Quantum Technologies).

Attributes:

Name	Type	Description
`api_key`	`str`	The API key required to access AQT's quantum computing services.
`workspace`	`str`	The AQT workspace where the simulator/hardware is located.

api_key

api_key: str = Field(description='AQT API key')

workspace

workspace: str = Field(description='AQT workspace')

AliceBobConfig

Bases: ProviderConfig

Configuration specific to Alice&Bob.

Attributes:

Name	Type	Description
`distance`	`int \| None`	The number of times information is duplicated in the repetition code. - Tooltip: Phase-flip probability decreases exponentially with this parameter, bit-flip probability increases linearly. - Supported Values: 3 to 300, though practical values are usually lower than 30. - Default: None.
`kappa_1`	`float \| None`	The rate at which the cat qubit loses one photon, creating a bit-flip. - Tooltip: Lower values mean lower error rates. - Supported Values: 10 to 10^5. Current hardware is at ~10^3. - Default: None.
`kappa_2`	`float \| None`	The rate at which the cat qubit is stabilized using two-photon dissipation. - Tooltip: Higher values mean lower error rates. - Supported Values: 100 to 10^9. Current hardware is at ~10^5. - Default: None.
`average_nb_photons`	`float \| None`	The average number of photons. - Tooltip: Bit-flip probability decreases exponentially with this parameter, phase-flip probability increases linearly. - Supported Values: 4 to 10^5, though practical values are usually lower than 30. - Default: None.

average_nb_photons

average_nb_photons: float | None = Field(
    default=None, description="Average number of photons"
)

distance

distance: int | None = Field(
    default=None, description="Repetition code distance"
)

kappa_1

kappa_1: float | None = Field(
    default=None,
    description="One-photon dissipation rate (Hz)",
)

kappa_2

kappa_2: float | None = Field(
    default=None,
    description="Two-photon dissipation rate (Hz)",
)

ProviderConfig

Bases: BaseModel

Provider-specific configuration data for execution, such as API keys and machine-specific parameters.

execute

execute(quantum_program: QuantumProgram) -> ExecutionJob

Execute a quantum program. The preferences for execution are set on the quantum program using the method set_execution_preferences.

Parameters:

Name	Type	Description	Default
`quantum_program`	`QuantumProgram`	The quantum program to execute. This is the result of the synthesize method.	required

Returns:

Name	Type	Description
`ExecutionJob`	`ExecutionJob`	The result of the execution.

For examples please see Execution Documentation

estimate_sample_cost

estimate_sample_cost(
    quantum_program: QuantumProgram,
    execution_options: ExecutionPreferences,
) -> CostEstimateResult

Estimate the cost for sampling a quantum program.

Parameters:

Name	Type	Description	Default
`quantum_program`	`QuantumProgram`	The quantum program (output of synthesize).	required
`execution_options`	`ExecutionPreferences`	Execution preferences (backend, shots, transpilation).	required

Returns:

Type	Description
`CostEstimateResult`	CostEstimateResult with cost and currency.

estimate_sample_batch_cost

estimate_sample_batch_cost(
    quantum_program: QuantumProgram,
    execution_backend: BackendPreferencesTypes,
    transpilation_level: TranspilationOption = DECOMPOSE,
    shots: int = 1000,
    params: list[dict] | None = None,
) -> CostEstimateResult

Estimate the cost for batch sampling a quantum program.

Parameters:

Name	Type	Description	Default
`quantum_program`	`QuantumProgram`	The quantum program (output of synthesize).	required
`execution_backend`	`BackendPreferencesTypes`	Backend preferences for the target backend.	required
`transpilation_level`	`TranspilationOption`	Transpilation option for the circuit.	`DECOMPOSE`
`shots`	`int`	Number of shots per sample.	`1000`
`params`	`list[dict] \| None`	Optional list of parameter sets for batch. If None, single sample.	`None`

Returns:

Type	Description
`CostEstimateResult`	CostEstimateResult with cost and currency.

ExecutionSession

ExecutionSession(
    quantum_program: QuantumProgram | str,
    execution_preferences: (
        ExecutionPreferences | None
    ) = None,
)

A session for executing a quantum program or OpenQASM source text. ExecutionSession allows to execute the quantum program with different parameters and operations without the need to re-synthesize the model. The session must be closed in order to ensure resources are properly cleaned up. It's recommended to use ExecutionSession as a context manager for this purpose. Alternatively, you can directly use the close method.

Attributes:

Name	Type	Description
`program`	`QuantumProgram`	The quantum program to execute, or a placeholder when the first constructor argument was OpenQASM source text.
`execution_preferences`	`Optional[ExecutionPreferences]`	Execution preferences for the Quantum Program.

Parameters:

Name	Type	Description	Default
`quantum_program`	`QuantumProgram \| str`	A synthesized `QuantumProgram` or OpenQASM 2.0/3.0 source as a string (same as the first argument to `sample`).	required
`execution_preferences`	`ExecutionPreferences \| None`	Optional execution preferences (backend, shots, transpilation, etc.).	`None`

Methods:

Name	Description
`batch_estimate`	Estimates the expectation value of the given Hamiltonian multiple times using the quantum program, with the given parameters for each iteration. The number of estimations is determined by the length of the parameters list.
`batch_sample`	Samples the quantum program multiple times with the given parameters for each iteration. The number of samples is determined by the length of the parameters list.
`close`	Close the session and clean up its resources.
`estimate`	Estimates the expectation value of the given Hamiltonian using the quantum program.
`estimate_cost`	Estimates circuit cost using a classical cost function.
`get_session_id`
`minimize`	Minimizes the given cost function using the quantum program.
`sample`	Samples the quantum program with the given parameters, if any.
`set_measured_state_filter`	When simulating on a statevector simulator, emulate the behavior of postprocessing
`submit_batch_estimate`	Initiates an execution job with the `batch_estimate` primitive.
`submit_batch_sample`	Initiates an execution job with the `batch_sample` primitive.
`submit_estimate`	Initiates an execution job with the `estimate` primitive.
`submit_minimize`	Initiates an execution job with the `minimize` primitive.
`submit_sample`	Initiates an execution job with the `sample` primitive.
`update_execution_preferences`	Update the execution preferences for the session.

program

program = _openqasm_session_placeholder_program()

batch_estimate

batch_estimate(
    hamiltonian: Hamiltonian,
    parameters: list[ExecutionParams],
) -> list[EstimationResult]

Estimates the expectation value of the given Hamiltonian multiple times using the quantum program, with the given parameters for each iteration. The number of estimations is determined by the length of the parameters list.

.. deprecated:: Pass a list of parameter dicts to :meth:estimate instead.

Parameters:

Name	Type	Description	Default
`hamiltonian`	`Hamiltonian`	The Hamiltonian to estimate the expectation value of.	required
`parameters`	`list[ExecutionParams]`	A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	required

Returns:

Type	Description
`list[EstimationResult]`	List[EstimationResult]: The results of all the estimation iterations.

batch_sample

batch_sample(
    parameters: list[ExecutionParams],
) -> list[ExecutionDetails]

Samples the quantum program multiple times with the given parameters for each iteration. The number of samples is determined by the length of the parameters list.

.. deprecated:: Pass a list of parameter dicts to :meth:sample instead.

Parameters:

Name	Type	Description	Default
`parameters`	`list[ExecutionParams]`	A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	required

Returns:

Type	Description
`list[ExecutionDetails]`	List[ExecutionDetails]: The results of all the sampling iterations.

close

close() -> None

Close the session and clean up its resources.

estimate

estimate(
    hamiltonian: Hamiltonian,
    parameters: list[ExecutionParams],
) -> list[EstimationResult]

estimate(
    hamiltonian: Hamiltonian,
    parameters: ExecutionParams | None = ...,
) -> EstimationResult

estimate(
    hamiltonian: Hamiltonian,
    parameters: (
        ExecutionParams | list[ExecutionParams] | None
    ) = None,
) -> EstimationResult | list[EstimationResult]

Estimates the expectation value of the given Hamiltonian using the quantum program.

Parameters:

Name	Type	Description	Default
`hamiltonian`	`Hamiltonian`	The Hamiltonian to estimate the expectation value of.	required
`parameters`	`ExecutionParams \| list[ExecutionParams] \| None`	A dictionary of parameter values, or a list of dictionaries for batch execution. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	`None`

Returns:

Type	Description
`EstimationResult \| list[EstimationResult]`	The estimation result, or a list of results when `parameters`
`EstimationResult \| list[EstimationResult]`	is a list.

See Also

More information about Hamiltonians.

estimate_cost

estimate_cost(
    cost_func: Callable[[ParsedState], float],
    parameters: ExecutionParams | None = None,
    quantile: float = 1.0,
) -> float

Estimates circuit cost using a classical cost function.

Parameters:

Name	Type	Description	Default
`cost_func`	`Callable[[ParsedState], float]`	classical circuit sample cost function	required
`parameters`	`ExecutionParams \| None`	execution parameters sent to 'sample'	`None`
`quantile`	`float`	drop cost values outside the specified quantile	`1.0`

Returns:

Type	Description
`float`	cost estimation

See Also

sample

get_session_id

get_session_id() -> str

minimize

minimize(
    cost_function: Hamiltonian | QmodExpressionCreator,
    initial_params: ExecutionParams,
    max_iteration: int,
    quantile: float = 1.0,
    tolerance: float | None = None,
) -> list[tuple[float, ExecutionParams]]

Minimizes the given cost function using the quantum program.

Parameters:

Name	Type	Description	Default
`cost_function`	`Hamiltonian \| QmodExpressionCreator`	The cost function to minimize. It can be one of the following: - A quantum cost function defined by a Hamiltonian. - A classical cost function represented as a callable that returns a Qmod expression. The callable should accept `QVar`s as arguments and use names matching the Model outputs.	required
`initial_params`	`ExecutionParams`	The initial parameters for the minimization. Only Models with exactly one execution parameter are supported. This parameter must be of type `CReal` or `CArray`. The dictionary must contain a single key-value pair, where: - The key is the name of the parameter. - The value is either a float or a list of floats.	required
`max_iteration`	`int`	The maximum number of iterations for the minimization.	required
`quantile`	`float`	The quantile to use for cost estimation.	`1.0`
`tolerance`	`float \| None`	The tolerance for the minimization.	`None`

Returns:

Type	Description
`list[tuple[float, ExecutionParams]]`	A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration. `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.

See Also

The Execution Tutorial has examples on using this method in variational quantum algorithms. More information about Hamiltonians.

sample

sample(
    parameters: list[ExecutionParams],
) -> list[ExecutionDetails]

sample(
    parameters: ExecutionParams | None = ...,
) -> ExecutionDetails

sample(
    parameters: (
        ExecutionParams | list[ExecutionParams] | None
    ) = None,
) -> ExecutionDetails | list[ExecutionDetails]

Samples the quantum program with the given parameters, if any.

Parameters:

Name	Type	Description	Default
`parameters`	`ExecutionParams \| list[ExecutionParams] \| None`	A dictionary of parameter values, or a list of dictionaries for batch execution. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	`None`

Returns:

Type	Description
`ExecutionDetails \| list[ExecutionDetails]`	The result of the sampling, or a list of results when
`ExecutionDetails \| list[ExecutionDetails]`	`parameters` is a list.

set_measured_state_filter

set_measured_state_filter(
    output_name: str, condition: Callable
) -> None

When simulating on a statevector simulator, emulate the behavior of postprocessing by discarding amplitudes for which their states are "undesirable".

Parameters:

Name	Type	Description	Default
`output_name`	`str`	The name of the register to filter	required
`condition`	`Callable`	Filter out values of the statevector for which this callable is False	required

submit_batch_estimate

submit_batch_estimate(
    hamiltonian: Hamiltonian,
    parameters: list[ExecutionParams],
    *,
    _check_deprecation: bool = True
) -> ExecutionJob

Initiates an execution job with the batch_estimate primitive.

.. deprecated:: Pass a list of parameter dicts to :meth:submit_estimate instead.

Parameters:

Name	Type	Description	Default
`hamiltonian`	`Hamiltonian`	The Hamiltonian to estimate the expectation value of.	required
`parameters`	`list[ExecutionParams]`	A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	required

Returns:

Type	Description
`ExecutionJob`	The execution job.

submit_batch_sample

submit_batch_sample(
    parameters: list[ExecutionParams],
) -> ExecutionJob

Initiates an execution job with the batch_sample primitive.

.. deprecated:: Pass a list of parameter dicts to :meth:submit_sample instead.

Parameters:

Name	Type	Description	Default
`parameters`	`list[ExecutionParams]`	A list of the parameters for each iteration. Each item is a dictionary where each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	required

Returns:

Type	Description
`ExecutionJob`	The execution job.

submit_estimate

submit_estimate(
    hamiltonian: Hamiltonian,
    parameters: (
        ExecutionParams | list[ExecutionParams] | None
    ) = None,
    *,
    _check_deprecation: bool = True
) -> ExecutionJob

Initiates an execution job with the estimate primitive.

This is a non-blocking version of estimate: it gets the same parameters and initiates the same execution job, but instead of waiting for the result, it returns the job object immediately.

Parameters:

Name	Type	Description	Default
`hamiltonian`	`Hamiltonian`	The Hamiltonian to estimate the expectation value of.	required
`parameters`	`ExecutionParams \| list[ExecutionParams] \| None`	A dictionary of parameter values, or a list of dictionaries for batch execution. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	`None`

Returns:

Type	Description
`ExecutionJob`	The execution job.

submit_minimize

submit_minimize(
    cost_function: Hamiltonian | QmodExpressionCreator,
    initial_params: ExecutionParams,
    max_iteration: int,
    quantile: float = 1.0,
    tolerance: float | None = None,
    *,
    _check_deprecation: bool = True
) -> ExecutionJob

Initiates an execution job with the minimize primitive.

This is a non-blocking version of minimize: it gets the same parameters and initiates the same execution job, but instead of waiting for the result, it returns the job object immediately.

Parameters:

Name	Type	Description	Default
`cost_function`	`Hamiltonian \| QmodExpressionCreator`	The cost function to minimize. It can be one of the following: - A quantum cost function defined by a Hamiltonian. - A classical cost function represented as a callable that returns a Qmod expression. The callable should accept `QVar`s as arguments and use names matching the Model outputs.	required
`initial_params`	`ExecutionParams`	The initial parameters for the minimization. Only Models with exactly one execution parameter are supported. This parameter must be of type `CReal` or `CArray`. The dictionary must contain a single key-value pair, where: - The key is the name of the parameter. - The value is either a float or a list of floats.	required
`max_iteration`	`int`	The maximum number of iterations for the minimization.	required
`quantile`	`float`	The quantile to use for cost estimation.	`1.0`
`tolerance`	`float \| None`	The tolerance for the minimization.	`None`

Returns:

Type	Description
`ExecutionJob`	The execution job.

submit_sample

submit_sample(
    parameters: (
        ExecutionParams | list[ExecutionParams] | None
    ) = None,
) -> ExecutionJob

Initiates an execution job with the sample primitive.

This is a non-blocking version of sample: it gets the same parameters and initiates the same execution job, but instead of waiting for the result, it returns the job object immediately.

Parameters:

Name	Type	Description	Default
`parameters`	`ExecutionParams \| list[ExecutionParams] \| None`	A dictionary of parameter values, or a list of dictionaries for batch execution. Each key should be the name of a parameter in the quantum program (parameters of the main function), and the value should be the value to set for that parameter.	`None`

Returns:

Type	Description
`ExecutionJob`	The execution job.

update_execution_preferences

update_execution_preferences(
    execution_preferences: ExecutionPreferences | None,
) -> None

Update the execution preferences for the session.

Parameters:

Name	Type	Description	Default
`execution_preferences`	`ExecutionPreferences \| None`	The execution preferences to update.	required

Returns:

Type	Description
`None`	None

ExecutionPreferences

Bases: BaseModel

Represents the execution settings for running a quantum program. Execution preferences for running a quantum program.

For more details, refer to: ExecutionPreferences example: ExecutionPreferences..

Attributes:

Name	Type	Description
`noise_properties`	`Optional[NoiseProperties]`	Properties defining the noise in the quantum circuit. Defaults to `None`.
`random_seed`	`int`	The random seed used for the execution. Defaults to a randomly generated seed.
`backend_preferences`	`BackendPreferencesTypes`	Preferences for the backend used to execute the circuit. Defaults to the Classiq Simulator.
`num_shots`	`Optional[PositiveInt]`	The number of shots (executions) to be performed.
`transpile_to_hardware`	`TranspilationOption`	Option to transpile the circuit to the hardware's basis gates before execution. Defaults to `TranspilationOption.DECOMPOSE`.
`job_name`	`Optional[str]`	The name of the job, with a minimum length of 1 character.

amplitude_threshold

amplitude_threshold: float = Field(
    default=0.0,
    ge=0,
    description="In state vector simulation, only states with amplitude magnitude strictly greater than this threshold are included in the result. Defaults to 0 (filters exactly zero-amplitude states). Overridden by include_zero_amplitude_outputs=True.",
)

backend_preferences

backend_preferences: BackendPreferencesTypes = (
    backend_preferences_field(backend_name=SIMULATOR)
)

include_zero_amplitude_outputs

include_zero_amplitude_outputs: bool = Field(
    default=False,
    description="In state vector simulation, whether to include zero-amplitude states in the result. When True, overrides amplitude_threshold.",
)

job_name

job_name: str | None = Field(
    min_length=1, description="The job name", default=None
)

noise_properties

noise_properties: NoiseProperties | None = Field(
    default=None,
    description="Properties of the noise in the circuit",
)

num_shots

num_shots: PositiveInt | None = Field(default=None)

random_seed

random_seed: int = Field(
    default_factory=create_random_seed,
    description="The random seed used for the execution",
)

transpile_to_hardware

transpile_to_hardware: TranspilationOption = Field(
    default=DECOMPOSE,
    description="Transpile the circuit to the hardware basis gates before execution",
    title="Transpilation Option",
)

CostEstimateResult

Bases: BaseModel

Result of sample cost estimation.

Attributes:

Name	Type	Description
`cost`	`float`
`currency`	`str`

cost

cost: float = Field(description='Estimated cost')

currency

currency: str = Field(
    default="USD", description="Currency code"
)

BackendPreferences

Bases: BaseModel

Preferences for the execution of the quantum program.

Attributes:

Name	Type	Description
`backend_service_provider`	`str`	Provider company or cloud for the requested backend.
`backend_name`	`str`	Name of the requested backend or target.

Methods:

Name	Description
`batch_preferences`
`is_nvidia_backend`

backend_name

backend_name: str = Field(
    ...,
    description="Name of the requested backend or target.",
)

backend_service_provider

backend_service_provider: ProviderVendor = Field(
    ...,
    description="Provider company or cloud for the requested backend.",
)

hw_provider

hw_provider: Provider

batch_preferences

batch_preferences(
    *, backend_names: Iterable[str], **kwargs: Any
) -> list[BackendPreferences]

is_nvidia_backend

is_nvidia_backend() -> bool

jobs

Classes:

Name	Description
`ClassiqExecutionResultError`
`ExecutionJob`
`ExecutionJobFilters`	Filter parameters for querying execution jobs.
`ExecutionJobResults`	Results from `ExecutionJob.result()`: list-like with job-level metadata.
`SubmittedCircuit`	A quantum circuit that was submitted to the provider.

Functions:

Name	Description
`get_execution_actions`	Query execution jobs with optional filters.
`get_execution_actions_async`
`get_execution_jobs`	Query execution jobs.
`get_execution_jobs_async`

Attributes:

Name	Type	Description
`CURRENCY_CODE`
`RUNTIME_MS`
`TOTAL_COST`

CURRENCY_CODE

CURRENCY_CODE = 'currency_code'

RUNTIME_MS

RUNTIME_MS = 'runtime_ms'

TOTAL_COST

TOTAL_COST = 'total_cost'

ClassiqExecutionResultError

ClassiqExecutionResultError(primitive: str)

Bases: ClassiqError

ExecutionJob

ExecutionJob(details: ExecutionJobDetails)

Methods:

Name	Description
`cancel_async`	Cancels the execution job. This implies the cancellation of any ongoing jobs
`cost`
`from_id`
`from_id_async`
`get_batch_estimate_result`	Returns the job's result as a single batch_estimate result after validation. If the result is not yet available, waits for it.
`get_batch_sample_result`	Returns the job's result as a single batch_sample result after validation. If the result is not yet available, waits for it.
`get_estimate_result`	Returns the job's result as a single estimate result after validation. If the result is not yet available, waits for it.
`get_minimization_result`	Returns the job's result as a single minimization result after validation. If the result is not yet available, waits for it.
`get_sample_result`	Returns the job's result as a single sample result after validation. If the result is not yet available, waits for it.
`get_submitted_circuits`	Returns the quantum circuits that were submitted to the provider.
`get_submitted_circuits_async`	Returns the quantum circuits that were submitted to the provider.
`open_in_ide`
`poll_async`
`rename_async`
`result_async`
`result_value`

Attributes:

Name	Type	Description
`backend_name`	`str \| None`
`cancel`
`end_time`	`datetime \| None`
`error`	`str \| None`
`hardware_execution_duration_ms`	`int \| None`
`id`	`str`
`ide_url`	`str`
`name`	`str \| None`
`num_shots`	`int \| None`
`poll`
`program_id`	`str \| None`
`provider`	`str \| None`
`rename`
`result`
`start_time`	`datetime`
`status`	`JobStatus`

backend_name

backend_name: str | None

cancel

cancel = syncify_function(cancel_async)

end_time

end_time: datetime | None

error

error: str | None

hardware_execution_duration_ms

hardware_execution_duration_ms: int | None

id

id: str

ide_url

ide_url: str

name

name: str | None

num_shots

num_shots: int | None

poll

poll = syncify_function(poll_async)

program_id

program_id: str | None

provider

provider: str | None

rename

rename = syncify_function(rename_async)

result

result = syncify_function(result_async)

start_time

start_time: datetime

status

status: JobStatus

cancel_async

cancel_async(
    _http_client: AsyncClient | None = None,
) -> None

Cancels the execution job. This implies the cancellation of any ongoing jobs sent to the provider during this execution job.

The function returns without waiting to the actual cancellation. It is possible to continue polling the job in order to ensure its cancellation, which might not be immediate.

cost

cost(*, verbose: bool = False) -> str | JobCost

from_id

from_id(
    id: str, _http_client: AsyncClient | None = None
) -> ExecutionJob

from_id_async

from_id_async(
    id: str, _http_client: AsyncClient | None = None
) -> ExecutionJob

get_batch_estimate_result

get_batch_estimate_result(
    _http_client: AsyncClient | None = None,
) -> list[EstimationResult]

Returns the job's result as a single batch_estimate result after validation. If the result is not yet available, waits for it.

Returns:

Type	Description
`list[EstimationResult]`	The batch_estimate result of the execution job.

Raises:

Type	Description
`ClassiqExecutionResultError`	In case the result does not contain a single batch_estimate result.
`ClassiqAPIError`	In case the job has failed.

get_batch_sample_result

get_batch_sample_result(
    _http_client: AsyncClient | None = None,
) -> list[ExecutionDetails]

Returns the job's result as a single batch_sample result after validation. If the result is not yet available, waits for it.

Returns:

Type	Description
`list[ExecutionDetails]`	The batch_sample result of the execution job.

Raises:

Type	Description
`ClassiqExecutionResultError`	In case the result does not contain a single batch_sample result.
`ClassiqAPIError`	In case the job has failed.

get_estimate_result

get_estimate_result(
    _http_client: AsyncClient | None = None,
) -> EstimationResult

Returns the job's result as a single estimate result after validation. If the result is not yet available, waits for it.

Returns:

Type	Description
`EstimationResult`	The estimate result of the execution job.

Raises:

Type	Description
`ClassiqExecutionResultError`	In case the result does not contain a single estimate result.
`ClassiqAPIError`	In case the job has failed.

get_minimization_result

get_minimization_result(
    _http_client: AsyncClient | None = None,
) -> TaggedMinimizeResult

Returns the job's result as a single minimization result after validation. If the result is not yet available, waits for it.

Returns:

Type	Description
`TaggedMinimizeResult`	The minimization result of the execution job.

Raises:

Type	Description
`ClassiqExecutionResultError`	In case the result does not contain a single minimization result.
`ClassiqAPIError`	In case the job has failed.

get_sample_result

get_sample_result(
    _http_client: AsyncClient | None = None,
) -> ExecutionDetails

Returns the job's result as a single sample result after validation. If the result is not yet available, waits for it.

Returns:

Type	Description
`ExecutionDetails`	The sample result of the execution job.

Raises:

Type	Description
`ClassiqExecutionResultError`	In case the result does not contain a single sample result.
`ClassiqAPIError`	In case the job has failed.

get_submitted_circuits

get_submitted_circuits(
    _http_client: AsyncClient | None = None,
) -> list[SubmittedCircuit]

Returns the quantum circuits that were submitted to the provider.

An execution job may submit multiple circuits (e.g. batch execution with different parameter sets). The returned list preserves submission order and matches the order of results in get_batch_sample_result().

Circuits are returned with parameters already assigned (as submitted). Supports sample jobs only.

get_submitted_circuits_async

get_submitted_circuits_async(
    _http_client: AsyncClient | None = None,
) -> list[SubmittedCircuit]

Returns the quantum circuits that were submitted to the provider.

An execution job may submit multiple circuits (e.g. batch execution with different parameter sets). The returned list preserves submission order and matches the order of results in get_batch_sample_result().

Circuits are returned with parameters already assigned (as submitted). Supports sample jobs only.

open_in_ide

open_in_ide() -> None

poll_async

poll_async(
    timeout_sec: float | None = None,
    _http_client: AsyncClient | None = None,
) -> None

rename_async

rename_async(
    name: str, _http_client: AsyncClient | None = None
) -> None

result_async

result_async(
    timeout_sec: float | None = None,
    _http_client: AsyncClient | None = None,
) -> ExecutionJobResults

result_value

result_value(*args: Any, **kwargs: Any) -> Any

ExecutionJobFilters

ExecutionJobFilters(
    id: str | None = None,
    session_id: str | None = None,
    status: JobStatus | None = None,
    name: str | None = None,
    provider: str | None = None,
    backend: str | None = None,
    program_id: str | None = None,
    total_cost_min: float | None = None,
    total_cost_max: float | None = None,
    start_time_min: datetime | None = None,
    start_time_max: datetime | None = None,
    end_time_min: datetime | None = None,
    end_time_max: datetime | None = None,
)

Filter parameters for querying execution jobs.

All filters are combined using AND logic: only jobs matching all specified filters are returned. Range filters (with _min/_max suffixes) are inclusive. Datetime filters are compared against the job's timestamps.

Methods:

Name	Description
`format_filters`	Convert filter fields to API kwargs, excluding None values and converting datetimes.

Attributes:

Name	Type	Description
`backend`	`str \| None`
`end_time_max`	`datetime \| None`
`end_time_min`	`datetime \| None`
`id`	`str \| None`
`name`	`str \| None`
`program_id`	`str \| None`
`provider`	`str \| None`
`session_id`	`str \| None`
`start_time_max`	`datetime \| None`
`start_time_min`	`datetime \| None`
`status`	`JobStatus \| None`
`total_cost_max`	`float \| None`
`total_cost_min`	`float \| None`

backend

backend: str | None = None

end_time_max

end_time_max: datetime | None = None

end_time_min

end_time_min: datetime | None = None

id

id: str | None = None

name

name: str | None = None

program_id

program_id: str | None = None

provider

provider: str | None = None

session_id

session_id: str | None = None

start_time_max

start_time_max: datetime | None = None

start_time_min

start_time_min: datetime | None = None

status

status: JobStatus | None = None

total_cost_max

total_cost_max: float | None = None

total_cost_min

total_cost_min: float | None = None

format_filters

format_filters() -> dict[str, Any]

Convert filter fields to API kwargs, excluding None values and converting datetimes.

ExecutionJobResults

ExecutionJobResults(
    results: ResultsCollection,
    *,
    hardware_execution_duration_ms: int | None = None
)

Bases: UserList

Results from ExecutionJob.result(): list-like with job-level metadata.

Attributes:

Name	Type	Description
`hardware_execution_duration_ms`	`int \| None`

hardware_execution_duration_ms

hardware_execution_duration_ms: int | None = (
    hardware_execution_duration_ms
)

SubmittedCircuit

SubmittedCircuit(qasm: str)

A quantum circuit that was submitted to the provider.

Wraps the circuit in QASM format. Use to_qasm() for the text representation or to_qiskit() for a Qiskit QuantumCircuit (requires qiskit).

Methods:

Name	Description
`to_qasm`	Return the circuit as a QASM string (OpenQASM 2.0 or 3.0).
`to_qiskit`	Return the circuit as a Qiskit QuantumCircuit. Requires qiskit.

to_qasm

to_qasm() -> str

Return the circuit as a QASM string (OpenQASM 2.0 or 3.0).

to_qiskit

to_qiskit() -> Any

Return the circuit as a Qiskit QuantumCircuit. Requires qiskit.

get_execution_actions

get_execution_actions(
    offset: int = 0,
    limit: int = 50,
    filters: ExecutionJobFilters | None = None,
) -> DataFrame

Query execution jobs with optional filters.

Parameters:

Name	Type	Description	Default
`offset`	`int`	Number of results to skip (default: 0)	`0`
`limit`	`int`	Maximum number of results to return (default: 50)	`50`
`filters`	`ExecutionJobFilters \| None`	Optional ExecutionJobFilters object containing filter parameters.	`None`

Returns:

Type	Description
`DataFrame`	pandas.DataFrame containing execution job information with columns:
`DataFrame`	id, name, start_time, end_time, provider, backend_name, status,
`DataFrame`	num_shots, program_id, error, total_cost, currency_code, runtime_ms
`DataFrame`	(provider-reported hardware execution duration in milliseconds when available).

Examples:

Query all jobs:

df = get_execution_actions(limit=10)

Query with filters:

filters = ExecutionJobFilters(status="COMPLETED", provider="ibm") df = get_execution_actions(filters=filters, limit=10)

get_execution_actions_async

get_execution_actions_async(
    offset: int = 0,
    limit: int = 50,
    filters: ExecutionJobFilters | None = None,
) -> DataFrame

get_execution_jobs

get_execution_jobs(
    offset: int = 0, limit: int = 50
) -> list[ExecutionJob]

Query execution jobs.

Parameters:

Name	Type	Description	Default
`offset`	`int`	Number of results to skip (default: 0)	`0`
`limit`	`int`	Maximum number of results to return (default: 50)	`50`

Returns:

Type	Description
`list[ExecutionJob]`	List of ExecutionJob objects.

Examples:

Query all jobs:

jobs = get_execution_jobs(limit=10)

get_execution_jobs_async

get_execution_jobs_async(
    offset: int = 0, limit: int = 50
) -> list[ExecutionJob]

assign_parameters

assign_parameters(
    quantum_program: QuantumProgram,
    parameters: ExecutionParams,
) -> QuantumProgram

Assign parameters to a parametric quantum program.

Parameters:

Name	Type	Description	Default
`quantum_program`	`QuantumProgram`	The quantum program to be assigned. This is the result of the synthesize method.	required
`parameters`	`ExecutionParams`	The parameter assignments.	required

Returns:

Name	Type	Description
`QuantumProgram`	`QuantumProgram`	The quantum program after assigning parameters.

transpile

transpile(
    quantum_program: QuantumProgram,
    preferences: Preferences | None = None,
) -> QuantumProgram

Transpiles a quantum program.

Parameters:

Name	Type	Description	Default
`quantum_program`	`QuantumProgram`	The quantum program to transpile. This is the result of the synthesize method.	required
`preferences`	`Preferences \| None`	The transpilation preferences.	`None`

Returns:

Name	Type	Description
`QuantumProgram`	`QuantumProgram`	The result of the transpilation (Optional).

get_budget

get_budget(
    provider: ProviderVendor | None = None,
) -> UserBudgets

Retrieve the user's budget information for quantum computing resources.

Parameters:

Name	Type	Description	Default
`provider`	`ProviderVendor \| None`	(Optional) The quantum backend provider to filter budgets by. If not provided, budgets for all providers will be returned.	`None`

Returns:

Name	Type	Description
`UserBudgets`	`UserBudgets`	An object containing the user's budget information.

set_budget_limit

set_budget_limit(
    provider: ProviderVendor, limit: float
) -> UserBudgets

Set a budget limit for a specific quantum backend provider.

Parameters:

Name	Type	Description	Default
`provider`	`ProviderVendor`	The quantum backend provider for which to set the budget limit.	required
`limit`	`float`	The budget limit to set. Must be greater than zero and not exceed the available budget.	required

Returns:

Name	Type	Description
`UserBudgets`	`UserBudgets`	An object containing the updated budget information.

Raises:

Type	Description
`ValueError`	If the provider is unsupported, no budget is found, or the limit is invalid.

clear_budget_limit

clear_budget_limit(provider: ProviderVendor) -> UserBudgets

Clear the budget limit for a specific quantum backend provider.

Parameters:

Name	Type	Description	Default
`provider`	`ProviderVendor`	The quantum backend provider for which to clear the budget limit.	required

Returns:

Name	Type	Description
`UserBudgets`	`UserBudgets`	An object containing the updated budget information.

Raises:

Type	Description
`ValueError`	If the provider is unsupported.