5.4. 约束不可行性分析

在对实际应用中的优化问题进行建模求解的过程中，往往会遇到问题不可行的情况。而不可行问题必然是由某些约束互相之间冲突导致的，如何分析问题的不可行性并识别出导致冲突的关键约束成为求解器应用的重要一环。

这类导致问题不可行的最小约束子集被称为不可约不可行系统 (IIS, irreduciable infeasible system)。MindOpt 设计了用来计算 IIS 的 API，用户可以通过利用该 API 来对不可行问题进行分析。再依据此对 IIS 中的约束进行修正或移除，可以使得优化问题变得可行，以便于更好地对实际问题进行分析建模和获得最优决策。

需要注意的是，在线性规划问题中，IIS 可能并不是唯一的。若存在多个 IIS，则需要对优化问题进行多次调整，才能使其变得可行。例如：

\[\begin{split}\text{c}_1: ~~ x_1 \leq 1 \\ \text{c}_2: ~~ x_1 \geq 2 \\ \text{c}_3: ~~ x_2 \leq 3 \\ \text{c}_4: ~~ x_2 \geq 4 \\\end{split}\]

在这个例子中，我们很容易知道 \(c_1\) 与 \(c_2\) 为一组 IIS，\(c_3\) 与 \(c_4\) 为一组 IIS。在同时移除 \(c_1\) 或 \(c_2\) 中的任意一条约束以及 \(c_3\) 或 \(c_4\) 中的任意一条约束后，该问题将变得可行。

我们将通过一个更加实际的例子，来展示如何在 MindOpt 中使用约束不可行性分析来获取 IIS。考虑如下的不可行约束系统：

\[\begin{split}\text{Constraints:} & & \\ & -0.5 x_0 + x_1 &>= 0.5 \\ & 2 x_0 - x_1 &>= 3 \\ & 3 x_0 + x_1 &<= 6 \\ & 3 x_3 - x_4 &<= 2 \\ & x_0 + x_4 &<= 10 \\ & x_0 + 2 x_1 + x_3 &<= 14 \\ & x_1 + x_3 &>= 1 \\ \text{Bounds:} & & \\ & 5 <= x_3 & \\ & 0 <= x_4 <= 2 &\end{split}\]

其中，前面三组约束构成一组IIS，而第四个约束和变量上下界则构成另外一组IIS。

Note

MindOpt 目前采用过滤算法来寻找IIS。过滤算法虽然能在短时间找出一组IIS，但无法保证IIS的规模是所有IIS组合中最小的。此外，若使用者对约束顺序做调整，则 MindOpt 也可能会产生不同的IIS。

Note

实际操作上，我们建议使用者修复IIS中的冲突后，再将修改后的模型输入至求解IIS的API，并修复下一个IIS；依此直至所有的冲突都得以修复。

接下来，我们将分别说明如何在 C/C++/Python 环境中应用 MindOpt 来获取不可行问题的 IIS。

5.4.1. C API: Mdo_computeIIS

首先，参考 C 语言的建模和优化 中的方法创建优化问题并设置参数：

    /*------------------------------------------------------------------*/
    /* Step 1. Create a model and change the parameters.                */
    /*------------------------------------------------------------------*/
    printf(" Create a model and change the parameters.\n\n");
    /* Create an empty model. */
    MDO_CHECK_CALL(Mdo_createMdl(&model));
    /* Turn-off the presolver so that solver won't terminate with an MDO_INF_OR_UBD status. */
    MDO_CHECK_CALL(Mdo_setIntParam(model, MDO_INT_PARAM_PRESOLVE, 0));
    /* Use dual-Simplex method. */
    MDO_CHECK_CALL(Mdo_setIntParam(model, MDO_INT_PARAM_METHOD, 1));

    /*------------------------------------------------------------------*/
    /* Step 2. Input model.                                             */
    /*------------------------------------------------------------------*/
    printf("\nStep 2. Input model.\n\n");    
    /* The following three input methods will all result in the same model. */
    /* Change to minimization problem. */
    MDO_CHECK_CALL(Mdo_setIntAttr(model, MDO_INT_ATTR_MIN_SENSE, MDO_YES));
    
    /* Add variables. */
    for (i = 0; i < 5; ++i)
    {
        MDO_CHECK_CALL(Mdo_addCol(model, lbs[i], ubs[i], objs[i], 0, NULL, NULL, col_names[i], MDO_NO));    
    }    
    /* Add two constraints. 
     * The coefficients of the constraint matrix are inputted in a row-wise order.
     */
    MDO_CHECK_CALL(Mdo_addRows(model, 7, lhss, rhss, csr_bgn, csr_indices, csr_values, row_names));

