PuLP Documentation

Solving an optimization problem with PuLP follows a non-linear process that can be broken down into five general steps. PuLP acts as a 'shortcut' by allowing you to formulate the mathematical program directly in Python, which can then be passed to various solvers (e.g., CPLEX, COIN, gurobi) without manually entering the program into solver-specific software.

The 5 Steps of Optimization:

1. Getting the problem description: Moving from an abstract description to a formal, rigorous model description.
2. Formulating the mathematical program: Translating the problem into math. This involves:
   • Identifying Decision Variables (quantifiable decisions).
   • Formulating the Objective Function (minimizing or maximizing a goal, like cost or profit).
   • Formulating Constraints (logical or explicit restrictions expressed via decision variables).
   • Identifying Data (the 'hard numbers' for variable bounds and coefficients).
3. Solving the mathematical program: Using algorithms (like Revised Simplex or Interior Point Methods) or heuristics to find an optimal or near-optimal solution.
4. Performing post-optimal analysis: Examining the robustness of the solution by testing how changes in data (e.g., increasing costs) affect the outcome.
5. Presenting the solution and analysis: Translating mathematical results back into actionable business decisions for stakeholders.

PuLP allows access to the official solver's native API objects through the prob.solverModel attribute. This attribute is populated when buildSolverModel() is executed (usually during prob.solve()). This is useful for accessing advanced features like dual prices, extreme rays, or specific solver parameters not exposed by PuLP.

Example: Accessing OR-Tools CpModel:

import pulp
prob = pulp.LpProblem("name", pulp.LpMinimize)
x = prob.add_variable("x", lowBound=0)
prob += x
status = prob.solve(pulp.CPSAT(msg=False))
model = prob.solverModel  # This is an ortools.sat.python.cp_model.CpModel

Example: Accessing CPLEX API before solving: You can use lower-level methods to manipulate the solver model before the actual solve call:

import pulp
prob = pulp.LpProblem('name', pulp.LpMinimize)
x = prob.add_variable('x', lowBound=0)
prob += x

solver = pulp.CPLEX_PY()
solver.buildSolverModel(prob)
# Edit the object before solving (e.g., loading MIP starts)
solver.solverModel.MIP_starts.read(SOME_MST_FILE)
# Solve and then fill PuLP variables
solver.callSolver(prob)
status = solver.findSolutionValues(prob)

import pulp
prob = pulp.LpProblem("name", pulp.LpMinimize)
x = prob.add_variable("x", lowBound=0)
prob += x
status = prob.solve(pulp.CPSAT(msg=False))
prob.solverModel  # ortools.sat.python.cp_model.CpModel

When calling orloge.get_info_log_solver, the returned dictionary contains the following structured data:

• best_bound: The best lower bound found.
• best_solution: The best objective value found.
• cut_info: A dictionary containing best_bound, best_solution, time, and a cuts dictionary (e.g., counts for Clique, Gomory, Implied bound, MIR).
• first_relaxed: The first relaxed objective value.
• first_solution: The first solution objective value.
• gap: The optimality gap.
• matrix: Information about the original matrix (constraints, nonzeros, variables).
• matrix_post: Information about the matrix after presolve.
• nodes: Number of nodes explored.
• presolve: Details on presolve performance (cols, rows, time).
• progress: A pandas.DataFrame containing the step-by-step solver progress (e.g., Node, NodesLeft, Objective, Depth, Gap, Time).
• rootTime: Time spent at the root node.
• sol_code: Solver solution code.
• solver: The name of the solver used.
• status: Human-readable status string.
• status_code: Numerical status code.
• time: Total execution time.
• version: Solver version.

# Example of the dictionary structure returned by orloge
{
    'best_bound': -41.0,
    'best_solution': -41.0,
    'cut_info': {
                 'best_bound': -167.97894,
                 'best_solution': -41.0,
                 'cuts': {'Clique': 1, 'Gomory': 16, 'Implied bound': 23, 'MIR': 22},
                 'time': 21.0
                },
    'first_relaxed': -178.94318,
    'first_solution': -41.0,
    'gap': 0.0,
    'matrix': {'constraints': 53467, 'nonzeros': 199175, 'variables': 26871},
    'matrix_post': {'constraints': 35616, 'nonzeros': 149085, 'variables': 22010},
    'nodes': 526.0,
    'presolve': {'cols': 4861, 'rows': 17851, 'time': 3.4},
    'progress': <pandas.DataFrame>,
    'rootTime': 0.7,
    'sol_code': 1,
    'solver': 'GUROBI',
    'status': 'Optimal solution found',
    'status_code': 1,
    'time': 46.67,
    'version': '7.0.0'
}