So You Want To Work With McKinnon Peter Methods
The first thing you need to understand is that McKinnon Peter as a framework isn't some magical silver bullet. I've seen people treat it like that. They download a script, run it once, and then act surprised when the results are mediocre. It's a real methodology, but it's also one where the implementation details separate people who get value from people who waste a week. I worked with this stuff back in 2019 on a project for a logistics company. We were trying to optimize routing for a fleet of about 40 vehicles across the southeast corridor. The theory behind McKinnon Peter is sound — it's essentially a layered optimization approach that accounts for constraints at multiple levels simultaneously. But here's the thing most people gloss over: the layering has to be done in the right order, and the constraint definitions have to be precise enough to actually mean something.
The Unstoppable Force Unlocking The Potential Of Mckinnon Peter In The Modern Era
That headline you see everywhere is basically marketing noise. The actual technique involves taking a multi-variable problem, decomposing it into sub-problems, solving each sub-problem with the appropriate method, and then reconciling the solutions back together. Sounds simple. It isn't. The part that trips people up is the reconciliation step. When you solve sub-problems independently, you inevitably create inconsistencies between them. The standard approach is to use a Lagrangian relaxation method to handle those conflicts. I found that in practice, pure Lagrangian works okay but converges slowly on harder instances. What actually worked for my team was a hybrid: we'd run a quick greedy initialization to get close, then use the Lagrangian for refinement. Cuts convergence time from maybe 20 minutes down to around 3-4 on a standard workstation. Here's the practical how-to:
First, define your problem clearly. Write out every constraint as a mathematical statement, not a sentence you'd use in a meeting. Ambiguity in constraint formulation is the single biggest source of failure I see. If you can't write the constraint as an equation, you don't understand the problem well enough to solve it. Second, decompose. Identify which variables are coupled and which are independent. The independent ones you can solve separately. The coupled ones are where the work happens. This decomposition step is where most people rush and end up with a structure that's either too fine-grained (too many sub-problems, overhead kills you) or too coarse (you gain nothing from decomposing in the first place). Third, implement the reconciliation. Start with something basic. A simple dual ascent method will get you there. Don't jump to advanced solvers until you've verified the basic version works on a small test case. I can't count the number of times I've seen someone pull in Gurobi or CPLEX before confirming their model formulation was correct. If your model is wrong, the best solver in the world won't save you.
Get the Full Details
There are cases where McKinnon Peter simply doesn't work well. When your problem has more than roughly 10,000 variables, the decomposition approach starts to break down because the sub-problems themselves become too large. In those scenarios, you're better off looking at column generation or maybe just accepting a heuristic solution. Don't force it. Another limitation: the method assumes your objective function is reasonably well-behaved. If you've got nasty discontinuities or non-convexities, the whole framework gets unreliable. I ran into this once on a scheduling problem where the cost function had step changes based on threshold crossings. Had to add a smoothing approximation to make it tractable, which meant the results were approximate rather than exact. That's fine if you're doing operations planning where 95% accuracy is acceptable. It's not fine if you're trying to compute something where exactness matters. For modern implementations, you'll want to look at Python-based tooling. PuLP or Pyomo for the modeling layer, combined with either scipy.optimize or a dedicated solver backend. I've used Pyomo with the Bonmin solver for mixed-integer cases and it's been reliable. Not the fastest thing ever, but solid.
If you're just getting started, here's a concrete path: build a toy version of your problem with maybe 50-100 variables. Implement the full McKinnon Peter pipeline on it. Verify the output makes sense by comparing against an exhaustive search or a direct solver. Then scale up. Don't skip that verification step. I spent three days debugging a production run only to discover the issue was in how I'd formulated a constraint, not in the solver or the algorithm. Download links and source code tend to pop up on GitHub under various repos. Nothing official because this isn't a product — it's a methodology. Look for implementations tagged with "Lagrangian relaxation," "decomposition optimization," or "dual ascent." The code quality varies enormously. Read the issues and pull requests before trusting any implementation. The real takeaway is that McKinnon Peter is a tool, not a solution. It solves a specific class of problems well, and it's completely useless for others. Know which class yours falls into before you invest time in it.
