Regret Analysis and Minimax Decision Rules: How to Make Better Choices Under Uncertainty

Last Updated June 6, 2026

Regret Analysis and Minimax Decision Rules examines how decision-makers compare choices when outcomes are uncertain, probabilities are unreliable, and the cost of being wrong matters as much as the possibility of being right. In decision science, regret analysis shifts attention from absolute performance to the loss created by choosing one option when another option would have performed better under the future that actually occurs.

Regret Analysis and Minimax Decision Rules connects decision theory, robust decision-making, deep uncertainty, expected utility, downside protection, scenario comparison, sensitivity analysis, robust satisficing, value of information, game theory, statistical decision functions, and accountable judgment. Its central argument is that some decisions should not be evaluated only by expected value or best-case performance. When probabilities are contested, failures are costly, and decision-makers must act before uncertainty is resolved, regret and minimax rules help reveal vulnerability, downside exposure, and the consequences of choosing poorly across plausible futures.

Many decisions are made under uncertainty. A government chooses an infrastructure investment before climate, demand, funding, and political conditions are known. A hospital chooses a preparedness strategy before the next crisis is specified. A company chooses a technology path before regulation, adoption, competitors, and public expectations stabilize. A public agency chooses a policy before all consequences can be observed.

In these situations, decision-makers often ask which option has the highest expected value, strongest forecasted performance, or best average outcome. Those questions are useful when probabilities are credible and outcome distributions are understood. But when uncertainty is deep, probability estimates may be fragile. A strategy that looks best on average may fail badly in an adverse future. A strategy that looks conservative may preserve acceptable performance across many futures.

Regret analysis changes the comparison. It asks: if a particular future occurs, how much worse is this option than the option we would have chosen with hindsight? Minimax decision rules extend that logic by asking which option protects against the worst loss, the worst regret, or the worst failure across the scenario set. These tools do not remove judgment. They make the structure of downside protection explicit.

Why Regret Analysis Matters

Regret analysis matters because many decisions are judged after the future has revealed information that was unavailable at the time of choice. Once the outcome is known, it becomes tempting to ask why decision-makers did not choose the option that now appears obvious. Regret analysis formalizes that hindsight comparison without pretending that hindsight was available in advance.

Regret is not simply emotional disappointment. In decision analysis, regret is a structured measure of opportunity loss. It compares the payoff from the selected action with the payoff from the best action that could have been selected for the state of the world that occurred. This makes regret useful when the decision-maker cares about being protected against severe hindsight losses.

Regret analysis is especially important when outcomes are asymmetric, when the worst mistake would be politically, financially, ethically, or institutionally costly, and when the decision-maker cannot assign reliable probabilities to future states. It helps decision-makers see not only which option might perform well, but which option exposes them to the greatest avoidable loss.

Regret analysis matters because responsible decision-making is not only about chasing the best possible outcome. It is also about understanding how badly a decision could look, perform, or fail when uncertainty resolves differently than expected.

Back to top ↑

What Is Regret Analysis?

Regret analysis is a method for evaluating decisions by comparing each action’s performance against the best action that would have been chosen in each possible future state. It asks how much value is lost by choosing an action that turns out not to be optimal for the future that occurs.

For each future state, the analyst identifies the best payoff available among all actions. Then, for every action, the analyst subtracts that action’s payoff from the best payoff in that future state. The result is a regret value. A regret of zero means the action is best in that future. A larger regret means the action performs farther below the hindsight-best alternative.

This method is useful because it separates two questions. The first question is: how well does an action perform in absolute terms? The second question is: how much worse is it than the best action in that scenario? Regret analysis answers the second question.

Regret analysis is a disciplined way of asking: if this future occurs, how costly would it be to have chosen this option instead of the best available alternative?

Back to top ↑

The Decision Matrix: Actions, States, Payoffs, and Losses

Regret analysis begins with a decision matrix. Rows represent actions. Columns represent possible states of the world. Each cell contains the payoff, utility, cost, loss, or performance value associated with choosing an action if a particular state occurs.

The matrix can be built using financial returns, service reliability, health outcomes, emissions reductions, resilience scores, policy performance, expected lives saved, system capacity, operational continuity, or any other decision-relevant measure. The key requirement is that each action can be compared across the same set of future states.

Payoff matrices use higher values to represent better outcomes. Loss or cost matrices use lower values to represent better outcomes. Regret can be calculated in either case, but the direction must be handled carefully. For payoff matrices, regret is the gap below the best payoff. For cost matrices, regret is the excess cost above the lowest cost.

The decision matrix makes uncertainty visible. The regret matrix makes missed opportunity visible.

Back to top ↑

Opportunity Loss and Regret

Opportunity loss is the value of the best missed alternative. In regret analysis, opportunity loss is calculated for each action under each state of the world. If an action is the best available choice in a particular state, its regret is zero. If another action would have performed better, regret is the performance gap.

