Algorithms

Algorithms consume problems through a uniform lifecycle:

problem = ...
algorithm.validate(problem)     # list[str], empty when valid
result  = algorithm.solve(problem, runtime=None)

The base contract is Algorithm; results are typed *Result dataclasses that serialize via to_dict() / to_json(). A ExecutionRuntime may be passed to route every circuit evaluation through the MQ-04 pipeline; without one, algorithms use the internal NumPy state-vector engine.

Built-ins

  • VQE — variational ground-state finder for an EigenvalueProblem (parameter-shift or operator gradients).

  • QAOA — variational solver for an OptimizationProblem (CNOT parity chains for ZZ terms).

  • GroverSearch — amplitude amplification for SearchProblem.

  • PhaseEstimation — eigenphase of a unitary Operator.

  • QFT / inverse_qft_circuit — quantum Fourier transform circuits.

  • HamiltonianSimulation (Trotter / qDRIFT / fourth-order), HHL, VQD, AdaptVQE, ShorsAlgorithm, BernsteinVazirani, DeutschJozsa, quantum walks (DiscreteQuantumWalk, ContinuousQuantumWalk).

Example

from microquantum import EigenvalueProblem, Operator, Parameter, QuantumCircuit
from microquantum.algorithms import VQE
from microquantum.optimizers import COBYLA

theta = Parameter("theta")
ansatz = QuantumCircuit(1).ry(theta, 0)

vqe = VQE(ansatz, Operator.Z(), COBYLA(max_iter=100))
problem = EigenvalueProblem(Operator.Z(), k=1, name="z")

print(vqe.validate(problem))            # []
result = vqe.solve(problem, initial_params={theta: 0.5})
print(result.eigenvalue)                # ~ -1.0
print(result.to_dict()["eigenstate"])   # optimal {"theta": ...}

Optimizers

Classical optimizers in microquantum.optimizers share one interface (Optimizer): minimize(cost_fn, gradient_fn=None, initial_params) -> OptimizerResult. Gradient-free (COBYLA, NelderMead), gradient-based (GradientDescent, Adam, SPSA, QNSPSA) and quasi-Newton (BFGS, L-BFGS-B) families are available.