Chemistry - Classiq Docs

Members:

Name	Description
`FermionHamiltonianProblem`	Defines an electronic-structure problem using a Fermionic operator and electron count.

FermionHamiltonianProblem

Defines an electronic-structure problem using a Fermionic operator and electron count. Can also be constructed from a MolecularData object using the from_molecule method. Methods:

Name	Description
from_molecule	Constructs a `FermionHamiltonianProblem` from a molecule data.

Attributes:

Name	Type	Description
`occupied_alpha`	`list[int]`
`virtual_alpha`	`list[int]`
`occupied_beta`	`list[int]`
`virtual_beta`	`list[int]`
`occupied`	`list[int]`
`virtual`	`list[int]`
`fermion_hamiltonian`	`FermionOperator`	The fermionic hamiltonian of the problem. Assumed to be in the block-spin labeling.
`n_orbitals`	`int`	Number of spatial orbitals.
`n_alpha`	`int`	Number of alpha particles.
`n_beta`	`int`	Number of beta particles.
`n_particles`	`tuple[int, int]`	Number of alpha and beta particles.

from_molecule

from_molecule(
cls: ,
molecule: MolecularData,
first_active_index: int = 0,
remove_orbitals: Sequence[int] | None = None,
op_compression_tol: float = 1e-13
) -> FermionHamiltonianProblem

Constructs a FermionHamiltonianProblem from a molecule data. Parameters:

Name	Type	Description	Default
`cls`	“		required
`molecule`	`MolecularData`	The molecule data.	required
`first_active_index`	`int`	The first active index, indicates all prior indices are freezed.	0
`remove_orbitals`	`Sequence[int] \| None`	Active indices to be removed.	None
`op_compression_tol`	`float`	Tolerance for trimming the fermion operator.	1e-13

Returns:

Type: FermionHamiltonianProblem
The fermion hamiltonian problem. Members:

Name	Description
`FermionHamiltonianProblem`	Defines an electronic-structure problem using a Fermionic operator and electron count.
`MappingMethod`	Mapping methods from fermionic operators to qubits operators.
`FermionToQubitMapper`	Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see `MappingMethod`).

FermionHamiltonianProblem

Defines an electronic-structure problem using a Fermionic operator and electron count. Can also be constructed from a MolecularData object using the from_molecule method. Methods:

Name	Description
from_molecule	Constructs a `FermionHamiltonianProblem` from a molecule data.

Attributes:

Name	Type	Description
`occupied_alpha`	`list[int]`
`virtual_alpha`	`list[int]`
`occupied_beta`	`list[int]`
`virtual_beta`	`list[int]`
`occupied`	`list[int]`
`virtual`	`list[int]`
`fermion_hamiltonian`	`FermionOperator`	The fermionic hamiltonian of the problem. Assumed to be in the block-spin labeling.
`n_orbitals`	`int`	Number of spatial orbitals.
`n_alpha`	`int`	Number of alpha particles.
`n_beta`	`int`	Number of beta particles.
`n_particles`	`tuple[int, int]`	Number of alpha and beta particles.

from_molecule

from_molecule(
cls: ,
molecule: MolecularData,
first_active_index: int = 0,
remove_orbitals: Sequence[int] | None = None,
op_compression_tol: float = 1e-13
) -> FermionHamiltonianProblem

Constructs a FermionHamiltonianProblem from a molecule data. Parameters:

Name	Type	Description	Default
`cls`	“		required
`molecule`	`MolecularData`	The molecule data.	required
`first_active_index`	`int`	The first active index, indicates all prior indices are freezed.	0
`remove_orbitals`	`Sequence[int] \| None`	Active indices to be removed.	None
`op_compression_tol`	`float`	Tolerance for trimming the fermion operator.	1e-13

Returns:

Type: FermionHamiltonianProblem
The fermion hamiltonian problem.

MappingMethod

Mapping methods from fermionic operators to qubits operators. Attributes:

Name	Type	Description
`JORDAN_WIGNER`	`'jw'`
`BRAVYI_KITAEV`	`'bk'`

FermionToQubitMapper

Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see MappingMethod). Methods:

Name	Description
map	Maps the given fermionic operator to a qubits operator using the mapper’s configuration.
get_num_qubits	Gets the number of qubits after mapping the given problem into qubits space.

Attributes:

Name	Type	Description
`method`	`MappingMethod`	The mapping method.

map

map(
self: ,
fermion_op: FermionOperator,
args: Any = (),
kwargs: Any = 
) -> QubitOperator

Maps the given fermionic operator to a qubits operator using the mapper’s configuration. Parameters:

Name	Type	Description	Default
`self`	“		required
`fermion_op`	`FermionOperator`	A fermionic operator.	required
`args`	`Any`		()
`kwargs`	`Any`

Returns:

Type: QubitOperator
The mapped qubits operator.

get_num_qubits

get_num_qubits(
self: ,
problem: FermionHamiltonianProblem
) -> int

Gets the number of qubits after mapping the given problem into qubits space. Parameters:

Name	Type	Description	Default
`self`	“		required
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required

Returns:

Type: int
The number of qubits. Members:

Name	Description
`FermionToQubitMapper`	Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see `MappingMethod`).
`MappingMethod`	Mapping methods from fermionic operators to qubits operators.
`FermionHamiltonianProblem`	Defines an electronic-structure problem using a Fermionic operator and electron count.
`Z2SymTaperMapper`	Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see `MappingMethod`), and taking advantage of Z…

FermionToQubitMapper

Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see MappingMethod). Methods:

Name	Description
map	Maps the given fermionic operator to a qubits operator using the mapper’s configuration.
get_num_qubits	Gets the number of qubits after mapping the given problem into qubits space.

Attributes:

Name	Type	Description
`method`	`MappingMethod`	The mapping method.

map

map(
self: ,
fermion_op: FermionOperator,
args: Any = (),
kwargs: Any = 
) -> QubitOperator

Maps the given fermionic operator to a qubits operator using the mapper’s configuration. Parameters:

Name	Type	Description	Default
`self`	“		required
`fermion_op`	`FermionOperator`	A fermionic operator.	required
`args`	`Any`		()
`kwargs`	`Any`

Returns:

Type: QubitOperator
The mapped qubits operator.

get_num_qubits

get_num_qubits(
self: ,
problem: FermionHamiltonianProblem
) -> int

Gets the number of qubits after mapping the given problem into qubits space. Parameters:

Name	Type	Description	Default
`self`	“		required
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required

Returns:

Type: int
The number of qubits.

MappingMethod

Mapping methods from fermionic operators to qubits operators. Attributes:

Name	Type	Description
`JORDAN_WIGNER`	`'jw'`
`BRAVYI_KITAEV`	`'bk'`

FermionHamiltonianProblem

Defines an electronic-structure problem using a Fermionic operator and electron count. Can also be constructed from a MolecularData object using the from_molecule method. Methods:

Name	Description
from_molecule	Constructs a `FermionHamiltonianProblem` from a molecule data.

Attributes:

Name	Type	Description
`occupied_alpha`	`list[int]`
`virtual_alpha`	`list[int]`
`occupied_beta`	`list[int]`
`virtual_beta`	`list[int]`
`occupied`	`list[int]`
`virtual`	`list[int]`
`fermion_hamiltonian`	`FermionOperator`	The fermionic hamiltonian of the problem. Assumed to be in the block-spin labeling.
`n_orbitals`	`int`	Number of spatial orbitals.
`n_alpha`	`int`	Number of alpha particles.
`n_beta`	`int`	Number of beta particles.
`n_particles`	`tuple[int, int]`	Number of alpha and beta particles.

from_molecule

from_molecule(
cls: ,
molecule: MolecularData,
first_active_index: int = 0,
remove_orbitals: Sequence[int] | None = None,
op_compression_tol: float = 1e-13
) -> FermionHamiltonianProblem

Constructs a FermionHamiltonianProblem from a molecule data. Parameters:

Name	Type	Description	Default
`cls`	“		required
`molecule`	`MolecularData`	The molecule data.	required
`first_active_index`	`int`	The first active index, indicates all prior indices are freezed.	0
`remove_orbitals`	`Sequence[int] \| None`	Active indices to be removed.	None
`op_compression_tol`	`float`	Tolerance for trimming the fermion operator.	1e-13

