Sensitivity Analysis and Scenario Comparison: How to Test Assumptions and Make Better Decisions

Last Updated June 5, 2026

Sensitivity analysis and scenario comparison are essential tools in decision science because they reveal how decisions change when assumptions, parameters, risks, evidence, and external conditions shift. Instead of relying on one model, one forecast, one probability estimate, or one preferred narrative, these methods test whether a decision remains credible across uncertainty.

Sensitivity Analysis and Scenario Comparison examines how decision-makers evaluate assumption dependence, identify key drivers, test thresholds, compare alternative futures, detect fragile recommendations, and move from narrow optimization toward robustness. These methods are especially important when decisions depend on uncertain probabilities, costs, benefits, behavioral responses, system dynamics, stakeholder values, or long-horizon conditions. They do not eliminate uncertainty. They make uncertainty visible enough to support better judgment.

In many decision contexts, conclusions depend heavily on assumptions. A policy model may depend on compliance rates. A financial decision may depend on demand growth, inflation, interest rates, or volatility. A healthcare decision may depend on diagnostic accuracy and patient risk tolerance. An infrastructure plan may depend on climate exposure, asset lifetime, maintenance cost, and service disruption. An AI governance decision may depend on model drift, false-positive rates, appeal capacity, and harm severity.

When assumptions are uncertain, a single “best estimate” can be misleading. Sensitivity analysis asks how results change when inputs vary. Scenario comparison asks how strategies perform across coherent alternative futures. Together, these methods help decision-makers understand whether a recommendation is stable, fragile, reversible, robust, or dependent on one narrow view of the world.

Why Sensitivity Analysis Matters

Sensitivity analysis matters because many decisions appear stronger than they really are. A model may recommend one option under baseline assumptions, but that recommendation may collapse when a probability, cost, demand estimate, discount rate, risk exposure, behavioral response, or implementation assumption changes slightly. Without sensitivity analysis, decision-makers may mistake a fragile conclusion for a robust one.

This is especially dangerous in high-stakes decisions because numerical outputs can create false confidence. A model may present a precise expected value, net present value, risk-adjusted score, or utility ranking. But precision in the output does not guarantee reliability in the decision. If the model depends on uncertain inputs, the recommendation must be tested under variation.

Sensitivity analysis also improves learning. It identifies which assumptions matter most. If a decision is insensitive to a parameter, then more research on that parameter may not improve the decision much. If a decision is highly sensitive to a parameter, then evidence collection, monitoring, expert review, or contingency planning should focus there.

The central value of sensitivity analysis is disciplined doubt. It asks whether the decision remains defensible when the world is less convenient than the baseline model assumes.

Back to top ↑

What Is Sensitivity Analysis?

Sensitivity analysis examines how changes in input variables affect model outputs, decision rankings, expected value, expected utility, risk measures, costs, benefits, or other decision-relevant results. It treats model inputs as uncertain rather than fixed.

A sensitivity analysis begins with a model or decision rule. The analyst identifies uncertain inputs, varies them across plausible ranges, and observes how the outcome changes. The purpose is not only to see whether the final number changes. The purpose is to understand which assumptions drive the decision and where the recommendation may fail.

For example, an infrastructure plan may appear attractive when maintenance costs are low and climate stress is moderate. Sensitivity analysis tests what happens if maintenance costs rise, climate stress intensifies, construction delays occur, demand shifts, or discount rates change. A decision that performs well only under the most favorable assumptions is fragile.

Sensitivity analysis can be simple or advanced. A simple analysis may vary one input at a time. A more advanced analysis may vary multiple parameters simultaneously, assign distributions to inputs, test correlated uncertainty, simulate thousands of parameter combinations, or identify thresholds where rankings reverse.

Back to top ↑

What Is Scenario Comparison?

Scenario comparison evaluates how decisions perform across coherent alternative futures. A scenario is not merely a parameter value. It is a structured story or state of the world built from multiple conditions that plausibly occur together. Scenarios may include economic conditions, regulatory regimes, technology adoption, climate stress, behavioral response, political constraints, supply-chain disruption, or institutional capacity.

Scenario comparison is especially useful when uncertainty is broad, systemic, or difficult to assign precise probabilities. In some decisions, the problem is not that one parameter is uncertain. The problem is that the future itself may unfold in several different ways. Scenario comparison helps decision-makers test strategies across those different worlds.

For example, a public agency might compare a policy under baseline growth, fiscal constraint, social resistance, climate stress, and rapid technology change. A business might compare a strategy across market expansion, stagnation, regulatory tightening, platform disruption, and supply-chain instability. A resilience plan might compare options across frequent moderate shocks, rare severe shocks, and compound stress events.

Scenario comparison shifts attention from “Which future is most likely?” to “Which strategies remain credible if several futures are plausible?”

Back to top ↑

Sensitivity Analysis vs. Scenario Comparison

Sensitivity analysis and scenario comparison are closely related, but they are not identical. Sensitivity analysis usually varies one or more inputs to understand the effect of parameter uncertainty. Scenario comparison evaluates strategies across structured combinations of assumptions that represent different possible contexts.

In practical terms, sensitivity analysis is often more diagnostic, while scenario comparison is often more strategic. Sensitivity analysis identifies key drivers, thresholds, and fragile assumptions. Scenario comparison evaluates how strategies perform under alternative futures, stress conditions, and system contexts.

