# Models

## Attribute interface

`MathOptInterface.is_set_by_optimize`

— Function`is_set_by_optimize(::AnyAttribute)`

Return a `Bool`

indicating whether the value of the attribute is set during an `optimize!`

call, that is, the attribute is used to query the result of the optimization.

If an attribute can be set by the user, define `is_copyable`

instead.

An attribute cannot be both `is_copyable`

and `is_set_by_optimize`

.

**Default fallback**

This function returns `false`

by default so it should be implemented for attributes that are set by `optimize!`

.

**Undefined behavior**

Querying the value of the attribute that `is_set_by_optimize`

before a call to `optimize!`

is undefined and depends on solver-specific behavior.

`MathOptInterface.is_copyable`

— Function`is_copyable(::AnyAttribute)`

Return a `Bool`

indicating whether the value of the attribute may be copied during `copy_to`

using `set`

.

If an attribute `is_copyable`

, then it cannot be modified by the optimizer, and `get`

must always return the value that was `set`

by the user.

If an attribute is the result of an optimization, define `is_set_by_optimize`

instead.

An attribute cannot be both `is_set_by_optimize`

and `is_copyable`

.

**Default fallback**

By default `is_copyable(attr)`

returns `!is_set_by_optimize(attr)`

, which is most probably `true`

.

If an attribute should not be copied, define `is_copyable(::MyAttribute) = false`

.

`MathOptInterface.get`

— Function`MOI.get(b::AbstractBridge, ::MOI.NumberOfVariables)::Int64`

Return the number of variables created by the bridge `b`

in the model.

See also `MOI.NumberOfConstraints`

.

**Implementation notes**

- There is a default fallback, so you need only implement this if the bridge adds new variables.

`MOI.get(b::AbstractBridge, ::MOI.ListOfVariableIndices)`

Return the list of variables created by the bridge `b`

.

See also `MOI.ListOfVariableIndices`

.

**Implementation notes**

- There is a default fallback, so you need only implement this if the bridge adds new variables.

`MOI.get(b::AbstractBridge, ::MOI.NumberOfConstraints{F,S})::Int64 where {F,S}`

Return the number of constraints of the type `F`

-in-`S`

created by the bridge `b`

.

See also `MOI.NumberOfConstraints`

.

**Implementation notes**

- There is a default fallback, so you need only implement this for the constraint types returned by
`added_constraint_types`

.

`MOI.get(b::AbstractBridge, ::MOI.ListOfConstraintIndices{F,S}) where {F,S}`

Return a `Vector{ConstraintIndex{F,S}}`

with indices of all constraints of type `F`

-in-`S`

created by the bride `b`

.

See also `MOI.ListOfConstraintIndices`

.

**Implementation notes**

- There is a default fallback, so you need only implement this for the constraint types returned by
`added_constraint_types`

.

```
function MOI.get(
model::MOI.ModelLike,
attr::MOI.AbstractConstraintAttribute,
bridge::AbstractBridge,
)
```

Return the value of the attribute `attr`

of the model `model`

for the constraint bridged by `bridge`

.

`get(optimizer::AbstractOptimizer, attr::AbstractOptimizerAttribute)`

Return an attribute `attr`

of the optimizer `optimizer`

.

`get(model::ModelLike, attr::AbstractModelAttribute)`

Return an attribute `attr`

of the model `model`

.

`get(model::ModelLike, attr::AbstractVariableAttribute, v::VariableIndex)`

If the attribute `attr`

is set for the variable `v`

in the model `model`

, return its value, return `nothing`

otherwise. If the attribute `attr`

is not supported by `model`

then an error should be thrown instead of returning `nothing`

.

`get(model::ModelLike, attr::AbstractVariableAttribute, v::Vector{VariableIndex})`

Return a vector of attributes corresponding to each variable in the collection `v`

in the model `model`

.

`get(model::ModelLike, attr::AbstractConstraintAttribute, c::ConstraintIndex)`

If the attribute `attr`

is set for the constraint `c`

in the model `model`

, return its value, return `nothing`

otherwise. If the attribute `attr`

is not supported by `model`

then an error should be thrown instead of returning `nothing`

.

```
get(
model::ModelLike,
attr::AbstractConstraintAttribute,
c::Vector{ConstraintIndex{F,S}},
) where {F,S}
```

Return a vector of attributes corresponding to each constraint in the collection `c`

in the model `model`

.

`get(model::ModelLike, ::Type{VariableIndex}, name::String)`

If a variable with name `name`

exists in the model `model`

, return the corresponding index, otherwise return `nothing`

. Errors if two variables have the same name.

```
get(
model::ModelLike,
::Type{ConstraintIndex{F,S}},
name::String,
) where {F,S}
```

If an `F`

-in-`S`

constraint with name `name`

exists in the model `model`

, return the corresponding index, otherwise return `nothing`

. Errors if two constraints have the same name.

`get(model::ModelLike, ::Type{ConstraintIndex}, name::String)`

If *any* constraint with name `name`

exists in the model `model`

, return the corresponding index, otherwise return `nothing`

. This version is available for convenience but may incur a performance penalty because it is not type stable. Errors if two constraints have the same name.

`MathOptInterface.get!`

— Function`get!(output, model::ModelLike, args...)`

An in-place version of `get`

.

The signature matches that of `get`

except that the result is placed in the vector `output`

.

`MathOptInterface.set`

— Function```
function MOI.set(
model::MOI.ModelLike,
attr::MOI.AbstractConstraintAttribute,
bridge::AbstractBridge,
value,
)
```

Set the value of the attribute `attr`

of the model `model`

for the constraint bridged by `bridge`

.

`set(optimizer::AbstractOptimizer, attr::AbstractOptimizerAttribute, value)`

Assign `value`

to the attribute `attr`

of the optimizer `optimizer`

.

`set(model::ModelLike, attr::AbstractModelAttribute, value)`

Assign `value`

to the attribute `attr`

of the model `model`

.

`set(model::ModelLike, attr::AbstractVariableAttribute, v::VariableIndex, value)`

Assign `value`

to the attribute `attr`

of variable `v`

in model `model`

.

```
set(
model::ModelLike,
attr::AbstractVariableAttribute,
v::Vector{VariableIndex},
vector_of_values,
)
```

Assign a value respectively to the attribute `attr`

of each variable in the collection `v`

in model `model`

.

```
set(
model::ModelLike,
attr::AbstractConstraintAttribute,
c::ConstraintIndex,
value,
)
```

Assign a value to the attribute `attr`

of constraint `c`

in model `model`

.

```
set(
model::ModelLike,
attr::AbstractConstraintAttribute,
c::Vector{ConstraintIndex{F,S}},
vector_of_values,
) where {F,S}
```

Assign a value respectively to the attribute `attr`

of each constraint in the collection `c`

in model `model`

.

An `UnsupportedAttribute`

error is thrown if `model`

does not support the attribute `attr`

