LogosQ Optimizer

Classical optimization algorithms for variational quantum algorithms, providing stable and fast parameter optimization.

Features

• Adam: Adaptive moment estimation with momentum
• L-BFGS: Quasi-Newton method for smooth objectives
• SPSA: Gradient-free stochastic approximation
• Natural Gradient: Fisher information-aware optimization
• GPU acceleration: Optional CUDA support

Quick Start

use logosq_optimizer::{Adam, Optimizer};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let optimizer = Adam::new()
        .with_learning_rate(0.01)
        .with_beta1(0.9);
    
    let mut params = vec![0.1; 16];
    let gradients = vec![0.01; 16];
    
    optimizer.step(&mut params, &gradients, 0)?;
    Ok(())
}

Installation

[dependencies]
logosq-optimizer = "0.1"

License

MIT OR Apache-2.0

lib.rs:

LogosQ Optimizer

Classical optimization algorithms for variational quantum algorithms, providing stable and fast parameter optimization for VQE, QAOA, and other hybrid workflows.

Overview

This crate provides a comprehensive suite of optimizers designed for the unique challenges of variational quantum algorithms:

• Gradient-based: Adam, L-BFGS, Gradient Descent with momentum
• Gradient-free: COBYLA, Nelder-Mead, SPSA
• Quantum-aware: Parameter-shift gradients, natural gradient

Key Features

• Auto-differentiation: Compute gradients via parameter-shift rule
• GPU acceleration: Optional CUDA support for large-scale optimization
• Numerical stability: Validated against edge cases where other libs fail
• Chemical accuracy: Achieve < 1.6 mHa precision in molecular simulations

Performance Comparison

Installation

Add to your Cargo.toml:

[dependencies]
logosq-optimizer = "0.1"

Feature Flags

• gpu: Enable CUDA-accelerated optimization
• autodiff: Enable automatic differentiation
• blas: Enable BLAS-accelerated linear algebra

Dependencies

• ndarray: Matrix operations
• nalgebra: Linear algebra (optional)

Usage Tutorials

Optimizing VQE Parameters

use logosq_optimizer::{Adam, Optimizer};

let optimizer = Adam::new()
    .with_learning_rate(0.01)
    .with_beta1(0.9)
    .with_beta2(0.999);

let mut params = vec![0.1; 16];
let gradients = vec![0.01; 16];

optimizer.step(&mut params, &gradients, 0).unwrap();
println!("Updated params: {:?}", &params[..3]);

L-BFGS Optimization

use logosq_optimizer::{LBFGS, ConvergenceCriteria};

let optimizer = LBFGS::new()
    .with_memory_size(10)
    .with_convergence(ConvergenceCriteria {
        gradient_tolerance: 1e-6,
        function_tolerance: 1e-8,
        max_iterations: 200,
    });

println!("L-BFGS configured with memory size 10");

Optimizer Details

Adam (Adaptive Moment Estimation)

Update rule: $$m_t = \beta_1 m_{t-1} + (1-\beta_1) g_t$$ $$v_t = \beta_2 v_{t-1} + (1-\beta_2) g_t^2$$ $$\hat{m}_t = m_t / (1 - \beta_1^t)$$ $$\hat{v}t = v_t / (1 - \beta_2^t)$$ $$\theta_t = \theta{t-1} - \alpha \hat{m}_t / (\sqrt{\hat{v}_t} + \epsilon)$$

Hyperparameters:

• learning_rate (α): Step size, typically 0.001-0.1
• beta1: First moment decay, default 0.9
• beta2: Second moment decay, default 0.999
• epsilon: Numerical stability, default 1e-8

L-BFGS (Limited-memory BFGS)

Quasi-Newton method using limited memory for Hessian approximation.

Hyperparameters:

• memory_size: Number of past gradients to store (5-20)
• line_search: Wolfe conditions for step size

Best for: Smooth, well-conditioned objectives (VQE)

SPSA (Simultaneous Perturbation Stochastic Approximation)

Gradient-free method using random perturbations.

Update rule: $$g_k \approx \frac{f(\theta + c_k \Delta_k) - f(\theta - c_k \Delta_k)}{2 c_k} \Delta_k^{-1}$$

Hyperparameters:

• a, c: Step size sequences
• A: Stability constant

Best for: Noisy objectives, hardware execution

Gradient Descent with Momentum

$$v_t = \mu v_{t-1} + \alpha g_t$$ $$\theta_t = \theta_{t-1} - v_t$$

Natural Gradient

Uses Fisher information matrix for parameter-space geometry: $$\theta_{t+1} = \theta_t - \alpha F^{-1} \nabla L$$

Integration with LogosQ-Algorithms

use logosq_optimizer::{Adam, Optimizer};

// Use custom optimizer for VQE
let optimizer = Adam::new().with_learning_rate(0.05);
let mut params = vec![0.0; 16];
let grads = vec![0.01; 16];

optimizer.step(&mut params, &grads, 0).unwrap();

Numerical Stability

Edge Cases Handled

Validation

All optimizers are tested against:

• Rosenbrock function (non-convex)
• Rastrigin function (many local minima)
• VQE energy landscapes (quantum-specific)

Performance Benchmarks

VQE Training Loop (H2 molecule, 4 qubits)

Hardware Requirements

• CPU: Any x86_64 with SSE4.2
• GPU (optional): CUDA 11.0+, compute capability 7.0+

Contributing

To add a new optimizer:

1. Implement the Optimizer trait
2. Add convergence tests on standard benchmarks
3. Include gradient verification tests
4. Document hyperparameters and mathematical derivation

License

MIT OR Apache-2.0

Patent Notice

Some optimization methods may be covered by patents in certain jurisdictions. Users are responsible for ensuring compliance with applicable laws.

Changelog

v0.1.0

• Initial release with Adam, L-BFGS, SPSA, SGD
• Parameter-shift gradient computation
• GPU acceleration support