接下来，当优化问题不可行时，使用 Mdo_computeIIS() 获取不可约不可行子系统的行列坐标，并打印对应的约束名与变量名：

    case MDO_INFEASIBLE:
        printf("Optimizer terminated with an INFEASIBLE status.\n");
        printf("Compute IIS.\n");
        MDO_CHECK_CALL(Mdo_computeIIS(model, &num_iis_rows, idx_iis_rows, &num_iis_cols, idx_iis_cols));
        printf("Computed IIS has %d rows and %d columns.\n", num_iis_rows, num_iis_cols);
        printf("Populating IIS.\n");
        for (i = 0; i < num_iis_rows; ++i)
        {
            char row_name_iis[1024] = { "\0" };
            Mdo_getRowName(model, idx_iis_rows[i], row_name_iis, 1024, NULL);
            printf(" Constraint: %s\n", row_name_iis);
        }
        for (j = 0; j < num_iis_cols; ++j)
        {
            char col_name_iis[1024] = { "\0" };
            Mdo_getColName(model, idx_iis_cols[j], col_name_iis, 1024, NULL);
            printf(" Variable: %10d\n", col_name_iis);
        }
        break;

MdoLoIIS.c 提供了完整源代码：

/**
 *  Description
 *  -----------
 *
 *  Linear optimization.
 *   - Compute IIS of an infeasible problem.
 * 
 *  Formulation
 *  -----------
 *
 *  Minimize
 *  Obj:
 *  Subject To
 *  c0:  -0.500000000 x0 + x1 >= 0.500000000
 *  c1:  2 x0 - x1 >= 3
 *  c2:  3 x0 + x1 <= 6
 *  c3:  3 x3 - x4 <= 2 <- conflicts with variable bounds!
 *  c4:  x0 + x4 <= 10
 *  c5:  x0 + 2 x1 + x3 <= 14
 *  c6:  x1 + x3 >= 1
 *  Bounds
 *   5 <= x3
 *   0 <= x4 <= 2
 *  End
 */
#include <stdio.h>
#include <stdlib.h>
#include "Mindopt.h"


/* Macro to check the return code */
#define MDO_CHECK_CALL(MDO_CALL)                                    \
    code = MDO_CALL;                                                \
    if (code != MDO_OKAY)                                           \
    {                                                               \
        Mdo_explainResult(model, code, str);                        \
        Mdo_freeMdl(&model);                                        \
        fprintf(stderr, "===================================\n");   \
        fprintf(stderr, "Error   : code <%d>\n", code);             \
        fprintf(stderr, "Reason  : %s\n", str);                     \
        fprintf(stderr, "===================================\n");   \
        return (int)code;                                           \
    }