(see `supports`

) and a `SetAttributeNotAllowed`

error is thrown if it supports the attribute `attr`

but it cannot be set.

```
set(
model::ModelLike,
::ConstraintSet,
c::ConstraintIndex{F,S},
set::S,
) where {F,S}
```

Change the set of constraint `c`

to the new set `set`

which should be of the same type as the original set.

```
set(
model::ModelLike,
::ConstraintFunction,
c::ConstraintIndex{F,S},
func::F,
) where {F,S}
```

Replace the function in constraint `c`

with `func`

. `F`

must match the original function type used to define the constraint.

Setting the constraint function is not allowed if `F`

is `VariableIndex`

; a `SettingVariableIndexNotAllowed`

error is thrown instead. This is because, it would require changing the index `c`

since the index of `VariableIndex`

constraints must be the same as the index of the variable.

`MathOptInterface.supports`

— Function```
MOI.supports(
model::MOI.ModelLike,
attr::MOI.AbstractConstraintAttribute,
BT::Type{<:AbstractBridge},
)
```

Return a `Bool`

indicating whether `BT`

supports setting `attr`

to `model`

.

`supports(model::ModelLike, sub::AbstractSubmittable)::Bool`

Return a `Bool`

indicating whether `model`

supports the submittable `sub`

.

`supports(model::ModelLike, attr::AbstractOptimizerAttribute)::Bool`

Return a `Bool`

indicating whether `model`

supports the optimizer attribute `attr`

. That is, it returns `false`

if `copy_to(model, src)`

shows a warning in case `attr`

is in the `ListOfOptimizerAttributesSet`

of `src`

; see `copy_to`

for more details on how unsupported optimizer attributes are handled in copy.

`supports(model::ModelLike, attr::AbstractModelAttribute)::Bool`

Return a `Bool`

indicating whether `model`

supports the model attribute `attr`

. That is, it returns `false`

if `copy_to(model, src)`

cannot be performed in case `attr`

is in the `ListOfModelAttributesSet`

of `src`

.

```
supports(
model::ModelLike,
attr::AbstractVariableAttribute,
::Type{VariableIndex},
)::Bool
```

Return a `Bool`

indicating whether `model`

supports the variable attribute `attr`

. That is, it returns `false`

if `copy_to(model, src)`

cannot be performed in case `attr`

is in the `ListOfVariableAttributesSet`

of `src`

.

```
supports(
model::ModelLike,
attr::AbstractConstraintAttribute,
::Type{ConstraintIndex{F,S}},
)::Bool where {F,S}
```

Return a `Bool`

indicating whether `model`

supports the constraint attribute `attr`

applied to an `F`

-in-`S`

constraint. That is, it returns `false`

if `copy_to(model, src)`

cannot be performed in case `attr`

is in the `ListOfConstraintAttributesSet`

of `src`

.

For all five methods, if the attribute is only not supported in specific circumstances, it should still return `true`

.

Note that `supports`

is only defined for attributes for which `is_copyable`

returns `true`

as other attributes do not appear in the list of attributes set obtained by `ListOfXXXAttributesSet`

.

`MathOptInterface.attribute_value_type`

— Function`attribute_value_type(attr::AnyAttribute)`

Given an attribute `attr`

, return the type of value expected by `get`

, or returned by `set`

.

**Notes**

- Only implement this if it make sense to do so. If un-implemented, the default is
`Any`

.

## Model interface

`MathOptInterface.ModelLike`

— Type`ModelLike`

Abstract supertype for objects that implement the "Model" interface for defining an optimization problem.

`MathOptInterface.is_empty`

— Function`is_empty(model::ModelLike)`

Returns `false`

if the `model`

has any model attribute set or has any variables or constraints.

Note that an empty model can have optimizer attributes set.

`MathOptInterface.empty!`

— Function`empty!(model::ModelLike)`

Empty the model, that is, remove all variables, constraints and model attributes but not optimizer attributes.

`MathOptInterface.write_to_file`

— Function`write_to_file(model::ModelLike, filename::String)`

Write the current model to the file at `filename`

.

Supported file types depend on the model type.

`MathOptInterface.read_from_file`

— Function`read_from_file(model::ModelLike, filename::String)`

Read the file `filename`

into the model `model`

. If `model`

is non-empty, this may throw an error.

Supported file types depend on the model type.

**Note**

Once the contents of the file are loaded into the model, users can query the variables via `get(model, ListOfVariableIndices())`

. However, some filetypes, such as LP files, do not maintain an explicit ordering of the variables. Therefore, the returned list may be in an arbitrary order.

To avoid depending on the order of the indices, look up each variable index by name using `get(model, VariableIndex, "name")`

.

`MathOptInterface.supports_incremental_interface`

— Function`supports_incremental_interface(model::ModelLike)`

Return a `Bool`

indicating whether `model`

supports building incrementally via `add_variable`

and `add_constraint`

.

The main purpose of this function is to determine whether a model can be loaded into `model`

incrementally or whether it should be cached and copied at once instead.

`MathOptInterface.copy_to`

— Function`copy_to(dest::ModelLike, src::ModelLike)::IndexMap`

Copy the model from `src`

into `dest`

.

The target `dest`

is emptied, and all previous indices to variables and constraints in `dest`

are invalidated.

Returns an `IndexMap`

object that translates variable and constraint indices from the `src`

model to the corresponding indices in the `dest`

model.

**Notes**

- If a constraint that in
`src`

is not supported by`dest`

, then an`UnsupportedConstraint`

error is thrown. - If an
`AbstractModelAttribute`

,`AbstractVariableAttribute`

, or`AbstractConstraintAttribute`

is set in`src`

but not supported by`dest`

, then an`UnsupportedAttribute`

error is thrown.

`AbstractOptimizerAttribute`

s are *not* copied to the `dest`

model.

**IndexMap**

Implementations of `copy_to`

must return an `IndexMap`

. For technical reasons, this type is defined in the Utilities submodule as `MOI.Utilities.IndexMap`

. However, since it is an integral part of the MOI API, we provide `MOI.IndexMap`

as an alias.

**Example**

```
# Given empty `ModelLike` objects `src` and `dest`.
x = add_variable(src)
is_valid(src, x) # true
is_valid(dest, x) # false (`dest` has no variables)
index_map = copy_to(dest, src)
is_valid(dest, x) # false (unless index_map[x] == x)
is_valid(dest, index_map[x]) # true
```

`MathOptInterface.IndexMap`

— Type`IndexMap()`

The dictionary-like object returned by `copy_to`

.

**IndexMap**

Implementations of `copy_to`

must return an `IndexMap`

. For technical reasons, the `IndexMap`

type is defined in the Utilities submodule as `MOI.Utilities.IndexMap`

. However, since it is an integral part of the MOI API, we provide this `MOI.IndexMap`

as an alias.

## Model attributes

`MathOptInterface.AbstractModelAttribute`

— Type`AbstractModelAttribute`