The two methods work best together. Sensitivity analysis can identify which variables deserve scenario attention. Scenario comparison can reveal whether parameter variation should be interpreted as part of a broader future condition. Together, they prevent both narrow model testing and vague scenario storytelling.

A mature decision process uses sensitivity analysis to understand assumption dependence and scenario comparison to understand strategic performance across uncertainty.

Back to top ↑

Assumption Dependence and Fragile Conclusions

Assumption dependence occurs when a model conclusion is driven by particular inputs or structural choices. This is not automatically a problem. All models depend on assumptions. The problem arises when assumptions are uncertain, contested, or hidden, while the decision recommendation is presented as stable or objective.

Fragile conclusions are recommendations that look strong under baseline assumptions but reverse under plausible variation. A policy may appear cost-effective only if participation is high. A financial strategy may dominate only if volatility remains low. A technology deployment may look safe only if false-positive rates remain within optimistic bounds. A climate adaptation strategy may look efficient only if hazard exposure grows slowly.

Sensitivity analysis exposes fragile conclusions. It helps distinguish between a decision that is genuinely robust and a decision that is merely optimized for one assumption set. This distinction is central to decision quality.

A recommendation is stronger when it survives plausible challenge. Sensitivity analysis makes that challenge systematic rather than anecdotal.

Back to top ↑

Types of Sensitivity Analysis

Different types of sensitivity analysis answer different questions. One-way sensitivity analysis varies a single input while holding others constant. Multi-way sensitivity analysis varies multiple inputs at once. Threshold analysis identifies the values at which the preferred decision changes. Probabilistic sensitivity analysis assigns distributions to uncertain inputs and evaluates a distribution of outcomes.

Each method has a different role. One-way analysis is clear and interpretable, but it may miss interactions. Multi-way analysis captures interactions, but it can become harder to communicate. Threshold analysis is highly decision-relevant because it identifies tipping points. Probabilistic sensitivity analysis gives a richer picture of uncertainty, but it depends on defensible input distributions.

The best choice depends on the decision. A simple procurement model may need one-way sensitivity analysis. A policy model may need threshold analysis around participation and implementation capacity. A financial risk model may need probabilistic sensitivity analysis. A climate infrastructure decision may need scenario comparison plus stress testing.

Good practice often combines multiple methods: one-way analysis for clarity, threshold analysis for decision relevance, probabilistic analysis for distributional insight, and scenarios for strategic context.

Back to top ↑

Scenario Design and Coherent Alternative Futures

Scenario comparison is only useful when scenarios are thoughtfully designed. A scenario should be plausible, coherent, decision-relevant, distinct from other scenarios, and connected to the uncertainties that matter. Weak scenarios are vague, generic, overly dramatic, politically convenient, or disconnected from the actual decision.

Scenario design begins by identifying key uncertainties. These may include demand, cost, climate stress, public acceptance, regulation, technological change, geopolitical instability, supply-chain reliability, model performance, or institutional capacity. The analyst then combines these uncertainties into coherent future conditions.

A strong scenario set does not simply include “best case,” “base case,” and “worst case.” That structure can be useful for stress testing, but it often oversimplifies uncertainty. Better scenario sets represent qualitatively different futures that challenge different assumptions.

Scenario comparison is not about predicting which scenario will happen. It is about testing strategies against conditions that could matter.

Back to top ↑

Identifying Key Drivers and Leverage Variables

One of the most valuable outputs of sensitivity analysis is the identification of key drivers. A key driver is an input that has disproportionate influence on the model output, decision ranking, risk score, expected utility, or threshold breach. Knowing the key drivers helps decision-makers focus attention where it matters.

Key drivers vary by domain. In a financial model, demand growth, price elasticity, volatility, interest rates, or inflation may dominate. In a public policy model, participation, implementation capacity, administrative cost, compliance, or political legitimacy may matter most. In infrastructure planning, climate exposure, asset lifetime, maintenance burden, and service interruption may dominate. In AI governance, false-positive rates, false-negative rates, appeal capacity, model drift, and harm severity may be critical.

Identifying key drivers helps allocate analytic effort. It is rarely useful to refine every parameter equally. Decision-makers should prioritize the uncertainties that can change the decision.

Key-driver analysis turns sensitivity analysis into decision intelligence. It shows where evidence, monitoring, design, governance, and adaptation should concentrate.

Back to top ↑

Thresholds, Tipping Points, and Preference Reversals

Threshold analysis identifies the point at which the preferred decision changes. This is one of the most practical forms of sensitivity analysis because it translates uncertainty into a decision-relevant question: how much would an assumption need to change before we should choose differently?

For example, a project may be preferred if demand growth exceeds 3 percent, but not if demand growth falls below that threshold. A medical intervention may be justified if diagnostic probability exceeds a treatment threshold. A policy may be worth scaling if implementation cost remains below a certain level. A risk mitigation strategy may become mandatory if downside probability crosses a governance threshold.

Threshold analysis is valuable because it supports monitoring. If the decision depends on a key threshold, the organization can track the relevant indicator and define a review trigger. This connects sensitivity analysis to adaptive decision-making.

Threshold analysis helps decision-makers avoid both overconfidence and paralysis. It shows what would have to be true for the decision to change.

Back to top ↑

From Sensitivity to Robustness

Sensitivity analysis and scenario comparison both contribute to robustness. A robust decision performs acceptably across a wide range of assumptions, scenarios, and stress conditions. It may not be the best option under one favored forecast, but it remains viable when the future deviates from expectation.