int main(void)
{
    /* Variables. */
    char str[1024] = { "\0" };
    MdoMdl * model = NULL;
    MdoResult code = MDO_OKAY;
    MdoStatus status = MDO_UNKNOWN;
    double val;
    int num_iis_rows, num_iis_cols;
    int idx_iis_rows[7], idx_iis_cols[5];
    int i, j;

    const int csr_bgn[] = {0, 2, 4, 6, 8, 10, 13, 15};
    const int csr_indices[] = 
    {
        0,   1, 
        0,   1,
        0,   1,
        3,   4,
        0,   4,
        0,   1,   3,
        1,   3  
    };
    const double csr_values[] = 
    {
       -0.5, 1,
        2,  -1,
        3,   1,
        3,  -1,
        1,   1,
        1,   2,   1,
        1,   1
    };

    const double lhss[] = 
    {          
        0.5, 3.0, -MDO_INFINITY, -MDO_INFINITY, -MDO_INFINITY, -MDO_INFINITY, 1.0 
    };
    const double rhss[] = 
    {
        MDO_INFINITY, MDO_INFINITY, 6.0, 2.0, 10.0, 14.0, MDO_INFINITY
    };
    const char* row_names[] = { "c0", "c1" , "c2" , "c3" , "c4" , "c5" , "c6" };

    const double lbs[] =  {          0.0,          0.0,          0.0,          5.0, 0.0 };
    const double ubs[] =  { MDO_INFINITY, MDO_INFINITY, MDO_INFINITY, MDO_INFINITY, 2.0 };
    const double objs[] = {          0.0,          0.0,          0.0,          0.0, 0.0 };
    const char* col_names[] = { "x0", "x1", "x2", "x3", "x4" };
      
    /*------------------------------------------------------------------*/
    /* Step 1. Create a model and change the parameters.                */
    /*------------------------------------------------------------------*/
    printf(" Create a model and change the parameters.\n\n");
    /* Create an empty model. */
    MDO_CHECK_CALL(Mdo_createMdl(&model));
    /* Turn-off the presolver so that solver won't terminate with an MDO_INF_OR_UBD status. */
    MDO_CHECK_CALL(Mdo_setIntParam(model, MDO_INT_PARAM_PRESOLVE, 0));
    /* Use dual-Simplex method. */
    MDO_CHECK_CALL(Mdo_setIntParam(model, MDO_INT_PARAM_METHOD, 1));

    /*------------------------------------------------------------------*/
    /* Step 2. Input model.                                             */
    /*------------------------------------------------------------------*/
    printf("\nStep 2. Input model.\n\n");    
    /* The following three input methods will all result in the same model. */
    /* Change to minimization problem. */
    MDO_CHECK_CALL(Mdo_setIntAttr(model, MDO_INT_ATTR_MIN_SENSE, MDO_YES));
    
    /* Add variables. */
    for (i = 0; i < 5; ++i)
    {
        MDO_CHECK_CALL(Mdo_addCol(model, lbs[i], ubs[i], objs[i], 0, NULL, NULL, col_names[i], MDO_NO));    
    }    
    /* Add two constraints. 
     * The coefficients of the constraint matrix are inputted in a row-wise order.
     */
    MDO_CHECK_CALL(Mdo_addRows(model, 7, lhss, rhss, csr_bgn, csr_indices, csr_values, row_names));

    /*------------------------------------------------------------------*/
    /* Step 3. Solve the problem and populate the result.               */
    /*------------------------------------------------------------------*/
    printf("\nStep 3. Solve the problem and populate the result.\n\n");
    /* Solve the problem. */
    MDO_CHECK_CALL(Mdo_solveProb(model));
    Mdo_displayResults(model);

    switch (Mdo_getStatus(model))
    {
    case MDO_UNKNOWN:
        printf("Optimizer terminated with an UNKNOWN status.\n");
        break;
    case MDO_OPTIMAL:
        MDO_CHECK_CALL(Mdo_getRealAttr(model, MDO_REAL_ATTR_PRIMAL_OBJ_VAL, &val));
        printf("Optimizer terminated with an OPTIMAL status.\n");
        printf(" - Primal objective : %e.\n", val);
        break;
    case MDO_INFEASIBLE:
        printf("Optimizer terminated with an INFEASIBLE status.\n");
        printf("Compute IIS.\n");
        MDO_CHECK_CALL(Mdo_computeIIS(model, &num_iis_rows, idx_iis_rows, &num_iis_cols, idx_iis_cols));
        printf("Computed IIS has %d rows and %d columns.\n", num_iis_rows, num_iis_cols);
        printf("Populating IIS.\n");
        for (i = 0; i < num_iis_rows; ++i)
        {
            char row_name_iis[1024] = { "\0" };
            Mdo_getRowName(model, idx_iis_rows[i], row_name_iis, 1024, NULL);
            printf(" Constraint: %s\n", row_name_iis);
        }
        for (j = 0; j < num_iis_cols; ++j)
        {
            char col_name_iis[1024] = { "\0" };
            Mdo_getColName(model, idx_iis_cols[j], col_name_iis, 1024, NULL);
            printf(" Variable: %10d\n", col_name_iis);
        }
        break;
    case MDO_UNBOUNDED:
        printf("Optimizer terminated with an UNBOUNDED status.\n");
        break;
    case MDO_INF_OR_UBD:
        printf("Optimizer terminated with an INFEASIBLE or UNBOUNDED status.\n");
        break;
    }

    /*------------------------------------------------------------------*/
    /* Step 4. Free the model.                                          */
    /*------------------------------------------------------------------*/
    printf("\nStep 4. Free the model.\n");
    /* Free the model. */
    Mdo_freeMdl(&model);
       
    return (int)code;
}