Abstract supertype for attribute objects that can be used to set or get attributes (properties) of the model.

`MathOptInterface.Name`

— Type`Name()`

A model attribute for the string identifying the model. It has a default value of `""`

if not set`.

`MathOptInterface.ObjectiveFunction`

— Type`ObjectiveFunction{F<:AbstractScalarFunction}()`

A model attribute for the objective function which has a type `F<:AbstractScalarFunction`

.

`F`

should be guaranteed to be equivalent but not necessarily identical to the function type provided by the user.

Throws an `InexactError`

if the objective function cannot be converted to `F`

, for example, the objective function is quadratic and `F`

is `ScalarAffineFunction{Float64}`

or it has non-integer coefficient and `F`

is `ScalarAffineFunction{Int}`

.

`MathOptInterface.ObjectiveFunctionType`

— Type`ObjectiveFunctionType()`

A model attribute for the type `F`

of the objective function set using the `ObjectiveFunction{F}`

attribute.

**Example**

```
julia> import MathOptInterface as MOI
julia> model = MOI.Utilities.Model{Float64}();
julia> x = MOI.add_variable(model)
MOI.VariableIndex(1)
julia> MOI.set(model, MOI.ObjectiveFunction{MOI.VariableIndex}(), x)
julia> MOI.get(model, MOI.ObjectiveFunctionType())
MathOptInterface.VariableIndex
```

`MathOptInterface.ObjectiveSense`

— Type`ObjectiveSense()`

A model attribute for the objective sense of the objective function, which must be an `OptimizationSense`

: `MIN_SENSE`

, `MAX_SENSE`

, or `FEASIBILITY_SENSE`

. The default is `FEASIBILITY_SENSE`

.

**Interaction with ObjectiveFunction**

Setting the sense to `FEASIBILITY_SENSE`

unsets the `ObjectiveFunction`

attribute. That is, if you first set `ObjectiveFunction`

and then set `ObjectiveSense`

to be `FEASIBILITY_SENSE`

, no objective function will be passed to the solver.

In addition, some reformulations of `ObjectiveFunction`

via bridges rely on the value of `ObjectiveSense`

. Therefore, you should set `ObjectiveSense`

before setting `ObjectiveFunction`

.

`MathOptInterface.OptimizationSense`

— Type`OptimizationSense`

An enum for the value of the `ObjectiveSense`

attribute.

**Values**

Possible values are:

`MIN_SENSE`

: the goal is to minimize the objective function`MAX_SENSE`

: the goal is to maximize the objective function`FEASIBILITY_SENSE`

: the model does not have an objective function

`MathOptInterface.MIN_SENSE`

— Constant`MIN_SENSE::OptimizationSense`

An instance of the `OptimizationSense`

enum.

`MIN_SENSE`

: the goal is to minimize the objective function

`MathOptInterface.MAX_SENSE`

— Constant`MAX_SENSE::OptimizationSense`

An instance of the `OptimizationSense`

enum.

`MAX_SENSE`

: the goal is to maximize the objective function

`MathOptInterface.FEASIBILITY_SENSE`

— Constant`FEASIBILITY_SENSE::OptimizationSense`

An instance of the `OptimizationSense`

enum.

`FEASIBILITY_SENSE`

: the model does not have an objective function

`MathOptInterface.NumberOfVariables`

— Type`NumberOfVariables()`

A model attribute for the number of variables in the model.

`MathOptInterface.ListOfVariableIndices`

— Type`ListOfVariableIndices()`

A model attribute for the `Vector{VariableIndex}`

of all variable indices present in the model (that is, of length equal to the value of `NumberOfVariables`

in the order in which they were added.

`MathOptInterface.ListOfConstraintTypesPresent`

— Type`ListOfConstraintTypesPresent()`

A model attribute for the list of tuples of the form `(F,S)`

, where `F`

is a function type and `S`

is a set type indicating that the attribute `NumberOfConstraints{F,S}`

has a value greater than zero.

`MathOptInterface.NumberOfConstraints`

— Type`NumberOfConstraints{F,S}()`

A model attribute for the number of constraints of the type `F`

-in-`S`

present in the model.

`MathOptInterface.ListOfConstraintIndices`

— Type`ListOfConstraintIndices{F,S}()`

A model attribute for the `Vector{ConstraintIndex{F,S}}`

of all constraint indices of type `F`

-in-`S`

in the model (that is, of length equal to the value of `NumberOfConstraints{F,S}`

) in the order in which they were added.

`MathOptInterface.ListOfOptimizerAttributesSet`

— Type`ListOfOptimizerAttributesSet()`

An optimizer attribute for the `Vector{AbstractOptimizerAttribute}`

of all optimizer attributes that were set.

`MathOptInterface.ListOfModelAttributesSet`

— Type`ListOfModelAttributesSet()`

A model attribute for the `Vector{AbstractModelAttribute}`

of all model attributes `attr`

such that:

`is_copyable(attr)`

returns`true`

, and- the attribute was set to the model

`MathOptInterface.ListOfVariableAttributesSet`

— Type`ListOfVariableAttributesSet()`

A model attribute for the `Vector{AbstractVariableAttribute}`

of all variable attributes `attr`

such that 1) `is_copyable(attr)`

returns `true`

and 2) the attribute was set to variables.

`MathOptInterface.ListOfVariablesWithAttributeSet`

— Type`ListOfVariablesWithAttributeSet(attr::AbstractVariableAttribute)`

A model attribute for the `Vector{VariableIndex}`

of all variables with the attribute `attr`

set.

The returned list may not be minimal, so some elements may have their default value set.

**Note**

This is an optional attribute to implement. The default fallback is to get `ListOfVariableIndices`

.

`MathOptInterface.ListOfConstraintAttributesSet`

— Type`ListOfConstraintAttributesSet{F, S}()`

A model attribute for the `Vector{AbstractConstraintAttribute}`

of all constraint attributes `attr`

such that:

`is_copyable(attr)`

returns`true`

and- the attribute was set to
`F`

-in-`S`

constraints.

**Note**

The attributes `ConstraintFunction`

and `ConstraintSet`

should not be included in the list even if then have been set with `set`

.

`MathOptInterface.ListOfConstraintsWithAttributeSet`

— Type`ListOfConstraintsWithAttributeSet{F,S}(attr:AbstractConstraintAttribute)`

A model attribute for the `Vector{ConstraintIndex{F,S}}`

of all constraints with the attribute `attr`

set.

The returned list may not be minimal, so some elements may have their default value set.

**Note**

This is an optional attribute to implement. The default fallback is to get `ListOfConstraintIndices`

.

`MathOptInterface.UserDefinedFunction`

— Type`UserDefinedFunction(name::Symbol, arity::Int) <: AbstractModelAttribute`

Set this attribute to register a user-defined function by the name of `name`

with `arity`

arguments.

Once registered, `name`

will appear in `ListOfSupportedNonlinearOperators`

.

You cannot register multiple `UserDefinedFunction`

s with the same `name`

but different `arity`

.

**Value type**

The value to be set is a tuple containing one, two, or three functions to evaluate the function, the first-order derivative, and the second-order derivative respectively. Both derivatives are optional, but if you pass the second-order derivative you must also pass the first-order derivative.

For univariate functions with `arity == 1`

, the functions in the tuple must have the form:

`f(x::T)::T`

: returns the value of the function at`x`

`∇f(x::T)::T`

: returns the first-order derivative of`f`

with respect to`x`

`∇²f(x::T)::T`

: returns the second-order derivative of`f`

with respect to`x`

.

For multivariate functions with `arity > 1`

, the functions in the tuple must have the form:

`f(x::T...)::T`

: returns the value of the function at`x`

`∇f(g::AbstractVector{T}, x::T...)::Nothing`

: fills the components of`g`

, with`g[i]`

being the first-order partial derivative of`f`

with respect to`x[i]`

`∇²f(H::AbstractMatrix{T}, x::T...)::Nothing`

: fills the non-zero components of`H`

, with`H[i, j]`

being the second-order partial derivative of`f`

with respect to`x[i]`

and then`x[j]`

.`H`

is initialized to the zero matrix, so you do not need to set any zero elements.

**Example**

```
julia> import MathOptInterface as MOI
julia> f(x, y) = x^2 + y^2
f (generic function with 1 method)
julia> function ∇f(g, x, y)
g .= 2 * x, 2 * y
return
end
∇f (generic function with 1 method)
julia> function ∇²f(H, x...)
H[1, 1] = H[2, 2] = 2.0
return
end
∇²f (generic function with 1 method)
julia> model = MOI.Utilities.UniversalFallback(MOI.Utilities.Model{Float64}());
julia> MOI.set(model, MOI.UserDefinedFunction(:f, 2), (f,))
julia> MOI.set(model, MOI.UserDefinedFunction(:g, 2), (f, ∇f))
julia> MOI.set(model, MOI.UserDefinedFunction(:h, 2), (f, ∇f, ∇²f))
julia> x = MOI.add_variables(model, 2)
2-element Vector{MathOptInterface.VariableIndex}:
MOI.VariableIndex(1)
MOI.VariableIndex(2)
julia> MOI.set(model, MOI.ObjectiveSense(), MOI.MIN_SENSE)
julia> obj_f = MOI.ScalarNonlinearFunction(:f, Any[x[1], x[2]])
f(MOI.VariableIndex(1), MOI.VariableIndex(2))
julia> MOI.set(model, MOI.ObjectiveFunction{typeof(obj_f)}(), obj_f)
julia> print(model)
Minimize ScalarNonlinearFunction:
f(v[1], v[2])
Subject to:
```

`MathOptInterface.ListOfSupportedNonlinearOperators`

— Type`ListOfSupportedNonlinearOperators() <: AbstractModelAttribute`

When queried with `get`

, return a `Vector{Symbol}`

listing the operators supported by the model.

## Optimizer interface

`MathOptInterface.AbstractOptimizer`

— Type`AbstractOptimizer <: ModelLike`

Abstract supertype for objects representing an instance of an optimization problem tied to a particular solver. This is typically a solver's in-memory representation. In addition to `ModelLike`

, `AbstractOptimizer`

objects let you solve the model and query the solution.

`MathOptInterface.OptimizerWithAttributes`

— Type```
struct OptimizerWithAttributes
optimizer_constructor
params::Vector{Pair{AbstractOptimizerAttribute,<:Any}}
end
```

Object grouping an optimizer constructor and a list of optimizer attributes. Instances are created with `instantiate`

.

`MathOptInterface.optimize!`

— Function`optimize!(optimizer::AbstractOptimizer)`

Optimize the problem contained in `optimizer`

.

Before calling `optimize!`

, the problem should first be constructed using the incremental interface (see `supports_incremental_interface`

) or `copy_to`

.

`MathOptInterface.optimize!`

— Method`optimize!(dest::AbstractOptimizer, src::ModelLike)::Tuple{IndexMap,Bool}`

A "one-shot" call that copies the problem from `src`

into `dest`

and then uses `dest`

to optimize the problem.

Returns a tuple of an `IndexMap`

and a `Bool`

`copied`

.

- The
`IndexMap`

object translates variable and constraint indices from the`src`

model to the corresponding indices in the`dest`

optimizer. See`copy_to`

for details. - If
`copied == true`

,`src`

was copied to`dest`

and then cached, allowing incremental modification if supported by the solver. - If
`copied == false`

, a cache of the model was*not*kept in`dest`

. Therefore, only the solution information (attributes for which`is_set_by_optimize`

is true) is available to query.

The main purpose of `optimize!`

method with two arguments is for use in `Utilities.CachingOptimizer`

.

**Relationship to the single-argument optimize!**

The default fallback of `optimize!(dest::AbstractOptimizer, src::ModelLike)`

is

```
function optimize!(dest::AbstractOptimizer, src::ModelLike)
index_map = copy_to(dest, src)
optimize!(dest)
return index_map, true
end
```

Therefore, subtypes of `AbstractOptimizer`

should either implement this two-argument method, or implement both `copy_to(::Optimizer, ::ModelLike)`

and `optimize!(::Optimizer)`

.

`MathOptInterface.instantiate`

— Function```
instantiate(
optimizer_constructor,
with_cache_type::Union{Nothing,Type} = nothing,
with_bridge_type::Union{Nothing,Type} = nothing,
)
```

Create an instance of an optimizer by either:

- calling
`optimizer_constructor.optimizer_constructor()`

and setting the parameters in`optimizer_constructor.params`

if`optimizer_constructor`

is a`OptimizerWithAttributes`

- calling
`optimizer_constructor()`

if`optimizer_constructor`

is callable.

**with cachetype**

If `with_cache_type`

is not `nothing`

, then the optimizer is wrapped in a `Utilities.CachingOptimizer`

to store a cache of the model. This is most useful if the optimizer you are constructing does not support the incremental interface (see `supports_incremental_interface`

).

**with bridgetype**

If `with_bridge_type`

is not `nothing`

, the optimizer is wrapped in a `Bridges.full_bridge_optimizer`

, enabling all the bridges defined in the MOI.Bridges submodule with coefficient type `with_bridge_type`

.

In addition, if the optimizer created by `optimizer_constructor`

does not support the incremental interface (see `supports_incremental_interface`

), then, irrespective of `with_cache_type`

, the optimizer is wrapped in a `Utilities.CachingOptimizer`

to store a cache of the bridged model.

If `with_cache_type`

and `with_bridge_type`

are both not `nothing`

, then they must be the same type.

`MathOptInterface.default_cache`

— Function`default_cache(optimizer::ModelLike, ::Type{T}) where {T}`

Return a new instance of the default model type to be used as cache for `optimizer`

in a `Utilities.CachingOptimizer`

for holding constraints of coefficient type `T`

. By default, this returns `Utilities.UniversalFallback(Utilities.Model{T}())`

. If copying from a instance of a given model type is faster for `optimizer`

then a new method returning an instance of this model type should be defined.

## Optimizer attributes

`MathOptInterface.AbstractOptimizerAttribute`

— Type`AbstractOptimizerAttribute`

Abstract supertype for attribute objects that can be used to set or get attributes (properties) of the optimizer.

**Notes**

The difference between `AbstractOptimizerAttribute`

and `AbstractModelAttribute`

lies in the behavior of `is_empty`

, `empty!`

and `copy_to`

. Typically optimizer attributes affect only how the model is solved.

`MathOptInterface.SolverName`

— Type`SolverName()`

An optimizer attribute for the string identifying the solver/optimizer.

`MathOptInterface.SolverVersion`

— Type`SolverVersion()`

An optimizer attribute for the string identifying the version of the solver.

For solvers supporting semantic versioning, the `SolverVersion`

should be a string of the form "vMAJOR.MINOR.PATCH", so that it can be converted to a Julia `VersionNumber`

(for example, `VersionNumber("v1.2.3")).

