Fair Aggregation: Balancing Utility and Fairness

TL;DR — When a single choice must serve a whole group, you combine each person's satisfaction s_i into one score and pick the highest-scoring option. Three classic rules exist: Average (maximize the mean — but it can abandon one person), Least-Misery (maximize the worst-off — but it settles for bland), and Most-Pleasure (maximize the happiest — deliberately unfair). A tunable middle ground is score = mean(s) - lambda * var(s): reward average satisfaction, subtract a penalty for how unevenly it is spread, and turn the dial lambda to trade utility against fairness. This breaks when satisfactions are not comparable numbers (ordinal-only preferences), when the option set is not fixed, or when "fair" should mean priority by need rather than equality.

---

1. Simple explanation

Sometimes one decision has to cover many people at once: which trip the group takes, which movie the family streams, which time everyone meets. Each person has their own happiness with each option, but only one option can win. Aggregation is the rule that turns "how happy is each person" into "which single option we pick."

The naive rule is to average everyone's happiness and pick the highest average. It sounds fair, but it isn't: an option that thrills the majority and crushes one person can still have the best average. The opposite rule — only protect the least-happy person — never abandons anyone, but it drags the group to a dull, safe choice that nobody is excited about. Real fairness lives between these two, and you want a knob to decide where between them.

Analogy — booking one trip for the whole group. Everyone rates the candidate trips. Average books the adventure trek two friends love and the third with a bad knee can't do — great average, one person sits out. Least-Misery books a gentle city stroll: nobody is excluded, nobody is thrilled. The fair pick looks at both the group's average happiness and how lopsided it is, and picks, say, a relaxed coastal town with optional hikes that keeps the average high and leaves nobody stranded. The knob is how much you personally weight "nobody stranded" against "highest average."

---

2. Diagram

 Satisfaction grid  (rows = options, cols = people; 1.0 = loves it, 0 = hates it)

               Ann    Ben    Cara     mean   min    var
  BeachTrip    0.95   0.90   0.20      0.68   0.20   0.117   <- high mean, Cara abandoned
  SafariLodge  0.60   0.60   0.60      0.60   0.60   0.000   <- everyone equal, nobody thrilled
  IslandTrip   0.75   0.50   0.70      0.65   0.50   0.012   <- high-ish mean AND balanced

 Which option each rule picks:
    AVERAGE      -> BeachTrip     (best mean, ignores Cara at 0.20)
    LEAST-MISERY -> SafariLodge   (best worst-case, but bland)
    MOST-PLEASURE-> BeachTrip     (best single person; unfair)

 The fairness dial:  score = mean - lambda * var
    lambda = 0  |-------------------------------->  pure UTILITY   (= Average)
    lambda small|      pick moves toward balance
    lambda large|-------------------------------->  pure FAIRNESS  (equal shares)

    lambda: 0        1          3          5
    pick:  BeachTrip IslandTrip IslandTrip SafariLodge
           (selfish) (balanced)  (balanced) (equal)

---

3. How it works

3.1 The input: per-person satisfaction

Every method starts from the same thing: a number s_i in [0, 1] for each person i and each candidate option, where 1 means "perfect for me" and 0 means "no good." Where s_i comes from depends on the domain — a star rating, a predicted rating from a recommender, or the cosine similarity between a person's preference vector and an item's feature vector. The aggregation rules below do not care how s_i was produced; they only need the numbers to be cardinal (real values you can average) and comparable across people (your 0.8 means roughly what my 0.8 means). Section 8 returns to what happens when that assumption is shaky.

3.2 The three classic aggregators

These are the standard strategies in group recommendation (Masthoff). For an option with satisfaction list s = [s_1, ..., s_n]:

You then compute the score for every option in the feasible set and take the argmax. Average and Most-Pleasure both reward concentration of happiness; Least-Misery rewards protecting the floor. None of them lets you choose the balance.

3.3 The utility–fairness dial

The fix is to reward high average happiness but subtract a penalty for inequality:

  score(option) = mean(s)  -  lambda * var(s)
                  \_______/    \___________/
                   utility       unfairness

var(s) is the variance of the satisfaction list — a measure of how spread out (unequal) the happiness is. It is 0 when everyone is equally happy and grows as people diverge. lambda >= 0 is the dial:

• lambda = 0 → the penalty vanishes → this is exactly Average (pure utility).
• lambda small → high average, but options that strand someone are penalized.
• lambda large → inequality dominates → the rule pushes toward equal satisfaction for all.

