# 7.12 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. 9.3 (Debugging infeasibility) has instructions on how to deal with this situation and debug it **by hand**. We recommend Sec. 9.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 Fusion 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 Fusion 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. 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.

## 7.12.1 Example PINFEAS¶

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

Creating the model

In order to fetch the infeasibility certificate we must have access to the objects representing both variables and constraints after optimization. We will implement the problem as having two linear constraints `s`

and `d`

of dimensions 3 and 4, respectively.

```
// Construct the sample model from the example in the manual
Matrix sMat = Matrix.Sparse(3, 7, new int[]{0,0,1,1,2,2,2},
new int[]{0,1,2,3,4,5,6},
new double[]{1,1,1,1,1,1,1});
double[] sBound = new double[]{200, 1000, 1000};
Matrix dMat = Matrix.Sparse(4, 7, new int[]{0,0,1,2,2,3,3},
new int[]{0,4,1,2,5,3,6},
new double[]{1,1,1,1,1,1,1});
double[] dBound = new double[]{1100, 200, 500, 500};
double[] c = new double[]{1, 2, 5, 2, 1, 2, 1};
using(Model M = new Model("pinfeas"))
{
Variable x = M.Variable("x", 7, Domain.GreaterThan(0));
Constraint s = M.Constraint("s", Expr.Mul(sMat, x), Domain.LessThan(sBound));
Constraint d = M.Constraint("d", Expr.Mul(dMat, x), Domain.EqualsTo(dBound));
M.Objective(ObjectiveSense.Minimize, Expr.Dot(c,x));
```

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). Finally, we declare that we are interested in retrieving certificates and not just optimal solutions by calling `Model.AcceptedSolutionStatus`

, see Sec. 8.1.4 (Retrieving solution values). All these steps are demonstrated in the snippet below:

```
// Check problem status
if (M.GetProblemStatus() == ProblemStatus.PrimalInfeasible) {
// Set the tolerance at which we consider a dual value as essential
double eps = 1e-7;
// We want to retrieve infeasibility certificates
M.AcceptedSolutionStatus(AccSolutionStatus.Certificate);
```

Going through the certificate for a single item

We can define a fairly generic function which takes an array of 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 certificate for a single object,
//which can be a variable or constraint
public static void analyzeCertificate(String name, // name of the analyzed object
long size, // size of the object
double[] duals, // actual dual values
double eps) { // tolerance determining when a dual value is considered important
for(int i = 0; i < size; i++) {
if (Math.Abs(duals[i]) > eps)
Console.WriteLine("{0}[{1}], dual = {2}", name, i, duals[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:

```
using System;
using mosek.fusion;
namespace mosek.fusion.example
{
public class pinfeas {
//Analyzes and prints infeasibility certificate for a single object,
//which can be a variable or constraint
public static void analyzeCertificate(String name, // name of the analyzed object
long size, // size of the object
double[] duals, // actual dual values
double eps) { // tolerance determining when a dual value is considered important
for(int i = 0; i < size; i++) {
if (Math.Abs(duals[i]) > eps)
Console.WriteLine("{0}[{1}], dual = {2}", name, i, duals[i]);
}
}
public static void Main(string[] args) {
// Construct the sample model from the example in the manual
Matrix sMat = Matrix.Sparse(3, 7, new int[]{0,0,1,1,2,2,2},
new int[]{0,1,2,3,4,5,6},
new double[]{1,1,1,1,1,1,1});
double[] sBound = new double[]{200, 1000, 1000};
Matrix dMat = Matrix.Sparse(4, 7, new int[]{0,0,1,2,2,3,3},
new int[]{0,4,1,2,5,3,6},
new double[]{1,1,1,1,1,1,1});
double[] dBound = new double[]{1100, 200, 500, 500};
double[] c = new double[]{1, 2, 5, 2, 1, 2, 1};
using(Model M = new Model("pinfeas"))
{
Variable x = M.Variable("x", 7, Domain.GreaterThan(0));
Constraint s = M.Constraint("s", Expr.Mul(sMat, x), Domain.LessThan(sBound));
Constraint d = M.Constraint("d", Expr.Mul(dMat, x), Domain.EqualsTo(dBound));
M.Objective(ObjectiveSense.Minimize, Expr.Dot(c,x));
// Useful for debugging
M.WriteTask("pinfeas.ptf"); // Save to a readable file
M.SetLogHandler(Console.Out); // Enable log output
// Solve the problem
M.Solve();
// Check problem status
if (M.GetProblemStatus() == ProblemStatus.PrimalInfeasible) {
// Set the tolerance at which we consider a dual value as essential
double eps = 1e-7;
// We want to retrieve infeasibility certificates
M.AcceptedSolutionStatus(AccSolutionStatus.Certificate);
// Go through variable bounds
Console.WriteLine("Variable bounds important for infeasibility: ");
analyzeCertificate("x", x.GetSize(), x.Dual(), eps);
// Go through constraint bounds
Console.WriteLine("Constraint bounds important for infeasibility: ");
analyzeCertificate("s", s.GetSize(), s.Dual(), eps);
analyzeCertificate("d", d.GetSize(), d.Dual(), 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:
x[5], dual = 1.0
x[6], dual = 1.0
Constraint bounds important for infeasibility:
s[0], dual = -1.0
s[2], dual = -1.0
d[0], dual = 1.0
d[1], dual = 1.0
```

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