5.4.2. C++ API：computeIIS

首先，参考 C++ 的建模和优化 中的方法创建优化问题并设置参数：

        model.setIntAttr(MDO_INT_ATTR::MIN_SENSE, MDO_YES);

        /* Add variables. */
        std::vector<MdoVar> x;
        x.push_back(model.addVar(0.0, MDO_INFINITY, 0.0, "x0", MDO_NO));
        x.push_back(model.addVar(0.0, MDO_INFINITY, 0.0, "x1", MDO_NO));
        x.push_back(model.addVar(0.0, MDO_INFINITY, 0.0, "x2", MDO_NO));
        x.push_back(model.addVar(5.0, MDO_INFINITY, 0.0, "x3", MDO_NO));
        x.push_back(model.addVar(0.0, 2.0,          0.0, "x4", MDO_NO));

        /* Add constraints. */
        model.addCons(-0.5 * x[0]       + x[1]                     >= 0.5,  "c0");
        model.addCons( 2.0 * x[0]       - x[1]                     >= 3.0,  "c1");
        model.addCons( 3.0 * x[0]       + x[1]                     <= 6.0,  "c2");
        model.addCons(                          3.0 * x[3] - x[4]  <= 2.0,  "c3");
        model.addCons(       x[0]                          + x[4]  <= 10.0, "c4");
        model.addCons(       x[0] + 2.0 * x[1]      + x[3]         <= 14.0, "c5");
        model.addCons(       x[1] +                   x[3]         >= 1.0,  "c6");

接下来，当优化问题不可行时，使用 mindopt::MdoModel::computeIIS() 获取不可约不可行子系统的行列坐标，并打印对应的约束名与变量名：

        case MDO_INFEASIBLE:
            std::cout << "Optimizer terminated with an INFEASIBLE status." << std::endl;
            std::cout << "Compute IIS." << std::endl;
            model.computeIIS(idx_rows, idx_cols);

            std::cout << "Computed IIS has " << idx_rows.size() << " rows and " << idx_cols.size() << " columns." << std::endl;
            std::cout << "Populating IIS." << std::endl;
            for (int i : idx_rows)
            {
                std::cout << "Constraint: " << model.getStrAttrIndex("RowName", i) << std::endl;
            }
            for (int j : idx_cols)
            {
                std::cout << "Variable: " << model.getStrAttrIndex("ColName", j) << std::endl;
            }
            break;