We do not require Semantic Versioning because some solvers use alternate versioning systems. For example, CPLEX uses Calendar Versioning, so `SolverVersion`

will return a string like `"202001"`

.

`MathOptInterface.Silent`

— Type`Silent()`

An optimizer attribute for silencing the output of an optimizer. When `set`

to `true`

, it takes precedence over any other attribute controlling verbosity and requires the solver to produce no output. The default value is `false`

which has no effect. In this case the verbosity is controlled by other attributes.

**Note**

Every optimizer should have verbosity on by default. For instance, if a solver has a solver-specific log level attribute, the MOI implementation should set it to `1`

by default. If the user sets `Silent`

to `true`

, then the log level should be set to `0`

, even if the user specifically sets a value of log level. If the value of `Silent`

is `false`

then the log level set to the solver is the value given by the user for this solver-specific parameter or `1`

if none is given.

`MathOptInterface.TimeLimitSec`

— Type`TimeLimitSec()`

An optimizer attribute for setting a time limit (in seconds) for an optimization. When `set`

to `nothing`

, it deactivates the solver time limit. The default value is `nothing`

.

`MathOptInterface.ObjectiveLimit`

— Type`ObjectiveLimit()`

An optimizer attribute for setting a limit on the objective value.

The provided limit must be a `Union{Real,Nothing}`