This is a major shift in decision logic. Traditional optimization asks which option performs best under a particular model. Robust decision-making asks which option performs well enough across many plausible models. This is especially important under deep uncertainty, where probabilities, outcomes, model structures, or stakeholder values may be contested.

Robustness does not mean avoiding risk entirely. It means avoiding strategies that depend on narrow assumptions, fragile forecasts, hidden value judgments, or optimistic conditions. It also means designing strategies that can adapt as evidence changes.

Robustness is not a technical add-on. It is a decision philosophy for uncertain environments.

Back to top ↑

Probabilistic Sensitivity Analysis

Probabilistic sensitivity analysis assigns probability distributions to uncertain inputs rather than varying them one at a time. This allows uncertainty to propagate through the model and produces a distribution of possible outcomes. It is especially useful when several inputs are uncertain at once.

For example, instead of assuming a single value for cost growth, demand, compliance, or failure probability, the analyst defines plausible distributions for each. The model is then run many times, drawing from those distributions. The result is not one output, but a range of outputs with estimated frequencies.

This approach is useful for risk analysis, health economics, financial modeling, infrastructure planning, and policy evaluation. It can show the probability that one option dominates, the probability of threshold breach, the distribution of regret, and the likelihood that a recommendation changes under input uncertainty.

Probabilistic sensitivity analysis is powerful, but it requires careful input distributions. Poorly justified distributions can create false sophistication. The method should document how distributions were chosen and how sensitive results are to those distribution choices.

Back to top ↑

Integration with Decision Trees and Probabilistic Models

Sensitivity analysis and scenario comparison are often used with decision trees, expected value models, expected utility models, risk models, Bayesian models, and multi-criteria decision analysis. They test whether the results of those models are stable under alternative assumptions.

In a decision tree, sensitivity analysis can vary branch probabilities, payoffs, test accuracy, information cost, or utility functions. This reveals whether the preferred branch depends on a specific probability or payoff estimate. Scenario comparison can evaluate how the tree performs under different future conditions.

In probabilistic models, sensitivity analysis can test input distributions, correlation assumptions, tail behavior, model structure, and threshold conditions. In Bayesian models, prior and likelihood sensitivity can show whether the posterior or recommended action depends on contested assumptions. In multi-criteria models, weight sensitivity can reveal whether rankings depend on hidden value judgments.

Sensitivity analysis is therefore not a separate method at the edge of decision modeling. It is part of responsible model use.

Back to top ↑

Sensitivity Analysis in Complex Systems

In complex systems, sensitivity analysis becomes more difficult and more important. Outcomes may depend on feedback loops, delays, nonlinear thresholds, adaptation, interdependence, and cascading effects. A small change in one variable may have little effect in one region of the system but large effects near a threshold.

Complex systems also produce interaction effects. The combined effect of two variables may be different from the sum of their individual effects. For example, infrastructure risk may depend not only on rainfall intensity and asset condition separately, but on their interaction. Public policy outcomes may depend on both compliance and institutional capacity. AI harms may depend on model drift, user behavior, oversight capacity, and appeal mechanisms interacting together.

In these settings, one-way sensitivity analysis may be insufficient. Multi-way sensitivity, global sensitivity analysis, scenario comparison, simulation, and stress testing become more important.

Complex systems require sensitivity analysis that respects structure. The question is not only which input matters most, but how inputs interact across system behavior.

Back to top ↑

Behavioral and Organizational Considerations

Sensitivity analysis and scenario comparison are analytical methods, but their use is shaped by human judgment and organizational incentives. Decision-makers may prefer scenarios that support existing plans, dismiss uncomfortable futures, anchor on baseline assumptions, or treat sensitivity analysis as a compliance exercise rather than a learning process.

Behavioral biases can distort interpretation. Confirmation bias can lead teams to vary only assumptions that preserve the preferred option. Availability bias can overemphasize dramatic recent events. Overconfidence can narrow parameter ranges. Anchoring can make baseline assumptions feel more realistic than they are. Groupthink can suppress dissent about fragile assumptions.

Organizations can also misuse scenarios. A leadership team may ask for “realistic” scenarios but define realism as anything close to current expectations. A model review may include sensitivity tables but ignore the fact that rankings reverse under plausible conditions. A board presentation may show only the baseline case because adverse scenarios are politically uncomfortable.

The purpose of sensitivity analysis is not to make a decision look rigorous. It is to expose how the decision could fail, reverse, or require revision.

Back to top ↑

Applications Across Decision Contexts

Sensitivity analysis and scenario comparison are widely used because uncertainty affects nearly every domain of serious decision-making. Their specific inputs and outputs differ by field, but the core purpose remains the same: test how decisions perform when assumptions change.

In public policy, these methods test implementation uncertainty, cost variation, behavioral response, equity effects, and political feasibility. In finance, they test market volatility, interest rates, credit risk, liquidity, and downside exposure. In engineering, they test design assumptions, reliability, failure rates, and stress conditions. In healthcare, they test diagnostic accuracy, treatment effectiveness, patient risk, and cost-effectiveness. In sustainability and climate planning, they test long-horizon uncertainty, adaptation pathways, and irreversible consequences.

Across domains, these methods improve decision quality by making uncertainty operational rather than rhetorical.

Back to top ↑

Limitations and Challenges

Sensitivity analysis and scenario comparison have limitations. Sensitivity analysis can be too narrow if it varies only easy-to-quantify inputs while ignoring structural uncertainty. It can also become mechanical, producing tables and charts without changing the decision process. Scenario comparison can become vague if scenarios are not connected to decision metrics, thresholds, or actions.