MdoLoIIS.cpp 提供了完整源代码：

/**
 *  Description
 *  -----------
 *
 *  Linear optimization.
 *   - Compute IIS of an infeasible problem.
 * 
 *  Formulation
 *  -----------
 *
 *  Minimize
 *  Obj:
 *  Subject To
 *  c0:  -0.500000000 x0 + x1 >= 0.500000000
 *  c1:  2 x0 - x1 >= 3
 *  c2:  3 x0 + x1 <= 6
 *  c3:  3 x3 - x4 <= 2 <- conflicts with variable bounds!
 *  c4:  x0 + x4 <= 10
 *  c5:  x0 + 2 x1 + x3 <= 14
 *  c6:  x1 + x3 >= 1
 *  Bounds
 *   5 <= x3
 *   0 <= x4 <= 2
 *  End
 */
#include <iostream>
#include <vector>
#include "MindoptCpp.h"

using namespace mindopt;

int main(void)
{
    std::vector<int> idx_rows, idx_cols;

    /*------------------------------------------------------------------*/
    /* Step 1. Create a model and change the parameters.                */
    /*------------------------------------------------------------------*/
    /* Create an empty model. */
    MdoModel model;
    /* Turn-off the presolver so that solver won't terminate with an MDO_INF_OR_UBD status. */
    model.setIntParam(MDO_INT_PARAM::PRESOLVE, 0);
    /* Use dual-Simplex method. */
    model.setIntParam(MDO_INT_PARAM::METHOD, 1);

    try 
    {
        /*------------------------------------------------------------------*/
        /* Step 2. Input model.                                             */
        /*------------------------------------------------------------------*/
        /* Change to minimization problem. */
        model.setIntAttr(MDO_INT_ATTR::MIN_SENSE, MDO_YES);

        /* Add variables. */
        std::vector<MdoVar> x;
        x.push_back(model.addVar(0.0, MDO_INFINITY, 0.0, "x0", MDO_NO));
        x.push_back(model.addVar(0.0, MDO_INFINITY, 0.0, "x1", MDO_NO));
        x.push_back(model.addVar(0.0, MDO_INFINITY, 0.0, "x2", MDO_NO));
        x.push_back(model.addVar(5.0, MDO_INFINITY, 0.0, "x3", MDO_NO));
        x.push_back(model.addVar(0.0, 2.0,          0.0, "x4", MDO_NO));

        /* Add constraints. */
        model.addCons(-0.5 * x[0]       + x[1]                     >= 0.5,  "c0");
        model.addCons( 2.0 * x[0]       - x[1]                     >= 3.0,  "c1");
        model.addCons( 3.0 * x[0]       + x[1]                     <= 6.0,  "c2");
        model.addCons(                          3.0 * x[3] - x[4]  <= 2.0,  "c3");
        model.addCons(       x[0]                          + x[4]  <= 10.0, "c4");
        model.addCons(       x[0] + 2.0 * x[1]      + x[3]         <= 14.0, "c5");
        model.addCons(       x[1] +                   x[3]         >= 1.0,  "c6");

        /*------------------------------------------------------------------*/
        /* Step 3. Solve the problem and populate the result.               */
        /*------------------------------------------------------------------*/
        /* Solve the problem. */
        model.solveProb();
        model.displayResults();

        switch (model.getStatus())
        {
        case MDO_UNKNOWN:
            std::cout << "Optimizer terminated with an UNKNOWN status." << std::endl;
            break;
        case MDO_OPTIMAL:
            std::cout << "Optimizer terminated with an OPTIMAL status." << std::endl;
            break;
        case MDO_INFEASIBLE:
            std::cout << "Optimizer terminated with an INFEASIBLE status." << std::endl;
            std::cout << "Compute IIS." << std::endl;
            model.computeIIS(idx_rows, idx_cols);

            std::cout << "Computed IIS has " << idx_rows.size() << " rows and " << idx_cols.size() << " columns." << std::endl;
            std::cout << "Populating IIS." << std::endl;
            for (int i : idx_rows)
            {
                std::cout << "Constraint: " << model.getStrAttrIndex("RowName", i) << std::endl;
            }
            for (int j : idx_cols)
            {
                std::cout << "Variable: " << model.getStrAttrIndex("ColName", j) << std::endl;
            }
            break;
        case MDO_UNBOUNDED:
            std::cout << "Optimizer terminated with an UNBOUNDED status." << std::endl;
            break;
        case MDO_INF_OR_UBD:
            std::cout << "Optimizer terminated with an INFEASIBLE or UNBOUNDED status." << std::endl;
            break;
        }
    }
    catch (MdoException & e)
    {
        std::cerr << "===================================" << std::endl;
        std::cerr << "Error   : code <" << e.getResult() << ">" << std::endl;
        std::cerr << "Reason  : " << model.explainResult(e.getResult()) << std::endl;
        std::cerr << "===================================" << std::endl;

        return static_cast<int>(e.getResult());
    }

    return static_cast<int>(MDO_OKAY);
}