This is different from simply recording whether an option succeeded or failed. A strategy may produce a positive outcome but still generate high regret if another strategy would have performed much better in the same future. Conversely, a strategy may produce a modest outcome but low regret if all other strategies also perform poorly in that future.

Regret therefore captures relative performance. It asks not only whether the outcome was good or bad, but whether the selected action left significant value on the table relative to what was possible under the realized state.

Regret is powerful because it measures avoidable disappointment, not just bad outcomes.

Back to top ↑

Maximin, Minimax, and Minimax Regret

Maximin, minimax, and minimax regret are related but distinct decision rules. They are often used when the decision-maker wants protection against adverse outcomes and does not trust a single probability distribution over future states.

The maximin rule applies to payoff matrices. It selects the action whose worst payoff is highest. This is a conservative rule: look at the worst that can happen under each action, then choose the action with the best worst case.

The minimax rule is often used for losses or costs. It selects the action whose maximum loss is lowest. This is also conservative: identify the worst loss each action can produce, then choose the action with the smallest worst loss.

The minimax regret rule selects the action whose maximum regret is lowest. Instead of minimizing the worst absolute loss, it minimizes the worst missed opportunity relative to the best action in each state. This can be less conservative than maximin because it focuses on avoidable underperformance rather than worst absolute outcome.

Maximin asks, “Which option has the best worst case?” Minimax regret asks, “Which option limits the worst hindsight disappointment?”

Back to top ↑

Expected Value vs. Regret-Based Reasoning

Expected value and regret-based reasoning answer different questions. Expected value asks which action has the highest average payoff after weighting outcomes by probabilities. Regret analysis asks how much each action could underperform relative to the hindsight-best action in each state.

Expected value is powerful when probabilities are credible, outcomes can be valued consistently, and repeated decisions allow averages to matter. It is less reliable when probabilities are speculative, outcomes are one-off, risks are asymmetric, political accountability is high, or decision-makers care about severe avoidable losses.

Regret-based reasoning is useful when the decision-maker wants to avoid being badly wrong. It can reveal cases where a high expected-value option creates large exposure to missed opportunity in some futures, or where a more balanced option performs acceptably even when it is not best in any single future.

Expected value is often a good answer to “What performs best on average?” Regret analysis is often a better answer to “What protects us from being badly wrong?”

Back to top ↑

Regret Analysis Under Deep Uncertainty

Regret analysis is especially useful under deep uncertainty because it does not require the decision-maker to assign a precise probability to each future state. Instead, it asks how strategies perform across a set of plausible futures. This makes it valuable when probabilities, models, outcomes, or stakeholder values are uncertain or contested.

In deep uncertainty, the scenario set itself is a judgment. The analyst must decide which futures are plausible enough to include, how broad the scenario space should be, and how performance should be measured. Regret analysis does not solve those questions. It makes their consequences visible.

Minimax regret can be attractive because it avoids choosing an action that would look severely inferior under any plausible future. But it can also be sensitive to the scenario set. Adding, removing, or redefining scenarios can change which action has the lowest maximum regret. This is why regret analysis should be paired with sensitivity analysis, scenario review, and decision records.

Under deep uncertainty, regret analysis is not a substitute for judgment. It is a way to make judgment more explicit, testable, and accountable.

Back to top ↑

Scenario Design and Sensitivity

Regret analysis depends heavily on the scenario set. If the scenario set is too narrow, a strategy may appear robust because it has not been tested against enough futures. If the scenario set is extreme but unrealistic, the analysis may overemphasize rare or poorly justified conditions. If scenarios are chosen strategically to favor one option, regret analysis can become a tool of justification rather than inquiry.

Good scenario design should include plausible baseline futures, adverse futures, boundary conditions, structural shifts, and stakeholder-relevant futures. The goal is not to include every imaginable possibility. The goal is to include futures that are decision-relevant: futures that would change which action appears responsible.

Sensitivity analysis is essential. Decision-makers should test whether the preferred action changes when scenarios are added, removed, reweighted, or reframed. If a minimax regret recommendation depends on one scenario, that scenario deserves special scrutiny.

Regret analysis is only as honest as the scenarios and performance measures used to construct it.

Back to top ↑

Downside Protection and Conservative Choice

Regret analysis and minimax rules often support downside protection. They help decision-makers avoid options that produce severe underperformance under some plausible futures, even if those options perform well under favorable assumptions.

This does not mean regret analysis always recommends the most conservative option. Maximin can be highly conservative because it focuses on the worst absolute payoff. Minimax regret can sometimes produce a more balanced recommendation because it focuses on the worst gap from the best available action. An option with a mediocre worst case may still be chosen if its worst regret is limited.

Downside protection is especially important when decisions are hard to reverse, when failure affects vulnerable groups, when public trust is at stake, when cascading effects are possible, or when the cost of being wrong is much larger than the benefit of being slightly more right.

Downside protection is not fearfulness. It is a disciplined response to decisions where severe avoidable loss matters.

Back to top ↑

Robust Satisficing, Thresholds, and Acceptability

