Week 11: Multi-Criteria Decision Making & Goal Programming

This week’s big question: real decisions almost never have a single number to maximize. You care about cost and quality and time and space, goals that pull against each other. How do you turn several competing criteria into one defensible choice?

Before the week

Read: Taylor, Introduction to Management Science (13e): Chapter 9, “Multicriteria Decision Making,” pp. 443–469 (focus: goal programming with deviation variables, and weighted / AHP-style scoring). What we call weighted scoring the book files under “Scoring Models” on p. 467.
Warm-up self-check, weighted averages and comparing scores on different scales:

Session 1: Mon, Nov 2 · Scoring across many criteria (TBD)

🧩 Puzzle

The nonprofit’s new office. A small nonprofit is choosing among three office sites and cares about three things: monthly cost (cheaper is better), access to public transit (higher is better), and usable space (more is better). Site A is cheap but cramped, Site C is roomy and well-connected but pricey, and Site B sits in the middle. No site wins on everything, so which one do you pick?

Build the skill 1: put every criterion on the same 0–1 scale

The trouble is that cost is in dollars, access is a 1–10 rating, and space is in square meters. You can’t add them directly. So first normalize each criterion onto a common 0–1 scale, where 1 = best and 0 = worst for that criterion. For a “higher is better” criterion like space, the biggest value maps to 1; for a “lower is better” criterion like cost, the smallest value maps to 1. The standard recipe is min–max: take $(value - \min) / (\max - \min)$, then flip it to $1 -$ that for a lower-is-better criterion. With three sites scored as Cost (120, 90, 150), Access (8, 6, 9), and Space (40, 30, 55):

Cost (lower better): A $\to$ 0.5, B $\to$ 1.0, C $\to$ 0.0
Access (higher better): A $\to$ 0.67, B $\to$ 0.0, C $\to$ 1.0
Space (higher better): A $\to$ 0.4, B $\to$ 0.0, C $\to$ 1.0

Now every number lives on the same ruler and the criteria are finally comparable.

Build the skill 2: weight, sum, and watch the winner flip

Not every criterion matters equally, so attach a weight that sums to 1 across the criteria, multiply each normalized score by its weight, and add them up to a single weighted score for each site. With weights Cost 0.5, Access 0.3, Space 0.2 the totals come out close:

Site A $= 0.5(0.5) + 0.3(0.67) + 0.2(0.4) \approx \mathbf{0.53}$
Site B $= 0.5(1.0) + 0.3(0.0) + 0.2(0.0) = \mathbf{0.50}$
Site C $= 0.5(0.0) + 0.3(1.0) + 0.2(1.0) = \mathbf{0.50}$

So Site A wins, but only barely. Drag the weight sliders and watch the ranking: nudge weight toward Space or Access and the winner flips to Site C; lean harder on Cost and Site B takes over.

That fragility is the lesson: when scores are this close, the “winner” is really a statement about your weights, not an objective fact about the sites.

A second, simpler way to score (Taylor’s scoring model). Min–max normalization is one option, but the textbook’s everyday scoring model skips it: a team just grades each option 0–100 on each criterion (their own honest judgment) and uses weights that sum to 1, so $\text{score}_i = \sum_j w_j\, g_{ij}$ with $w_j \in [0,1]$ and $g_{ij}$ a 0–100 grade. Say a food cart is picking among three street spots on foot traffic (weight 0.35), rent (0.30), visibility (0.20), and permit ease (0.15). Grade Spot A as 80/60/70/90: its score is $0.35(80)+0.30(60)+0.20(70)+0.15(90) = \mathbf{73.5}$. Spot B (70/80/60/70) scores 71.0 and Spot C (90/50/85/60) scores 72.5, so Spot A wins. This is faster than normalizing and is what most real scorecards use, but the grades are pure judgment, which is exactly why you must disclose your method: min–max and “grade it 0–100” can crown different winners from the same situation.

Where the weights come from: AHP

Both methods above just assert the weights. Cost 0.5, Access 0.3, Space 0.2, as if they fell from the sky. The Analytic Hierarchy Process (AHP) earns them instead, from a string of simple pairwise comparisons. You only ever answer one question at a time: “comparing just these two, how much more do I prefer this one?”, scored on Taylor’s 1–9 preference scale, where $1$ is equally preferred, $5$ strongly, $9$ extremely, and the reciprocal ($1/5$) records the case where the other option wins.

Fill one such matrix per criterion, normalize each column by its column sum, then average each row. That row average is the alternatives’ preference vector on that criterion, and it sums to 1. Run the same exercise once more to weight the criteria against each other, and combine exactly as in Build the skill 2: weight × score, summed. Every number is now earned from a comparison rather than asserted, which is what makes the weights defensible, and AHP can even check its own coherence with a consistency measure.