5.4.3. Python API: compute_iis

首先，参考 Python 的建模与优化 中的方法创建优化问题并设置参数：

        # Step 2. Input model.
        # Change to minimization problem.
        model.set_int_attr(MDO_INT_ATTR.MIN_SENSE, 1)

        # Add variables.
        # Note that the nonzero elements are inputted in a column-wise order here.
        x = []
        x.append(model.add_var(0.0, MDO_INFINITY, 0.0, None, "x0", False))
        x.append(model.add_var(0.0, MDO_INFINITY, 0.0, None, "x1", False))
        x.append(model.add_var(0.0, MDO_INFINITY, 0.0, None, "x2", False))
        x.append(model.add_var(5.0, MDO_INFINITY, 0.0, None, "x3", False))
        x.append(model.add_var(0.0,          2.0, 0.0, None, "x4", False))

        # Add constraints.
        # Note that the nonzero elements are inputted in a row-wise order here.
        conss = []
        conss.append(model.add_cons(-0.5 * x[0]       + x[1]                     >= 0.5,  "c0"))
        conss.append(model.add_cons( 2.0 * x[0]       - x[1]                     >= 3.0,  "c1"))
        conss.append(model.add_cons( 3.0 * x[0]       + x[1]                     <= 6.0,  "c2"))
        conss.append(model.add_cons(                          3.0 * x[3] - x[4]  <= 2.0,  "c3"))
        conss.append(model.add_cons(       x[0]                          + x[4]  <= 10.0, "c4"))
        conss.append(model.add_cons(       x[0] + 2.0 * x[1]      + x[3]         <= 14.0, "c5"))
        conss.append(model.add_cons(       x[1] +                   x[3]         >= 1.0,  "c6"))        

接下来，当优化问题不可行时，使用 mindoptpy.MdoModel.compute_iis() 获取不可约不可行子系统的行列坐标，并打印对应的约束名与变量名：

        status_code, status_msg = model.get_status()
        if status_msg == "INFEASIBLE":
            print("Optimizer terminated with an MDO_INFEASIBLE status (code {0}).".format(status_code))
            print("Compute IIS.")
            idx_rows, idx_cols = model.compute_iis()

            print("Computed IIS has {0} rows and {1} columns.".format(len(idx_rows), len(idx_cols)))
            print("Populating IIS.")
            for i in idx_rows:
                print("Constraint: {0}".format(conss[i].get_str_attr("RowName")))
            for j in idx_cols:
                print("Variable: {0}".format(x[j].get_str_attr("ColName")))

mdo_lo_iis.py 提供了完整源代码：