.

When `set`

to `nothing`

, the limit reverts to the solver's default.

The default value is `nothing`

.

The solver may stop when the `ObjectiveValue`

is better (lower for minimization, higher for maximization) than the `ObjectiveLimit`

. If stopped, the `TerminationStatus`

should be `OBJECTIVE_LIMIT`

.

`MathOptInterface.SolutionLimit`

— Type`SolutionLimit()`

An optimizer attribute for setting a limit on the number of available feasible solutions.

**Default values**

The provided limit must be a `Union{Nothing,Int}`

.

When `set`

to `nothing`

, the limit reverts to the solver's default.

The default value is `nothing`

.

**Termination criteria**

The solver may stop when the `ResultCount`

is larger than or equal to the `SolutionLimit`

. If stopped because of this attribute, the `TerminationStatus`

must be `SOLUTION_LIMIT`

.

**Solution quality**

The quality of the available solutions is solver-dependent. The set of resulting solutions is not guaranteed to contain an optimal solution.

`MathOptInterface.NodeLimit`

— Type`NodeLimit()`

An optimizer attribute for setting a limit on the number of branch-and-bound nodes explored by a mixed-integer program (MIP) solver.

**Default values**

The provided limit must be a `Union{Nothing,Int}`

.

When `set`

to `nothing`

, the limit reverts to the solver's default.

The default value is `nothing`

.

**Termination criteria**

The solver may stop when the `NodeCount`

is larger than or equal to the `NodeLimit`

. If stopped because of this attribute, the `TerminationStatus`

must be `NODE_LIMIT`

.

`MathOptInterface.RawOptimizerAttribute`

— Type`RawOptimizerAttribute(name::String)`

An optimizer attribute for the solver-specific parameter identified by `name`

.

`MathOptInterface.NumberOfThreads`

— Type`NumberOfThreads()`

An optimizer attribute for setting the number of threads used for an optimization. When set to `nothing`

uses solver default. Values are positive integers. The default value is `nothing`

.

`MathOptInterface.RawSolver`

— Type`RawSolver()`

A model attribute for the object that may be used to access a solver-specific API for this optimizer.

`MathOptInterface.AbsoluteGapTolerance`

— Type`AbsoluteGapTolerance()`

An optimizer attribute for setting the absolute gap tolerance for an optimization. This is an *optimizer* attribute, and should be set before calling `optimize!`

. When set to `nothing`

(if supported), uses solver default.

To set a *relative* gap tolerance, see `RelativeGapTolerance`

.

The mathematical definition of "absolute gap", and its treatment during the optimization, are solver-dependent. However, assuming no other limit nor issue is encountered during the optimization, most solvers that implement this attribute will stop once $|f - b| ≤ g_{abs}$, where $b$ is the best bound, $f$ is the best feasible objective value, and $g_{abs}$ is the absolute gap.

`MathOptInterface.RelativeGapTolerance`

— Type`RelativeGapTolerance()`

An optimizer attribute for setting the relative gap tolerance for an optimization. This is an *optimizer* attribute, and should be set before calling `optimize!`

. When set to `nothing`

(if supported), uses solver default.

If you are looking for the relative gap of the current best solution, see `RelativeGap`

. If no limit nor issue is encountered during the optimization, the value of `RelativeGap`

should be at most as large as `RelativeGapTolerance`

.

```
# Before optimizing: set relative gap tolerance
# set 0.1% relative gap tolerance
MOI.set(model, MOI.RelativeGapTolerance(), 1e-3)
MOI.optimize!(model)
# After optimizing (assuming all went well)
# The relative gap tolerance has not changed...
MOI.get(model, MOI.RelativeGapTolerance()) # returns 1e-3
# ... and the relative gap of the obtained solution is smaller or equal to the
# tolerance
MOI.get(model, MOI.RelativeGap()) # should return something ≤ 1e-3
```

The mathematical definition of "relative gap", and its allowed range, are solver-dependent. Typically, solvers expect a value between `0.0`

and `1.0`

.

`MathOptInterface.AutomaticDifferentiationBackend`

— Type`AutomaticDifferentiationBackend() <: AbstractOptimizerAttribute`

An `AbstractOptimizerAttribute`

for setting the automatic differentiation backend used by the solver.

The value must be a subtype of `Nonlinear.AbstractAutomaticDifferentiation`

.

List of attributes useful for optimizers

`MathOptInterface.TerminationStatus`

— Type`TerminationStatus()`