Another challenge is scope. Too many sensitivity tests can overwhelm decision-makers. Too few can hide fragility. Too many scenarios can diffuse attention. Too few can reinforce baseline thinking. The goal is not maximum analysis. The goal is decision-relevant analysis.

These methods also depend on judgment. Analysts must decide which inputs to vary, what ranges are plausible, which scenarios matter, how to represent uncertainty, and which outcomes count. That judgment should be documented, not hidden.

The strength of these methods depends on their connection to action. Analysis that does not inform decisions, thresholds, monitoring, or revision is only decoration.

Back to top ↑

Summary Table: Sensitivity, Scenarios, and Decision Quality

The table below summarizes how sensitivity analysis and scenario comparison support decision quality.

Decision quality improves when uncertainty is not hidden behind the baseline case. Sensitivity and scenario work make uncertainty part of the decision architecture.

Back to top ↑

Back to top ↑

Mathematical Lens: Local Sensitivity, Elasticity, Thresholds, and Scenario Robustness

The mathematical lens clarifies how sensitivity analysis and scenario comparison translate uncertainty into structured decision diagnostics.

A model output can be written as a function of uncertain inputs:

Local sensitivity to an input \(x_i\) can be represented as a partial derivative:

Elasticity expresses sensitivity in relative terms:

Threshold analysis identifies the input value at which the preferred action changes:

Scenario performance evaluates an action across a set of scenarios:

Expected scenario performance can be calculated if scenario probabilities are assigned:

Robustness can be represented as worst-case performance across scenarios:

Regret compares an action to the best action available in each scenario:

The mathematical lesson is simple: a decision should not be evaluated only by its baseline result. It should be evaluated by how its result changes when inputs, scenarios, and assumptions change.

Back to top ↑

R Workflow: Ranking Stability, Thresholds, and Scenario Robustness Profiles

The R workflow below compares stylized strategies across scenarios, parameter weights, threshold conditions, robustness scores, and regret profiles. It uses base R so it can run without additional package installation.

# sensitivity_analysis_scenario_comparison_workflow.R
# Base R workflow for ranking stability, scenario comparison,
# threshold analysis, robustness profiles, and regret diagnostics.

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(
    "Efficiency Strategy",
    "Balanced Strategy",
    "Resilience Strategy",
    "Adaptive Strategy",
    "Precautionary Strategy"
  ),
  cost_score = c(0.92, 0.76, 0.58, 0.70, 0.62),
  resilience_score = c(0.38, 0.72, 0.94, 0.86, 0.91),
  flexibility_score = c(0.44, 0.70, 0.68, 0.91, 0.74),
  implementation_score = c(0.88, 0.78, 0.62, 0.71, 0.69),
  downside_protection = c(0.34, 0.66, 0.88, 0.81, 0.93),
  stringsAsFactors = FALSE
)

scenarios <- data.frame( scenario = c( "Baseline", "Fiscal Stress", "High Volatility", "Climate Stress", "Implementation Constraint", "Compound Stress" ), cost_weight = c(0.30, 0.45, 0.20, 0.15, 0.25, 0.20), resilience_weight = c(0.22, 0.20, 0.30, 0.40, 0.25, 0.35), flexibility_weight = c(0.18, 0.15, 0.28, 0.20, 0.20, 0.25), implementation_weight = c(0.20, 0.15, 0.12, 0.10, 0.25, 0.10), downside_weight = c(0.10, 0.05, 0.10, 0.15, 0.05, 0.10), scenario_probability = c(0.30, 0.15, 0.18, 0.14, 0.13, 0.10), stringsAsFactors = FALSE ) if (any(abs(rowSums(scenarios[, c( "cost_weight", "resilience_weight", "flexibility_weight", "implementation_weight", "downside_weight" )]) - 1) > 1e-8)) {
  stop("Scenario weights must sum to 1.")
}

scenario_results <- data.frame()

for (i in seq_len(nrow(strategies))) {
  strategy <- strategies[i, ]

  for (j in seq_len(nrow(scenarios))) {
    scenario <- scenarios[j, ]

    composite_score <- (
      strategy$cost_score * scenario$cost_weight +
      strategy$resilience_score * scenario$resilience_weight +
      strategy$flexibility_score * scenario$flexibility_weight +
      strategy$implementation_score * scenario$implementation_weight +
      strategy$downside_protection * scenario$downside_weight
    )

    scenario_results <- rbind(
      scenario_results,
      data.frame(
        strategy = strategy$strategy,
        scenario = scenario$scenario,
        composite_score = composite_score,
        scenario_probability = scenario$scenario_probability,
        stringsAsFactors = FALSE
      )
    )
  }
}

scenario_results$scenario_rank <- ave(
  -scenario_results$composite_score,
  scenario_results$scenario,
  FUN = function(x) rank(x, ties.method = "min")
)

write.csv(
  scenario_results,
  file.path(tables_dir, "scenario_strategy_scores.csv"),
  row.names = FALSE
)

robustness_summary <- do.call(
  rbind,
  lapply(
    split(scenario_results, scenario_results$strategy),
    function(x) {
      data.frame(
        strategy = unique(x$strategy),
        average_score = mean(x$composite_score),
        probability_weighted_score = sum(x$composite_score * x$scenario_probability),
        minimum_score = min(x$composite_score),
        maximum_score = max(x$composite_score),
        score_range = max(x$composite_score) - min(x$composite_score),
        average_rank = mean(x$scenario_rank),
        worst_rank = max(x$scenario_rank),
        best_rank = min(x$scenario_rank),
        rank_range = max(x$scenario_rank) - min(x$scenario_rank),
        stringsAsFactors = FALSE
      )
    }
  )
)

