# 6.13 Retrieving infeasibility certificates¶

When a continuous problem is declared as primal or dual infeasible, **MOSEK** provides a Farkas-type infeasibility certificate. If, as it happens in many cases, the problem is infeasible due to an unintended mistake in the formulation or because some individual constraint is too tight, then it is likely that infeasibility can be isolated to a few linear constraints/bounds that mutually contradict each other. In this case it is easy to identify the source of infeasibility. The tutorial in Sec. 8.3 (Debugging infeasibility) has instructions on how to deal with this situation and debug it **by hand**. We recommend Sec. 8.3 (Debugging infeasibility) as an introduction to infeasibility certificates and how to deal with infeasibilities in general.

Some users, however, would prefer to obtain the infeasibility certificate using Optimizer API for Julia, for example in order to repair the issue automatically, display the information to the user, or perhaps simply because the infeasibility was one of the intended outcomes that should be analyzed in the code.

In this tutorial we show how to obtain such an infeasibility certificate with Optimizer API for Julia in the most typical case, that is when the linear part of a problem is primal infeasible. A Farkas-type primal infeasibility certificate consists of the dual values of linear constraints and bounds. The names of duals corresponding to various parts of the problem are defined in Sec. 12.1.2 (Infeasibility for Linear Optimization). Each of the dual values (multipliers) indicates that a certain multiple of the corresponding constraint should be taken into account when forming the collection of mutually contradictory equalities/inequalities.

## 6.13.1 Example PINFEAS¶

For the purpose of this tutorial we use the same example as in Sec. 8.3 (Debugging infeasibility), that is the primal infeasible problem

Checking infeasible status and adjusting settings

After the model has been solved we check that it is indeed infeasible. If yes, then we choose a threshold for when a certificate value is considered as an important contributor to infeasibility (ideally we would like to list all nonzero duals, but just like an optimal solution, an infeasibility certificate is also subject to floating-point rounding errors). All these steps are demonstrated in the snippet below:

```
# Check problem status, we use the interior point solution
if getprosta(task,MSK_SOL_ITR) == MSK_PRO_STA_PRIM_INFEAS
# Set the tolerance at which we consider a dual value as essential
eps = 1e-7
```

Going through the certificate for a single item

We can define a fairly generic function which takes an array of lower and upper dual values and all other required data and prints out the positions of those entries whose dual values exceed the given threshold. These are precisely the values we are interested in:

```
"""
Analyzes and prints infeasibility contributing elements
sl - dual values for lower bounds
su - dual values for upper bounds
eps - tolerance for when a nunzero dual value is significant
"""
function analyzeCertificate(sl :: Vector{Float64}, su :: Vector{Float64}, eps :: Float64)
for i in 1:length(sl)
if abs(sl[i]) > eps
println("#$i, lower, dual = $(sl[i])")
end
if abs(su[i]) > eps
println("#$i, upper, dual = $(su[i])")
end
end
end
```

Full source code

All that remains is to call this function for all variable and constraint bounds for which we want to know their contribution to infeasibility. Putting all these pieces together we obtain the following full code:

```
using Mosek
# Set up a simple linear problem from the manual for test purposes
function testProblem(func :: Function)
maketask() do task
# Use remote server: putoptserverhost(task,"http://solve.mosek.com:30080")
appendvars(task,7)
appendcons(task,7);
putclist(task,
Int32[1,2,3,4,5,6,7],
Float64[1,2,5,2,1,2,1])
putaijlist(task,
Int32[1,1,2,2,3,3,3,4,4,5,6,6,7,7],
Int32[1,2,3,4,5,6,7,1,5,2,3,6,4,7],
Float64[1,1,1,1,1,1,1,1,1,1,1,1,1,1])
putconboundslice(task,
1, 8,
[MSK_BK_UP,MSK_BK_UP,MSK_BK_UP,MSK_BK_FX,MSK_BK_FX,MSK_BK_FX,MSK_BK_FX],
Float64[-Inf, -Inf, -Inf, 1100, 200, 500, 500],
Float64[200, 1000, 1000, 1100, 200, 500, 500])
putvarboundsliceconst(task,1, 8, MSK_BK_LO, 0.0, +Inf)
func(task)
end
end
"""
Analyzes and prints infeasibility contributing elements
sl - dual values for lower bounds
su - dual values for upper bounds
eps - tolerance for when a nunzero dual value is significant
"""
function analyzeCertificate(sl :: Vector{Float64}, su :: Vector{Float64}, eps :: Float64)
for i in 1:length(sl)
if abs(sl[i]) > eps
println("#$i, lower, dual = $(sl[i])")
end
if abs(su[i]) > eps
println("#$i, upper, dual = $(su[i])")
end
end
end
# In this example we set up a simple problem
# One could use any task or a task read from a file
testProblem() do task
# Use remote server: putoptserverhost(task,"http://solve.mosek.com:30080")
# Useful for debugging
writedata(task,"pinfeas.ptf"); # Write file in human-readable format
# Attach a log stream printer to the task
putstreamfunc(task,MSK_STREAM_LOG,msg -> print(msg))
# Perform the optimization.
optimize(task)
solutionsummary(task,MSK_STREAM_LOG)
# Check problem status, we use the interior point solution
if getprosta(task,MSK_SOL_ITR) == MSK_PRO_STA_PRIM_INFEAS
# Set the tolerance at which we consider a dual value as essential
eps = 1e-7
println("Variable bounds important for infeasibility: ");
analyzeCertificate(getslx(task,MSK_SOL_ITR), getsux(task,MSK_SOL_ITR), eps)
println("Constraint bounds important for infeasibility: ")
analyzeCertificate(getslc(task,MSK_SOL_ITR), getsuc(task,MSK_SOL_ITR), eps)
else
println("The problem is not primal infeasible, no certificate to show")
end
end
```

Running this code will produce the following output:

```
Variable bounds important for infeasibility:
#6: lower, dual = 1.000000e+00
#7: lower, dual = 1.000000e+00
Constraint bounds important for infeasibility:
#1: upper, dual = 1.000000e+00
#3: upper, dual = 1.000000e+00
#4: lower, dual = 1.000000e+00
#5: lower, dual = 1.000000e+00
```

indicating the positions of bounds which appear in the infeasibility certificate with nonzero values.