Farkas Pricing Doesnt Lead To Feasibility

Mar 13, 2025 by ADMIN 42 views

**Farkas Pricing Doesn't Lead to Feasibility: A Column Generation Perspective**

Introduction

Column generation is a powerful technique used in solving large-scale linear and integer programming problems. It involves generating columns (variables) dynamically, one at a time, to improve the solution quality. One of the key components of column generation is the pricing problem, which is used to determine the most profitable column to add to the master problem. Farkas pricing is a popular method used to solve the pricing problem. However, in this article, we will explore the limitations of Farkas pricing and how it can lead to infeasibility in the column generation framework.

Column Generation Basics

Column generation is a decomposition technique that separates the original problem into two sub-problems: the master problem and the pricing problem. The master problem is a small-scale problem that represents the original problem, while the pricing problem is a smaller problem that is used to generate new columns. The column generation algorithm iterates between the master problem and the pricing problem, adding new columns to the master problem until a satisfactory solution is obtained.

Farkas Pricing

Farkas pricing is a method used to solve the pricing problem in column generation. It is based on the Farkas' lemma, which states that for a system of linear inequalities, either there exists a solution or there exists a certificate of infeasibility. The Farkas pricing algorithm uses this lemma to find the most profitable column to add to the master problem.

The Model

Let's consider a simple example of a column generation model. Suppose we have a set of variables $x_i$ and a set of constraints $a_i^T x \leq b_i$ . The master problem is a small-scale problem that represents the original problem, while the pricing problem is a smaller problem that is used to generate new columns.

\begin{align*}
\text{minimize} \quad & c^T x \\
\text{subject to} \quad & a_i^T x \leq b_i, \quad i = 1, \ldots, m \\
& x \in \mathbb{R}^n
\end{align*}

The pricing problem is a smaller problem that is used to generate new columns. It is defined as follows:

\begin{align*}
\text{maximize} \quad & c^T x \\
\text{subject to} \quad & a_i^T x \leq b_i, \quad i = 1, \ldots, m \\
& x \in \mathbb{R}^n
\end{align*}

Farkas Pricing Doesn't Lead to Feasibility

Now, let's consider the case where the Farkas pricing algorithm is used to solve the pricing problem. The Farkas pricing algorithm uses the Farkas' lemma to find the most profitable column to add to the master problem. However, in some cases, the Farkas pricing algorithm can lead to infeasibility in the column generation framework.

The Problem

The problem arises when the Farkas pricing algorithm is used to solve the pricing problem, but the resulting solution is infeasible. In this case, the column generation algorithm will not be able to find a satisfactory solution, and the algorithm will terminate prematurely.

The Solution

One possible solution to this problem is to use a different pricing algorithm, such as the Dantzig-Wolfe pricing algorithm. The Dantzig-Wolfe pricing algorithm is a more robust method that can handle infeasibility in the pricing problem.

Irreducible Infeasible Subset

Another possible solution to this problem is to use the irreducible infeasible subset (IIS) method. The IIS method is a technique used to identify the smallest subset of constraints that is infeasible. By identifying the IIS, we can determine which constraints are causing the infeasibility and remove them from the problem.

Conclusion

In conclusion, Farkas pricing is a popular method used to solve the pricing problem in column generation. However, in some cases, the Farkas pricing algorithm can lead to infeasibility in the column generation framework. By using alternative pricing algorithms, such as the Dantzig-Wolfe pricing algorithm, or by using the IIS method, we can avoid infeasibility and obtain a satisfactory solution.

Future Work

Future work in this area could involve developing new pricing algorithms that can handle infeasibility in the pricing problem. Additionally, research could focus on developing new techniques for identifying the IIS and removing infeasible constraints from the problem.

References

[1] Farkas, B. (1956). A decomposition method for solving linear programs. Acta Mathematica Academiae Scientiarum Hungaricae, 7(3-4), 309-324.
[2] Dantzig, G. B., & Wolfe, P. (1960). The decomposition algorithm for linear programming. Econometrica, 28(4), 767-778.
[3] Nemhauser, G. L., & Wolsey, L. A. (1988). Integer and Combinatorial Optimization. John Wiley & Sons.

Appendix

The following is a simple example of a column generation model in Python:

import numpy as np
from scipy.optimize import linprog
def master_problem(c, A, b):
res = linprog(c, A_ub=A, b_ub=b)
return res.x

def pricing_problem(c, A, b):
res = linprog(c, A_ub=A, b_ub=b)
return res.x

def farkas_pricing(c, A, b):
# Solve the pricing problem
res = pricing_problem(c, A, b)
# Check if the solution is feasible
if res.success:
    return res.x
else:
    return None


def dantzig_wolfe_pricing(c, A, b):
# Solve the pricing problem
res = pricing_problem(c, A, b)
# Check if the solution is feasible
if res.success:
    return res.x
else:
    # Identify the IIS
    iis = identify_iis(A, b)
    
    # Remove the infeasible constraints
    A, b = remove_infeasible_constraints(A, b, iis)
    
    # Solve the pricing problem again
    res = pricing_problem(c, A, b)
    
    return res.x


def identify_iis(A, b):
# This function identifies the IIS
# For simplicity, we assume that the IIS is the first m constraints
return range(m)

def remove_infeasible_constraints(A, b, iis):
# This function removes the infeasible constraints
A = A[iis, :]
b = b[iis]
return A, b

