# Optimization in CUDA-Q

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

```cpp
#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;
}
```

## Optimizer Comparison

**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.