Returns:

Type: FermionHamiltonianProblem
The fermion hamiltonian problem.

Z2SymTaperMapper

Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see MappingMethod), and taking advantage of Z2 symmetries in order to taper off qubits. Methods:

Name	Description
set_sector	Sets the symmetry sector coefficients.
map	Maps the given fermionic operator to qubits operator by using the mapper’s method, and subsequently by tapering off qubits according to Z2 symmetries.
get_num_qubits	Gets the number of qubits after mapping the given problem into qubits space.
from_problem	Initializes a `Z2SymTaperMapper` object from a fermion problem (i.e.

Attributes:

Name	Type	Description
`method`	`MappingMethod`	The mapping method.
`generators`	`tuple[QubitOperator, ...]`	Generators representing the Z2 symmetries.
`x_ops`	`tuple[QubitOperator, ...]`	Single-qubit X operations, such that each operation anti-commutes with its matching generator and commutes with all other generators.

set_sector

set_sector(
self: ,
sector: Sequence[int]
) -> None

Sets the symmetry sector coefficients. Parameters:

Name	Type	Description	Default
`self`	“		required
`sector`	`Sequence[int]`	(Sequence[int]): Symmetry sector coefficients, each is 1 or -1.	required

map

map(
self: ,
fermion_op: FermionOperator,
args: Any = (),
is_invariant: bool = False,
kwargs: Any = 
) -> QubitOperator

Maps the given fermionic operator to qubits operator by using the mapper’s method, and subsequently by tapering off qubits according to Z2 symmetries. Parameters:

Name	Type	Description	Default
`self`	“		required
`fermion_op`	`FermionOperator`	A fermionic operator.	required
`args`	`Any`		()
`is_invariant`	`bool`	If `False`, the operator is not necessarily in the symmetry subspace, and thus gets projected onto it before tapering.	False
`kwargs`	`Any`

Returns:

Type: QubitOperator
The mapped qubits operator.

get_num_qubits

get_num_qubits(
self: ,
problem: FermionHamiltonianProblem
) -> int

Gets the number of qubits after mapping the given problem into qubits space. Parameters:

Name	Type	Description	Default
`self`	“		required
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required

Returns:

Type: int
The number of qubits.

from_problem

from_problem(
cls: ,
problem: FermionHamiltonianProblem,
method: MappingMethod = MappingMethod.JORDAN_WIGNER,
sector_from_hartree_fock: bool = True,
tol: float = 1e-14
) -> Z2SymTaperMapper

Initializes a Z2SymTaperMapper object from a fermion problem (i.e. computing the Z2 symmetries from the problem definition). Parameters:

Name	Type	Description	Default
`cls`	“		required
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required
`method`	`MappingMethod`	The mapping method.	MappingMethod.JORDAN_WIGNER
`sector_from_hartree_fock`	`bool`	Whether to compute the symmetry sector coefficients according to the Hartree-Fock state.	True
`tol`	`float`	Tolerance for trimming off terms.	1e-14

Returns:

Type: Z2SymTaperMapper
The Z2 symmetries taper mapper. Members:

Name	Description
`FermionToQubitMapper`	Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see `MappingMethod`).
`FermionHamiltonianProblem`	Defines an electronic-structure problem using a Fermionic operator and electron count.
`get_hf_fermion_op`	Constructs a fermion operator that creates the Hartree-Fock reference state in block-spin ordering.
`get_hf_state`	Computes the qubits state after applying the Hartree-Fock operator defined by the given problem and mapper.

FermionToQubitMapper

Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see MappingMethod). Methods:

Name	Description
map	Maps the given fermionic operator to a qubits operator using the mapper’s configuration.
get_num_qubits	Gets the number of qubits after mapping the given problem into qubits space.

Attributes:

Name	Type	Description
`method`	`MappingMethod`	The mapping method.

map

map(
self: ,
fermion_op: FermionOperator,
args: Any = (),
kwargs: Any = 
) -> QubitOperator

Maps the given fermionic operator to a qubits operator using the mapper’s configuration. Parameters:

Name	Type	Description	Default
`self`	“		required
`fermion_op`	`FermionOperator`	A fermionic operator.	required
`args`	`Any`		()
`kwargs`	`Any`

Returns:

Type: QubitOperator
The mapped qubits operator.

get_num_qubits

get_num_qubits(
self: ,
problem: FermionHamiltonianProblem
) -> int

Gets the number of qubits after mapping the given problem into qubits space. Parameters:

Name	Type	Description	Default
`self`	“		required
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required

Returns:

Type: int
The number of qubits.

FermionHamiltonianProblem

Defines an electronic-structure problem using a Fermionic operator and electron count. Can also be constructed from a MolecularData object using the from_molecule method. Methods:

Name	Description
from_molecule	Constructs a `FermionHamiltonianProblem` from a molecule data.

Attributes:

Name	Type	Description
`occupied_alpha`	`list[int]`
`virtual_alpha`	`list[int]`
`occupied_beta`	`list[int]`
`virtual_beta`	`list[int]`
`occupied`	`list[int]`
`virtual`	`list[int]`
`fermion_hamiltonian`	`FermionOperator`	The fermionic hamiltonian of the problem. Assumed to be in the block-spin labeling.
`n_orbitals`	`int`	Number of spatial orbitals.
`n_alpha`	`int`	Number of alpha particles.
`n_beta`	`int`	Number of beta particles.
`n_particles`	`tuple[int, int]`	Number of alpha and beta particles.

from_molecule

from_molecule(
cls: ,
molecule: MolecularData,
first_active_index: int = 0,
remove_orbitals: Sequence[int] | None = None,
op_compression_tol: float = 1e-13
) -> FermionHamiltonianProblem

Constructs a FermionHamiltonianProblem from a molecule data. Parameters:

Name	Type	Description	Default
`cls`	“		required
`molecule`	`MolecularData`	The molecule data.	required
`first_active_index`	`int`	The first active index, indicates all prior indices are freezed.	0
`remove_orbitals`	`Sequence[int] \| None`	Active indices to be removed.	None
`op_compression_tol`	`float`	Tolerance for trimming the fermion operator.	1e-13

Returns:

Type: FermionHamiltonianProblem
The fermion hamiltonian problem.

get_hf_fermion_op

get_hf_fermion_op(
problem: FermionHamiltonianProblem
) -> FermionOperator

Constructs a fermion operator that creates the Hartree-Fock reference state in block-spin ordering. Parameters:

Name	Type	Description	Default
`problem`	`FermionHamiltonianProblem`	The fermion problem. The Hartree-Fock fermion operator depends only on the number of spatial orbitals and the number of alpha and beta particles.	required

Returns:

Type: FermionOperator
The Hartree-Fock fermion operator.

get_hf_state

get_hf_state(
problem: FermionHamiltonianProblem,
mapper: FermionToQubitMapper
) -> list[bool]

Computes the qubits state after applying the Hartree-Fock operator defined by the given problem and mapper. The Qmod function prepare_basis_state can be used on the returned value to allocate and initialize the qubits array. Parameters:

Name	Type	Description	Default
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required
`mapper`	`FermionToQubitMapper`	The mapper from fermion operator to qubits operator.	required

Returns:

Type: list[bool]
The qubits state, given as a list of boolean values for each qubit. Members:

Name	Description
`FermionToQubitMapper`	Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see `MappingMethod`).
`FermionHamiltonianProblem`	Defines an electronic-structure problem using a Fermionic operator and electron count.
`SparsePauliOp`	Represents a collection of sparse Pauli operators.
`get_ucc_hamiltonians`	Computes the UCC hamiltonians of the given problem in the desired excitations, using the given mapper.
`get_excitations`	Gets all the possible excitations of the given problem according to the given number of excitations, preserving the particles spin.

FermionToQubitMapper

Mapper between fermionic operators to qubits operators, using one of the supported mapping methods (see MappingMethod). Methods:

Name	Description
map	Maps the given fermionic operator to a qubits operator using the mapper’s configuration.
get_num_qubits	Gets the number of qubits after mapping the given problem into qubits space.

Attributes:

Name	Type	Description
`method`	`MappingMethod`	The mapping method.