robustness_summary$robustness_score <- (
  0.40 * robustness_summary$probability_weighted_score +
  0.35 * robustness_summary$minimum_score -
  0.15 * robustness_summary$score_range -
  0.10 * robustness_summary$average_rank / max(robustness_summary$average_rank)
)

robustness_summary <- robustness_summary[order(-robustness_summary$robustness_score), ]

write.csv(
  robustness_summary,
  file.path(tables_dir, "strategy_robustness_summary.csv"),
  row.names = FALSE
)

regret_rows <- data.frame()

for (scenario_name in unique(scenario_results$scenario)) {
  subset_rows <- scenario_results[scenario_results$scenario == scenario_name, ]
  best_score <- max(subset_rows$composite_score)

  regret_rows <- rbind(
    regret_rows,
    data.frame(
      strategy = subset_rows$strategy,
      scenario = subset_rows$scenario,
      composite_score = subset_rows$composite_score,
      best_scenario_score = best_score,
      regret = best_score - subset_rows$composite_score,
      stringsAsFactors = FALSE
    )
  )
}

regret_summary <- aggregate(
  regret ~ strategy,
  data = regret_rows,
  FUN = function(x) c(mean_regret = mean(x), max_regret = max(x))
)

regret_summary <- data.frame(
  strategy = regret_summary$strategy,
  average_regret = regret_summary$regret[, "mean_regret"],
  maximum_regret = regret_summary$regret[, "max_regret"],
  stringsAsFactors = FALSE
)

regret_summary <- regret_summary[order(regret_summary$maximum_regret), ]

write.csv(
  regret_rows,
  file.path(tables_dir, "scenario_regret_detail.csv"),
  row.names = FALSE
)

write.csv(
  regret_summary,
  file.path(tables_dir, "scenario_regret_summary.csv"),
  row.names = FALSE
)

threshold_grid <- seq(0.05, 0.60, by = 0.01)
threshold_rows <- data.frame()

for (w in threshold_grid) {
  temp <- scenarios
  temp$resilience_weight <- w

  remaining <- 1 - temp$resilience_weight
  original_other_total <- temp$cost_weight + temp$flexibility_weight + temp$implementation_weight + temp$downside_weight

  temp$cost_weight <- remaining * temp$cost_weight / original_other_total
  temp$flexibility_weight <- remaining * temp$flexibility_weight / original_other_total
  temp$implementation_weight <- remaining * temp$implementation_weight / original_other_total
  temp$downside_weight <- remaining * temp$downside_weight / original_other_total

  rows <- data.frame()

  for (i in seq_len(nrow(strategies))) {
    s <- strategies[i, ]

    for (j in seq_len(nrow(temp))) {
      sc <- temp[j, ]

      score <- (
        s$cost_score * sc$cost_weight +
        s$resilience_score * sc$resilience_weight +
        s$flexibility_score * sc$flexibility_weight +
        s$implementation_score * sc$implementation_weight +
        s$downside_protection * sc$downside_weight
      )

      rows <- rbind(
        rows,
        data.frame(
          strategy = s$strategy,
          scenario = sc$scenario,
          score = score,
          probability = sc$scenario_probability,
          stringsAsFactors = FALSE
        )
      )
    }
  }

  weighted_scores <- aggregate(
    score * probability ~ strategy,
    data = rows,
    FUN = sum
  )

  names(weighted_scores) <- c("strategy", "probability_weighted_score")
  winner <- weighted_scores$strategy[which.max(weighted_scores$probability_weighted_score)]

  threshold_rows <- rbind(
    threshold_rows,
    data.frame(
      resilience_weight = w,
      winning_strategy = winner,
      winning_score = max(weighted_scores$probability_weighted_score),
      stringsAsFactors = FALSE
    )
  )
}