This is the same shape as the mean–variance tradeoff in portfolio theory: there you maximize expected return - lambda * risk, where lambda is your risk aversion. Here "return" is group happiness and "risk" is unfairness. Borrowing that form is why the method is defensible rather than ad hoc.

3.4 Weighting members (optional)

If some members should count more (an organizer, a guest of honor, or — in an interactive setting — someone who has been overruled and deserves more say), attach weights w_i >= 0 with sum(w_i) = 1 and use a weighted mean inside the score:

  score(option) = ( sum_i w_i * s_i )  -  lambda * var(s)

Equal weights w_i = 1/n recover Section 3.3.

Boundary condition — when this stops applying. The whole family assumes s_i values are cardinal and interpersonally comparable, and that the set of options is fixed while you score it. If people can only rank options (ordinal preferences), averaging is meaningless and you should use a voting rule (Borda, Copeland) instead. If "fair" means the person with the greatest need is served first (triage, accessibility), equality-of-satisfaction is the wrong target — use a priority/lexicographic rule. And none of these rules is strategyproof: a member who learns the formula can exaggerate their scores to swing the pick.

---

4. The math

4.1 The formulas

For an option with s = [s_1, ..., s_n] and mean m = (1/n) * sum_i s_i:

  Average       A(s)   = m
  Least-Misery  L(s)   = min_i s_i
  Most-Pleasure P(s)   = max_i s_i
  Variance      var(s) = (1/n) * sum_i (s_i - m)^2
  Fair          F(s)   = m - lambda * var(s)

Two useful facts. First, F reduces to A at lambda = 0 and, as lambda -> infinity, argmax F selects the option with the smallest variance (perfect equality) among those not already ruled out — so the single dial genuinely spans utility to equality. Second, because subtracting variance never increases an option's score, F(s) <= A(s) always: fairness costs some average utility, and lambda sets how much.

4.2 Worked example

Three people (Ann, Ben, Cara), three options. Satisfaction grid as in Section 2.

  BeachTrip    [0.95, 0.90, 0.20]
  SafariLodge  [0.60, 0.60, 0.60]
  IslandTrip   [0.75, 0.50, 0.70]

Means: BeachTrip = (0.95+0.90+0.20)/3 = 0.683, SafariLodge = 0.600, IslandTrip = 0.650.

Variances (population): for BeachTrip the deviations from 0.683 are +0.267, +0.217, -0.483, squared and averaged give var = 0.117. SafariLodge is flat so var = 0.000. IslandTrip gives var = 0.012.

Now the classic rules: Average picks the max mean → BeachTrip (0.683), even though Cara sits at 0.20. Least-Misery picks the max of the minimums → SafariLodge (min 0.60 beats 0.20 and 0.50). Most-Pleasure picks the max single score → BeachTrip (0.95).

Now turn the dial F = mean - lambda*var:

  lambda=0:  BeachTrip 0.683  SafariLodge 0.600  IslandTrip 0.650  -> BeachTrip
  lambda=1:  BeachTrip 0.566  SafariLodge 0.600  IslandTrip 0.638  -> IslandTrip
  lambda=3:  BeachTrip 0.332  SafariLodge 0.600  IslandTrip 0.615  -> IslandTrip
  lambda=5:  BeachTrip 0.097  SafariLodge 0.600  IslandTrip 0.592  -> SafariLodge

Same numbers, same options — only lambda changed, and the pick moved BeachTrip → IslandTrip → SafariLodge (selfish-average → balanced → perfectly equal). IslandTrip is the interesting one: at moderate fairness it wins because it keeps a high mean (0.65) and leaves nobody below 0.50 — exactly the "fair and satisfying" middle that neither Average nor Least-Misery can reach.

---

5. Real code

# Aggregating group satisfaction into one choice, four ways.
# Each option has one satisfaction score s_i in [0,1] per person.
options = {
    "BeachTrip":   [0.95, 0.90, 0.20],
    "SafariLodge": [0.60, 0.60, 0.60],
    "IslandTrip":  [0.75, 0.50, 0.70],
}

def mean(s):     return sum(s) / len(s)
def variance(s): m = mean(s); return sum((x - m) ** 2 for x in s) / len(s)