map

map(
self: ,
fermion_op: FermionOperator,
args: Any = (),
kwargs: Any = 
) -> QubitOperator

Maps the given fermionic operator to a qubits operator using the mapper’s configuration. Parameters:

Name	Type	Description	Default
`self`	“		required
`fermion_op`	`FermionOperator`	A fermionic operator.	required
`args`	`Any`		()
`kwargs`	`Any`

Returns:

Type: QubitOperator
The mapped qubits operator.

get_num_qubits

get_num_qubits(
self: ,
problem: FermionHamiltonianProblem
) -> int

Gets the number of qubits after mapping the given problem into qubits space. Parameters:

Name	Type	Description	Default
`self`	“		required
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required

Returns:

Type: int
The number of qubits.

FermionHamiltonianProblem

Defines an electronic-structure problem using a Fermionic operator and electron count. Can also be constructed from a MolecularData object using the from_molecule method. Methods:

Name	Description
from_molecule	Constructs a `FermionHamiltonianProblem` from a molecule data.

Attributes:

Name	Type	Description
`occupied_alpha`	`list[int]`
`virtual_alpha`	`list[int]`
`occupied_beta`	`list[int]`
`virtual_beta`	`list[int]`
`occupied`	`list[int]`
`virtual`	`list[int]`
`fermion_hamiltonian`	`FermionOperator`	The fermionic hamiltonian of the problem. Assumed to be in the block-spin labeling.
`n_orbitals`	`int`	Number of spatial orbitals.
`n_alpha`	`int`	Number of alpha particles.
`n_beta`	`int`	Number of beta particles.
`n_particles`	`tuple[int, int]`	Number of alpha and beta particles.

from_molecule

from_molecule(
cls: ,
molecule: MolecularData,
first_active_index: int = 0,
remove_orbitals: Sequence[int] | None = None,
op_compression_tol: float = 1e-13
) -> FermionHamiltonianProblem

Constructs a FermionHamiltonianProblem from a molecule data. Parameters:

Name	Type	Description	Default
`cls`	“		required
`molecule`	`MolecularData`	The molecule data.	required
`first_active_index`	`int`	The first active index, indicates all prior indices are freezed.	0
`remove_orbitals`	`Sequence[int] \| None`	Active indices to be removed.	None
`op_compression_tol`	`float`	Tolerance for trimming the fermion operator.	1e-13

Returns:

Type: FermionHamiltonianProblem
The fermion hamiltonian problem.

SparsePauliOp

Represents a collection of sparse Pauli operators. Methods:

Name	Description
get_tuples_representation

Attributes:

Name	Type	Description
`terms`	`CArray[SparsePauliTerm]`	The list of chosen sparse Pauli terms, corresponds to a product of them. (See: SparsePauliTerm)
`num_qubits`	`CInt`	The number of qubits in the Hamiltonian.

get_tuples_representation

get_tuples_representation(
self: ,
reverse_order: bool
) -> list[tuple[str, int | float | complex]]

Parameters:

Name	Type	Description	Default
`self`	“		required
`reverse_order`	`bool`		required

get_ucc_hamiltonians

get_ucc_hamiltonians(
problem: FermionHamiltonianProblem,
mapper: FermionToQubitMapper,
excitations: int | Sequence[int]
) -> list[SparsePauliOp]

Computes the UCC hamiltonians of the given problem in the desired excitations, using the given mapper. Parameters:

Name	Type	Description	Default
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required
`mapper`	`FermionToQubitMapper`	The mapper from fermion to qubits operators.	required
`excitations`	`int \| Sequence[int]`	A single desired excitation or an excitations list.	required

Returns:

Type: list[SparsePauliOp]
The UCC hamiltonians.

get_excitations

get_excitations(
problem: FermionHamiltonianProblem,
num_excitations: int
) -> set[tuple[tuple[int, …], tuple[int, …]]]

Gets all the possible excitations of the given problem according to the given number of excitations, preserving the particles spin. Parameters:

Name	Type	Description	Default
`problem`	`FermionHamiltonianProblem`	The fermion problem.	required
`num_excitations`	`int`	Number of excitations.	required

Returns:

Type: set[tuple[tuple[int, ...], tuple[int, ...]]]
A set of all possible excitations, specified as a pair of source and target indices. Members:

Name	Description
`DFTState`	Post-DFT handle returned to the user, recording the resolved spin mode, functional, and method.
`EmbeddingCalculator`	User-facing embedding driver, backed by queued backend jobs.
`EmbeddingConfig`	Embedding-method parameters.
`MeanFieldData`	Fragment / environment densities, electron counts, and active-MO basis.
`MoleculeSpec`	User-facing molecular description.
`QuantumData`	Solver-facing bundle: embedded + physical Hamiltonians and scalars.
`SpinMode`	Which mean-field treatment the backend should use.
`ValidationCheck`	Validation diagnostics the embedding pipeline can run.
`embedding_calculator`	User-facing API for projection-based WF-in-DFT embedding.
`chemistry_job`	Detached handle for a long-running chemistry backend job.

DFTState

Post-DFT handle returned to the user, recording the resolved spin mode, functional, and method. Threaded back into later stages. Attributes:

Name	Type	Description
`spin_mode`	`SpinMode`
`xc_functional`	`str`
`method`	`CalculationMethod`

EmbeddingCalculator

User-facing embedding driver, backed by queued backend jobs. Methods:

Name	Description
run_dft	Run the full-system mean field and cache the result.
submit_dft	Enqueue the full-system mean field and return a job handle.
run_dft_embedding	Run the full embedding pipeline in one backend call.
submit_dft_embedding	Enqueue the full embedding pipeline and return a job handle.
run_validations	Run a batch of post-hoc validations in a single backend call.

Attributes:

Name	Type	Description
`spec`
`spin_mode`
`auto_validations`	`tuple[ValidationCheck, ...]`
`validation_results`	`ValidationResults`
`config`	`EmbeddingConfig \| None`
`effective_spin_mode`	`SpinMode`

run_dft

run_dft(
self: ,
xc_functional: str = ‘B3LYP’,
method: CalculationMethod = CalculationMethod.DFT
) -> DFTState

Run the full-system mean field and cache the result. Blocks until the backend job finishes. For a long run prefer submit_dft(), which returns a handle you can poll later. method selects DFT (default, using xc_functional) or Hartree-Fock (xc_functional is then ignored). Parameters:

Name	Type	Default
`self`	“	required
`xc_functional`	`str`	’B3LYP’
`method`	`CalculationMethod`	CalculationMethod.DFT

submit_dft

submit_dft(
self: ,
xc_functional: str = ‘B3LYP’,
method: CalculationMethod = CalculationMethod.DFT
) -> ChemistryJob[DFTState]

Enqueue the full-system mean field and return a job handle. The non-blocking counterpart to run_dft(): the DFT runs server-side (it can take hours) while the client is free to exit. Call .result() on the returned handle to fetch the DFTState once ready — doing so also caches the state for run_dft_embedding(), exactly as run_dft() does. Parameters:

Name	Type	Default
`self`	“	required
`xc_functional`	`str`	’B3LYP’
`method`	`CalculationMethod`	CalculationMethod.DFT

run_dft_embedding

run_dft_embedding(
self: ,
config: EmbeddingConfig
) -> tuple[MeanFieldData, QuantumData]

Run the full embedding pipeline in one backend call. Blocks until the backend job finishes. For a long run prefer submit_dft_embedding(), which returns a handle you can poll later. Reuses the cached DFTState from a prior run_dft call if present; otherwise the backend runs the full-system DFT first using config.xc_functional. Auto-validations registered at construction are computed in the same call and stored on self.validation_results. Parameters:

Name	Type	Description	Default
`self`	“		required
`config`	`EmbeddingConfig`		required

submit_dft_embedding

submit_dft_embedding(
self: ,
config: EmbeddingConfig
) -> ChemistryJob[tuple[MeanFieldData, QuantumData]]

Enqueue the full embedding pipeline and return a job handle. The non-blocking counterpart to run_dft_embedding(). Call .result() on the returned handle to fetch the (MeanFieldData, QuantumData) tuple once ready; doing so caches the embedding state for subsequent run_validations() calls and emits any n_active_virtuals warning, exactly as the blocking method does. Parameters:

Name	Type	Description	Default
`self`	“		required
`config`	`EmbeddingConfig`		required

run_validations

run_validations(
self: ,
checks: Sequence[ValidationCheck]
) -> ValidationResults

Run a batch of post-hoc validations in a single backend call. Parameters:

Name	Type	Description	Default
`self`	“		required
`checks`	`Sequence[ValidationCheck]`		required

EmbeddingConfig

Embedding-method parameters. Attributes:

Name	Type	Description
`fragment_atoms`	`tuple[int, ...]`
`method`	`CalculationMethod`
`xc_functional`	`str`
`mu`	`float`
`w_cut`	`float`
`sv_tol`	`float`
`n_active_virtuals`	`int \| None`
`freeze_core`	`bool`

MeanFieldData

Fragment / environment densities, electron counts, and active-MO basis. Attributes:

Name	Type	Description
`D_A`	`np.ndarray`
`D_B`	`np.ndarray`
`atom_indices`	`tuple[int, ...]`
`n_electrons_A`	`int`
`C_active`	`np.ndarray \| tuple[np.ndarray, np.ndarray]`
`E_DFT_fragment`	`float`
`n_electrons_B`	`int`

MoleculeSpec

User-facing molecular description. Methods:

Name	Description
from_pdb_file	Build a spec from a local `.pdb` file.
from_xyz_file	Build a spec from a local `.xyz` file.

Attributes:

Name	Type	Description
`atom`	`str`
`basis`	`str`
`charge`	`int`
`spin`	`int`
`unit`	`str`

from_pdb_file

from_pdb_file(
cls: ,
path: str | Path,
basis: str = ‘cc-pVDZ’,
charge: int = 0,
spin: int = 0,
unit: str = ‘Angstrom’
) -> MoleculeSpec

Build a spec from a local .pdb file. The file is read on the client; only its contents are sent to the backend (the backend never opens paths). The remaining arguments mirror the MoleculeSpec fields. Parameters:

Name	Type	Default
`cls`	“	required
`path`	`str \| Path`	required
`basis`	`str`	’cc-pVDZ’
`charge`	`int`	0
`spin`	`int`	0
`unit`	`str`	’Angstrom’

from_xyz_file

from_xyz_file(
cls: ,
path: str | Path,
basis: str = ‘cc-pVDZ’,
charge: int = 0,
spin: int = 0,
unit: str = ‘Angstrom’
) -> MoleculeSpec

Build a spec from a local .xyz file. The file is read on the client; only its contents are sent to the backend (the backend never opens paths). The remaining arguments mirror the MoleculeSpec fields. Parameters:

Name	Type	Default
`cls`	“	required
`path`	`str \| Path`	required
`basis`	`str`	’cc-pVDZ’
`charge`	`int`	0
`spin`	`int`	0
`unit`	`str`	’Angstrom’

QuantumData

Solver-facing bundle: embedded + physical Hamiltonians and scalars. Attributes:

Name	Type	Description
`hamiltonian_emb`	`FermionOperator`
`hamiltonian_phys`	`FermionOperator`
`n_particles`	`tuple[int, int]`
`env_correction`	`float`

SpinMode

Which mean-field treatment the backend should use. Attributes:

Name	Type	Description
`AUTO`	`'auto'`
`RESTRICTED`	`'restricted'`
`UNRESTRICTED`	`'unrestricted'`

ValidationCheck

Validation diagnostics the embedding pipeline can run. Attributes:

Name	Type	Description
`DFT_IN_DFT`	`'dft_in_dft'`
`FCI_ACTIVE_SPACE`	`'fci_active_space'`
`PROBABILITY_LEAK`	`'probability_leak'`
`TRACE_CONSERVATION`	`'trace_conservation'`
`GEOMETRY_PERTURBATION`	`'geometry_perturbation'`

embedding_calculator

User-facing API for projection-based WF-in-DFT embedding. Mirrors the local prototype: users build a MoleculeSpec and an EmbeddingConfig, then drive the pipeline through EmbeddingCalculator. Under the hood every stage is a queued backend job (the heavy pyscf / openfermion chemistry runs server-side and never ships to the client). The calculator exchanges the serializable wire models defined in classiq.interface.applications.chemistry.embedding with the backend and rehydrates the results into the dataclasses below. The embedded / physical Hamiltonians come back as real openfermion.FermionOperator objects, ready to feed into a quantum solver. Methods:

Name	Description
run

Attributes:

Name	Type	Description
`ValidationResults`

run

run(
coro: Awaitable[T]
) -> T

Parameters:

Name	Type	Description	Default
`coro`	`Awaitable[T]`		required

embedding_calculator.ArrayModel

A numpy array flattened to (shape, data) for JSON transport. Real-valued only (every array crossing the embedding boundary — densities, MO coefficients, overlaps — is real). Rebuild with np.asarray(data).reshape(shape). Attributes:

Name	Type	Description
`shape`	`list[NonNegativeInt]`
`data`	`list[float]`

embedding_calculator.CalculationMethod

Electronic-structure method for the mean-field stage. DFT runs Kohn-Sham with the configured xc_functional; HF runs Hartree-Fock (realized by setting the PySCF SCF object’s xc to "HF", which makes RKS/UKS reproduce RHF/UHF exactly). xc_functional is ignored when method is HF. Attributes:

Name	Type	Description
`DFT`	`'dft'`
`HF`	`'hf'`

embedding_calculator.DFTStateModel

Serializable DFTState — the serialized Mole + SCF bundle. Attributes:

Name	Type	Description
`mol_dumps`	`str`
`scf`	`ScfPayload`
`spin_mode`	`SpinMode`
`xc_functional`	`str`
`method`	`CalculationMethod`

embedding_calculator.EmbeddingConfigModel

Serializable EmbeddingConfig (all primitives). Attributes:

Name	Type	Description
`fragment_atoms`	`list[NonNegativeInt]`
`method`	`CalculationMethod`
`xc_functional`	`str`
`mu`	`float`
`w_cut`	`float`
`sv_tol`	`float`
`n_active_virtuals`	`int \| None`
`freeze_core`	`bool`

embedding_calculator.FermionOperatorModel

Serializable openfermion.FermionOperator (its term -> coefficient map). Attributes:

Name	Type	Description
`terms`	`list[FermionTerm]`

embedding_calculator.MeanFieldDataModel

Serializable MeanFieldData. c_active holds one ArrayModel for the restricted backend or two (alpha, beta) for the unrestricted backend; c_active_is_tuple records which so it can be rebuilt to the right shape. Attributes:

Name	Type	Description
`atom_indices`	`list[int]`
`d_a`	`ArrayModel`
`n_electrons_a`	`int`
`c_active`	`list[ArrayModel]`
`c_active_is_tuple`	`bool`
`e_dft_fragment`	`float`
`d_b`	`ArrayModel`
`n_electrons_b`	`int`

embedding_calculator.MoleculeSpecModel

Serializable MoleculeSpec. Exactly one of atom or mol_dumps is populated. mol_dumps carries a pre-built pyscf.gto.Mole serialized via Mole.dumps(). Attributes:

Name	Type	Description
`atom`	`str \| None`
`basis`	`str`
`charge`	`int`
`spin`	`int`
`unit`	`str`
`mol_dumps`	`str \| None`

embedding_calculator.QuantumDataModel

Serializable QuantumData — the two fermion Hamiltonians + scalars. Attributes:

Name	Type	Description
`hamiltonian_emb`	`FermionOperatorModel`
`hamiltonian_phys`	`FermionOperatorModel`
`n_particles`	`tuple[int, int]`
`env_correction`	`float`

embedding_calculator.SpinMode

Which mean-field treatment the backend should use. Attributes:

Name	Type	Description
`AUTO`	`'auto'`
`RESTRICTED`	`'restricted'`
`UNRESTRICTED`	`'unrestricted'`

embedding_calculator.ValidationCheck

Validation diagnostics the embedding pipeline can run. Attributes:

Name	Type	Description
`DFT_IN_DFT`	`'dft_in_dft'`
`FCI_ACTIVE_SPACE`	`'fci_active_space'`
`PROBABILITY_LEAK`	`'probability_leak'`
`TRACE_CONSERVATION`	`'trace_conservation'`
`GEOMETRY_PERTURBATION`	`'geometry_perturbation'`

embedding_calculator.ValidationResultModel

One validation check’s outcome: a pass/fail flag plus a JSON-safe info dict. Attributes:

Name	Type	Description
`passed`	`bool`
`info`	`dict[str, Any]`

embedding_calculator.RunDftEmbeddingInput

Attributes:

Name	Type	Description
`spec`	`MoleculeSpecModel`
`config`	`EmbeddingConfigModel`
`spin_mode`	`SpinMode`
`dft_state`	`DFTStateModel \| None`
`auto_validations`	`list[ValidationCheck]`

embedding_calculator.RunDftEmbeddingOutput

Attributes:

Name	Type	Description
`dft_state`	`DFTStateModel`
`mean_field_data`	`MeanFieldDataModel`
`quantum_data`	`QuantumDataModel`
`validation_results`	`dict[ValidationCheck, ValidationResultModel]`
`n_active_virtuals_warning`	`str \| None`

embedding_calculator.RunDftInput

Attributes:

Name	Type	Description
`spec`	`MoleculeSpecModel`
`xc_functional`	`str`
`spin_mode`	`SpinMode`
`method`	`CalculationMethod`

embedding_calculator.RunDftOutput

Attributes:

Name	Type	Description
`dft_state`	`DFTStateModel`

embedding_calculator.RunValidationsInput

Attributes:

Name	Type	Description
`dft_state`	`DFTStateModel`
`mean_field_data`	`MeanFieldDataModel`
`quantum_data`	`QuantumDataModel`
`config`	`EmbeddingConfigModel`
`checks`	`list[ValidationCheck]`

embedding_calculator.ApiWrapper

Methods:

Name	Description
call_get_benchmark_classes
call_submit_benchmark
call_get_benchmark_results
call_list_benchmark_sessions
call_cancel_benchmark_session
call_generation_task
call_transpilation_task
call_assign_parameters_task
call_export_task
call_transpiled_circuit_metrics_task
call_circuit_metrics_task
call_qasm_to_qmod_task
submit_chemistry_run_dft_task
submit_chemistry_run_dft_embedding_task
call_chemistry_run_dft_task
call_chemistry_run_dft_embedding_task
call_chemistry_run_validations_task
call_get_visual_model
call_visualization_task
call_create_execution_session
call_create_openqasm_execution_session
call_close_execution_session
call_create_session_job
call_convert_quantum_program
call_execute_execution_input
call_estimate_sample_cost
call_get_execution_job_details
call_get_execution_job_result
call_get_submitted_circuits
call_patch_execution_job
call_cancel_execution_job
call_query_execution_jobs
call_query_synthesis_actions
call_analysis_task
get_generated_circuit_from_qasm
get_analyzer_app_data
call_rb_analysis_task
call_hardware_connectivity_task
call_table_graphs_task
call_available_devices_task
call_get_all_hardware_devices
call_get_all_budgets
call_set_budget_limit
call_clear_budget_limit
call_initialize_logical_noise
call_get_logical_noise
call_remove_logical_noise

call_get_benchmark_classes

call_get_benchmark_classes(
cls:
) -> dict[BenchmarkClass, BenchmarkClassMetadata]

Parameters:

Name	Type	Description	Default
`cls`	“		required

call_submit_benchmark

call_submit_benchmark(
cls: ,
request: BenchmarkRequest,
http_client: httpx.AsyncClient | None = None
) -> BenchmarkSession

Parameters:

Name	Type	Default
`cls`	“	required
`request`	`BenchmarkRequest`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_get_benchmark_results

call_get_benchmark_results(
cls: ,
session: BenchmarkSession,
http_client: httpx.AsyncClient | None = None
) -> BenchmarkSession

Parameters:

Name	Type	Default
`cls`	“	required
`session`	`BenchmarkSession`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_list_benchmark_sessions

call_list_benchmark_sessions(
cls: ,
http_client: httpx.AsyncClient | None = None
) -> list[BenchmarkSession]

Parameters:

Name	Type	Description	Default
`cls`	“		required
`http_client`	`httpx.AsyncClient \| None`		None

call_cancel_benchmark_session

call_cancel_benchmark_session(
cls: ,
session_id: str,
http_client: httpx.AsyncClient | None = None
) -> None

Parameters:

Name	Type	Default
`cls`	“	required
`session_id`	`str`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_generation_task

call_generation_task(
cls: ,
model: Model,
http_client: httpx.AsyncClient | None = None
) -> generator_result.QuantumProgram

Parameters:

Name	Type	Default
`cls`	“	required
`model`	`Model`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_transpilation_task

call_transpilation_task(
cls: ,
params: TranspilationParams,
http_client: httpx.AsyncClient | None = None
) -> generator_result.QuantumProgram

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`TranspilationParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_assign_parameters_task

call_assign_parameters_task(
cls: ,
params: ParameterAssignmentsParams,
http_client: httpx.AsyncClient | None = None
) -> generator_result.QuantumProgram

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`ParameterAssignmentsParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_export_task

call_export_task(
cls: ,
params: ExportParams,
http_client: httpx.AsyncClient | None = None
) -> TargetCode

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`ExportParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_transpiled_circuit_metrics_task

call_transpiled_circuit_metrics_task(
cls: ,
program: generator_result.QuantumProgram,
http_client: httpx.AsyncClient | None = None
) -> ProgramData

Parameters:

Name	Type	Default
`cls`	“	required
`program`	`generator_result.QuantumProgram`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_circuit_metrics_task

call_circuit_metrics_task(
cls: ,
program: generator_result.QuantumProgram,
http_client: httpx.AsyncClient | None = None
) -> CircuitMetrics

Parameters:

Name	Type	Default
`cls`	“	required
`program`	`generator_result.QuantumProgram`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_qasm_to_qmod_task

call_qasm_to_qmod_task(
cls: ,
params: QasmToQmodParams,
http_client: httpx.AsyncClient | None = None
) -> QmodCode

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`QasmToQmodParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

submit_chemistry_run_dft_task

submit_chemistry_run_dft_task(
cls: ,
params: RunDftInput,
http_client: httpx.AsyncClient | None = None
) -> JobID

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`RunDftInput`	required
`http_client`	`httpx.AsyncClient \| None`	None

submit_chemistry_run_dft_embedding_task

submit_chemistry_run_dft_embedding_task(
cls: ,
params: RunDftEmbeddingInput,
http_client: httpx.AsyncClient | None = None
) -> JobID

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`RunDftEmbeddingInput`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_chemistry_run_dft_task

call_chemistry_run_dft_task(
cls: ,
params: RunDftInput,
http_client: httpx.AsyncClient | None = None
) -> RunDftOutput

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`RunDftInput`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_chemistry_run_dft_embedding_task

call_chemistry_run_dft_embedding_task(
cls: ,
params: RunDftEmbeddingInput,
http_client: httpx.AsyncClient | None = None
) -> RunDftEmbeddingOutput

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`RunDftEmbeddingInput`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_chemistry_run_validations_task

call_chemistry_run_validations_task(
cls: ,
params: RunValidationsInput,
http_client: httpx.AsyncClient | None = None
) -> RunValidationsOutput

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`RunValidationsInput`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_get_visual_model

call_get_visual_model(
cls: ,
program_id: str,
http_client: httpx.AsyncClient | None = None
) -> ProgramVisualModel

Parameters:

Name	Type	Default
`cls`	“	required
`program_id`	`str`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_visualization_task

call_visualization_task(
cls: ,
circuit: generator_result.QuantumProgram,
http_client: httpx.AsyncClient | None = None
) -> ProgramVisualModel

Parameters:

Name	Type	Default
`cls`	“	required
`circuit`	`generator_result.QuantumProgram`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_create_execution_session

call_create_execution_session(
cls: ,
circuit: generator_result.QuantumProgram,
http_client: httpx.AsyncClient | None = None
) -> str

Parameters:

Name	Type	Default
`cls`	“	required
`circuit`	`generator_result.QuantumProgram`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_create_openqasm_execution_session