A model attribute for the `TerminationStatusCode`

explaining why the optimizer stopped.

`MathOptInterface.TerminationStatusCode`

— Type`TerminationStatusCode`

An Enum of possible values for the `TerminationStatus`

attribute. This attribute is meant to explain the reason why the optimizer stopped executing in the most recent call to `optimize!`

.

**Values**

Possible values are:

`OPTIMIZE_NOT_CALLED`

: The algorithm has not started.`OPTIMAL`

: The algorithm found a globally optimal solution.`INFEASIBLE`

: The algorithm concluded that no feasible solution exists.`DUAL_INFEASIBLE`

: The algorithm concluded that no dual bound exists for the problem. If, additionally, a feasible (primal) solution is known to exist, this status typically implies that the problem is unbounded, with some technical exceptions.`LOCALLY_SOLVED`

: The algorithm converged to a stationary point, local optimal solution, could not find directions for improvement, or otherwise completed its search without global guarantees.`LOCALLY_INFEASIBLE`

: The algorithm converged to an infeasible point or otherwise completed its search without finding a feasible solution, without guarantees that no feasible solution exists.`INFEASIBLE_OR_UNBOUNDED`

: The algorithm stopped because it decided that the problem is infeasible or unbounded; this occasionally happens during MIP presolve.`ALMOST_OPTIMAL`

: The algorithm found a globally optimal solution to relaxed tolerances.`ALMOST_INFEASIBLE`

: The algorithm concluded that no feasible solution exists within relaxed tolerances.`ALMOST_DUAL_INFEASIBLE`

: The algorithm concluded that no dual bound exists for the problem within relaxed tolerances.`ALMOST_LOCALLY_SOLVED`

: The algorithm converged to a stationary point, local optimal solution, or could not find directions for improvement within relaxed tolerances.`ITERATION_LIMIT`

: An iterative algorithm stopped after conducting the maximum number of iterations.`TIME_LIMIT`

: The algorithm stopped after a user-specified computation time.`NODE_LIMIT`

: A branch-and-bound algorithm stopped because it explored a maximum number of nodes in the branch-and-bound tree.`SOLUTION_LIMIT`

: The algorithm stopped because it found the required number of solutions. This is often used in MIPs to get the solver to return the first feasible solution it encounters.`MEMORY_LIMIT`

: The algorithm stopped because it ran out of memory.`OBJECTIVE_LIMIT`

: The algorithm stopped because it found a solution better than a minimum limit set by the user.`NORM_LIMIT`

: The algorithm stopped because the norm of an iterate became too large.`OTHER_LIMIT`

: The algorithm stopped due to a limit not covered by one of the`_LIMIT_`

statuses above.`SLOW_PROGRESS`

: The algorithm stopped because it was unable to continue making progress towards the solution.`NUMERICAL_ERROR`

: The algorithm stopped because it encountered unrecoverable numerical error.`INVALID_MODEL`

: The algorithm stopped because the model is invalid.`INVALID_OPTION`

: The algorithm stopped because it was provided an invalid option.`INTERRUPTED`

: The algorithm stopped because of an interrupt signal.`OTHER_ERROR`

: The algorithm stopped because of an error not covered by one of the statuses defined above.

`MathOptInterface.OPTIMIZE_NOT_CALLED`

— Constant`OPTIMIZE_NOT_CALLED::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`OPTIMIZE_NOT_CALLED`

: The algorithm has not started.

`MathOptInterface.OPTIMAL`

— Constant`OPTIMAL::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`OPTIMAL`

: The algorithm found a globally optimal solution.

`MathOptInterface.INFEASIBLE`

— Constant`INFEASIBLE::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`INFEASIBLE`

: The algorithm concluded that no feasible solution exists.

`MathOptInterface.DUAL_INFEASIBLE`

— Constant`DUAL_INFEASIBLE::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`DUAL_INFEASIBLE`

: The algorithm concluded that no dual bound exists for the problem. If, additionally, a feasible (primal) solution is known to exist, this status typically implies that the problem is unbounded, with some technical exceptions.

`MathOptInterface.LOCALLY_SOLVED`

— Constant`LOCALLY_SOLVED::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`LOCALLY_SOLVED`

: The algorithm converged to a stationary point, local optimal solution, could not find directions for improvement, or otherwise completed its search without global guarantees.

`MathOptInterface.LOCALLY_INFEASIBLE`

— Constant`LOCALLY_INFEASIBLE::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`LOCALLY_INFEASIBLE`

: The algorithm converged to an infeasible point or otherwise completed its search without finding a feasible solution, without guarantees that no feasible solution exists.

`MathOptInterface.INFEASIBLE_OR_UNBOUNDED`

— Constant`INFEASIBLE_OR_UNBOUNDED::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`INFEASIBLE_OR_UNBOUNDED`

: The algorithm stopped because it decided that the problem is infeasible or unbounded; this occasionally happens during MIP presolve.

`MathOptInterface.ALMOST_OPTIMAL`

— Constant`ALMOST_OPTIMAL::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`ALMOST_OPTIMAL`

: The algorithm found a globally optimal solution to relaxed tolerances.

`MathOptInterface.ALMOST_INFEASIBLE`

— Constant`ALMOST_INFEASIBLE::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`ALMOST_INFEASIBLE`

: The algorithm concluded that no feasible solution exists within relaxed tolerances.

`MathOptInterface.ALMOST_DUAL_INFEASIBLE`

— Constant`ALMOST_DUAL_INFEASIBLE::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`ALMOST_DUAL_INFEASIBLE`

: The algorithm concluded that no dual bound exists for the problem within relaxed tolerances.

`MathOptInterface.ALMOST_LOCALLY_SOLVED`

— Constant`ALMOST_LOCALLY_SOLVED::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`ALMOST_LOCALLY_SOLVED`

: The algorithm converged to a stationary point, local optimal solution, or could not find directions for improvement within relaxed tolerances.

`MathOptInterface.ITERATION_LIMIT`

— Constant`ITERATION_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`ITERATION_LIMIT`

: An iterative algorithm stopped after conducting the maximum number of iterations.

`MathOptInterface.TIME_LIMIT`

— Constant`TIME_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`TIME_LIMIT`

: The algorithm stopped after a user-specified computation time.

`MathOptInterface.NODE_LIMIT`

— Constant`NODE_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`NODE_LIMIT`

: A branch-and-bound algorithm stopped because it explored a maximum number of nodes in the branch-and-bound tree.

`MathOptInterface.SOLUTION_LIMIT`

— Constant`SOLUTION_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`SOLUTION_LIMIT`

: The algorithm stopped because it found the required number of solutions. This is often used in MIPs to get the solver to return the first feasible solution it encounters.

`MathOptInterface.MEMORY_LIMIT`

— Constant`MEMORY_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`MEMORY_LIMIT`

: The algorithm stopped because it ran out of memory.

`MathOptInterface.OBJECTIVE_LIMIT`

