Algorithm classes

QDK/Chemistry provides a comprehensive set of algorithm classes which express core methodological primitives for quantum and classical chemistry calculations. All algorithms follow a factory pattern design, allowing you to create instances by name and configured through a unified settings interface.

Contents

• Factory pattern
• Settings
• Active space selection
• Energy estimation
• Hamiltonian construction
• Orbital localization
• Multi-configuration calculations
• Multi-Configuration Self-Consistent Field
• Projected Multi-Configuration calculations
• Qubit mapping
• Self-consistent field (SCF) solver
• Stability analysis
• State preparation
• Hadamard test
• Phase estimation
• Phase estimation circuit builder
• Evolution circuit builder
• Hamiltonian Unitary Builder
• Controlled circuit mapper
• Circuit execution

Quick reference

The following table summarizes the available algorithm classes in QDK/Chemistry and their purposes. For detailed documentation, refer to the linked pages.

Algorithm Class	Purpose	Input → Output
ScfSolver	Mean-field (HF/DFT) calculations	Structure → Orbitals
OrbitalLocalizer	Orbital transformations	Orbitals → Orbitals
ActiveSpaceSelector	Active space identification	Wavefunction → Wavefunction
HamiltonianConstructor	Molecular Hamiltonian construction	Orbitals → Hamiltonian
MultiConfigurationCalculator	Many-body wavefunction calculations	Hamiltonian → Wavefunction
ProjectedMultiConfigurationCalculator	Projected many-body wavefunction calculations	Hamiltonian → Wavefunction
MultiConfigurationScf	Coupled Orbital-Wavefunction calculations.	Orbitals → Wavefunction
QubitMapper	Fermion-to-qubit mapping	Hamiltonian → QubitOperator
StatePreparation	Quantum state preparation	Wavefunction → Circuit
HadamardTest	Controlled-unitary overlap estimation	Circuit + UnitaryRepresentation → CircuitExecutorData
ExpectationEstimator	Quantum energy expectation values	Circuit + QubitOperator → Energy
StabilityChecker	SCF stability analysis	Orbitals → Stability
PhaseEstimation	Quantum phase estimation	Circuit + QubitOperator → QpeResult
QpeCircuitBuilder	Phase estimation circuit composition	Circuit + QubitOperator → Circuit list
EvolutionCircuitBuilder	Time-evolution circuit composition	TimeDependentQubitHamiltonian + Circuit → Circuit
HamiltonianUnitaryBuilder	Hamiltonian simulation unitaries	QubitOperator → UnitaryRepresentation
ControlledCircuitMapper	Controlled-unitary circuit synthesis	UnitaryRepresentation → Circuit
CircuitExecutor	Quantum circuit execution	Circuit → CircuitExecutorData

Term grouper

The term_grouper algorithm type partitions the Pauli terms of a QubitOperator into algorithm-relevant subsets and stores the result on term_partition. A grouper consumes a QubitOperator and returns a new QubitOperator whose term_partition field is populated; the input is not mutated.

Strategies include full commutation grouping, qubit-wise commutation grouping, and trivial (identity) grouping. Use registry.available("term_grouper") to list implementations.

Example:

from qdk_chemistry.algorithms import registry

grouper = registry.create("term_grouper", "qubit_wise_commuting")
grouped = grouper.run(qubit_hamiltonian)
grouped.term_partition  # FlatPartition(strategy="qubit_wise_commuting", ...)

Discovering implementations

Each algorithm class exposes multiple implementations that can be discovered at runtime. Use available() to list registered implementations:

Python API

from qdk_chemistry.algorithms import available, create

# List all registered SCF solver implementations
print(available("scf_solver"))  # ['qdk', 'pyscf']

# Create a specific implementation
solver = create("scf_solver", "qdk")

# Inspect available settings
print(solver.settings())

C++ API

#include <qdk/chemistry/algorithms/scf.hpp>

// List all registered SCF solver implementations
auto names = qdk::chemistry::algorithms::ScfSolver::available();
for (const auto& name : names) {
  std::cout << name << std::endl;
}

// Create a specific implementation
auto solver = qdk::chemistry::algorithms::ScfSolver::create("pyscf");

For details on creating, loading, and using custom algorithm implementations, see the plugin system and factory pattern documentation.