Regret analysis should often be combined with robust satisficing. Robust satisficing asks whether an option meets acceptable performance thresholds across enough plausible futures. This is important because the lowest regret option may still perform below a non-negotiable threshold in some futures.

For example, a water policy may have low maximum regret but still fail to meet minimum reliability under drought. A healthcare strategy may minimize regret across scenarios but still fail a staffing safety threshold. An AI deployment may have low regret in performance terms but fail accountability or fairness thresholds. In these cases, regret is not enough.

Thresholds define what counts as acceptable. They can represent legal requirements, safety levels, ethical boundaries, service standards, climate targets, public-health capacity, financial solvency, or institutional legitimacy. Strong decision analysis should evaluate both regret and threshold compliance.

A good decision may need low regret and acceptable performance. One without the other can be misleading.

Back to top ↑

Behavioral Dimensions of Regret

Regret is both a formal decision concept and a behavioral experience. People anticipate regret before choosing and experience regret after outcomes are known. This can improve judgment when it encourages careful scenario comparison, but it can also distort judgment when fear of regret becomes excessive.

Anticipated regret can make decision-makers overly cautious. They may avoid action because they fear blame if the decision fails. They may choose the option that will be easiest to justify rather than the option that is most robust. They may overemphasize vivid failure scenarios and underweight less visible but more consequential risks.

Organizations also respond to regret socially. Leaders may prefer decisions that diffuse responsibility. Committees may choose compromise options that minimize blame rather than risk. Public institutions may avoid decisions that create visible regret even when inaction creates hidden regret. Decision hygiene is needed to separate disciplined regret analysis from blame avoidance.

Formal regret analysis is most useful when it disciplines regret, rather than merely amplifying fear of being wrong.

Back to top ↑

Governance and Accountability

Regret analysis supports accountability when it is documented clearly. A decision record should show which actions were considered, which scenarios were included, how payoffs were estimated, how regret was calculated, which rule was used, and why that rule was appropriate for the decision context.

This matters because regret can be politically powerful after outcomes occur. If a decision produces visible loss, stakeholders may ask why the hindsight-best option was not chosen. A decision record can show what was knowable at the time, what uncertainty was recognized, and why the chosen option limited downside, regret, or threshold failure under the scenario set.

Governance also matters because regret analysis can be manipulated. Scenario sets can be selected to favor a preferred option. Performance measures can be chosen to hide important harms. Regret can be minimized for the institution while shifted onto the public, workers, patients, ecosystems, or future generations. Accountable regret analysis must therefore include transparency, stakeholder review, and ethical scrutiny.

Regret analysis becomes accountable when the decision-maker can explain not only what was chosen, but what forms of regret were considered, accepted, reduced, or transferred.

Back to top ↑

Applications Across Decision Contexts

Regret analysis and minimax decision rules apply across domains where decision-makers must choose before uncertainty resolves and where the cost of being wrong is significant. The method is especially useful when probability estimates are weak, decisions are hard to reverse, and stakeholders care about defensible downside protection.

Across domains, regret analysis helps decision-makers compare not only what they hope will happen, but what they will wish they had protected against if the future changes.

Back to top ↑

Limitations and Challenges

Regret analysis has real limitations. It depends on the set of actions, the set of scenarios, and the payoff measures used. If important options are excluded, the regret matrix may mislead. If scenarios are poorly designed, the recommendation may be fragile. If payoffs compress values too aggressively, the analysis may hide ethical, distributional, or institutional concerns.

Minimax regret can also be sensitive to irrelevant or poorly specified alternatives. Adding an option that is never chosen can sometimes change regret comparisons by changing the hindsight benchmark. This means regret analysis should not be treated as mechanically neutral. It is a structured decision aid, not a substitute for judgment.

Another limitation is that regret is relative. A low-regret option may still produce unacceptable absolute outcomes if all options perform poorly in a severe future. For that reason, regret should be paired with absolute performance thresholds, robustness analysis, stakeholder review, and adaptive planning.

Regret analysis is strongest when its assumptions are visible and its recommendations are tested against alternative scenarios, values, and decision rules.

Back to top ↑

Summary Table: Regret Analysis and Minimax Decision Rules

The table below summarizes the main concepts used in regret-based decision analysis.

Regret analysis helps decision-makers see the cost of being wrong. Minimax decision rules help them choose how much protection against being wrong they need.

Back to top ↑

Back to top ↑

Mathematical Lens: Regret, Maximin, Minimax, and Minimax Regret

The mathematical lens clarifies the difference between payoff optimization, downside protection, and regret minimization.

Let \(A\) be the set of available actions and \(S\) be the set of possible states of the world. Let \(U(a,s)\) represent the payoff or utility of action \(a\) if state \(s\) occurs.

For a payoff matrix, regret is the gap between the best available payoff in a state and the payoff from action \(a\):

For cost or loss matrices, where lower values are better, regret is the excess cost relative to the lowest cost in each state:

Threshold-based robustness can be combined with regret:

A vulnerability set identifies the states where an action fails the threshold:

The mathematical lesson is that different decision rules protect against different failures. Expected value protects average performance. Maximin protects the worst payoff. Minimax regret protects against the worst hindsight gap. Threshold analysis protects minimum acceptability.

Back to top ↑

R Workflow: Comparing Expected Value, Maximin, and Minimax Regret

The R workflow below compares decision strategies using expected value, maximin, minimax regret, threshold pass rate, and vulnerability counts. It uses base R so it can run without additional package installation.

# regret_analysis_minimax_decision_rules_workflow.R
# Base R workflow for regret analysis and minimax decision rules:
# expected value, maximin, minimax regret, threshold compliance,
# vulnerability analysis, and decision-rule comparison.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE) if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")

dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

strategies <- data.frame(
  strategy = c(
    "Aggressive Commitment",
    "Balanced Adaptive Strategy",
    "Defensive Resilience Strategy",
    "Staged Optionality Strategy",
    "Modular No-Regrets Strategy",
    "Learning Portfolio Strategy"
  ),
  stable_growth = c(0.92, 0.76, 0.61, 0.73, 0.70, 0.74),
  fiscal_stress = c(0.29, 0.68, 0.80, 0.81, 0.75, 0.77),
  climate_disruption = c(0.18, 0.64, 0.84, 0.79, 0.82, 0.80),
  technology_shift = c(0.55, 0.75, 0.63, 0.87, 0.80, 0.88),
  governance_stress = c(0.34, 0.71, 0.73, 0.76, 0.82, 0.78),
  social_contestation = c(0.38, 0.72, 0.69, 0.77, 0.79, 0.83),
  stringsAsFactors = FALSE
)

scenarios <- c(
  "stable_growth",
  "fiscal_stress",
  "climate_disruption",
  "technology_shift",
  "governance_stress",
  "social_contestation"
)

scenario_weights <- c( stable_growth = 0.18, fiscal_stress = 0.16, climate_disruption = 0.18, technology_shift = 0.17, governance_stress = 0.15, social_contestation = 0.16 ) if (abs(sum(scenario_weights) - 1) > 1e-9) {
  stop("Scenario weights must sum to 1.")
}

performance_threshold <- 0.70

payoff_matrix <- as.matrix(strategies[, scenarios])
scenario_bests <- apply(payoff_matrix, 2, max)

regret_matrix <- matrix(0, nrow = nrow(payoff_matrix), ncol = length(scenarios))
colnames(regret_matrix) <- scenarios

for (j in seq_along(scenarios)) {
  regret_matrix[, j] <- scenario_bests[j] - payoff_matrix[, j]
}

results <- data.frame( strategy = strategies$strategy, expected_value = as.vector(payoff_matrix %*% scenario_weights), maximin_value = apply(payoff_matrix, 1, min), best_case = apply(payoff_matrix, 1, max), performance_range = apply(payoff_matrix, 1, max) - apply(payoff_matrix, 1, min), average_regret = rowMeans(regret_matrix), maximum_regret = apply(regret_matrix, 1, max), threshold_pass_rate = rowMeans(payoff_matrix >= performance_threshold),
  vulnerability_count = rowSums(payoff_matrix < performance_threshold),
  stringsAsFactors = FALSE
)

results$expected_value_rank <- rank(-results$expected_value, ties.method = "min")
results$maximin_rank <- rank(-results$maximin_value, ties.method = "min")
results$minimax_regret_rank <- rank(results$maximum_regret, ties.method = "min")
results$threshold_rank <- rank(-results$threshold_pass_rate, ties.method = "min")

results$combined_robustness_score <- (
  0.25 * results$maximin_value +
    0.25 * (1 - results$maximum_regret) +
    0.25 * results$threshold_pass_rate +
    0.15 * results$expected_value +
    0.10 * (1 - results$performance_range)
)

results$combined_rank <- rank(-results$combined_robustness_score, ties.method = "min")

results$review_flag <- ifelse(
  results$maximin_value < 0.50 | results$maximum_regret > 0.35 |
    results$threshold_pass_rate < 0.50,
  "review",
  "acceptable"
)

results <- results[order(results$combined_rank), ]

write.csv(
  strategies,
  file.path(tables_dir, "regret_payoff_matrix.csv"),
  row.names = FALSE
)

write.csv(
  data.frame(scenario = names(scenario_weights), weight = as.numeric(scenario_weights)),
  file.path(tables_dir, "regret_scenario_weights.csv"),
  row.names = FALSE
)

regret_table <- data.frame(
  strategy = strategies$strategy,
  regret_matrix,
  check.names = FALSE,
  stringsAsFactors = FALSE
)

write.csv(
  regret_table,
  file.path(tables_dir, "regret_matrix.csv"),
  row.names = FALSE
)

vulnerability_table <- data.frame(
  strategy = strategies$strategy,
  payoff_matrix < performance_threshold,
  check.names = FALSE,
  stringsAsFactors = FALSE
)