call_create_openqasm_execution_session(
cls: ,
qasm: str,
execution_preferences: ExecutionPreferences,
http_client: httpx.AsyncClient | None = None
) -> str

Parameters:

Name	Type	Default
`cls`	“	required
`qasm`	`str`	required
`execution_preferences`	`ExecutionPreferences`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_close_execution_session

call_close_execution_session(
cls: ,
session_id: str,
http_client: httpx.AsyncClient | None = None
) -> None

Parameters:

Name	Type	Default
`cls`	“	required
`session_id`	`str`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_create_session_job

call_create_session_job(
cls: ,
session_id: str,
primitives_input: PrimitivesInput,
http_client: httpx.AsyncClient | None = None
) -> execution_request.ExecutionJobDetails

Parameters:

Name	Type	Default
`cls`	“	required
`session_id`	`str`	required
`primitives_input`	`PrimitivesInput`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_convert_quantum_program

call_convert_quantum_program(
cls: ,
circuit: generator_result.QuantumProgram,
http_client: httpx.AsyncClient | None = None
) -> dict

Parameters:

Name	Type	Default
`cls`	“	required
`circuit`	`generator_result.QuantumProgram`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_execute_execution_input

call_execute_execution_input(
cls: ,
execution_input: dict,
http_client: httpx.AsyncClient | None = None
) -> execution_request.ExecutionJobDetails

Parameters:

Name	Type	Default
`cls`	“	required
`execution_input`	`dict`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_estimate_sample_cost

call_estimate_sample_cost(
cls: ,
execution_input: dict,
batch_params: list[dict] | None = None,
http_client: httpx.AsyncClient | None = None
) -> dict

Parameters:

Name	Type	Default
`cls`	“	required
`execution_input`	`dict`	required
`batch_params`	`list[dict] \| None`	None
`http_client`	`httpx.AsyncClient \| None`	None

call_get_execution_job_details

call_get_execution_job_details(
cls: ,
job_id: JobID,
http_client: httpx.AsyncClient | None = None
) -> execution_request.ExecutionJobDetails

Parameters:

Name	Type	Default
`cls`	“	required
`job_id`	`JobID`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_get_execution_job_result

call_get_execution_job_result(
cls: ,
job_id: JobID,
http_client: httpx.AsyncClient | None = None
) -> classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults

Parameters:

Name	Type	Default
`cls`	“	required
`job_id`	`JobID`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_get_submitted_circuits

call_get_submitted_circuits(
cls: ,
job_id: JobID,
http_client: httpx.AsyncClient | None = None
) -> execution_request.SubmittedCircuitsResponse

Parameters:

Name	Type	Default
`cls`	“	required
`job_id`	`JobID`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_patch_execution_job

call_patch_execution_job(
cls: ,
job_id: JobID,
name: str,
http_client: httpx.AsyncClient | None = None
) -> execution_request.ExecutionJobDetails

Parameters:

Name	Type	Default
`cls`	“	required
`job_id`	`JobID`	required
`name`	`str`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_cancel_execution_job

call_cancel_execution_job(
cls: ,
job_id: JobID,
http_client: httpx.AsyncClient | None = None
) -> None

Parameters:

Name	Type	Default
`cls`	“	required
`job_id`	`JobID`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_query_execution_jobs

call_query_execution_jobs(
cls: ,
offset: int,
limit: int,
http_client: httpx.AsyncClient | None = None,
extra_query_params: Any = 
) -> execution_request.ExecutionJobsQueryResults

Parameters:

Name	Type	Default
`cls`	“	required
`offset`	`int`	required
`limit`	`int`	required
`http_client`	`httpx.AsyncClient \| None`	None
`extra_query_params`	`Any`

call_query_synthesis_actions

call_query_synthesis_actions(
cls: ,
offset: int,
limit: int,
http_client: httpx.AsyncClient | None = None,
extra_query_params: Any | None = 
) -> SynthesisActionsQueryResults

Parameters:

Name	Type	Default
`cls`	“	required
`offset`	`int`	required
`limit`	`int`	required
`http_client`	`httpx.AsyncClient \| None`	None
`extra_query_params`	`Any \| None`

call_analysis_task

call_analysis_task(
cls: ,
params: analysis_params.AnalysisParams,
http_client: httpx.AsyncClient | None = None
) -> analysis_result.Analysis

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`analysis_params.AnalysisParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

get_generated_circuit_from_qasm

get_generated_circuit_from_qasm(
cls: ,
params: analysis_result.QasmCode,
http_client: httpx.AsyncClient | None = None
) -> generator_result.QuantumProgram

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`analysis_result.QasmCode`	required
`http_client`	`httpx.AsyncClient \| None`	None

get_analyzer_app_data

get_analyzer_app_data(
cls: ,
params: analysis_result.DataID,
http_client: httpx.AsyncClient | None = None
) -> generator_result.QuantumProgram

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`analysis_result.DataID`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_rb_analysis_task

call_rb_analysis_task(
cls: ,
params: AnalysisRBParams,
http_client: httpx.AsyncClient | None = None
) -> analysis_result.RbResults

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`AnalysisRBParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_hardware_connectivity_task

call_hardware_connectivity_task(
cls: ,
params: analysis_params.AnalysisHardwareParams,
http_client: httpx.AsyncClient | None = None
) -> analysis_result.GraphResult

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`analysis_params.AnalysisHardwareParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_table_graphs_task

call_table_graphs_task(
cls: ,
params: analysis_params.AnalysisHardwareListParams,
http_client: httpx.AsyncClient | None = None
) -> analysis_result.GraphResult

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`analysis_params.AnalysisHardwareListParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_available_devices_task

call_available_devices_task(
cls: ,
params: analysis_params.AnalysisOptionalDevicesParams,
http_client: httpx.AsyncClient | None = None
) -> analysis_result.DevicesResult

Parameters:

Name	Type	Default
`cls`	“	required
`params`	`analysis_params.AnalysisOptionalDevicesParams`	required
`http_client`	`httpx.AsyncClient \| None`	None

call_get_all_hardware_devices

call_get_all_hardware_devices(
cls: ,
http_client: httpx.AsyncClient | None = None
) -> list[HardwareInformation]

Parameters:

Name	Type	Description	Default
`cls`	“		required
`http_client`	`httpx.AsyncClient \| None`		None

call_get_all_budgets

call_get_all_budgets(
cls:
) -> list[UserBudget]

Parameters:

Name	Type	Description	Default
`cls`	“		required

call_set_budget_limit

call_set_budget_limit(
cls: ,
provider: str,
budget_limit: float
) -> UserBudget

Parameters:

Name	Type	Default
`cls`	“	required
`provider`	`str`	required
`budget_limit`	`float`	required

call_clear_budget_limit

call_clear_budget_limit(
cls: ,
provider: str
) -> UserBudget

Parameters:

Name	Type	Description	Default
`cls`	“		required
`provider`	`str`		required

call_initialize_logical_noise

call_initialize_logical_noise(
cls: ,
params: InitializeLogicalNoiseParams
) -> None

Parameters:

Name	Type	Description	Default
`cls`	“		required
`params`	`InitializeLogicalNoiseParams`		required

call_get_logical_noise

call_get_logical_noise(
cls: ,
name: str
) -> LogicalNoiseParameters

Parameters:

Name	Type	Description	Default
`cls`	“		required
`name`	`str`		required

call_remove_logical_noise

call_remove_logical_noise(
cls: ,
name: str
) -> None

Parameters:

Name	Type	Description	Default
`cls`	“		required
`name`	`str`		required

embedding_calculator.ChemistryJob

Methods:

Name	Description
from_id	Reconnect to a previously submitted job by its id.
status_async
result_async	Wait for the job to finish and return its (transformed) result.
cancel_async

Attributes:

Name	Type	Description
`id`	`str`
`status`
`result`
`cancel`

from_id

from_id(
cls: ,
id: str,
job_route: str,
result_type: type[pydantic.BaseModel]
) -> ChemistryJob

Reconnect to a previously submitted job by its id. The result is fetchable while the job’s result is still retained by the backend (see MAX_KEEP_RESULT); reconnecting much later may fail. Parameters:

Name	Type	Default
`cls`	“	required
`id`	`str`	required
`job_route`	`str`	required
`result_type`	`type[pydantic.BaseModel]`	required

status_async

status_async(
self: ,
_http_client: httpx.AsyncClient | None = None
) -> JobStatus

Parameters:

Name	Type	Description	Default
`self`	“		required
`_http_client`	`httpx.AsyncClient \| None`		None

result_async

result_async(
self: ,
timeout_sec: float | None = None,
_http_client: httpx.AsyncClient | None = None
) -> ResultT

Wait for the job to finish and return its (transformed) result. Raises ClassiqAPIError if the job failed or was cancelled, or if polling exceeds timeout_sec (None waits indefinitely). Parameters:

Name	Type	Default
`self`	“	required
`timeout_sec`	`float \| None`	None
`_http_client`	`httpx.AsyncClient \| None`	None

cancel_async

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

Parameters:

Name	Type	Description	Default
`self`	“		required
`_http_client`	`httpx.AsyncClient \| None`		None

embedding_calculator.MoleculeSpec

User-facing molecular description. Methods:

Name	Description
from_pdb_file	Build a spec from a local `.pdb` file.
from_xyz_file	Build a spec from a local `.xyz` file.

Attributes:

Name	Type	Description
`atom`	`str`
`basis`	`str`
`charge`	`int`
`spin`	`int`
`unit`	`str`

from_pdb_file

from_pdb_file(
cls: ,
path: str | Path,
basis: str = ‘cc-pVDZ’,
charge: int = 0,
spin: int = 0,
unit: str = ‘Angstrom’
) -> MoleculeSpec

Name	Type	Default
`cls`	“	required
`path`	`str \| Path`	required
`basis`	`str`	’cc-pVDZ’
`charge`	`int`	0
`spin`	`int`	0
`unit`	`str`	’Angstrom’

from_xyz_file

from_xyz_file(
cls: ,
path: str | Path,
basis: str = ‘cc-pVDZ’,
charge: int = 0,
spin: int = 0,
unit: str = ‘Angstrom’
) -> MoleculeSpec

Name	Type	Default
`cls`	“	required
`path`	`str \| Path`	required
`basis`	`str`	’cc-pVDZ’
`charge`	`int`	0
`spin`	`int`	0
`unit`	`str`	’Angstrom’

embedding_calculator.EmbeddingConfig

Embedding-method parameters. Attributes:

Name	Type	Description
`fragment_atoms`	`tuple[int, ...]`
`method`	`CalculationMethod`
`xc_functional`	`str`
`mu`	`float`
`w_cut`	`float`
`sv_tol`	`float`
`n_active_virtuals`	`int \| None`
`freeze_core`	`bool`

embedding_calculator.DFTState

Post-DFT handle returned to the user, recording the resolved spin mode, functional, and method. Threaded back into later stages. Attributes:

Name	Type	Description
`spin_mode`	`SpinMode`
`xc_functional`	`str`
`method`	`CalculationMethod`

embedding_calculator.MeanFieldData

Fragment / environment densities, electron counts, and active-MO basis. Attributes:

Name	Type	Description
`D_A`	`np.ndarray`
`D_B`	`np.ndarray`
`atom_indices`	`tuple[int, ...]`
`n_electrons_A`	`int`
`C_active`	`np.ndarray \| tuple[np.ndarray, np.ndarray]`
`E_DFT_fragment`	`float`
`n_electrons_B`	`int`

embedding_calculator.QuantumData

Solver-facing bundle: embedded + physical Hamiltonians and scalars. Attributes:

Name	Type	Description
`hamiltonian_emb`	`FermionOperator`
`hamiltonian_phys`	`FermionOperator`
`n_particles`	`tuple[int, int]`
`env_correction`	`float`

embedding_calculator.EmbeddingCalculator

User-facing embedding driver, backed by queued backend jobs. Methods:

Name	Description
run_dft	Run the full-system mean field and cache the result.
submit_dft	Enqueue the full-system mean field and return a job handle.
run_dft_embedding	Run the full embedding pipeline in one backend call.
submit_dft_embedding	Enqueue the full embedding pipeline and return a job handle.
run_validations	Run a batch of post-hoc validations in a single backend call.

Attributes:

Name	Type	Description
`spec`
`spin_mode`
`auto_validations`	`tuple[ValidationCheck, ...]`
`validation_results`	`ValidationResults`
`config`	`EmbeddingConfig \| None`
`effective_spin_mode`	`SpinMode`

run_dft

run_dft(
self: ,
xc_functional: str = ‘B3LYP’,
method: CalculationMethod = CalculationMethod.DFT
) -> DFTState

Name	Type	Default
`self`	“	required
`xc_functional`	`str`	’B3LYP’
`method`	`CalculationMethod`	CalculationMethod.DFT

submit_dft

submit_dft(
self: ,
xc_functional: str = ‘B3LYP’,
method: CalculationMethod = CalculationMethod.DFT
) -> ChemistryJob[DFTState]

Name	Type	Default
`self`	“	required
`xc_functional`	`str`	’B3LYP’
`method`	`CalculationMethod`	CalculationMethod.DFT

run_dft_embedding

run_dft_embedding(
self: ,
config: EmbeddingConfig
) -> tuple[MeanFieldData, QuantumData]

Name	Type	Description	Default
`self`	“		required
`config`	`EmbeddingConfig`		required

submit_dft_embedding

submit_dft_embedding(
self: ,
config: EmbeddingConfig
) -> ChemistryJob[tuple[MeanFieldData, QuantumData]]

Name	Type	Description	Default
`self`	“		required
`config`	`EmbeddingConfig`		required

run_validations

run_validations(
self: ,
checks: Sequence[ValidationCheck]
) -> ValidationResults

Run a batch of post-hoc validations in a single backend call. Parameters:

Name	Type	Description	Default
`self`	“		required
`checks`	`Sequence[ValidationCheck]`		required

chemistry_job

Detached handle for a long-running chemistry backend job. EmbeddingCalculator.submit_* returns one of these instead of blocking: a chemistry DFT run can take hours, so the SDK hands the user a job id and lets them fetch the result later (result) — the job keeps running server-side even if the client process exits. from_id reconnects to a job submitted by an earlier process. The handle is generic over the user-facing return type ResultT: a transform callback maps the parsed wire output (result_type) to that type (and, for the calculator, threads the freshly computed state back into the calculator so a later stage can reuse it). Without a transform the parsed wire model is returned as-is, which is what from_id does. Methods:

Name	Description
syncify_function

Attributes:

Name	Type	Description
`JSONObject`
`WireT`
`ResultT`

syncify_function

syncify_function(
async_func: Callable[…, Awaitable[T]]
) -> Callable[…, T]

Parameters:

Name	Type	Description	Default
`async_func`	`Callable[..., Awaitable[T]]`		required

chemistry_job.ClassiqAPIError

Attributes:

Name	Type	Description
`status_code`

chemistry_job.JobDescription

Methods:

Name	Description
validate_status_and_fields

Attributes:

Name	Type	Description
`status`	`JobStatus`
`failure_details`	`str \| None`
`result`	`T \| None`

validate_status_and_fields

validate_status_and_fields(
self:
) -> Self

Parameters:

Name	Type	Description	Default
`self`	“		required

chemistry_job.JobID

Attributes:

Name	Type	Description
`job_id`	`str`

chemistry_job.JobStatus

Methods:

Name	Description
is_final

Attributes:

Name	Type	Description
`QUEUED`	`'QUEUED'`
`RUNNING`	`'RUNNING'`
`READY`	`'READY'`
`COMPLETED`	`'COMPLETED'`
`FAILED`	`'FAILED'`
`CANCELLING`	`'CANCELLING'`
`CANCELLED`	`'CANCELLED'`
`UNKNOWN`	`'UNKNOWN'`

is_final

is_final(
self:
) -> bool

Parameters:

Name	Type	Description	Default
`self`	“		required

chemistry_job.JobPoller

Methods:

Name	Description
submit	Enqueue a job and return its id without waiting for completion.
fetch_description	Read a job’s current description with a single GET (no polling).
cancel
poll
run
run_pydantic

