Optimization finds parameters that minimize a cost function. CUDA-Q provides built-in optimizers (COBYLA, Adam, SLSQP) and integrates gradients for efficient training.

#include "cudaq.h"
#include "cudaq/optimizer.h"
#include "cudaq/gradients.h"
#include <vector>
#include <cmath>
 
struct CostCircuit {
  void operator()(std::vector<double> params) __qpu__ {
    cudaq::qvector q(2);
    ry(params[0], q[0]);
    ry(params[1], q[1]);
    cx(q[0], q[1]);
    rz(params[2], q[0]);
    mz(q);
  }
};
 
int main() {
  // Define cost function
  auto cost = [](std::vector<double> params) {
    auto result = cudaq::sample<CostCircuit>(1000, params);
    return result.probability("11");  // Minimize P(|11⟩)
  };
 
  // Initial guess
  std::vector<double> initial_params = {0.5, 0.5, 0.5};
 
  // Optimizer 1: COBYLA (gradient-free, robust)
  {
    cudaq::optimizers::COBYLA cobyla;
    cobyla.max_iterations = 100;
 
    auto [opt_params, opt_cost] = cobyla.optimize(initial_params, cost);
    printf("COBYLA result: cost = %.6f\n", opt_cost);
  }
 
  // Optimizer 2: Adam (gradient-based, fast)
  {
    cudaq::optimizers::Adam adam;
    adam.learning_rate = 0.01;
    adam.max_iterations = 100;
 
    auto [opt_params, opt_cost] = adam.optimize(initial_params, cost);
    printf("Adam result: cost = %.6f\n", opt_cost);
  }
 
  // Gradient-based optimization with automatic differentiation
  {
    cudaq::spin_op H = cudaq::spin::z(0) * cudaq::spin::z(1);
    cudaq::optimizers::COBYLA optimizer;
 
    auto [opt_params, opt_cost] = cudaq::vqe<CostCircuit>(
        H, optimizer, initial_params, 100
    );
    printf("VQE result: energy = %.6f\n", opt_cost);
  }
 
  return 0;
}

COBYLA: No gradient required, robust but slower convergence

Adam: Gradient-based, fast convergence, tunable learning rate

SLSQP: Sequential least squares, good for constrained problems

Choose based on problem structure and available gradients.