def average(s):       return mean(s)                     # utilitarian
def least_misery(s):  return min(s)                      # maximin (protect worst-off)
def most_pleasure(s): return max(s)                      # maximax
def fair(s, lam):     return mean(s) - lam * variance(s) # utility - lambda * unfairness

def pick(score_fn):   # argmax over the feasible set of options
    return max(options, key=lambda o: score_fn(options[o]))

print("option        mean   min    max    var")
for o, s in options.items():
    print(f"{o:<12} {mean(s):.3f}  {min(s):.3f}  {max(s):.3f}  {variance(s):.4f}")

print("\nclassic selectors:")
print("  Average       ->", pick(average))
print("  Least-Misery  ->", pick(least_misery))
print("  Most-Pleasure ->", pick(most_pleasure))

print("\nfairness dial (lambda sweep):")
for lam in (0, 1, 3, 5):
    scores = {o: fair(s, lam) for o, s in options.items()}
    winner = max(scores, key=scores.get)
    print(f"  lambda={lam}:  " + "  ".join(f"{o}={v:.3f}" for o, v in scores.items()) + f"   -> {winner}")

# Numeric claims made in the prose, checked automatically:
assert pick(average) == "BeachTrip"                 # high average, but Cara at 0.20
assert pick(least_misery) == "SafariLodge"          # protects the worst-off
assert pick(lambda s: fair(s, 1)) == "IslandTrip"   # the balanced middle
assert pick(lambda s: fair(s, 5)) == "SafariLodge"  # strong fairness -> equality
print("\nall asserts passed")

# Output:
#   option        mean   min    max    var
#   BeachTrip    0.683  0.200  0.950  0.1172
#   SafariLodge  0.600  0.600  0.600  0.0000
#   IslandTrip   0.650  0.500  0.750  0.0117
#
#   classic selectors:
#     Average       -> BeachTrip
#     Least-Misery  -> SafariLodge
#     Most-Pleasure -> BeachTrip
#
#   fairness dial (lambda sweep):
#     lambda=0:  BeachTrip=0.683  SafariLodge=0.600  IslandTrip=0.650   -> BeachTrip
#     lambda=1:  BeachTrip=0.566  SafariLodge=0.600  IslandTrip=0.638   -> IslandTrip
#     lambda=3:  BeachTrip=0.332  SafariLodge=0.600  IslandTrip=0.615   -> IslandTrip
#     lambda=5:  BeachTrip=0.097  SafariLodge=0.600  IslandTrip=0.592   -> SafariLodge
#
#   all asserts passed

---

6. Real-world example

A household streaming account builds a "Top Picks for tonight" row for whoever is watching together. The early version ranked titles by the average predicted rating across the three profiles on the couch. It worked until it didn't: an action-heavy title scored [0.9, 0.9, 0.2] — two housemates loved it, the third had repeatedly skipped that genre. Average put it first (mean 0.667), and the third person quietly stopped using the shared profile, which is the streaming-product version of "one person sits out."

Switching the shared row to mean - lambda*var with a modest lambda changed the outcome without hurting the majority much: a title scoring [0.8, 0.75, 0.7] (mean 0.75, variance 0.0017) now outranks the [0.9,0.9,0.2] title (mean 0.667, variance 0.109) because the second one is heavily penalized for its spread. The average-happiness cost of the fairer pick was small (a couple of hundredths), but the worst-off viewer went from 0.2 to 0.7. The lesson recurs everywhere group choices are automated: a metric that only tracks the average will, sooner or later, optimize by sacrificing a minority, and you will not see it in the aggregate numbers.

---

7. Interview questions companies actually ask

Q1. Why not just average everyone's preference and pick the top? Because the mean is blind to distribution. An option that delights most and alienates one can have the highest mean, so pure averaging systematically sacrifices minorities to lift the aggregate. You only notice if you also report a spread or worst-case metric.

Q2. What is the Least-Misery strategy and when is it right? Least-Misery scores each option by its minimum individual satisfaction and maximizes that. It is the right default when an unhappy member is very costly — a single veto can sink the group, or safety/inclusion matters more than delight (nobody should be stranded). Its weakness is that it ignores everyone above the minimum, so it converges to bland, universally-tolerable options.

Q3. How does mean - lambda*var trade utility against fairness, and what do the extremes mean? The mean term rewards total happiness; the variance term penalizes inequality; lambda sets the exchange rate. At lambda = 0 it is pure utilitarian averaging. As lambda grows, options with uneven satisfaction lose score fastest, and in the limit the rule selects the most equal option. So one scalar continuously interpolates from "highest average" to "most equal."

