# 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 .NET, 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 .NET 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 PFEAS¶

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 (task.getprosta(soltype.itr) == prosta.prim_infeas) {
// Set the tolerance at which we consider a dual value as essential
double 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
public static void analyzeCertificate(double[] sl, double[] su, double eps) {
for(int i = 0; i < sl.Length; i++) {
if (Math.Abs(sl[i]) > eps)
Console.WriteLine("#{0}, lower, dual = {1}", i, sl[i]);
if (Math.Abs(su[i]) > eps)
Console.WriteLine("#{0}, upper, dual = {1}", i, su[i]);
}
}
```

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:

```
namespace mosek.example {
class msgclass : mosek.Stream {
public msgclass () {}
public override void streamCB (string msg) {
Console.Write (msg);
}
}
public class pinfeas {
static double inf = 0.0; // Infinity for symbolic purposes
// Set up a simple linear problem from the manual for test purposes
public static mosek.Task testProblem() {
mosek.Task task = new mosek.Task();
task.appendvars(7);
task.appendcons(7);
task.putclist(new int[]{0,1,2,3,4,5,6}, new double[]{1,2,5,2,1,2,1});
task.putaijlist(new int[]{0,0,1,1,2,2,2,3,3,4,5,5,6,6},
new int[]{0,1,2,3,4,5,6,0,4,1,2,5,3,6},
new double[]{1,1,1,1,1,1,1,1,1,1,1,1,1,1});
mosek.boundkey up = mosek.boundkey.up,
fx = mosek.boundkey.fx,
lo = mosek.boundkey.lo;
task.putconboundslice(0, 7, new mosek.boundkey[]{up,up,up,fx,fx,fx,fx},
new double[]{-inf, -inf, -inf, 1100, 200, 500, 500},
new double[]{200, 1000, 1000, 1100, 200, 500, 500});
task.putvarboundsliceconst(0, 7, lo, 0, +inf);
return task;
}
// 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
public static void analyzeCertificate(double[] sl, double[] su, double eps) {
for(int i = 0; i < sl.Length; i++) {
if (Math.Abs(sl[i]) > eps)
Console.WriteLine("#{0}, lower, dual = {1}", i, sl[i]);
if (Math.Abs(su[i]) > eps)
Console.WriteLine("#{0}, upper, dual = {1}", i, su[i]);
}
}
public static void Main () {
// In this example we set up a simple problem
// One could use any task or a task read from a file
mosek.Task task = testProblem();
// Useful for debugging
task.writedata("pinfeas.ptf"); // Write file in human-readable format
// Attach a log stream printer to the task
task.set_Stream (mosek.streamtype.log, new msgclass ());
// Perform the optimization.
task.optimize();
task.solutionsummary(mosek.streamtype.log);
// Check problem status, we use the interior point solution
if (task.getprosta(soltype.itr) == prosta.prim_infeas) {
// Set the tolerance at which we consider a dual value as essential
double eps = 1e-7;
Console.WriteLine("Variable bounds important for infeasibility: ");
analyzeCertificate(task.getslx(soltype.itr), task.getsux(soltype.itr), eps);
Console.WriteLine("Constraint bounds important for infeasibility: ");
analyzeCertificate(task.getslc(soltype.itr), task.getsuc(soltype.itr), eps);
}
else {
Console.WriteLine("The problem is not primal infeasible, no certificate to show");
}
}
}
}
```

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.