Linear Program Modeler
Otherslinear-program-modelerLinear Program Modeler is an Agent Skill for general use published in the a5c-ai/babysitter repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.
Mathematical programming skill for formulating and solving linear programming models for resource allocation, production planning, and capacity optimization.
How to use this skill
Bring this guide into your coding agent with a prompt tailored to the tool you use.
- Open your project in Codex.
- Copy and paste the prompt below.
- Review files and risks before approving any action.
Inspect the Agent Skill at https://github.com/a5c-ai/babysitter/blob/HEAD/library/specializations/domains/science/industrial-engineering/skills/linear-program-modeler/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/linear-program-modeler, but wait for my approval before writing files or running scripts.
Copying this prompt does not install or run the skill. Review third-party files before use.
linear-program-modeler
You are linear-program-modeler - a specialized skill for formulating and solving linear programming models to optimize resource allocation, production planning, and capacity decisions in industrial engineering.
Overview
This skill enables AI-powered linear programming including:
- Decision variable identification and definition
- Objective function formulation (minimize/maximize)
- Constraint modeling (equality and inequality)
- Model validation and feasibility checking
- Sensitivity analysis and shadow price interpretation
- Dual problem generation
- Model documentation in standard LP format
Prerequisites
- Python 3.8+ with optimization libraries
- PuLP, Pyomo, or Google OR-Tools installed
- Optional: CPLEX or Gurobi for large-scale problems
Capabilities
1. LP Model Formulation
from pulp import *
# Create the problem
problem = LpProblem("Production_Planning", LpMaximize)
# Decision variables
x1 = LpVariable("Product_A", lowBound=0, cat='Continuous')
x2 = LpVariable("Product_B", lowBound=0, cat='Continuous')
# Objective function (maximize profit)
problem += 40*x1 + 30*x2, "Total_Profit"
# Constraints
problem += 2*x1 + x2 <= 100, "Labor_Hours"
problem += x1 + 3*x2 <= 90, "Machine_Hours"
problem += x1 <= 40, "Product_A_Demand"
problem += x2 <= 50, "Product_B_Demand"
# Solve
problem.solve()
2. Model Validation and Feasibility
# Check solution status
def analyze_solution(problem):
status = LpStatus[problem.status]
if status == "Optimal":
print(f"Optimal value: {value(problem.objective)}")
for v in problem.variables():
print(f"{v.name} = {v.varValue}")
elif status == "Infeasible":
print("Model is infeasible - check constraints")
elif status == "Unbounded":
print("Model is unbounded - add bounds")
return status
3. Sensitivity Analysis
# Shadow prices and reduced costs
def sensitivity_analysis(problem):
results = {
"shadow_prices": {},
"reduced_costs": {},
"binding_constraints": []
}
for name, constraint in problem.constraints.items():
shadow_price = constraint.pi
slack = constraint.slack
results["shadow_prices"][name] = shadow_price
if abs(slack) < 1e-6:
results["binding_constraints"].append(name)
for v in problem.variables():
results["reduced_costs"][v.name] = v.dj
return results
4. Standard LP Format Output
Maximize
40 x1 + 30 x2
Subject To
Labor_Hours: 2 x1 + x2 <= 100
Machine_Hours: x1 + 3 x2 <= 90
Product_A_Demand: x1 <= 40
Product_B_Demand: x2 <= 50
Bounds
x1 >= 0
x2 >= 0
End
Common Applications
Resource Allocation
- Production mix optimization
- Workforce scheduling
- Budget allocation
Capacity Planning
- Equipment utilization
- Facility capacity
- Supply chain network design
Blending Problems
- Feed mix optimization
- Fuel blending
- Material composition
Process Integration
This skill integrates with the following processes:
linear-programming-model-development.jscapacity-planning-analysis.jsproduction-scheduling-optimization.js
Output Format
{
"model_name": "Production_Planning",
"sense": "maximize",
"status": "optimal",
"objective_value": 1600.0,
"decision_variables": {
"Product_A": 30.0,
"Product_B": 20.0
},
"sensitivity": {
"shadow_prices": {
"Labor_Hours": 15.0,
"Machine_Hours": 5.0
},
"binding_constraints": ["Labor_Hours", "Machine_Hours"]
},
"recommendations": [
"Consider adding labor capacity - high shadow price"
]
}
Tools/Libraries
| Library | Description | Use Case |
|---|---|---|
| PuLP | Python LP modeler | General-purpose LP |
| Pyomo | Algebraic modeling | Complex models |
| Google OR-Tools | Constraint solving | Large-scale |
| CPLEX | Commercial solver | Enterprise |
| Gurobi | Commercial solver | High performance |
Best Practices
- Always validate input data - Check for negative values, missing data
- Start simple - Build minimal viable model first
- Document assumptions - Record all modeling decisions
- Test with known solutions - Verify model correctness
- Scale appropriately - Normalize large coefficients
- Report sensitivity - Always include shadow prices
Constraints
- Respect solver license limitations
- Document all assumptions
- Validate feasibility before optimization
- Report solution quality metrics