— Constant`OBJECTIVE_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`OBJECTIVE_LIMIT`

: The algorithm stopped because it found a solution better than a minimum limit set by the user.

`MathOptInterface.NORM_LIMIT`

— Constant`NORM_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`NORM_LIMIT`

: The algorithm stopped because the norm of an iterate became too large.

`MathOptInterface.OTHER_LIMIT`

— Constant`OTHER_LIMIT::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`OTHER_LIMIT`

: The algorithm stopped due to a limit not covered by one of the `_LIMIT_`

statuses above.

`MathOptInterface.SLOW_PROGRESS`

— Constant`SLOW_PROGRESS::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`SLOW_PROGRESS`

: The algorithm stopped because it was unable to continue making progress towards the solution.

`MathOptInterface.NUMERICAL_ERROR`

— Constant`NUMERICAL_ERROR::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`NUMERICAL_ERROR`

: The algorithm stopped because it encountered unrecoverable numerical error.

`MathOptInterface.INVALID_MODEL`

— Constant`INVALID_MODEL::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`INVALID_MODEL`

: The algorithm stopped because the model is invalid.

`MathOptInterface.INVALID_OPTION`

— Constant`INVALID_OPTION::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`INVALID_OPTION`

: The algorithm stopped because it was provided an invalid option.

`MathOptInterface.INTERRUPTED`

— Constant`INTERRUPTED::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`INTERRUPTED`

: The algorithm stopped because of an interrupt signal.

`MathOptInterface.OTHER_ERROR`

— Constant`OTHER_ERROR::TerminationStatusCode`

An instance of the `TerminationStatusCode`

enum.

`OTHER_ERROR`

: The algorithm stopped because of an error not covered by one of the statuses defined above.

`MathOptInterface.PrimalStatus`

— Type`PrimalStatus(result_index::Int = 1)`

A model attribute for the `ResultStatusCode`

of the primal result `result_index`

. If `result_index`

is omitted, it defaults to 1.

See `ResultCount`

for information on how the results are ordered.

If `result_index`

is larger than the value of `ResultCount`

then `NO_SOLUTION`

is returned.

`MathOptInterface.DualStatus`

— Type`DualStatus(result_index::Int = 1)`

A model attribute for the `ResultStatusCode`

of the dual result `result_index`

. If `result_index`

is omitted, it defaults to 1.

See `ResultCount`

for information on how the results are ordered.

If `result_index`

is larger than the value of `ResultCount`

then `NO_SOLUTION`

is returned.

`MathOptInterface.RawStatusString`

— Type`RawStatusString()`

A model attribute for a solver specific string explaining why the optimizer stopped.

`MathOptInterface.ResultCount`

— Type`ResultCount()`

A model attribute for the number of results available.

**Order of solutions**

A number of attributes contain an index, `result_index`

, which is used to refer to one of the available results. Thus, `result_index`

must be an integer between `1`

and the number of available results.

As a general rule, the first result (`result_index=1`

) is the most important result (for example, an optimal solution or an infeasibility certificate). Other results will typically be alternate solutions that the solver found during the search for the first result.

If a (local) optimal solution is available, that is, `TerminationStatus`

is `OPTIMAL`

or `LOCALLY_SOLVED`

, the first result must correspond to the (locally) optimal solution. Other results may be alternative optimal solutions, or they may be other suboptimal solutions; use `ObjectiveValue`

to distinguish between them.

If a primal or dual infeasibility certificate is available, that is, `TerminationStatus`

is `INFEASIBLE`

or `DUAL_INFEASIBLE`

and the corresponding `PrimalStatus`

or `DualStatus`

is `INFEASIBILITY_CERTIFICATE`

, then the first result must be a certificate. Other results may be alternate certificates, or infeasible points.

`MathOptInterface.ObjectiveValue`

— Type`ObjectiveValue(result_index::Int = 1)`

A model attribute for the objective value of the primal solution `result_index`

.

If the solver does not have a primal value for the objective because the `result_index`

is beyond the available solutions (whose number is indicated by the `ResultCount`

attribute), getting this attribute must throw a `ResultIndexBoundsError`

. Otherwise, if the result is unavailable for another reason (for instance, only a dual solution is available), the result is undefined. Users should first check `PrimalStatus`

before accessing the `ObjectiveValue`

attribute.

See `ResultCount`

for information on how the results are ordered.

`MathOptInterface.DualObjectiveValue`

— Type`DualObjectiveValue(result_index::Int = 1)`

A model attribute for the value of the objective function of the dual problem for the `result_index`

th dual result.

If the solver does not have a dual value for the objective because the `result_index`

is beyond the available solutions (whose number is indicated by the `ResultCount`

attribute), getting this attribute must throw a `ResultIndexBoundsError`

. Otherwise, if the result is unavailable for another reason (for instance, only a primal solution is available), the result is undefined. Users should first check `DualStatus`

before accessing the `DualObjectiveValue`

attribute.

See `ResultCount`

for information on how the results are ordered.

`MathOptInterface.ObjectiveBound`

— Type`ObjectiveBound()`

A model attribute for the best known bound on the optimal objective value.

`MathOptInterface.RelativeGap`

— Type`RelativeGap()`

A model attribute for the final relative optimality gap.

The definition of this gap is solver-dependent. However, most solvers implementing this attribute define the relative gap as some variation of $\frac{|b-f|}{|f|}$, where $b$ is the best bound and $f$ is the best feasible objective value.

`MathOptInterface.SolveTimeSec`

— Type`SolveTimeSec()`

A model attribute for the total elapsed solution time (in seconds) as reported by the optimizer.

`MathOptInterface.SimplexIterations`

— Type`SimplexIterations()`

A model attribute for the cumulative number of simplex iterations during the optimization process.

For a mixed-integer program (MIP), the return value is the total simplex iterations for all nodes.

`MathOptInterface.BarrierIterations`

— Type`BarrierIterations()`

A model attribute for the cumulative number of barrier iterations while solving a problem.

`MathOptInterface.NodeCount`

— Type`NodeCount()`

A model attribute for the total number of branch-and-bound nodes explored while solving a mixed-integer program (MIP).

### ResultStatusCode

`MathOptInterface.ResultStatusCode`

— Type`ResultStatusCode`

An Enum of possible values for the `PrimalStatus`

and `DualStatus`

attributes.

The values indicate how to interpret the result vector.

**Values**

Possible values are:

`NO_SOLUTION`

: the result vector is empty.`FEASIBLE_POINT`

: the result vector is a feasible point.`NEARLY_FEASIBLE_POINT`

: the result vector is feasible if some constraint tolerances are relaxed.`INFEASIBLE_POINT`

: the result vector is an infeasible point.`INFEASIBILITY_CERTIFICATE`

: the result vector is an infeasibility certificate. If the`PrimalStatus`

is`INFEASIBILITY_CERTIFICATE`