write.csv(
  vulnerability_table,
  file.path(tables_dir, "regret_vulnerability_table.csv"),
  row.names = FALSE
)

write.csv(
  results,
  file.path(tables_dir, "regret_decision_rule_comparison.csv"),
  row.names = FALSE
)

decision_rule_winners <- data.frame(
  rule = c("Expected value", "Maximin", "Minimax regret", "Threshold pass rate", "Combined robustness"),
  selected_strategy = c(
    results$strategy[which.min(results$expected_value_rank)],
    results$strategy[which.min(results$maximin_rank)],
    results$strategy[which.min(results$minimax_regret_rank)],
    results$strategy[which.min(results$threshold_rank)],
    results$strategy[which.min(results$combined_rank)]
  ),
  stringsAsFactors = FALSE
)

write.csv(
  decision_rule_winners,
  file.path(tables_dir, "regret_decision_rule_winners.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "maximum_regret_by_strategy.png"), width = 1200, height = 800)
barplot(
  results$maximum_regret,
  names.arg = results$strategy,
  las = 2,
  main = "Maximum Regret by Strategy",
  ylab = "Maximum regret"
)
grid()
dev.off()

png(file.path(figures_dir, "maximin_value_by_strategy.png"), width = 1200, height = 800)
barplot(
  results$maximin_value,
  names.arg = results$strategy,
  las = 2,
  main = "Maximin Value by Strategy",
  ylab = "Worst-case payoff"
)
grid()
dev.off()

png(file.path(figures_dir, "expected_value_vs_maximum_regret.png"), width = 1200, height = 800)
plot(
  results$expected_value,
  results$maximum_regret,
  xlab = "Expected value",
  ylab = "Maximum regret",
  main = "Expected Value vs Maximum Regret",
  pch = 19
)
text(
  results$expected_value,
  results$maximum_regret,
  labels = results$strategy,
  pos = 4,
  cex = 0.8
)
grid()
dev.off()

print(results)
print(regret_table)
print(decision_rule_winners)

This workflow demonstrates why different decision rules can select different strategies. Expected value may favor one option, maximin another, and minimax regret another. The point is not that one rule is always correct. The point is to make the decision attitude explicit.

Back to top ↑

Python Workflow: Scenario-Based Regret and Decision Rule Comparison

The Python workflow below uses only the standard library. It compares strategies across scenarios, calculates a regret matrix, evaluates expected value, maximin value, maximum regret, threshold compliance, vulnerability counts, and decision-rule winners, then exports a decision record.

# regret_analysis_minimax_decision_rules_simulation.py
# Standard-library workflow for regret analysis and minimax decision rules:
# expected value, maximin, minimax regret, threshold compliance,
# vulnerability analysis, decision-rule comparison, and decision records.

from __future__ import annotations

from pathlib import Path
import csv
import json
from statistics import mean

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"
RECORDS = ARTICLE_ROOT / "outputs" / "decision_records"

SCENARIOS = [
    "stable_growth",
    "fiscal_stress",
    "climate_disruption",
    "technology_shift",
    "governance_stress",
    "social_contestation",
]

SCENARIO_WEIGHTS = {
    "stable_growth": 0.18,
    "fiscal_stress": 0.16,
    "climate_disruption": 0.18,
    "technology_shift": 0.17,
    "governance_stress": 0.15,
    "social_contestation": 0.16,
}

STRATEGIES = [
    {
        "strategy": "Aggressive Commitment",
        "stable_growth": 0.92,
        "fiscal_stress": 0.29,
        "climate_disruption": 0.18,
        "technology_shift": 0.55,
        "governance_stress": 0.34,
        "social_contestation": 0.38,
    },
    {
        "strategy": "Balanced Adaptive Strategy",
        "stable_growth": 0.76,
        "fiscal_stress": 0.68,
        "climate_disruption": 0.64,
        "technology_shift": 0.75,
        "governance_stress": 0.71,
        "social_contestation": 0.72,
    },
    {
        "strategy": "Defensive Resilience Strategy",
        "stable_growth": 0.61,
        "fiscal_stress": 0.80,
        "climate_disruption": 0.84,
        "technology_shift": 0.63,
        "governance_stress": 0.73,
        "social_contestation": 0.69,
    },
    {
        "strategy": "Staged Optionality Strategy",
        "stable_growth": 0.73,
        "fiscal_stress": 0.81,
        "climate_disruption": 0.79,
        "technology_shift": 0.87,
        "governance_stress": 0.76,
        "social_contestation": 0.77,
    },
    {
        "strategy": "Modular No-Regrets Strategy",
        "stable_growth": 0.70,
        "fiscal_stress": 0.75,
        "climate_disruption": 0.82,
        "technology_shift": 0.80,
        "governance_stress": 0.82,
        "social_contestation": 0.79,
    },
    {
        "strategy": "Learning Portfolio Strategy",
        "stable_growth": 0.74,
        "fiscal_stress": 0.77,
        "climate_disruption": 0.80,
        "technology_shift": 0.88,
        "governance_stress": 0.78,
        "social_contestation": 0.83,
    },
]

PERFORMANCE_THRESHOLD = 0.70


def ensure_weights(weights: dict[str, float]) -> None:
    total = sum(weights.values())
    if abs(total - 1.0) > 1e-9:
        raise ValueError(f"Scenario weights must sum to 1. Got {total}.")


def payoff_rows() -> list[dict[str, object]]:
    return [
        {key: value for key, value in strategy.items() if key in ["strategy"] + SCENARIOS}
        for strategy in STRATEGIES
    ]


def scenario_bests() -> dict[str, float]:
    return {
        scenario: max(float(strategy[scenario]) for strategy in STRATEGIES)
        for scenario in SCENARIOS
    }


def regret_rows() -> list[dict[str, object]]:
    bests = scenario_bests()
    rows = []

    for strategy in STRATEGIES:
        row: dict[str, object] = {"strategy": strategy["strategy"]}
        for scenario in SCENARIOS:
            row[scenario] = round(bests[scenario] - float(strategy[scenario]), 6)
        rows.append(row)

    return rows


def vulnerability_rows() -> list[dict[str, object]]:
    rows = []

    for strategy in STRATEGIES:
        row: dict[str, object] = {"strategy": strategy["strategy"]}
        for scenario in SCENARIOS:
            row[scenario] = float(strategy[scenario]) < PERFORMANCE_THRESHOLD rows.append(row) return rows def rank_rows(rows: list[dict[str, object]], score_field: str, reverse: bool = True) -> list[dict[str, object]]:
    ranked = sorted(rows, key=lambda row: float(row[score_field]), reverse=reverse)
    output = []
    for rank, row in enumerate(ranked, start=1):
        item = dict(row)
        item["rank"] = rank
        output.append(item)
    return output


def decision_rule_comparison() -> list[dict[str, object]]:
    bests = scenario_bests()
    rows = []

    for strategy in STRATEGIES:
        payoffs = [float(strategy[scenario]) for scenario in SCENARIOS]
        regrets = [bests[scenario] - float(strategy[scenario]) for scenario in SCENARIOS]

        expected_value = sum(float(strategy[scenario]) * SCENARIO_WEIGHTS[scenario] for scenario in SCENARIOS)
        maximin_value = min(payoffs)
        best_case = max(payoffs)
        performance_range = best_case - maximin_value
        average_regret = mean(regrets)
        maximum_regret = max(regrets)
        threshold_pass_rate = sum(1 for value in payoffs if value >= PERFORMANCE_THRESHOLD) / len(payoffs)
        vulnerability_count = sum(1 for value in payoffs if value < PERFORMANCE_THRESHOLD)

        combined_score = (
            0.25 * maximin_value
            + 0.25 * (1 - maximum_regret)
            + 0.25 * threshold_pass_rate
            + 0.15 * expected_value
            + 0.10 * (1 - performance_range)
        )

        review = maximin_value < 0.50 or maximum_regret > 0.35 or threshold_pass_rate < 0.50 rows.append({ "strategy": strategy["strategy"], "expected_value": round(expected_value, 6), "maximin_value": round(maximin_value, 6), "best_case": round(best_case, 6), "performance_range": round(performance_range, 6), "average_regret": round(average_regret, 6), "maximum_regret": round(maximum_regret, 6), "threshold_pass_rate": round(threshold_pass_rate, 6), "vulnerability_count": vulnerability_count, "combined_robustness_score": round(combined_score, 6), "review_flag": "review" if review else "acceptable", }) expected_value_ranked = rank_rows(rows, "expected_value", reverse=True) maximin_ranked = rank_rows(rows, "maximin_value", reverse=True) minimax_regret_ranked = rank_rows(rows, "maximum_regret", reverse=False) threshold_ranked = rank_rows(rows, "threshold_pass_rate", reverse=True) combined_ranked = rank_rows(rows, "combined_robustness_score", reverse=True) rank_lookup = {} for label, ranked_rows in [ ("expected_value_rank", expected_value_ranked), ("maximin_rank", maximin_ranked), ("minimax_regret_rank", minimax_regret_ranked), ("threshold_rank", threshold_ranked), ("combined_rank", combined_ranked), ]: for row in ranked_rows: rank_lookup.setdefault(row["strategy"], {})[label] = row["rank"] output = [] for row in rows: item = dict(row) item.update(rank_lookup[row["strategy"]]) output.append(item) return sorted(output, key=lambda row: row["combined_rank"]) def decision_rule_winners(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    return [
        {
            "rule": "Expected value",
            "selected_strategy": min(rows, key=lambda row: row["expected_value_rank"])["strategy"],
        },
        {
            "rule": "Maximin",
            "selected_strategy": min(rows, key=lambda row: row["maximin_rank"])["strategy"],
        },
        {
            "rule": "Minimax regret",
            "selected_strategy": min(rows, key=lambda row: row["minimax_regret_rank"])["strategy"],
        },
        {
            "rule": "Threshold pass rate",
            "selected_strategy": min(rows, key=lambda row: row["threshold_rank"])["strategy"],
        },
        {
            "rule": "Combined robustness",
            "selected_strategy": min(rows, key=lambda row: row["combined_rank"])["strategy"],
        },
    ]


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows to write: {path}")
    with path.open("w", encoding="utf-8", newline="") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: dict[str, object]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")


def main() -> None:
    ensure_weights(SCENARIO_WEIGHTS)

    comparison = decision_rule_comparison()
    winners = decision_rule_winners(comparison)

    write_csv(TABLES / "regret_payoff_matrix.csv", payoff_rows())
    write_csv(TABLES / "regret_scenario_weights.csv", [{"scenario": k, "weight": v} for k, v in SCENARIO_WEIGHTS.items()])
    write_csv(TABLES / "regret_matrix.csv", regret_rows())
    write_csv(TABLES / "regret_vulnerability_table.csv", vulnerability_rows())
    write_csv(TABLES / "regret_decision_rule_comparison.csv", comparison)
    write_csv(TABLES / "regret_decision_rule_winners.csv", winners)

    write_json(
        RECORDS / "regret_analysis_decision_record.json",
        {
            "article": "Regret Analysis and Minimax Decision Rules",
            "decision_context": "Comparing strategies across uncertain scenarios using expected value, maximin, minimax regret, threshold compliance, and vulnerability analysis.",
            "scenarios": SCENARIOS,
            "scenario_weights": SCENARIO_WEIGHTS,
            "performance_threshold": PERFORMANCE_THRESHOLD,
            "decision_rule_comparison": comparison,
            "decision_rule_winners": winners,
            "modeling_principles": [
                "Regret measures opportunity loss relative to the hindsight-best action in each state.",
                "Maximin protects the worst absolute payoff.",
                "Minimax regret protects against the worst missed opportunity.",
                "Expected value requires credible probabilities.",
                "Regret should be evaluated alongside absolute thresholds and vulnerability sets."
            ],
        },
    )

    print("Regret analysis and minimax decision rules workflow complete.")
    print(TABLES / "regret_decision_rule_comparison.csv")
    print(TABLES / "regret_decision_rule_winners.csv")
    print(RECORDS / "regret_analysis_decision_record.json")


if __name__ == "__main__":
    main()

This workflow makes the decision rule visible. It shows when expected value, maximin, minimax regret, and threshold rules point toward the same option or pull decision-makers in different directions.

Back to top ↑

GitHub Repository

The companion repository for this article supports reproducible exploration of regret analysis, minimax decision rules, maximin reasoning, opportunity loss, threshold compliance, vulnerability analysis, scenario comparison, downside protection, and decision-record documentation.

articles/regret-analysis-and-minimax-decision-rules/
├── python/
│   ├── regret_analysis_minimax_decision_rules_simulation.py
│   ├── payoff_matrix_builder.py
│   ├── regret_matrix_calculator.py
│   ├── maximin_rule.py
│   ├── minimax_regret_rule.py
│   ├── threshold_compliance.py
│   ├── vulnerability_analysis.py
│   ├── decision_rule_comparison.py
│   ├── decision_record_exporter.py
│   └── run_all_regret_minimax_workflows.py
├── r/
│   ├── regret_analysis_minimax_decision_rules_workflow.R
│   ├── regret_tables.R
│   ├── minimax_rule_tables.R
│   ├── maximin_rule_tables.R
│   ├── threshold_review_tables.R
│   ├── decision_rule_summary.R
│   └── run_all_regret_minimax_workflows.R
├── julia/
│   ├── high_performance_regret_scan.jl
│   ├── minimax_regret_model.jl
│   └── maximin_model.jl
├── sql/
│   ├── schema_regret_analysis_minimax_decision_rules.sql
│   ├── strategies.sql
│   ├── scenarios.sql
│   ├── payoffs.sql
│   ├── regret.sql
│   ├── thresholds.sql
│   ├── decision_records.sql
│   └── sample_queries.sql
├── rust/
│   └── regret_minimax_cli.rs
├── go/
│   └── regret_minimax_runner.go
├── cpp/
│   ├── regret_matrix_core.cpp
│   └── minimax_regret_core.cpp
├── fortran/
│   └── numerical_regret_model.f90
├── c/
│   └── regret_minimax_core.c
├── docs/
│   ├── article_notes.md
│   ├── modeling_principles.md
│   ├── decision_matrix.md
│   ├── opportunity_loss.md
│   ├── maximin_minimax_minimax_regret.md
│   ├── expected_value_vs_regret.md
│   ├── scenario_sensitivity.md
│   ├── thresholds_and_vulnerability.md
│   ├── decision_records.md
│   ├── responsible_use.md
│   └── assumptions_and_limitations.md
├── data/
│   ├── synthetic_strategies.csv
│   ├── synthetic_scenarios.csv
│   ├── synthetic_payoff_matrix.csv
│   ├── synthetic_scenario_weights.csv
│   ├── synthetic_thresholds.csv
│   ├── synthetic_review_triggers.csv
│   └── synthetic_decision_records.csv
├── outputs/
│   ├── README.md
│   ├── figures/
│   ├── tables/
│   └── decision_records/
└── notebooks/
    ├── python_regret_analysis_minimax_decision_rules_walkthrough.ipynb
    └── r_regret_analysis_minimax_decision_rules_placeholder.ipynb

This repository structure reflects the article’s central argument: regret analysis becomes useful when payoff matrices, regret matrices, thresholds, vulnerabilities, decision rules, and decision records are explicit enough to inspect, rerun, and challenge.

Back to top ↑

Back to top ↑

Common Pitfalls

Regret analysis can fail when the mathematics appears cleaner than the decision context. The regret matrix may be precise, but the scenario set, payoff values, thresholds, and action list are all judgment calls. If those judgments are weak, biased, or hidden, the analysis will be misleading.

The most common mistake is treating minimax regret as automatically objective. It is a decision rule, not a substitute for designing the decision well.

Back to top ↑

Why Regret Analysis and Minimax Decision Rules Matter

Regret Analysis and Minimax Decision Rules matter because many consequential decisions are made before the future is known, before probabilities are reliable, and before the cost of being wrong is visible. In these settings, decision-makers need more than average performance. They need to understand missed opportunity, downside exposure, scenario vulnerability, threshold failure, and the trade-offs between ambition and protection.

Regret analysis provides a way to compare each action against the hindsight-best action in each future. Maximin protects against the worst absolute payoff. Minimax regret protects against the worst missed opportunity. Expected value optimizes average performance when probabilities are credible. Robust satisficing checks whether minimum standards are met across futures. Used together, these methods give decision-makers a richer view of uncertain choice.

The goal is not to eliminate regret. Some regret is unavoidable when decisions are made under uncertainty. The goal is to make regret visible before the decision is made, decide which forms of regret are acceptable, and preserve a record of why the chosen action was reasonable given what was knowable at the time.

Back to top ↑

Related Articles

• Decision Science
• What Is Decision Science?
• Why Uncertainty Changes Decision-Making
• Expected Value and Expected Utility
• Sensitivity Analysis and Scenario Comparison
• Robust Decision-Making
• Decision-Making Under Deep Uncertainty
• Value of Information and When to Wait
• Stakeholder Values and Decision Legitimacy
• Scenario Evaluation and Strategic Choice
• Risk, Tradeoffs, and Strategic Choices
• Mathematical Thinking

Back to top ↑

Further Reading

• Howard, R.A. and Abbas, A.E. (2023) Foundations of Decision Analysis. Harlow: Pearson. Available at: Pearson.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux. Available at: Macmillan.
• Lempert, R.J., Popper, S.W. and Bankes, S.C. (2003) Shaping the Next One Hundred Years: New Methods for Quantitative, Long-Term Policy Analysis. Santa Monica, CA: RAND Corporation. Available at: RAND.
• Luce, R.D. and Raiffa, H. (1989) Games and Decisions: Introduction and Critical Survey. Mineola, NY: Dover Publications. Available at: Dover Publications.
• RAND Corporation (no date) Robust Decision Making. Available at: RAND.
• Savage, L.J. (1972) The Foundations of Statistics. 2nd edn. Mineola, NY: Dover Publications. Available at: Google Books.
• Wald, A. (1949) “Statistical Decision Functions,” Annals of Mathematical Statistics, 20(2), pp. 165–205. Available at: Project Euclid.

Back to top ↑

References

• Anderson, E. and Zachary, S. (2022) “Minimax decision rules for planning under uncertainty.” Available at: arXiv.
• Howard, R.A. and Abbas, A.E. (2023) Foundations of Decision Analysis. Harlow: Pearson. Available at: Pearson.
• Lempert, R.J., Popper, S.W. and Bankes, S.C. (2003) Shaping the Next One Hundred Years: New Methods for Quantitative, Long-Term Policy Analysis. Santa Monica, CA: RAND Corporation. Available at: RAND.
• Luce, R.D. and Raiffa, H. (1989) Games and Decisions: Introduction and Critical Survey. Mineola, NY: Dover Publications. Available at: Dover Publications.
• Manski, C.F. (2019) “Statistical inference for statistical decisions.” Available at: arXiv.
• RAND Corporation (no date) Robust Decision Making. Available at: RAND.
• Savage, L.J. (1972) The Foundations of Statistics. 2nd edn. Mineola, NY: Dover Publications. Available at: Google Books.
• Wald, A. (1949) “Statistical Decision Functions,” Annals of Mathematical Statistics, 20(2), pp. 165–205. Available at: Project Euclid.

Back to top ↑