Minimum Value (Lower Bound, Infimum)

Function Form

$$y=min(x_1,x_2,\cdots ,x_n)$$

Constant Definition

$$M=\underset{i\in P}{max}(max(|x_i|))$$

Additional Variables

$\text{minmax}\in \mathbb{R}$: Lower bound.

$u_i\in \{0,1\}$: Indicator variable for whether the infimum is $x_i$.

Derived Symbol

$$y=\text{maxmin}$$

Mathematical Model

$$\text{s.t.}\text{maxmin}\le x_i,\mathrm{\forall }i\in P$$

The above model constrains $y$ to be a lower bound of $x_i$, suitable for maximization objective functions. If precise $y$ values are required in equality constraints or minimization objective functions, the following mathematical model must be additionally appended to ensure $y$ reaches the infimum:

$$\begin{array}{rlrlr}\text{s.t.}& \text{maxmin}& \ge & x_i-M\cdot (1-u_i),& \mathrm{\forall }i\in P\\ \\ & \sum _{i\in P}{u}_i& =& 1\end{array}$$

Code Example

kotlin

import kotlinx.coroutines.*
import fuookami.ospf.kotlin.utils.math.*
import fuookami.ospf.kotlin.core.frontend.variable.*
import fuookami.ospf.kotlin.core.frontend.expression.polynomial.*
import fuookami.ospf.kotlin.core.frontend.expression.symbol.linear_function.*
import fuookami.ospf.kotlin.core.frontend.inequality.*
import fuookami.ospf.kotlin.core.frontend.model.mechanism.*
import fuookami.ospf.kotlin.core.backend.plugins.scip.*

val x = RealVar("x")
x.range.leq(Flt64.five)
x.range.geq(Flt64.three)
val y = RealVar("y")
y.range.leq(Flt64.ten)
y.range.geq(Flt64.two)
val solver = ScipLinearSolver()

val maxmin = MaxMinFunction(listOf(x, y), name = "maxmin")
val model1 = LinearMetaModel()
model1.add(x)
model1.add(y)
model1.add(maxmin)
model1.minimize(maxmin)
val result1 = runBlocking { solver(model1) }
assert(result1.value!!.obj eq Flt64.two)

val model2 = LinearMetaModel()
model2.add(x)
model2.add(y)
model2.add(maxmin)
model2.maximize(maxmin)
val result2 = runBlocking { solver(model2) }
assert(result2.value!!.obj eq Flt64.five)

val min = MinFunction(listOf(x, y), name = "min")
val model3 = LinearMetaModel()
model3.add(x)
model3.add(y)
model3.add(min)
model3.minimize(min)
val result3 = runBlocking { solver(model3) }
assert(result3.value!!.obj ls Flt64.zero)       // -inf

val model4 = LinearMetaModel()
model4.add(x)
model4.add(y)
model4.add(min)
model4.maximize(min)
val result4 = runBlocking { solver(model4) }
assert(result4.value!!.obj eq Flt64.five)

Complete Implementation Reference:

• Kotlin

Complete Example Reference:

• Kotlin