"""
/**
 *  Description
 *  -----------
 *
 *  Linear optimization.
 *   - Compute IIS of an infeasible problem.
 * 
 *  Formulation
 *  -----------
 *
 *  Minimize
 *  Obj:
 *  Subject To
 *  c0:  -0.500000000 x0 + x1 >= 0.500000000
 *  c1:  2 x0 - x1 >= 3
 *  c2:  3 x0 + x1 <= 6
 *  c3:  3 x3 - x4 <= 2 <- conflit with variable bounds below!
 *  c4:  x0 + x4 <= 10
 *  c5:  x0 + 2 x1 + x3 <= 14
 *  c6:  x1 + x3 >= 1
 *  Bounds
 *   5 <= x3
 *   0 <= x4 <= 2
 *  End
 */
"""
from mindoptpy import *


if __name__ == "__main__":

    MDO_INFINITY = MdoModel.get_infinity()

    # Step 1. Create a model and change the parameters.
    model = MdoModel()
    # Turn-off the presolver so that solver won't terminate with an MDO_INF_OR_UBD status.
    model.set_int_param(MDO_INT_PARAM.PRESOLVE, 0)
    model.set_int_param(MDO_INT_PARAM.METHOD, 1)

    try:
        # Step 2. Input model.
        # Change to minimization problem.
        model.set_int_attr(MDO_INT_ATTR.MIN_SENSE, 1)

        # Add variables.
        # Note that the nonzero elements are inputted in a column-wise order here.
        x = []
        x.append(model.add_var(0.0, MDO_INFINITY, 0.0, None, "x0", False))
        x.append(model.add_var(0.0, MDO_INFINITY, 0.0, None, "x1", False))
        x.append(model.add_var(0.0, MDO_INFINITY, 0.0, None, "x2", False))
        x.append(model.add_var(5.0, MDO_INFINITY, 0.0, None, "x3", False))
        x.append(model.add_var(0.0,          2.0, 0.0, None, "x4", False))

        # Add constraints.
        # Note that the nonzero elements are inputted in a row-wise order here.
        conss = []
        conss.append(model.add_cons(-0.5 * x[0]       + x[1]                     >= 0.5,  "c0"))
        conss.append(model.add_cons( 2.0 * x[0]       - x[1]                     >= 3.0,  "c1"))
        conss.append(model.add_cons( 3.0 * x[0]       + x[1]                     <= 6.0,  "c2"))
        conss.append(model.add_cons(                          3.0 * x[3] - x[4]  <= 2.0,  "c3"))
        conss.append(model.add_cons(       x[0]                          + x[4]  <= 10.0, "c4"))
        conss.append(model.add_cons(       x[0] + 2.0 * x[1]      + x[3]         <= 14.0, "c5"))
        conss.append(model.add_cons(       x[1] +                   x[3]         >= 1.0,  "c6"))        

        # Step 3. Solve the problem and populate the result.
        model.solve_prob()
        model.display_results()

        status_code, status_msg = model.get_status()
        if status_msg == "INFEASIBLE":
            print("Optimizer terminated with an MDO_INFEASIBLE status (code {0}).".format(status_code))
            print("Compute IIS.")
            idx_rows, idx_cols = model.compute_iis()

            print("Computed IIS has {0} rows and {1} columns.".format(len(idx_rows), len(idx_cols)))
            print("Populating IIS.")
            for i in idx_rows:
                print("Constraint: {0}".format(conss[i].get_str_attr("RowName")))
            for j in idx_cols:
                print("Variable: {0}".format(x[j].get_str_attr("ColName")))
        else:
            print("Optimizer terminated with a(n) {0} status (code {1}).".format(status_msg, status_code))

    except MdoError as e:
        print("Received Mindopt exception.")
        print(" - Code          : {}".format(e.code))
        print(" - Reason        : {}".format(e.message))
    except Exception as e:
        print("Received exception.")
        print(" - Explanation   : {}".format(e))
    finally:
        # Step 4. Free the model.
        model.free_mdl()