write.csv(
  threshold_rows,
  file.path(tables_dir, "resilience_weight_threshold_analysis.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "robustness_score_by_strategy.png"), width = 1200, height = 800)
barplot(
  robustness_summary$robustness_score,
  names.arg = robustness_summary$strategy,
  las = 2,
  main = "Robustness Score by Strategy",
  ylab = "Robustness score"
)
grid()
dev.off()

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

png(file.path(figures_dir, "scenario_score_profiles.png"), width = 1200, height = 800)
plot(
  1,
  type = "n",
  xlim = c(1, length(unique(scenario_results$scenario))),
  ylim = range(scenario_results$composite_score),
  xaxt = "n",
  xlab = "Scenario",
  ylab = "Composite score",
  main = "Scenario Score Profiles"
)

scenario_names <- unique(scenario_results$scenario)
axis(1, at = seq_along(scenario_names), labels = scenario_names, las = 2)

for (strategy_name in unique(scenario_results$strategy)) {
  subset_rows <- scenario_results[scenario_results$strategy == strategy_name, ]
  subset_rows <- subset_rows[match(scenario_names, subset_rows$scenario), ]
  lines(seq_along(scenario_names), subset_rows$composite_score, type = "b")
}

legend("bottomleft", legend = unique(scenario_results$strategy), bty = "n", cex = 0.8)
grid()
dev.off()

print(robustness_summary)
print(regret_summary)
print(head(threshold_rows, 15))

This workflow evaluates strategy performance across scenarios, computes robustness and regret, and identifies how rankings change as the resilience weight varies. The outputs show whether the top-ranked strategy is genuinely robust or merely strong under a convenient weighting structure.

Back to top ↑

Python Workflow: Simulating Strategy Robustness, Regret, and Scenario Fragility

The Python workflow below simulates scenario performance under uncertain demand, cost, disruption, resilience, and adaptation parameters. It compares strategies by average performance, minimum performance, regret, downside breach rate, and robustness score. It uses only the Python standard library.

# sensitivity_analysis_scenario_comparison_simulation.py
# Standard-library workflow for scenario comparison, sensitivity,
# robustness, regret, downside breach, and decision records.

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
import csv
import json
import random
from statistics import mean, pstdev

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


@dataclass(frozen=True)
class Strategy:
    name: str
    base_value: float
    demand_sensitivity: float
    cost_sensitivity: float
    disruption_sensitivity: float
    resilience_buffer: float
    adaptation_capacity: float


@dataclass(frozen=True)
class Scenario:
    name: str
    demand_shift: float
    cost_pressure: float
    disruption_pressure: float
    volatility: float
    probability: float


def evaluate_strategy(strategy: Strategy, scenario: Scenario, rng: random.Random) -> float:
    random_shock = rng.gauss(0.0, scenario.volatility)

    value = (
        strategy.base_value
        + strategy.demand_sensitivity * scenario.demand_shift
        - strategy.cost_sensitivity * scenario.cost_pressure
        - strategy.disruption_sensitivity * scenario.disruption_pressure
        + strategy.resilience_buffer * max(0.0, scenario.disruption_pressure)
        + strategy.adaptation_capacity * abs(scenario.demand_shift)
        + random_shock
    )

    return value


def simulate(
    strategies: list[Strategy],
    scenarios: list[Scenario],
    trials_per_scenario: int = 750,
    seed: int = 42,
) -> list[dict[str, object]]:
    rng = random.Random(seed)
    rows: list[dict[str, object]] = []

    for scenario in scenarios:
      for trial in range(1, trials_per_scenario + 1):
        scenario_values: dict[str, float] = {}

        for strategy in strategies:
            value = evaluate_strategy(strategy, scenario, rng)
            scenario_values[strategy.name] = value

        best_value = max(scenario_values.values())

        for strategy_name, value in scenario_values.items():
            rows.append({
                "scenario": scenario.name,
                "trial": trial,
                "strategy": strategy_name,
                "value": round(value, 6),
                "best_trial_value": round(best_value, 6),
                "regret": round(best_value - value, 6),
                "downside_breach": value < 55.0, "scenario_probability": scenario.probability, }) return rows def summarize(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    strategies = sorted({str(row["strategy"]) for row in rows})
    output: list[dict[str, object]] = []

    for strategy in strategies:
        subset = [row for row in rows if row["strategy"] == strategy]
        values = [float(row["value"]) for row in subset]
        regrets = [float(row["regret"]) for row in subset]
        breaches = [bool(row["downside_breach"]) for row in subset]

        scenario_minima: list[float] = []
        scenario_averages: list[float] = []

        for scenario in sorted({str(row["scenario"]) for row in subset}):
            scenario_rows = [row for row in subset if row["scenario"] == scenario]
            scenario_values = [float(row["value"]) for row in scenario_rows]
            scenario_minima.append(min(scenario_values))
            scenario_averages.append(mean(scenario_values))

        average_value = mean(values)
        minimum_scenario_average = min(scenario_averages)
        worst_observed_value = min(values)
        average_regret = mean(regrets)
        maximum_regret = max(regrets)
        downside_breach_rate = sum(1 for breach in breaches if breach) / len(breaches)
        volatility = pstdev(values)

        robustness_score = (
            0.35 * average_value
            + 0.30 * minimum_scenario_average
            + 0.20 * worst_observed_value
            - 0.10 * maximum_regret
            - 0.05 * volatility
        )

        output.append({
            "strategy": strategy,
            "average_value": round(average_value, 6),
            "minimum_scenario_average": round(minimum_scenario_average, 6),
            "worst_observed_value": round(worst_observed_value, 6),
            "volatility": round(volatility, 6),
            "average_regret": round(average_regret, 6),
            "maximum_regret": round(maximum_regret, 6),
            "downside_breach_rate": round(downside_breach_rate, 6),
            "robustness_score": round(robustness_score, 6),
        })

    return sorted(output, key=lambda row: float(row["robustness_score"]), reverse=True)


def scenario_summary(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    output: list[dict[str, object]] = []
    scenarios = sorted({str(row["scenario"]) for row in rows})
    strategies = sorted({str(row["strategy"]) for row in rows})

    for scenario in scenarios:
        for strategy in strategies:
            subset = [
                row for row in rows
                if row["scenario"] == scenario and row["strategy"] == strategy
            ]
            values = [float(row["value"]) for row in subset]
            regrets = [float(row["regret"]) for row in subset]
            output.append({
                "scenario": scenario,
                "strategy": strategy,
                "average_value": round(mean(values), 6),
                "minimum_value": round(min(values), 6),
                "average_regret": round(mean(regrets), 6),
                "maximum_regret": round(max(regrets), 6),
                "downside_breach_rate": round(
                    sum(1 for row in subset if bool(row["downside_breach"])) / len(subset),
                    6,
                ),
            })

    return output


def threshold_analysis(strategies: list[Strategy]) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []

    demand_values = [x / 10 for x in range(-20, 31)]
    base_scenario = Scenario("Threshold Test", 0.0, 0.50, 0.50, 0.0, 1.0)

    for demand_shift in demand_values:
        scenario = Scenario(
            base_scenario.name,
            demand_shift,
            base_scenario.cost_pressure,
            base_scenario.disruption_pressure,
            base_scenario.volatility,
            base_scenario.probability,
        )
        rng = random.Random(1)
        scores = {
            strategy.name: evaluate_strategy(strategy, scenario, rng)
            for strategy in strategies
        }
        winner = max(scores.items(), key=lambda item: item[1])

        rows.append({
            "demand_shift": demand_shift,
            "winning_strategy": winner[0],
            "winning_value": round(winner[1], 6),
        })

    return rows


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:
    strategies = [
        Strategy("Efficiency Strategy", 78.0, 10.0, 16.0, 18.0, 4.0, 3.0),
        Strategy("Balanced Strategy", 75.0, 8.0, 10.0, 11.0, 9.0, 7.0),
        Strategy("Resilience Strategy", 70.0, 5.5, 8.0, 7.0, 16.0, 5.0),
        Strategy("Adaptive Strategy", 73.0, 7.0, 9.0, 9.0, 12.0, 12.0),
        Strategy("Precautionary Strategy", 68.0, 4.0, 6.0, 5.0, 18.0, 6.0),
    ]

    scenarios = [
        Scenario("Baseline", 0.50, 0.30, 0.20, 3.0, 0.30),
        Scenario("Fiscal Stress", -0.20, 1.00, 0.35, 4.5, 0.15),
        Scenario("High Volatility", 0.30, 0.55, 0.75, 8.0, 0.18),
        Scenario("Climate Stress", -0.10, 0.75, 1.25, 7.5, 0.14),
        Scenario("Implementation Constraint", 0.10, 0.80, 0.60, 5.5, 0.13),
        Scenario("Compound Stress", -0.45, 1.20, 1.55, 10.0, 0.10),
    ]

    trial_rows = simulate(strategies, scenarios, trials_per_scenario=750, seed=42)
    robustness_rows = summarize(trial_rows)
    scenario_rows = scenario_summary(trial_rows)
    threshold_rows = threshold_analysis(strategies)

    write_csv(TABLES / "scenario_simulation_trials.csv", trial_rows)
    write_csv(TABLES / "strategy_robustness_summary.csv", robustness_rows)
    write_csv(TABLES / "scenario_strategy_summary.csv", scenario_rows)
    write_csv(TABLES / "demand_threshold_analysis.csv", threshold_rows)

    write_json(
        RECORDS / "sensitivity_scenario_decision_record.json",
        {
            "article": "Sensitivity Analysis and Scenario Comparison",
            "decision_context": "Testing strategy performance across uncertain scenarios, parameters, regret, and robustness conditions.",
            "modeling_principles": [
                "Baseline results should not be treated as final recommendations.",
                "Decision rankings should be tested under plausible parameter variation.",
                "Scenarios should represent coherent alternative futures.",
                "Robustness requires acceptable performance across multiple conditions.",
                "Regret reveals the cost of being wrong in particular scenarios.",
                "Threshold analysis identifies when decisions should be reviewed.",
                "Sensitivity results should be preserved in accountable decision records.",
            ],
            "robustness_summary": robustness_rows,
            "threshold_summary": threshold_rows,
        },
    )

    print("Sensitivity analysis and scenario comparison workflow complete.")
    print(TABLES / "strategy_robustness_summary.csv")
    print(TABLES / "scenario_strategy_summary.csv")
    print(TABLES / "demand_threshold_analysis.csv")
    print(RECORDS / "sensitivity_scenario_decision_record.json")


if __name__ == "__main__":
    main()

This workflow shows how a strategy can perform well on average but still carry high regret, downside breach exposure, or scenario fragility. It also produces a decision record that documents the uncertainty tests behind the recommendation.

Back to top ↑

GitHub Repository

The companion repository for this article supports reproducible exploration of sensitivity analysis, scenario comparison, threshold testing, robustness scoring, regret analysis, probabilistic sensitivity, key-driver diagnostics, scenario stress testing, and decision-record documentation.

articles/sensitivity-analysis-and-scenario-comparison/
├── python/
│   ├── sensitivity_analysis_scenario_comparison_simulation.py
│   ├── one_way_sensitivity.py
│   ├── multi_way_sensitivity.py
│   ├── threshold_analysis.py
│   ├── scenario_robustness_profiles.py
│   ├── regret_analysis.py
│   ├── probabilistic_sensitivity.py
│   ├── key_driver_diagnostics.py
│   ├── decision_record_exporter.py
│   └── run_all_sensitivity_workflows.py
├── r/
│   ├── sensitivity_analysis_scenario_comparison_workflow.R
│   ├── ranking_stability_profiles.R
│   ├── scenario_robustness_report.R
│   ├── threshold_analysis_tables.R
│   ├── regret_summary_tables.R
│   ├── probabilistic_sensitivity_summary.R
│   └── run_all_sensitivity_workflows.R
├── julia/
│   ├── high_performance_sensitivity_scan.jl
│   ├── robustness_surface.jl
│   └── threshold_frontier.jl
├── sql/
│   ├── schema_sensitivity_scenarios.sql
│   ├── strategies.sql
│   ├── parameters.sql
│   ├── scenarios.sql
│   ├── scenario_scores.sql
│   ├── thresholds.sql
│   ├── model_runs.sql
│   └── decision_records.sql
├── rust/
│   └── sensitivity_diagnostics_cli.rs
├── go/
│   └── scenario_score_runner.go
├── cpp/
│   ├── sensitivity_core.cpp
│   └── regret_scan.cpp
├── fortran/
│   └── numerical_sensitivity_model.f90
├── c/
│   └── threshold_core.c
├── docs/
│   ├── article_notes.md
│   ├── modeling_principles.md
│   ├── sensitivity_analysis.md
│   ├── scenario_comparison.md
│   ├── threshold_analysis.md
│   ├── robustness.md
│   ├── regret_analysis.md
│   ├── probabilistic_sensitivity.md
│   ├── responsible_use.md
│   └── assumptions_and_limitations.md
├── data/
│   ├── synthetic_strategies.csv
│   ├── synthetic_parameters.csv
│   ├── synthetic_scenarios.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_sensitivity_scenario_walkthrough.ipynb
    └── r_sensitivity_scenario_placeholder.ipynb

This repository structure reflects the article’s central argument: sensitivity analysis and scenario comparison are most useful when assumption dependence, ranking stability, robustness, regret, thresholds, and review triggers are made explicit and reproducible.

Back to top ↑

Back to top ↑

Common Pitfalls

Sensitivity analysis and scenario comparison can improve decision quality, but only when used honestly. They can also become ritualized exercises that protect baseline assumptions instead of challenging them.

The most dangerous sensitivity analysis is one that confirms the baseline without testing whether the baseline deserves trust.

Back to top ↑

Why Sensitivity Analysis and Scenario Comparison Matter

Sensitivity analysis and scenario comparison matter because responsible decisions cannot depend on one convenient version of the future. They help decision-makers test assumptions, identify key drivers, detect fragile recommendations, compare strategies across uncertainty, and design review triggers for changing conditions.

Their deeper value is not only analytical. They improve judgment. They shift attention from prediction to evaluation, from baseline confidence to assumption transparency, and from narrow optimization to robust and adaptive choice. They make it harder for decision-makers to hide uncertainty behind a single number.

In modern decision science, sensitivity analysis and scenario comparison are not optional extras. They are part of accountable modeling. They show what would have to be true for a decision to hold, what would make it fail, and what should be monitored after action begins.

Back to top ↑

Related Articles

• Decision Science
• What Is Decision Science?
• Why Uncertainty Changes Decision-Making
• Expected Value and Expected Utility
• Decision Trees and Structured Choice
• Risk Analysis and Probabilistic Reasoning
• Bayesian Decision-Making
• Probability Calibration and Decision Confidence
• Forecasting and Decision Support
• Robust Decision-Making
• Decision-Making Under Deep Uncertainty
• Regret Analysis and Minimax Decision Rules

Back to top ↑

Further Reading

• Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D., Saisana, M. and Tarantola, S. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Saltelli, A., Chan, K. and Scott, E.M. (eds.) (2000) Sensitivity Analysis. Chichester: Wiley.
• Hammond, J.S., Keeney, R.L. and Raiffa, H. (1999) Smart Choices: A Practical Guide to Making Better Decisions. Boston, MA: Harvard Business School Press. Available at: https://store.hbr.org/product/smart-choices-a-practical-guide-to-making-better-decisions/15040
• Howard, R.A. and Abbas, A.E. (2023) Foundations of Decision Analysis. Harlow: Pearson. Available at: https://www.pearson.com/en-us/subject-catalog/p/foundations-of-decision-analysis/P200000003532/9780137981878
• 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: https://www.rand.org/pubs/monograph_reports/MR1626.html
• RAND Corporation (no date) Robust Decision Making. Available at: https://www.rand.org/topics/robust-decision-making.html
• Kahneman, D. (2013) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux. Available at: https://us.macmillan.com/books/9780374533557/thinkingfastandslow/
• Tetlock, P.E. and Gardner, D. (2016) Superforecasting: The Art and Science of Prediction. New York: Crown. Available at: https://www.penguinrandomhouse.com/books/227815/superforecasting-by-philip-e-tetlock-and-dan-gardner/

Back to top ↑

References

• Hammond, J.S., Keeney, R.L. and Raiffa, H. (1999) Smart Choices: A Practical Guide to Making Better Decisions. Boston, MA: Harvard Business School Press. Available at: https://store.hbr.org/product/smart-choices-a-practical-guide-to-making-better-decisions/15040
• Howard, R.A. and Abbas, A.E. (2023) Foundations of Decision Analysis. Harlow: Pearson. Available at: https://www.pearson.com/en-us/subject-catalog/p/foundations-of-decision-analysis/P200000003532/9780137981878
• Kahneman, D. (2013) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux. Available at: https://us.macmillan.com/books/9780374533557/thinkingfastandslow/
• 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: https://www.rand.org/pubs/monograph_reports/MR1626.html
• RAND Corporation (no date) Robust Decision Making. Available at: https://www.rand.org/topics/robust-decision-making.html
• Saltelli, A., Chan, K. and Scott, E.M. (eds.) (2000) Sensitivity Analysis. Chichester: Wiley.
• Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D., Saisana, M. and Tarantola, S. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Tetlock, P.E. and Gardner, D. (2016) Superforecasting: The Art and Science of Prediction. New York: Crown. Available at: https://www.penguinrandomhouse.com/books/227815/superforecasting-by-philip-e-tetlock-and-dan-gardner/

Back to top ↑