, then the primal result vector is a certificate of dual infeasibility. If the`DualStatus`

is`INFEASIBILITY_CERTIFICATE`

, then the dual result vector is a proof of primal infeasibility.`NEARLY_INFEASIBILITY_CERTIFICATE`

: the result satisfies a relaxed criterion for a certificate of infeasibility.`REDUCTION_CERTIFICATE`

: the result vector is an ill-posed certificate; see this article for details. If the`PrimalStatus`

is`REDUCTION_CERTIFICATE`

, then the primal result vector is a proof that the dual problem is ill-posed. If the`DualStatus`

is`REDUCTION_CERTIFICATE`

, then the dual result vector is a proof that the primal is ill-posed.`NEARLY_REDUCTION_CERTIFICATE`

: the result satisfies a relaxed criterion for an ill-posed certificate.`UNKNOWN_RESULT_STATUS`

: the result vector contains a solution with an unknown interpretation.`OTHER_RESULT_STATUS`

: the result vector contains a solution with an interpretation not covered by one of the statuses defined above

`MathOptInterface.NO_SOLUTION`

— Constant`NO_SOLUTION::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`NO_SOLUTION`

: the result vector is empty.

`MathOptInterface.FEASIBLE_POINT`

— Constant`FEASIBLE_POINT::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`FEASIBLE_POINT`

: the result vector is a feasible point.

`MathOptInterface.NEARLY_FEASIBLE_POINT`

— Constant`NEARLY_FEASIBLE_POINT::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`NEARLY_FEASIBLE_POINT`

: the result vector is feasible if some constraint tolerances are relaxed.

`MathOptInterface.INFEASIBLE_POINT`

— Constant`INFEASIBLE_POINT::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`INFEASIBLE_POINT`

: the result vector is an infeasible point.

`MathOptInterface.INFEASIBILITY_CERTIFICATE`

— Constant`INFEASIBILITY_CERTIFICATE::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`INFEASIBILITY_CERTIFICATE`

: the result vector is an infeasibility certificate. If the `PrimalStatus`

is `INFEASIBILITY_CERTIFICATE`

, then the primal result vector is a certificate of dual infeasibility. If the `DualStatus`

is `INFEASIBILITY_CERTIFICATE`

, then the dual result vector is a proof of primal infeasibility.

`MathOptInterface.NEARLY_INFEASIBILITY_CERTIFICATE`

— Constant`NEARLY_INFEASIBILITY_CERTIFICATE::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`NEARLY_INFEASIBILITY_CERTIFICATE`

: the result satisfies a relaxed criterion for a certificate of infeasibility.

`MathOptInterface.REDUCTION_CERTIFICATE`

— Constant`REDUCTION_CERTIFICATE::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`REDUCTION_CERTIFICATE`

: the result vector is an ill-posed certificate; see this article for details. If the `PrimalStatus`

is `REDUCTION_CERTIFICATE`

, then the primal result vector is a proof that the dual problem is ill-posed. If the `DualStatus`

is `REDUCTION_CERTIFICATE`

, then the dual result vector is a proof that the primal is ill-posed.

`MathOptInterface.NEARLY_REDUCTION_CERTIFICATE`

— Constant`NEARLY_REDUCTION_CERTIFICATE::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`NEARLY_REDUCTION_CERTIFICATE`

: the result satisfies a relaxed criterion for an ill-posed certificate.

`MathOptInterface.UNKNOWN_RESULT_STATUS`

— Constant`UNKNOWN_RESULT_STATUS::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`UNKNOWN_RESULT_STATUS`

: the result vector contains a solution with an unknown interpretation.

`MathOptInterface.OTHER_RESULT_STATUS`

— Constant`OTHER_RESULT_STATUS::ResultStatusCode`

An instance of the `ResultStatusCode`

enum.

`OTHER_RESULT_STATUS`

: the result vector contains a solution with an interpretation not covered by one of the statuses defined above

### Conflict Status

`MathOptInterface.compute_conflict!`

— Function`compute_conflict!(optimizer::AbstractOptimizer)`

Computes a minimal subset of constraints such that the model with the other constraint removed is still infeasible.

Some solvers call a set of conflicting constraints an Irreducible Inconsistent Subsystem (IIS).

See also `ConflictStatus`

and `ConstraintConflictStatus`

.

**Note**

If the model is modified after a call to `compute_conflict!`

, the implementor is not obliged to purge the conflict. Any calls to the above attributes may return values for the original conflict without a warning. Similarly, when modifying the model, the conflict can be discarded.

`MathOptInterface.ConflictStatus`

— Type`ConflictStatus()`

A model attribute for the `ConflictStatusCode`

explaining why the conflict refiner stopped when computing the conflict.

`MathOptInterface.ConstraintConflictStatus`

— Type`ConstraintConflictStatus()`

A constraint attribute indicating whether the constraint participates in the conflict. Its type is `ConflictParticipationStatusCode`

.

`MathOptInterface.ConflictStatusCode`

— Type`ConflictStatusCode`

An Enum of possible values for the `ConflictStatus`

attribute. This attribute is meant to explain the reason why the conflict finder stopped executing in the most recent call to `compute_conflict!`

.

Possible values are:

`COMPUTE_CONFLICT_NOT_CALLED`

: the function`compute_conflict!`

has not yet been called`NO_CONFLICT_EXISTS`

: there is no conflict because the problem is feasible`NO_CONFLICT_FOUND`

: the solver could not find a conflict`CONFLICT_FOUND`

: at least one conflict could be found

`MathOptInterface.ConflictParticipationStatusCode`

— Type`ConflictParticipationStatusCode`

An Enum of possible values for the `ConstraintConflictStatus`

attribute. This attribute is meant to indicate whether a given constraint participates or not in the last computed conflict.

**Values**

Possible values are:

`NOT_IN_CONFLICT`

: the constraint does not participate in the conflict`IN_CONFLICT`

: the constraint participates in the conflict`MAYBE_IN_CONFLICT`

: the constraint may participate in the conflict, the solver was not able to prove that the constraint can be excluded from the conflict

`MathOptInterface.NOT_IN_CONFLICT`

— Constant`NOT_IN_CONFLICT::ConflictParticipationStatusCode`

An instance of the `ConflictParticipationStatusCode`

enum.

`NOT_IN_CONFLICT`

: the constraint does not participate in the conflict

`MathOptInterface.IN_CONFLICT`

— Constant`IN_CONFLICT::ConflictParticipationStatusCode`

An instance of the `ConflictParticipationStatusCode`

enum.

`IN_CONFLICT`

: the constraint participates in the conflict

`MathOptInterface.MAYBE_IN_CONFLICT`

— Constant`MAYBE_IN_CONFLICT::ConflictParticipationStatusCode`

An instance of the `ConflictParticipationStatusCode`

enum.

`MAYBE_IN_CONFLICT`

: the constraint may participate in the conflict, the solver was not able to prove that the constraint can be excluded from the conflict