Agent skill
linear-program-modeler
Mathematical programming skill for formulating and solving linear programming models for resource allocation, production planning, and capacity optimization.
Install this agent skill to your Project
npx add-skill https://github.com/a5c-ai/babysitter/tree/main/library/specializations/domains/science/industrial-engineering/skills/linear-program-modeler
Metadata
Additional technical details for this skill
- author
- babysitter-sdk
- version
- 1.0.0
- category
- operations-research
- backlog id
- SK-IE-001
SKILL.md
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
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
gsd-tools
Central utility skill for GSD operations. Provides config parsing, slug generation, timestamps, path operations, and orchestrates calls to other specialized skills. Acts as the unified entry point that the original gsd-tools.cjs provided via its lib/ modules (commands, config, core, init).
model-profile-resolution
Resolve model profile (quality/balanced/budget) at orchestration start and map agents to specific models. Enables cost/quality tradeoffs by selecting appropriate AI models for each agent role.
verification-suite
Plan structure validation, phase completeness checks, reference integrity verification, and artifact existence confirmation. Provides the structured verification layer ensuring GSD artifacts are well-formed and complete.
state-management
STATE.md reading, writing, and field-level updates. Provides cross-session state persistence via .planning/STATE.md with structured fields for current task, completed phases, blockers, decisions, and quick tasks.
git-integration
Git commit patterns, formats, and conventions for GSD methodology. Provides atomic commits per task, structured commit messages, planning file commits, branch management, and milestone tag operations.
frontmatter-parsing
YAML frontmatter parsing and manipulation for .planning/ documents. Provides read, write, update, query, and validation operations on frontmatter blocks in GSD markdown artifacts.
Didn't find tool you were looking for?