Taylor works the whole method through, matrix by matrix, in ch. 9. Read it there. Wednesday goes to goal programming, which is where the modelling work in this week actually sits.

In practice: a single score hides the judgment calls

Weights are subjective. Cost 0.5 versus Cost 0.4 is a value judgment, not a measurement. Always do a sensitivity check, slide the weights and see whether your winner survives. If it flips easily, say so.
Normalization choice changes the ranking. Min–max (used here), divide-by-max, z-scores, or Taylor’s raw 0–100 grading can each crown a different alternative from the same situation. Pick one method and disclose it so reviewers can argue about the method, not just the result.
Are your comparisons even self-consistent? AHP’s signature check: if you say “V1 is strongly better than V2, and V2 strongly better than V3, but V3 is only slightly worse than V1,” your judgments contradict each other. AHP measures this with a consistency ratio (rule of thumb: keep it under about 0.10); a high ratio means redo the comparisons. Ad-hoc weights have no such alarm, which is part of why AHP is more defensible.
Beware false precision. “Site A scored 0.531” looks authoritative, but a 0.53-vs-0.50 gap can vanish if one rating shifts by a point. Report the close calls instead of hiding them behind a decimal.

Back to the puzzle

At the stated weights the nonprofit should lean toward Site A, it edges out the others at 0.53 versus 0.50 each. But the honest recommendation is “A wins narrowly, and if we value space or transit access even a little more, C becomes the better choice.” The weighted-scoring model didn’t make the decision for them; it made the trade-off visible so the board can argue about weights instead of arguing past each other. And if the board distrusts those round-number weights, AHP gives them a way to build the weights up from comparisons they actually believe.

In-class group practice (wrap-up)

To close Session 1, score a set of alternatives by hand in your group. Write your group’s names on the sheet and hand it to your TA before you leave. It counts toward participation.

Download: Week 11 group practice (Word)

Session 2: Wed, Nov 4 · Goal programming (TBD)

🧩 Puzzle

The community bakery. A volunteer co-op bakes $x$ loaves of bread and $y$ trays of muffins each day and has four things it wants. Keep the volunteers busy, hit a revenue target, not blow through its flour, and avoid overtime. These pull against each other: baking more raises revenue but burns volunteer hours and flour. What do you do when you can’t hit every target exactly, and some targets matter more than others?

Build the skill 1: turn “soft” targets into deviation variables

In ordinary linear programming you maximize one objective subject to hard constraints. But here the targets are goals, not iron rules. Falling \$40 short of revenue isn’t infeasible, it’s just disappointing. Goal programming captures that by attaching two deviation variables to each goal: $d^{+},d^{-}$ for how much you overshoot and undershoot the target, respectively. Each goal becomes an equation. For the bakery, with bread at \$6 and muffin trays at \$20, the revenue goal of \$900/day and the 80-lb flour cap (a loaf uses 1 lb, a tray 0.75 lb) become

\[6x + 20y + d^{-}_{\text{rev}} - d^{+}_{\text{rev}} = 900, \qquad x + 0.75y + d^{-}_{\text{flour}} - d^{+}_{\text{flour}} = 80.\]

There is one structural rule worth saying out loud: in any goal constraint at least one of $d^{+}$ and $d^{-}$ must be zero, you cannot simultaneously overshoot and undershoot the same target. Drag the production plan below and watch which goals a given $(x, y)$ meets or misses, the gap you see is the deviation:

The widget reports each plan as goals met / missed (never “infeasible”. A missed goal is just a nonzero deviation) and shows the three quantity goals; the P4 overtime goal is the $d^{+}$ companion of the P1 hours goal. Try the plan (50, 30): hours are $0.5(50)+0.4(30) = 37 \ge 32$, revenue is $6(50)+20(30) = 900$ (exactly on target) and flour is $50 + 0.75(30) = 72.5 \le 80$, comfortably under the cap. All three shown goals are met, so their deviations are zero.

Build the skill 2: rank the goals and minimize only the deviations you do not want

Instead of maximizing revenue, goal programming minimizes the unwanted deviations. The trick is naming, for each goal, which direction is “bad”:

Goal type	Example	Undesired deviation	You minimize
at-least (reach a floor)	revenue $\ge$ \$900	undershoot	$d^{-}$
at-most (stay under a cap)	flour $\le$ 80 lb	overshoot	$d^{+}$

When goals conflict, preemptive (priority) goal programming ranks them and writes a lexicographic objective. Satisfy Priority 1 as well as possible, then, without sacrificing it, work on Priority 2, and so on. Listing all four bakery goals in priority order:

P1: keep at least 32 volunteer-hours busy (a loaf needs 0.5 hr, a tray 0.4 hr): minimize $d^{-}_{\text{hrs}}$
P2: reach the revenue goal: minimize $d^{-}_{\text{rev}}$
P3: use no more than 80 lb of flour: minimize $d^{+}_{\text{flour}}$
P4: minimize overtime past the volunteer hours: minimize $d^{+}_{\text{hrs}}$

The lexicographic objective is then written with priority symbols $P_1, P_2, \dots$:

\[\min\; \big(\,P_1\, d^{-}_{\text{hrs}},\;\; P_2\, d^{-}_{\text{rev}},\;\; P_3\, d^{+}_{\text{flour}},\;\; P_4\, d^{+}_{\text{hrs}}\,\big).\]

How to read it: each $P_k$ term is the undesired deviation for that goal: an undershoot $d^{-}$ for an at-least goal, an overshoot $d^{+}$ for an at-most goal, and the optimizer drives them down strictly in priority order.

Build the skill 3: when goals tie, weight them instead of ranking them

Preemptive ranking says Priority 1 is untouchable: no amount of Priority-2 gain may cost it anything. That is often too rigid. Sometimes two goals genuinely sit at the same level and you are willing to trade one against the other. That is non-preemptive, or weighted, goal programming, and it is the other half of Taylor’s treatment.

Put revenue shortfall and flour overage both at Priority 2. Instead of ranking them you attach weights inside the level:

\[P_2\big(2\,d^{-}_{\text{rev}} + 1\,d^{+}_{\text{flour}}\big).\]

The 2-to-1 ratio says a dollar of missed revenue hurts twice as much as a pound of wasted flour, so the optimizer will happily waste two pounds of flour to recover one dollar of revenue, but not the reverse. Two things are worth being precise about. The weights trade goals off only within that level: they never let either goal eat into Priority 1, because distinct priority levels stay strictly preemptive. And the ratio is a judgment, not a measurement. Nothing in the data says revenue is twice as important as flour; somebody decided that, and a different pair of weights can return a different plan.

The practical rule: rank when the goals are genuinely not comparable (safety before convenience), and weight when they are (two budget lines you would happily trade at a stated rate).

In practice: priorities are politics, not just math

Priorities encode whose goal wins. Calling volunteer hours “P1” and overtime “P4” is an organizational choice: the model faithfully executes it, but the ranking itself came from people, not data.
Goal-programming answers are satisfactory, not optimal. This is the key expectation to set: a goal program does not find a single “best” point the way LP does. It finds the most satisfactory plan given the priorities, a result called satisficing. Telling a director “this is the best satisfactory plan, not the mathematical optimum” is honest and correct.
Within-level weights (and the priorities themselves) are judgments too. A 2-to-1 penalty ratio says missing revenue is “twice as bad” as wasting flour when both goals share a priority level. Re-run with a different ratio or a different priority order and the recommended plan can shift, so test a few.
The model isn’t the world. Deviation variables assume every miss is equally costly per unit. Real life has thresholds (you cannot bake half a volunteer; a health-code flour limit is hard, not soft) that a smooth penalty misses.

Back to the puzzle

The bakery reframes its day as four ranked goals and lets the optimizer honor them in order: first get the volunteers to 32 hours (minimize $d^{-}_{\text{hrs}}$), then chase the \$900 (minimize $d^{-}_{\text{rev}}$), then keep flour under 80 lb (minimize $d^{+}_{\text{flour}}$), and only last shave overtime. No single number got maximized; instead the co-op gets a plan that satisfies its goals in the order it actually cares about them, and it can read off exactly which lower-priority goals it had to give up to protect the higher ones.

After-class check

Questions spanning weighted scoring and AHP (compute totals, read a pairwise matrix), weight sensitivity, and goal programming (deviation variables, the at-least/at-most → undesired-deviation mapping, and priorities). Retry freely; nothing is submitted.

Weekly take-home (graded: submit on Canvas)

Everything for the take-home goes in one Excel workbook, and it works the same three contractor bids through both of this week’s methods. A city is replacing bus shelters, and one contractor’s safety rating comes from a different auditor on a different scale, so the raw scores cannot be compared until you normalize them. You choose and justify the weights, test how far the cost weight can move before the ranking flips, and check whether the committee’s AHP pairwise judgments were even consistent enough to use. Then the same bids become a goal program against two published commitments (a spending cap and a minimum number of shelters) and you solve it under both preemptive priority orders, where the answer changes. Two short responses plus the required AI-use disclosure go on the Free responses sheet. Upload the completed .xlsx on Canvas. That one file is your entire submission.