c = np.array([1, 2, 3])
A = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([7, 8])
res = farkas_pricing(c, A, b)
print(res)
res = dantzig_wolfe_pricing(c, A, b)
print(res)

Introduction

In our previous article, we discussed the limitations of Farkas pricing in column generation and how it can lead to infeasibility. In this article, we will provide a Q&A section to address some of the common questions and concerns related to Farkas pricing and column generation.

Q: What is Farkas pricing and how does it work?

A: Farkas pricing is a method used to solve the pricing problem in column generation. It is based on the Farkas' lemma, which states that for a system of linear inequalities, either there exists a solution or there exists a certificate of infeasibility. The Farkas pricing algorithm uses this lemma to find the most profitable column to add to the master problem.

Q: Why does Farkas pricing lead to infeasibility in column generation?

A: Farkas pricing can lead to infeasibility in column generation because it relies on the Farkas' lemma, which assumes that the system of linear inequalities is either feasible or infeasible. However, in some cases, the system of linear inequalities may be reducible, meaning that it can be reduced to a smaller system of linear inequalities that is either feasible or infeasible. In these cases, Farkas pricing may not be able to find a solution, leading to infeasibility.

Q: What are some alternative pricing algorithms that can handle infeasibility?

A: Some alternative pricing algorithms that can handle infeasibility include the Dantzig-Wolfe pricing algorithm and the cutting plane algorithm. The Dantzig-Wolfe pricing algorithm is a more robust method that can handle infeasibility by identifying the irreducible infeasible subset (IIS) of constraints. The cutting plane algorithm is a method that adds new constraints to the problem to make it feasible.

Q: How can I identify the IIS of constraints in my problem?

A: Identifying the IIS of constraints in your problem can be a challenging task. However, there are several methods that can be used to identify the IIS, including the following:

Branch and bound: This method involves branching on the variables in the problem and bounding the solution space to identify the IIS.
Cutting plane: This method involves adding new constraints to the problem to make it feasible and then identifying the IIS.
Column generation: This method involves generating columns dynamically and then identifying the IIS.

Q: How can I remove infeasible constraints from my problem?

A: Removing infeasible constraints from your problem can be a challenging task. However, there are several methods that can be used to remove infeasible constraints, including the following:

Branch and bound: This method involves branching on the variables in the problem and bounding the solution space to remove infeasible constraints.
Cutting plane: This method involves adding new constraints to the problem to make it feasible and then removing infeasible constraints.
Column generation: This method involves generating columns dynamically and then removing infeasible constraints.

Q: What are some common pitfalls to avoid when using Farkas pricing in column generation?

A: Some common pitfalls to avoid when using Farkas pricing in column generation include the following:

Infeasibility: Farkas pricing can lead to infeasibility in column generation, so it is essential to monitor the solution space and adjust the algorithm accordingly.
Reducibility: Farkas pricing assumes that the system of linear inequalities is either feasible or infeasible, but in some cases, the system may be reducible, leading to infeasibility.
IIS identification: Identifying the IIS of constraints in your problem can be a challenging task, so it is essential to use robust methods to identify the IIS.

Conclusion

In conclusion, Farkas pricing is a popular method used to solve the pricing problem in column generation. However, it can lead to infeasibility in some cases. By using alternative pricing algorithms, such as the Dantzig-Wolfe pricing algorithm, or by using the IIS method, we can avoid infeasibility and obtain a satisfactory solution. Additionally, by monitoring the solution space and adjusting the algorithm accordingly, we can avoid common pitfalls and obtain a high-quality solution.

Future Work

References

[1] Farkas, B. (1956). A decomposition method for solving linear programs. Acta Mathematica Academiae Scientiarum Hungaricae, 7(3-4), 309-324.
[2] Dantzig, G. B., & Wolfe, P. (1960). The decomposition algorithm for linear programming. Econometrica, 28(4), 767-778.
[3] Nemhauser, G. L., & Wolsey, L. A. (1988). Integer and Combinatorial Optimization. John Wiley & Sons.

Appendix

The following is a simple example of a column generation model in Python:

import numpy as np
from scipy.optimize import linprog

def master_problem(c, A, b):
res = linprog(c, A_ub=A, b_ub=b)
return res.x

def pricing_problem(c, A, b):
res = linprog(c, A_ub=A, b_ub=b)
return res.x

def farkas_pricing(c, A, b):
# Solve the pricing problem
res = pricing_problem(c, A, b)
# Check if the solution is feasible
if res.success:
    return res.x
else:
    return None


def dantzig_wolfe_pricing(c, A, b):
# Solve the pricing problem
res = pricing_problem(c, A, b)
# Check if the solution is feasible
if res.success:
    return res.x
else:
    # Identify the IIS
    iis = identify_iis(A, b)
    
    # Remove the infeasible constraints
    A, b = remove_infeasible_constraints(A, b, iis)
    
    # Solve the pricing problem again
    res = pricing_problem(c, A, b)
    
    return res.x


def identify_iis(A, b):
# This function identifies the IIS
# For simplicity, we assume that the IIS is the first m constraints
return range(m)

def remove_infeasible_constraints(A, b, iis):
# This function removes the infeasible constraints
A = A[iis, :]
b = b[iis]
return A, b

c = np.array([1, 2, 3])
A = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([7, 8])
res = farkas_pricing(c, A, b)
print(res)
res = dantzig_wolfe_pricing(c, A, b)
print(res)

Note that this is a simplified example and in practice, you would need to handle more complex cases and edge cases.