Attributes:

Name	Type	Description
`INITIAL_INTERVAL_SEC`	`'0.1'`
`INTERVAL_FACTOR`	`'1.5'`
`FINAL_INTERVAL_SEC`	`'25'`
`DEV_INTERVAL`	`'0.05'`

submit

submit(
self: ,
body: dict,
http_client: httpx.AsyncClient | None = None
) -> JobID

Enqueue a job and return its id without waiting for completion. The detached counterpart to run: callers hold on to the returned JobID and poll for the result later (e.g. via poll), so a long-running job survives the client process exiting. Parameters:

Name	Type	Default
`self`	“	required
`body`	`dict`	required
`http_client`	`httpx.AsyncClient \| None`	None

fetch_description

fetch_description(
self: ,
job_id: JobID,
http_client: httpx.AsyncClient | None = None
) -> GeneralJobDescription

Read a job’s current description with a single GET (no polling). Parameters:

Name	Type	Default
`self`	“	required
`job_id`	`JobID`	required
`http_client`	`httpx.AsyncClient \| None`	None

cancel

cancel(
self: ,
job_id: JobID,
http_client: httpx.AsyncClient | None = None
) -> None

Parameters:

Name	Type	Default
`self`	“	required
`job_id`	`JobID`	required
`http_client`	`httpx.AsyncClient \| None`	None

poll

poll(
self: ,
job_id: JobID,
timeout_sec: float | None,
response_parser: Callable[[JSONObject], T | None] = _general_job_description_parser,
http_client: httpx.AsyncClient | None = None
) -> T

Parameters:

Name	Type	Default
`self`	“	required
`job_id`	`JobID`	required
`timeout_sec`	`float \| None`	required
`response_parser`	`Callable[[JSONObject], T \| None]`	_general_job_description_parser
`http_client`	`httpx.AsyncClient \| None`	None

run

run(
self: ,
body: dict,
timeout_sec: float | None,
http_client: httpx.AsyncClient | None = None
) -> GeneralJobDescription

Parameters:

Name	Type	Default
`self`	“	required
`body`	`dict`	required
`timeout_sec`	`float \| None`	required
`http_client`	`httpx.AsyncClient \| None`	None

run_pydantic

run_pydantic(
self: ,
model: pydantic.BaseModel,
timeout_sec: float | None,
http_client: httpx.AsyncClient | None = None
) -> GeneralJobDescription

Parameters:

Name	Type	Default
`self`	“	required
`model`	`pydantic.BaseModel`	required
`timeout_sec`	`float \| None`	required
`http_client`	`httpx.AsyncClient \| None`	None

chemistry_job.ChemistryJob

Methods:

Name	Description
from_id	Reconnect to a previously submitted job by its id.
status_async
result_async	Wait for the job to finish and return its (transformed) result.
cancel_async

Attributes:

Name	Type	Description
`id`	`str`
`status`
`result`
`cancel`

from_id

from_id(
cls: ,
id: str,
job_route: str,
result_type: type[pydantic.BaseModel]
) -> ChemistryJob

Name	Type	Default
`cls`	“	required
`id`	`str`	required
`job_route`	`str`	required
`result_type`	`type[pydantic.BaseModel]`	required

status_async

status_async(
self: ,
_http_client: httpx.AsyncClient | None = None
) -> JobStatus

Parameters:

Name	Type	Description	Default
`self`	“		required
`_http_client`	`httpx.AsyncClient \| None`		None

result_async

result_async(
self: ,
timeout_sec: float | None = None,
_http_client: httpx.AsyncClient | None = None
) -> ResultT

Name	Type	Default
`self`	“	required
`timeout_sec`	`float \| None`	None
`_http_client`	`httpx.AsyncClient \| None`	None

cancel_async

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

Parameters:

Name	Type	Description	Default
`self`	“		required
`_http_client`	`httpx.AsyncClient \| None`		None

⌘I

​FermionHamiltonianProblem

​from_molecule

​FermionHamiltonianProblem

​from_molecule

​MappingMethod

​FermionToQubitMapper

​map

​get_num_qubits

​FermionToQubitMapper

​map

​get_num_qubits

​MappingMethod

​FermionHamiltonianProblem

​from_molecule

​Z2SymTaperMapper

​set_sector

​map

​get_num_qubits

​from_problem

​FermionToQubitMapper

​map

​get_num_qubits

​FermionHamiltonianProblem

​from_molecule

​get_hf_fermion_op

​get_hf_state

​FermionToQubitMapper

​map

​get_num_qubits

​FermionHamiltonianProblem

​from_molecule

​SparsePauliOp

​get_tuples_representation

​get_ucc_hamiltonians

​get_excitations

​DFTState

​EmbeddingCalculator

​run_dft

​submit_dft

​run_dft_embedding

​submit_dft_embedding

​run_validations

​EmbeddingConfig

​MeanFieldData

​MoleculeSpec

​from_pdb_file

​from_xyz_file

​QuantumData

​SpinMode

​ValidationCheck

​embedding_calculator

​run

​embedding_calculator.ArrayModel

​embedding_calculator.CalculationMethod

​embedding_calculator.DFTStateModel

​embedding_calculator.EmbeddingConfigModel

​embedding_calculator.FermionOperatorModel

​embedding_calculator.MeanFieldDataModel

​embedding_calculator.MoleculeSpecModel

​embedding_calculator.QuantumDataModel

​embedding_calculator.SpinMode

​embedding_calculator.ValidationCheck

​embedding_calculator.ValidationResultModel

​embedding_calculator.RunDftEmbeddingInput

​embedding_calculator.RunDftEmbeddingOutput

​embedding_calculator.RunDftInput

​embedding_calculator.RunDftOutput

​embedding_calculator.RunValidationsInput

​embedding_calculator.ApiWrapper

call_get_benchmark_classes

call_submit_benchmark

call_get_benchmark_results

call_list_benchmark_sessions

call_cancel_benchmark_session

call_generation_task

call_transpilation_task

call_assign_parameters_task

call_export_task

call_transpiled_circuit_metrics_task

call_circuit_metrics_task

FermionHamiltonianProblem

from_molecule

FermionHamiltonianProblem

from_molecule

MappingMethod

FermionToQubitMapper

map

get_num_qubits

FermionToQubitMapper

map

get_num_qubits

MappingMethod

FermionHamiltonianProblem

from_molecule

Z2SymTaperMapper

set_sector

map

get_num_qubits

from_problem

FermionToQubitMapper

map

get_num_qubits

FermionHamiltonianProblem

from_molecule

get_hf_fermion_op

get_hf_state

FermionToQubitMapper

map

get_num_qubits

FermionHamiltonianProblem

from_molecule

SparsePauliOp

get_tuples_representation

get_ucc_hamiltonians

get_excitations

DFTState

EmbeddingCalculator

run_dft

submit_dft

run_dft_embedding

submit_dft_embedding

run_validations

EmbeddingConfig

MeanFieldData

MoleculeSpec

from_pdb_file

from_xyz_file

QuantumData

SpinMode

ValidationCheck

embedding_calculator

run

embedding_calculator.ArrayModel

embedding_calculator.CalculationMethod

embedding_calculator.DFTStateModel

embedding_calculator.EmbeddingConfigModel

embedding_calculator.FermionOperatorModel

embedding_calculator.MeanFieldDataModel

embedding_calculator.MoleculeSpecModel

embedding_calculator.QuantumDataModel

embedding_calculator.SpinMode

embedding_calculator.ValidationCheck

embedding_calculator.ValidationResultModel

embedding_calculator.RunDftEmbeddingInput

embedding_calculator.RunDftEmbeddingOutput

embedding_calculator.RunDftInput

embedding_calculator.RunDftOutput

embedding_calculator.RunValidationsInput

embedding_calculator.ApiWrapper

embedding_calculator.ChemistryJob

embedding_calculator.MoleculeSpec

embedding_calculator.EmbeddingConfig

embedding_calculator.DFTState

embedding_calculator.MeanFieldData

embedding_calculator.QuantumData

embedding_calculator.EmbeddingCalculator

chemistry_job

syncify_function

chemistry_job.ClassiqAPIError

chemistry_job.JobDescription