Q4. How is fairness-as-low-variance different from envy-freeness? Variance measures how unequal the satisfaction levels are. Envy-freeness asks a different question: would any member prefer the outcome another member received? An allocation can have low variance yet still be envious, or be envy-free yet unequal. Variance is a cheap, differentiable proxy; envy is a per-pair comparison closer to the fairness people actually feel. Serious systems report both.

Q5. Your fairness metric improved but average satisfaction dropped — is that a bug? No; it is the tradeoff working. F(s) <= mean(s) always, so any nonzero lambda costs some average utility by construction. The question is whether the drop is small relative to the fairness gain. Report both curves across lambda (a Pareto frontier) and pick the knob where the worst-off improves a lot for a little average loss.

Q6. When would you not use variance-based fair aggregation? When preferences are ordinal-only (people can rank but not score) — use a voting rule; when "fair" means priority-by-need rather than equality — use a lexicographic/triage rule; and when members can game the input — you need a strategyproof mechanism, which plain mean-variance is not.

Q7. How do you choose lambda? It is a policy choice, not a learned parameter. Sweep it, plot average satisfaction against a fairness metric (min-satisfaction or a fairness index), and read off the knee of the curve; then sanity-check the actual picks at that lambda with stakeholders. There is no universally correct value — it encodes how much the group values equality.

---

8. When to use / tradeoffs

Reach for fair aggregation when:

• One option must serve several people whose preferences conflict, and you have cardinal, comparable satisfaction scores.
• You have seen (or fear) the "high average, one person abandoned" failure and want a knob to control it.
• You need to explain and defend the balance you struck — the single lambda and the mean/variance decomposition are auditable.

Do NOT use it when:

Honest limits. Variance is a symmetric penalty: it punishes an option for making one person much happier than the rest exactly as much as for making one person much sadder, which is not always what "fair" should mean. The method assumes satisfactions are interpersonally comparable — a strong assumption that rarely holds exactly, so treat s_i as approximate. lambda is a value judgment you must set and defend, not a fact you can optimize away. And the rule optimizes a snapshot: it says nothing about fairness over time (someone compromised today could be compensated tomorrow), which repeated-decision settings should track separately.

---

9. Summary + related articles

• Aggregation turns each person's satisfaction s_i into one group score; the classic rules are Average (mean), Least-Misery (min), and Most-Pleasure (max).
• Average maximizes total happiness but can abandon a minority; Least-Misery protects the worst-off but is bland; Most-Pleasure is deliberately unfair.
• score = mean(s) - lambda*var(s) is a tunable dial: lambda = 0 is pure Average, large lambda drives toward equal satisfaction, and moderate lambda finds the "fair and satisfying" middle.
• Fairness always costs some average utility (F <= mean); sweep lambda and pick the knee of the utility-vs-fairness curve.
• Boundary: needs cardinal, comparable scores and a fixed option set; use voting for ordinal preferences, priority rules for need-based fairness, and always filter hard constraints out before aggregating.

Related:

• Weighted Averages & Aggregation — the mean and weighted-mean machinery this builds on.
• Recommendation Systems — where group aggregation sits inside a full recommender.
• Backtesting, Baselines & Sensitivity Analysis — how to compare aggregation strategies honestly (average-vs-marginal, Pareto frontiers).

Resources

• Masthoff, J. (2015). "Group Recommender Systems: Aggregation, Satisfaction and Group Attributes." In Ricci, Rokach, Shapira (eds.), Recommender Systems Handbook (2nd ed.), Springer — the canonical treatment of Average, Least-Misery, and Most-Pleasure. (Chapter in the handbook; page range not verified here.)
• Jain, R., Chiu, D.-M., Hawe, W. (1984). "A Quantitative Measure of Fairness and Discrimination for Resource Allocation in Shared Computer Systems." DEC Technical Report TR-301 — origin of the Jain fairness index used as a variance-free spread measure.
• Sacharidis, D. (2019). "Top-N Group Recommendations with Fairness." ACM Symposium on Applied Computing (SAC) — a modern fairness-aware group-recommendation baseline. (Venue confirmed; DOI/pages not verified here.)
• Markowitz, H. (1952). "Portfolio Selection." Journal of Finance, 7(1), 77–91 — the return - lambda*risk mean–variance form this article borrows.