Rename AbstractOptimizationSolver to AbstractNLPSolver

Author: ocots

BREAKING.md

@@ -108,7 +108,7 @@ docp = DiscretizedModel(ocp, builder)
 ```julia
 registry = create_registry(
     AbstractOptimizationModeler => (ADNLPModeler, ExaModeler),
-    AbstractOptimizationSolver => (IpoptSolver, MadNLPSolver)
+    AbstractNLPSolver => (IpoptSolver, MadNLPSolver)
 )
 ```
 
@@ -117,7 +117,7 @@ registry = create_registry(
 ```julia
 registry = create_registry(
     AbstractNLPModeler => (Modelers.ADNLP, Modelers.Exa),
-    AbstractOptimizationSolver => (Solvers.Ipopt, Solvers.MadNLP)
+    AbstractNLPSolver => (Solvers.Ipopt, Solvers.MadNLP)
 )
 ```
 

docs/src/architecture.md

@@ -52,7 +52,7 @@ classDiagram
     }
 
     AbstractStrategy <|-- AbstractNLPModeler
-    AbstractStrategy <|-- AbstractOptimizationSolver
+    AbstractStrategy <|-- AbstractNLPSolver
     AbstractStrategy <|-- AbstractOptimalControlDiscretizer
 
     class AbstractNLPModeler {
@@ -63,14 +63,14 @@ classDiagram
     AbstractNLPModeler <|-- Modelers.ADNLP
     AbstractNLPModeler <|-- Modelers.Exa
 
-    class AbstractOptimizationSolver {
+    class AbstractNLPSolver {
         <<abstract>>
         (solver)(nlp; display) → Stats
     }
-    AbstractOptimizationSolver <|-- Solvers.Ipopt
-    AbstractOptimizationSolver <|-- Solvers.MadNLP
-    AbstractOptimizationSolver <|-- Solvers.MadNCL
-    AbstractOptimizationSolver <|-- Solvers.Knitro
+    AbstractNLPSolver <|-- Solvers.Ipopt
+    AbstractNLPSolver <|-- Solvers.MadNLP
+    AbstractNLPSolver <|-- Solvers.MadNCL
+    AbstractNLPSolver <|-- Solvers.Knitro
 
     class AbstractOptimalControlDiscretizer {
         <<abstract>>
@@ -81,7 +81,7 @@ classDiagram
 ```
 
 - **`AbstractNLPModeler`** (in `Modelers`): converts problems into NLP models and back into solutions.
-- **`AbstractOptimizationSolver`** (in `Solvers`): solves NLP models via backend libraries.
+- **`AbstractNLPSolver`** (in `Solvers`): solves NLP models via backend libraries.
 - **`AbstractOptimalControlDiscretizer`** (in CTDirect, external): discretizes continuous-time OCP into finite-dimensional problems. See [Implementing a Strategy](@ref) for a complete tutorial.
 
 ### Optimization / Builder Branch
@@ -165,7 +165,7 @@ sequenceDiagram
     participant Modeler as AbstractNLPModeler
     participant Problem as AbstractOptimizationProblem
     participant Builder as AbstractModelBuilder
-    participant Solver as AbstractOptimizationSolver
+    participant Solver as AbstractNLPSolver
     participant SolBuilder as AbstractSolutionBuilder
 
     User->>Solve: solve(problem, x0, modeler, solver)
@@ -248,7 +248,7 @@ Solvers use **Tag Dispatch** to separate type definitions (in `src/Solvers/`) fr
 ```mermaid
 flowchart LR
     subgraph src["src/Solvers/"]
-        SolverType["Solvers.Ipopt <: AbstractOptimizationSolver"]
+        SolverType["Solvers.Ipopt <: AbstractNLPSolver"]
         Tag["IpoptTag <: AbstractTag"]
         Callable["(solver)(nlp) → _solve(IpoptTag(), nlp, opts)"]
     end

docs/src/guides/implementing_a_solver.md

@@ -9,7 +9,7 @@ This guide explains how to implement an optimization solver in CTSolvers. Solver
 !!! tip "Prerequisites"
     Read [Architecture](@ref) and [Implementing a Strategy](@ref) first. A solver is a strategy with two additional requirements: a **callable interface** and a **Tag Dispatch** extension.
 
-## The AbstractOptimizationSolver Contract
+## The AbstractNLPSolver Contract
 
 A solver must satisfy **three contracts**:
 
@@ -26,16 +26,16 @@ classDiagram
         options(instance)::StrategyOptions
     }
 
-    class AbstractOptimizationSolver {
+    class AbstractNLPSolver {
         <<abstract>>
         (solver)(nlp; display) → Stats
     }
 
-    AbstractStrategy <|-- AbstractOptimizationSolver
-    AbstractOptimizationSolver <|-- Solvers.Ipopt
-    AbstractOptimizationSolver <|-- Solvers.MadNLP
-    AbstractOptimizationSolver <|-- Solvers.MadNCL
-    AbstractOptimizationSolver <|-- Solvers.Knitro
+    AbstractStrategy <|-- AbstractNLPSolver
+    AbstractNLPSolver <|-- Solvers.Ipopt
+    AbstractNLPSolver <|-- Solvers.MadNLP
+    AbstractNLPSolver <|-- Solvers.MadNCL
+    AbstractNLPSolver <|-- Solvers.Knitro
 ```
 
 The default callable throws `NotImplemented` with guidance.
@@ -67,7 +67,7 @@ struct IpoptTag <: AbstractTag end
 Like any strategy, the solver has a single `options` field:
 
 ```julia
-struct Solvers.Ipopt <: AbstractOptimizationSolver
+struct Solvers.Ipopt <: AbstractNLPSolver
     options::Strategies.StrategyOptions
 end
 ```
@@ -114,7 +114,7 @@ CTSolvers.Solvers.MadNLP()
 ```mermaid
 flowchart LR
     subgraph src["src/Solvers/ipopt_solver.jl"]
-        Type["Solvers.Ipopt <: AbstractOptimizationSolver"]
+        Type["Solvers.Ipopt <: AbstractNLPSolver"]
         Tag["IpoptTag <: AbstractTag"]
         Ctor["Solvers.Ipopt(; kwargs...)\n→ build_ipopt_solver(IpoptTag(); kwargs...)"]
         Stub["build_ipopt_solver(::AbstractTag)\n→ ExtensionError"]
@@ -287,7 +287,7 @@ To add a new solver (e.g., `MySolver` backed by `MyBackend`):
 ### In `src/Solvers/`
 
 1. Define `MyTag <: AbstractTag`
-2. Define `MySolver <: AbstractOptimizationSolver` with `options::StrategyOptions`
+2. Define `MySolver <: AbstractNLPSolver` with `options::StrategyOptions`
 3. Implement `Strategies.id(::Type{<:MySolver}) = :my_solver`
 4. Write constructor: `MySolver(; mode, kwargs...) = build_my_solver(MyTag(); mode, kwargs...)`
 5. Write stub: `build_my_solver(::AbstractTag; kwargs...) = throw(ExtensionError(...))`

src/Orchestration/disambiguation.jl

@@ -111,7 +111,7 @@ julia> method = (:collocation, :adnlp, :ipopt)
 julia> families = (
            discretizer = AbstractOptimalControlDiscretizer,
            modeler = AbstractNLPModeler,
-           solver = AbstractOptimizationSolver
+           solver = AbstractNLPSolver
        )
 
 julia> map = build_strategy_to_family_map(method, families, registry)

src/Orchestration/routing.jl

@@ -72,7 +72,7 @@ julia> method = (:collocation, :adnlp, :ipopt)
 julia> families = (
            discretizer = AbstractOptimalControlDiscretizer,
            modeler = AbstractNLPModeler,
-           solver = AbstractOptimizationSolver
+           solver = AbstractNLPSolver
        )
 
 julia> action_defs = [

src/Solvers/Solvers.jl

@@ -36,7 +36,7 @@ using CommonSolve
 stats = solve(nlp, solver, display=false)
 ```
 
-See also: [`AbstractOptimizationSolver`](@ref), [`Solvers.Ipopt`](@ref)
+See also: [`AbstractNLPSolver`](@ref), [`Solvers.Ipopt`](@ref)
 """
 module Solvers
 
@@ -70,7 +70,7 @@ include(joinpath(@__DIR__, "knitro.jl"))
 include(joinpath(@__DIR__, "common_solve_api.jl"))
 
 # Public API - abstract and concrete types
-export AbstractOptimizationSolver
+export AbstractNLPSolver
 export Ipopt, MadNLP, MadNCL, Knitro
 
 end # module Solvers

src/Solvers/abstract_solver.jl

@@ -4,7 +4,7 @@ $(TYPEDEF)
 Abstract base type for optimization solvers in the Control Toolbox.
 
 All concrete solver types must:
-1. Be a subtype of `AbstractOptimizationSolver`
+1. Be a subtype of `AbstractNLPSolver`
 2. Implement the `AbstractStrategy` contract:
    - `Strategies.id(::Type{<:MySolver})` - Return unique Symbol identifier
    - `Strategies.metadata(::Type{<:MySolver})` - Return StrategyMetadata with options
@@ -30,7 +30,7 @@ stats = solver(nlp, display=true)
 
 See also: [`Solvers.Ipopt`](@ref), [`Solvers.MadNLP`](@ref), [`Solvers.MadNCL`](@ref), [`Solvers.Knitro`](@ref)
 """
-abstract type AbstractOptimizationSolver <: Strategies.AbstractStrategy end
+abstract type AbstractNLPSolver <: Strategies.AbstractStrategy end
 
 """
 $(TYPEDSIGNATURES)
@@ -60,11 +60,11 @@ nlp = ADNLPModel(x -> sum(x.^2), zeros(5))
 stats = solver(nlp, display=false)
 ```
 """
-function (solver::AbstractOptimizationSolver)(nlp; display::Bool=true)
+function (solver::AbstractNLPSolver)(nlp; display::Bool=true)
     throw(Exceptions.NotImplemented(
         "Solver callable not implemented",
         required_method="(solver::$(typeof(solver)))(nlp; display=Bool)",
         suggestion="Implement the callable method for $(typeof(solver))",
-        context="AbstractOptimizationSolver - required method"
+        context="AbstractNLPSolver - required method"
     ))
 end

src/Solvers/common_solve_api.jl

@@ -24,7 +24,7 @@ High-level solve: Build NLP model, solve it, and build solution.
 - `problem::Optimization.AbstractOptimizationProblem`: The optimization problem
 - `initial_guess`: Initial guess for the solution
 - `modeler::Modelers.AbstractNLPModeler`: Modeler to build NLP
-- `solver::AbstractOptimizationSolver`: Solver to use
+- `solver::AbstractNLPSolver`: Solver to use
 - `display::Bool`: Whether to show solver output (default: true)
 
 # Returns
@@ -48,7 +48,7 @@ function CommonSolve.solve(
     problem::Optimization.AbstractOptimizationProblem,
     initial_guess,
     modeler::Modelers.AbstractNLPModeler,
-    solver::AbstractOptimizationSolver;
+    solver::AbstractNLPSolver;
     display::Bool=__display(),
 )
     # Build NLP model
@@ -70,7 +70,7 @@ Mid-level solve: Solve NLP problem directly.
 
 # Arguments
 - `nlp::NLPModels.AbstractNLPModel`: The NLP problem to solve
-- `solver::AbstractOptimizationSolver`: Solver to use
+- `solver::AbstractNLPSolver`: Solver to use
 - `display::Bool`: Whether to show solver output (default: true)
 
 # Returns
@@ -87,7 +87,7 @@ stats = solve(nlp, solver, display=false)
 """
 function CommonSolve.solve(
     nlp::NLPModels.AbstractNLPModel,
-    solver::AbstractOptimizationSolver;
+    solver::AbstractNLPSolver;
     display::Bool=__display(),
 )::SolverCore.AbstractExecutionStats
     return solver(nlp; display=display)
@@ -103,15 +103,15 @@ that may be compatible with the solver's callable interface.
 
 # Arguments
 - `nlp`: Problem to solve (any type compatible with solver)
-- `solver::AbstractOptimizationSolver`: Solver to use
+- `solver::AbstractNLPSolver`: Solver to use
 - `display::Bool`: Whether to show solver output (default: true)
 
 # Returns
 - Result from solver (type depends on solver implementation)
 """
 function CommonSolve.solve(
     nlp, 
-    solver::AbstractOptimizationSolver; 
+    solver::AbstractNLPSolver; 
     display::Bool=__display()
 )
     return solver(nlp; display=display)

src/Solvers/ipopt.jl

@@ -66,9 +66,9 @@ using NLPModelsIpopt
 - Options are validated at construction time using enriched `Exceptions.IncorrectArgument`
 - Callable interface: `(solver::Ipopt)(nlp; display=true)` provided by extension
 
-See also: [`AbstractOptimizationSolver`](@ref), [`MadNLP`](@ref), [`Knitro`](@ref)
+See also: [`AbstractNLPSolver`](@ref), [`MadNLP`](@ref), [`Knitro`](@ref)
 """
-struct Ipopt <: AbstractOptimizationSolver
+struct Ipopt <: AbstractNLPSolver
     "Solver configuration options containing validated option values"
     options::Strategies.StrategyOptions
 end

src/Solvers/knitro.jl

@@ -69,9 +69,9 @@ using NLPModelsKnitro
 - Callable interface: `(solver::Knitro)(nlp; display=true)` provided by extension
 - Requires valid Knitro license for operation
 
-See also: [`AbstractOptimizationSolver`](@ref), [`Ipopt`](@ref), [`MadNLP`](@ref)
+See also: [`AbstractNLPSolver`](@ref), [`Ipopt`](@ref), [`MadNLP`](@ref)
 """
-struct Knitro <: AbstractOptimizationSolver
+struct Knitro <: AbstractNLPSolver
     "Solver configuration options containing validated option values"
     options::Strategies.StrategyOptions
 end