Sensitivity Analysis for Algorithms and Models: How to Test What Results Depend On

Last Updated June 20, 2026

Sensitivity analysis for algorithms and models explains how computational outputs change when assumptions, inputs, parameters, thresholds, rules, data, or model structures shift. A model output is rarely meaningful by itself. It depends on choices: which variables are included, which parameters are fixed, which thresholds are used, which data are trusted, which algorithm is selected, and which uncertainty is ignored or represented.

Sensitivity analysis asks what happens when those choices are varied. Does the conclusion stay stable? Does one parameter dominate the result? Does a small threshold change reverse a decision? Does a model behave differently under alternative assumptions? Does performance collapse for edge cases, subgroups, or changed environments? These questions turn computational outputs into something more inspectable.

This article introduces sensitivity analysis as a core practice in algorithmic reasoning. It explains local and global sensitivity, one-at-a-time analysis, scenario comparison, parameter sweeps, threshold analysis, structural sensitivity, robustness, uncertainty, validation, governance, reproducibility, and interpretation limits.

This article explains sensitivity analysis, parameter sweeps, one-at-a-time variation, global sensitivity, local sensitivity, threshold testing, scenario comparison, perturbation analysis, robustness checks, structural uncertainty, model comparison, algorithmic stability, decision thresholds, subgroup sensitivity, computational evidence, reproducibility, governance, and representation risk. It emphasizes that a computational conclusion is stronger when we know what would change it.

Why Sensitivity Analysis Matters

Sensitivity analysis matters because computational systems often appear more certain than they are. A model may produce a single forecast, score, ranking, recommendation, risk estimate, simulation result, optimized plan, or classification. But that output depends on assumptions. If small changes in those assumptions produce large changes in the result, the conclusion may be fragile.

Sensitivity analysis makes fragility visible. It shows which inputs matter, which parameters dominate, which thresholds are unstable, which scenarios reverse conclusions, which model structures create different results, and which claims remain robust across reasonable variation.

A result that has never been challenged by sensitivity analysis is not yet well understood.

Back to top ↑

Sensitivity Analysis Defined

Sensitivity analysis is the study of how outputs change when inputs, parameters, assumptions, thresholds, rules, or model structures change. It asks which parts of a computational system have the greatest influence on results and whether conclusions remain stable under reasonable variation.

Sensitivity analysis is not only a technical add-on. It is a form of reasoning about dependence. It helps answer: What is this result relying on? What would make it change? What is stable? What is fragile? What has been assumed rather than demonstrated?

Sensitivity analysis shows whether outputs are consequences of strong evidence or artifacts of fragile choices.

Back to top ↑

Inputs, Parameters, Thresholds, and Assumptions

Sensitivity analysis begins by identifying what can vary. Some quantities are inputs: observed data, measured values, demand estimates, exposure levels, costs, distances, probabilities, or features. Some are parameters: coefficients, rates, weights, tolerances, constraints, learning rates, or transition probabilities. Some are thresholds: cutoffs for classification, eligibility, risk, intervention, ranking, alerting, or stopping.

Assumptions are broader. They include model boundaries, functional forms, missing-data rules, sampling procedures, update order, scenario definitions, and institutional rules. A responsible sensitivity review asks which assumptions are fixed, which are uncertain, which are contested, and which affect conclusions.

Sensitivity analysis makes assumptions visible by testing their consequences.

Back to top ↑

Local Sensitivity

Local sensitivity examines how outputs change near a reference point. It asks what happens when one input or parameter is changed slightly around a baseline value. This is useful when the baseline is meaningful and small perturbations are realistic.

Local sensitivity often resembles a derivative: how much does the output change per unit change in an input? It is common in numerical modeling, optimization, engineering, calibration, and decision-support systems where analysts want to understand marginal influence near current assumptions.

Local sensitivity is powerful, but it should not be mistaken for a complete view of model behavior.

Back to top ↑

Global Sensitivity

Global sensitivity examines how outputs change across broader ranges of inputs or parameters. Instead of asking what happens near one baseline, it asks how output variation is distributed across the full range of plausible uncertainty. Global sensitivity is especially important when systems are nonlinear, parameters interact, thresholds create abrupt changes, or baseline assumptions are uncertain.

Global approaches may use sampling, variance decomposition, scenario grids, Latin hypercube sampling, Sobol methods, Morris screening, Monte Carlo runs, or structured ensembles. The purpose is to identify which variables matter most across a broad uncertainty space.

Global sensitivity helps distinguish a robust conclusion from one that holds only in a narrow corner of assumption space.

Back to top ↑

One-at-a-Time Analysis

One-at-a-time sensitivity analysis varies one input or parameter while holding others fixed. It is simple, interpretable, and useful for first-pass review. It can identify obvious drivers and communicate the direction of influence clearly.

But one-at-a-time analysis can miss interactions. If two variables matter only together, varying each separately may understate their importance. It can also create false confidence if the ranges are too narrow or if the baseline is not representative.

One-at-a-time analysis is often the beginning of sensitivity review, not the end.

Back to top ↑

Scenario Comparison

Scenario comparison varies structured sets of assumptions rather than isolated parameters. A baseline scenario may represent current conditions. Alternative scenarios may represent optimistic, pessimistic, policy, stress, or intervention assumptions. Scenario analysis is especially useful when variables move together or when decision-makers need to compare plausible worlds.

Scenarios should be designed carefully. They should not be arbitrary collections of values chosen to support a preferred conclusion. They should be documented, justified, and linked to the question being asked.

Scenario analysis makes assumptions legible as bundles, which is often closer to how real decisions are made.

Back to top ↑

Threshold Sensitivity

Threshold sensitivity examines how decisions change when a cutoff changes. Thresholds are everywhere in computational systems: classification cutoffs, eligibility rules, alert triggers, risk categories, ranking boundaries, optimization constraints, stopping conditions, and intervention thresholds.

A model score may look continuous, but institutional action often becomes categorical. Above a threshold, someone receives service, review, denial, warning, ranking, priority, or intervention. Below the threshold, they do not. Sensitivity analysis should examine how many cases sit near the boundary and how decisions change across plausible cutoffs.

Threshold sensitivity is especially important when computational scores become institutional decisions.

Back to top ↑

Structural Sensitivity

Structural sensitivity examines how outputs change when the model form, algorithm, representation, or causal structure changes. This matters because not all uncertainty is about parameter values. Sometimes the deeper question is whether the chosen model structure is appropriate.

A linear model may reach different conclusions than a nonlinear model. An agent-based model may reveal behavior that an aggregate model hides. A network model may produce different outcomes than random mixing. A causal model may identify different effects than a correlational model. A classifier may behave differently depending on feature definitions.

Structural sensitivity asks whether the computational framing itself is driving the result.

Back to top ↑

Algorithmic Stability and Robustness

Algorithmic stability asks whether an algorithm’s output changes substantially when data, parameters, seeds, or operating conditions change slightly. Robustness asks whether conclusions remain reliable across reasonable variation. These ideas matter for prediction, ranking, optimization, simulation, classification, clustering, and decision support.

A ranking that changes dramatically after small data changes may be unstable. A classifier that flips decisions near a threshold may require review. An optimization result that depends on one cost estimate may be fragile. A simulation conclusion that appears only under one seed may be weak.

Stability is not always required, but instability must be known and communicated.

Back to top ↑

Sensitivity Analysis in Validation

Sensitivity analysis is a validation practice because it tests whether model claims are supported under uncertainty. A model may pass benchmark tests and still be fragile. It may fit observed data but depend heavily on one assumption. It may perform well on average but change decisions under threshold variation.

Validation should therefore include sensitivity evidence. This evidence helps reviewers decide whether the model is credible for the intended use, whether more data are needed, whether assumptions need governance review, and whether decision-makers should rely on the output.

Sensitivity analysis helps convert validation from a pass-fail ritual into a deeper evidence review.

Back to top ↑

Uncertainty and Sensitivity

Uncertainty analysis and sensitivity analysis are closely related. Uncertainty analysis asks how uncertain outputs are. Sensitivity analysis asks where that uncertainty comes from. If an output range is wide, sensitivity analysis can identify which inputs, assumptions, or parameters contribute most to that range.

This distinction matters. It is not enough to say that a model is uncertain. A responsible workflow should ask which uncertainties matter, which can be reduced, which are structural, which are unavoidable, and which are most relevant to decisions.

Sensitivity analysis helps prioritize uncertainty by showing which uncertainty matters for the result.

Back to top ↑

Governance and Decision Use

Sensitivity analysis has governance implications. If a decision depends heavily on a threshold, the threshold needs justification. If a model depends heavily on one data source, that source needs monitoring. If a conclusion depends on a contested assumption, that assumption needs review. If a model behaves differently across subgroups, fairness and accountability concerns may arise.

Sensitivity results should therefore be included in model documentation, validation reports, audit trails, model cards, datasheets, risk assessments, and decision-support summaries. They help define where the model can be used, where it should be monitored, and where it should not be relied on.

Sensitivity analysis is not only technical evidence. It is information for responsible decision governance.

Back to top ↑

Representation Risk

Representation risk appears when sensitivity analysis is presented as more complete than it is. A narrow parameter sweep may be described as a robust test. A one-at-a-time analysis may hide interactions. A polished tornado chart may imply that all important uncertainties were included, even if major structural assumptions were never varied.

Another risk is that sensitivity analysis can be used selectively. Analysts may test only assumptions that make the model look stable, while avoiding contested or high-impact assumptions. Responsible sensitivity analysis should state what was varied, what was fixed, what was excluded, and why.

Sensitivity analysis should expose dependence, not create a new layer of false confidence.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A model output can be represented as:

A local sensitivity measure can be written as:

A finite-difference approximation can be used when no analytic derivative is available:

A normalized sensitivity index can be written as:

A global variance-based framing can be represented as:

A robustness region can be represented as:

These formulas show why sensitivity analysis is central to computational reasoning: it studies dependence, variation, stability, and fragility.

Back to top ↑

Python Workflow: Sensitivity Analysis Audit

The Python workflow below creates a dependency-light sensitivity analysis audit. It defines a simple model, runs one-at-a-time parameter sweeps, compares scenarios, performs threshold sensitivity, tests random-seed variation, ranks parameter influence, and writes reproducible CSV and JSON outputs.

# sensitivity_analysis_algorithms_models_audit.py
# Dependency-light workflow for sensitivity analysis, parameter sweeps,
# threshold testing, scenario comparison, robustness review, and audit trails.

from __future__ import annotations

from dataclasses import asdict, dataclass, replace
from pathlib import Path
from statistics import mean, pstdev
import csv
import json
import math
import random
from datetime import datetime, timezone

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


@dataclass(frozen=True)
class ModelConfig:
    name: str
    demand_growth: float
    capacity_investment: float
    failure_rate: float
    adaptation_rate: float
    threshold: float
    noise_scale: float
    seed: int


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def clamp(value: float, low: float = 0.0, high: float = 1.0) -> float:
    return max(low, min(high, value))


def run_model(config: ModelConfig, periods: int = 40) -> dict[str, object]:
    rng = random.Random(config.seed)
    pressure = 0.45 + config.demand_growth * 0.20 - config.capacity_investment * 0.12
    resilience = 0.55 + config.capacity_investment * 0.18 + config.adaptation_rate * 0.12
    cumulative_risk = 0.0
    threshold_crossings = 0

    for period in range(1, periods + 1):
        shock = rng.gauss(0.0, config.noise_scale)
        pressure = clamp(
            pressure +
            config.demand_growth * 0.018 +
            config.failure_rate * 0.030 -
            config.adaptation_rate * 0.014 +
            shock,
            0.0,
            1.5
        )
        resilience = clamp(
            resilience +
            config.capacity_investment * 0.010 +
            config.adaptation_rate * 0.012 -
            config.failure_rate * 0.006,
            0.0,
            1.5
        )
        risk = clamp(pressure - resilience + 0.50, 0.0, 1.0)
        cumulative_risk += risk

        if risk >= config.threshold:
            threshold_crossings += 1

    average_risk = cumulative_risk / periods
    stability_margin = config.threshold - average_risk

    return {
        "name": config.name,
        "seed": config.seed,
        "demand_growth": config.demand_growth,
        "capacity_investment": config.capacity_investment,
        "failure_rate": config.failure_rate,
        "adaptation_rate": config.adaptation_rate,
        "threshold": config.threshold,
        "noise_scale": config.noise_scale,
        "periods": periods,
        "average_risk": round(average_risk, 6),
        "threshold_crossings": threshold_crossings,
        "stability_margin": round(stability_margin, 6),
        "interpretation": "Outputs depend on demand, capacity, failure, adaptation, threshold, noise, and random seed."
    }


def baseline_config() -> ModelConfig:
    return ModelConfig(
        name="baseline",
        demand_growth=0.45,
        capacity_investment=0.35,
        failure_rate=0.25,
        adaptation_rate=0.30,
        threshold=0.60,
        noise_scale=0.015,
        seed=2026
    )


def one_at_a_time_sweeps(base: ModelConfig) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    parameter_values = {
        "demand_growth": [0.20, 0.35, 0.45, 0.60, 0.75],
        "capacity_investment": [0.10, 0.25, 0.35, 0.50, 0.70],
        "failure_rate": [0.05, 0.15, 0.25, 0.40, 0.60],
        "adaptation_rate": [0.05, 0.20, 0.30, 0.45, 0.65],
        "noise_scale": [0.000, 0.010, 0.015, 0.030, 0.050],
    }

    for parameter, values in parameter_values.items():
        for value in values:
            updated = replace(base, name=f"oat_{parameter}_{value}", **{parameter: value})
            result = run_model(updated)
            result["sweep_type"] = "one_at_a_time"
            result["varied_parameter"] = parameter
            result["varied_value"] = value
            rows.append(result)

    return rows


def scenario_runs(base: ModelConfig) -> list[dict[str, object]]:
    scenarios = [
        replace(base, name="baseline"),
        replace(base, name="high_demand", demand_growth=0.75),
        replace(base, name="low_capacity", capacity_investment=0.10),
        replace(base, name="high_failure", failure_rate=0.60),
        replace(base, name="rapid_adaptation", adaptation_rate=0.65),
        replace(base, name="stress_case", demand_growth=0.80, capacity_investment=0.10, failure_rate=0.65, adaptation_rate=0.10),
        replace(base, name="resilience_case", demand_growth=0.30, capacity_investment=0.70, failure_rate=0.10, adaptation_rate=0.70),
    ]

    rows: list[dict[str, object]] = []

    for scenario in scenarios:
        result = run_model(scenario)
        result["sweep_type"] = "scenario"
        rows.append(result)

    return rows


def threshold_sweep(base: ModelConfig) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []

    for threshold in [0.35, 0.45, 0.55, 0.60, 0.65, 0.75, 0.85]:
        updated = replace(base, name=f"threshold_{threshold}", threshold=threshold)
        result = run_model(updated)
        result["sweep_type"] = "threshold_sweep"
        result["varied_parameter"] = "threshold"
        result["varied_value"] = threshold
        rows.append(result)

    return rows


def repeated_seed_runs(base: ModelConfig) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []

    for seed in range(1, 41):
        updated = replace(base, name="seed_ensemble", seed=seed)
        result = run_model(updated)
        result["sweep_type"] = "seed_ensemble"
        rows.append(result)

    return rows


def influence_ranking(oat_rows: list[dict[str, object]], base_result: dict[str, object]) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    base_risk = float(base_result["average_risk"])

    for parameter in sorted(set(str(row["varied_parameter"]) for row in oat_rows)):
        subset = [row for row in oat_rows if row["varied_parameter"] == parameter]
        risks = [float(row["average_risk"]) for row in subset]
        crossings = [float(row["threshold_crossings"]) for row in subset]

        rows.append({
            "parameter": parameter,
            "tested_values": len(subset),
            "min_average_risk": round(min(risks), 6),
            "max_average_risk": round(max(risks), 6),
            "risk_range": round(max(risks) - min(risks), 6),
            "max_absolute_change_from_baseline": round(max(abs(value - base_risk) for value in risks), 6),
            "threshold_crossing_range": round(max(crossings) - min(crossings), 6),
            "interpretation": "Larger ranges indicate stronger influence on model outputs across tested values."
        })

    rows.sort(key=lambda row: float(row["risk_range"]), reverse=True)

    return rows


def robustness_summary(all_rows: list[dict[str, object]]) -> dict[str, object]:
    risks = [float(row["average_risk"]) for row in all_rows]
    crossings = [float(row["threshold_crossings"]) for row in all_rows]
    high_risk_runs = [row for row in all_rows if float(row["average_risk"]) >= float(row["threshold"])]

    return {
        "runs_reviewed": len(all_rows),
        "min_average_risk": round(min(risks), 6),
        "max_average_risk": round(max(risks), 6),
        "mean_average_risk": round(mean(risks), 6),
        "std_average_risk": round(pstdev(risks), 6),
        "min_threshold_crossings": int(min(crossings)),
        "max_threshold_crossings": int(max(crossings)),
        "high_risk_run_count": len(high_risk_runs),
        "high_risk_run_share": round(len(high_risk_runs) / len(all_rows), 6),
        "interpretation": "Robustness review compares whether the main conclusion remains stable across sweeps, scenarios, thresholds, and seeds."
    }


def review_checklist() -> list[dict[str, object]]:
    return [
        {
            "check": "baseline_defined",
            "status": "complete",
            "question": "Is the reference case documented?"
        },
        {
            "check": "parameters_identified",
            "status": "complete",
            "question": "Are inputs, parameters, thresholds, and assumptions listed?"
        },
        {
            "check": "ranges_justified",
            "status": "partial",
            "question": "Are tested ranges tied to evidence, uncertainty, or plausible scenarios?"
        },
        {
            "check": "one_at_a_time_sweep_completed",
            "status": "complete",
            "question": "Was a first-pass parameter sweep performed?"
        },
        {
            "check": "scenario_comparison_completed",
            "status": "complete",
            "question": "Were structured scenarios compared?"
        },
        {
            "check": "threshold_sensitivity_completed",
            "status": "complete",
            "question": "Were decision cutoffs tested?"
        },
        {
            "check": "seed_sensitivity_completed",
            "status": "complete",
            "question": "Were stochastic runs repeated across seeds?"
        },
        {
            "check": "structural_sensitivity_reviewed",
            "status": "needs_review",
            "question": "Were alternative model structures compared?"
        },
        {
            "check": "governance_implications_documented",
            "status": "partial",
            "question": "Are sensitivity findings tied to monitoring, use limits, or decision governance?"
        }
    ]


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)

    if not rows:
        path.write_text("", encoding="utf-8")
        return

    fieldnames = sorted({key for row in rows for key in row.keys()})

    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


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


def main() -> None:
    base = baseline_config()
    base_result = run_model(base)
    oat_rows = one_at_a_time_sweeps(base)
    scenario_rows = scenario_runs(base)
    threshold_rows = threshold_sweep(base)
    seed_rows = repeated_seed_runs(base)
    influence_rows = influence_ranking(oat_rows, base_result)

    all_run_rows = [base_result] + oat_rows + scenario_rows + threshold_rows + seed_rows
    robustness = robustness_summary(all_run_rows)
    checklist_rows = review_checklist()

    audit_summary = {
        "article": "sensitivity_analysis_for_algorithms_and_models",
        "timestamp_utc": timestamp_utc(),
        "baseline_average_risk": base_result["average_risk"],
        "baseline_threshold_crossings": base_result["threshold_crossings"],
        "most_influential_parameter": influence_rows[0]["parameter"],
        "most_influential_parameter_risk_range": influence_rows[0]["risk_range"],
        "runs_reviewed": robustness["runs_reviewed"],
        "high_risk_run_share": robustness["high_risk_run_share"],
        "review_items_needing_attention": sum(1 for row in checklist_rows if row["status"] in {"partial", "needs_review"}),
        "interpretation": "Sensitivity analysis identifies which assumptions drive results, which conclusions remain robust, and which choices require governance review."
    }

    write_csv(TABLES / "baseline_result.csv", [base_result])
    write_csv(TABLES / "one_at_a_time_sensitivity.csv", oat_rows)
    write_csv(TABLES / "scenario_sensitivity.csv", scenario_rows)
    write_csv(TABLES / "threshold_sensitivity.csv", threshold_rows)
    write_csv(TABLES / "seed_sensitivity.csv", seed_rows)
    write_csv(TABLES / "parameter_influence_ranking.csv", influence_rows)
    write_csv(TABLES / "robustness_summary.csv", [robustness])
    write_csv(TABLES / "sensitivity_review_checklist.csv", checklist_rows)
    write_csv(TABLES / "sensitivity_analysis_audit_summary.csv", [audit_summary])

    write_json(JSON_DIR / "baseline_config.json", asdict(base))
    write_json(JSON_DIR / "baseline_result.json", base_result)
    write_json(JSON_DIR / "one_at_a_time_sensitivity.json", oat_rows)
    write_json(JSON_DIR / "scenario_sensitivity.json", scenario_rows)
    write_json(JSON_DIR / "threshold_sensitivity.json", threshold_rows)
    write_json(JSON_DIR / "seed_sensitivity.json", seed_rows)
    write_json(JSON_DIR / "parameter_influence_ranking.json", influence_rows)
    write_json(JSON_DIR / "robustness_summary.json", robustness)
    write_json(JSON_DIR / "sensitivity_review_checklist.json", checklist_rows)
    write_json(JSON_DIR / "sensitivity_analysis_audit_summary.json", audit_summary)

    print("Sensitivity analysis audit complete.")
    print(TABLES / "sensitivity_analysis_audit_summary.csv")


if __name__ == "__main__":
    main()

This workflow treats sensitivity analysis as an audit: define the baseline, vary assumptions, compare outputs, rank influence, test thresholds, repeat seeds, summarize robustness, and document what still needs review.

Back to top ↑

R Workflow: Sensitivity Summary and Diagnostics

The R workflow reads the Python-generated sensitivity outputs and creates summary diagnostics using base R. It compares parameter influence, scenario behavior, threshold sensitivity, seed variation, and review checklist status.

# sensitivity_analysis_algorithms_models_summary.R
# Base R workflow for summarizing sensitivity analysis outputs and 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")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

ranking_path <- file.path(tables_dir, "parameter_influence_ranking.csv")

if (!file.exists(ranking_path)) {
  stop(paste("Missing", ranking_path, "Run the Python workflow first."))
}

ranking_data <- read.csv(ranking_path, stringsAsFactors = FALSE)

png(
  file.path(figures_dir, "parameter_influence_ranking.png"),
  width = 1300,
  height = 850
)

barplot(
  ranking_data$risk_range,
  names.arg = ranking_data$parameter,
  las = 2,
  ylab = "Risk range",
  main = "Parameter Influence Ranking"
)

grid()
dev.off()

scenario_path <- file.path(tables_dir, "scenario_sensitivity.csv")

if (file.exists(scenario_path)) {
  scenario_data <- read.csv(scenario_path, stringsAsFactors = FALSE)

  png(
    file.path(figures_dir, "scenario_average_risk.png"),
    width = 1300,
    height = 850
  )

  barplot(
    scenario_data$average_risk,
    names.arg = scenario_data$name,
    las = 2,
    ylab = "Average risk",
    main = "Scenario Sensitivity: Average Risk"
  )

  grid()
  dev.off()
}

threshold_path <- file.path(tables_dir, "threshold_sensitivity.csv")

if (file.exists(threshold_path)) {
  threshold_data <- read.csv(threshold_path, stringsAsFactors = FALSE)

  png(
    file.path(figures_dir, "threshold_crossings_by_cutoff.png"),
    width = 1300,
    height = 850
  )

  plot(
    threshold_data$threshold,
    threshold_data$threshold_crossings,
    type = "b",
    pch = 19,
    xlab = "Threshold",
    ylab = "Threshold crossings",
    main = "Threshold Sensitivity"
  )

  grid()
  dev.off()
}

seed_path <- file.path(tables_dir, "seed_sensitivity.csv")

if (file.exists(seed_path)) {
  seed_data <- read.csv(seed_path, stringsAsFactors = FALSE)

  png(
    file.path(figures_dir, "seed_sensitivity_distribution.png"),
    width = 1300,
    height = 850
  )

  hist(
    seed_data$average_risk,
    breaks = 20,
    xlab = "Average risk",
    main = "Seed Sensitivity Distribution"
  )

  grid()
  dev.off()
}

checklist_path <- file.path(tables_dir, "sensitivity_review_checklist.csv")

if (file.exists(checklist_path)) {
  checklist_data <- read.csv(checklist_path, stringsAsFactors = FALSE)
  status_counts <- table(checklist_data$status)

  png(
    file.path(figures_dir, "sensitivity_review_checklist_status.png"),
    width = 1000,
    height = 750
  )

  barplot(
    status_counts,
    ylim = c(0, max(status_counts) + 1),
    ylab = "Count",
    main = "Sensitivity Review Checklist Status"
  )

  grid()
  dev.off()
}

audit_path <- file.path(tables_dir, "sensitivity_analysis_audit_summary.csv")
audit_data <- read.csv(audit_path, stringsAsFactors = FALSE)

r_summary <- data.frame(
  workflow_summary_rows = nrow(audit_data),
  baseline_average_risk = audit_data$baseline_average_risk[1],
  most_influential_parameter = audit_data$most_influential_parameter[1],
  most_influential_parameter_risk_range = audit_data$most_influential_parameter_risk_range[1],
  runs_reviewed = audit_data$runs_reviewed[1],
  review_items_needing_attention = audit_data$review_items_needing_attention[1]
)

write.csv(
  r_summary,
  file.path(tables_dir, "r_sensitivity_analysis_summary.csv"),
  row.names = FALSE
)

print(r_summary)

This workflow helps summarize which assumptions drive outputs, where thresholds matter, how scenarios compare, how stochastic variation behaves, and which review items still need attention.

Back to top ↑

GitHub Repository

The companion repository for this article provides reproducible code, synthetic sensitivity datasets, parameter sweeps, scenario comparisons, threshold tests, seed ensembles, influence rankings, robustness summaries, review checklists, governance artifacts, and Canvas-ready materials that extend the article into executable examples.

Back to top ↑

A Practical Method for Reviewing Sensitivity Analysis

A practical review begins by identifying the claim being made. The reviewer then asks what assumptions support that claim and which of those assumptions should be varied. Sensitivity analysis should be designed around the intended use of the model, not added after the fact as a decorative chart.

The goal is to understand what the result depends on before treating it as evidence.

Back to top ↑

Common Pitfalls

A common pitfall is treating sensitivity analysis as a chart rather than an inquiry. A tornado chart, parameter sweep, or scenario table is useful only if the tested ranges are meaningful and the right assumptions were varied. Another pitfall is testing only numerical parameters while ignoring structural assumptions, data-processing rules, thresholds, and model boundaries.

Common pitfalls include:

• too narrow ranges: tested values are so close to baseline that fragility remains hidden;
• unjustified ranges: low and high values are chosen without evidence or rationale;
• one-at-a-time overreliance: interactions among parameters are ignored;
• threshold neglect: decision cutoffs are treated as fixed rather than tested;
• structural blind spot: alternative model forms are never compared;
• data-rule invisibility: missingness, filtering, and outlier assumptions are left untested;
• single-seed confidence: stochastic workflows rely on one random seed;
• visual overclaim: charts imply more completeness than the analysis supports;
• governance disconnect: sensitivity findings do not affect monitoring or decision limits;
• selective reporting: fragile findings are omitted because they complicate the conclusion.

The remedy is explicit design: identify assumptions, justify ranges, test thresholds, compare scenarios, examine interactions, include structural alternatives when needed, preserve reproducible workflows, and connect findings to use limits.

Back to top ↑

Why Sensitivity Analysis Is Computational Reasoning

Sensitivity analysis for algorithms and models shows that computational reasoning is not only about producing outputs. It is also about understanding what those outputs depend on. A model result becomes more meaningful when analysts can say which assumptions matter, which inputs dominate, which thresholds are fragile, which conclusions are robust, and where the model should not be trusted.

This matters across scientific computing, simulation, machine learning, optimization, policy modeling, infrastructure planning, public-sector decision support, platform systems, risk analysis, environmental modeling, finance, health, and organizational analytics. Computational outputs often enter institutions as evidence. Sensitivity analysis asks whether that evidence is stable enough for the role it is being asked to play.

The practice also encourages humility. It reminds us that models are not neutral mirrors of reality. They are procedures built from choices. Some choices are evidence-based. Some are uncertain. Some are contested. Some are convenient. Some are invisible until tested.

A strong sensitivity analysis makes those dependencies visible. It turns model use from passive acceptance into active review. It helps decision-makers understand not just what the model says, but what would make it say something else.

The next article turns to uncertainty quantification in computational workflows: how uncertainty is measured, propagated, summarized, and communicated across computational systems.

Back to top ↑

Related Articles

• Model Validation, Testing, and Computational Evidence
• Uncertainty Quantification in Computational Workflows
• Monte Carlo Methods and Computational Uncertainty
• Computational Experiments and Reproducible Workflows
• Numerical Methods and Algorithmic Approximation
• Agent-Based Algorithms and Emergent Behavior
• Decision Rules, Thresholds, and Classification
• Optimization, Objectives, and Constraints

Further Reading

• Campolongo, F., Cariboni, J. and Saltelli, A. (2007) ‘An effective screening design for sensitivity analysis of large models’, Environmental Modelling & Software, 22(10), pp. 1509–1518.
• Hamby, D.M. (1994) ‘A review of techniques for parameter sensitivity analysis of environmental models’, Environmental Monitoring and Assessment, 32, pp. 135–154.
• Iooss, B. and Lemaître, P. (2015) ‘A review on global sensitivity analysis methods’, in Dellino, G. and Meloni, C. (eds.) Uncertainty Management in Simulation-Optimization of Complex Systems. New York: Springer, pp. 101–122.
• Morris, M.D. (1991) ‘Factorial sampling plans for preliminary computational experiments’, Technometrics, 33(2), pp. 161–174.
• Saltelli, A., Chan, K. and Scott, E.M. (eds.) (2000) Sensitivity Analysis. Chichester: Wiley.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2004) Sensitivity Analysis in Practice: A Guide to Assessing Scientific Models. Chichester: Wiley.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Sobol, I.M. (2001) ‘Global sensitivity indices for nonlinear mathematical models and their Monte Carlo estimates’, Mathematics and Computers in Simulation, 55(1–3), pp. 271–280.
• Saltelli, A. and Annoni, P. (2010) ‘How to avoid a perfunctory sensitivity analysis’, Environmental Modelling & Software, 25(12), pp. 1508–1517.
• Razavi, S. et al. (2021) ‘The future of sensitivity analysis: An essential discipline for systems modeling and policy support’, Environmental Modelling & Software, 137, 104954.

References

• Campolongo, F., Cariboni, J. and Saltelli, A. (2007) ‘An effective screening design for sensitivity analysis of large models’, Environmental Modelling & Software, 22(10), pp. 1509–1518.
• Hamby, D.M. (1994) ‘A review of techniques for parameter sensitivity analysis of environmental models’, Environmental Monitoring and Assessment, 32, pp. 135–154.
• Iooss, B. and Lemaître, P. (2015) ‘A review on global sensitivity analysis methods’, in Dellino, G. and Meloni, C. (eds.) Uncertainty Management in Simulation-Optimization of Complex Systems. New York: Springer, pp. 101–122.
• Morris, M.D. (1991) ‘Factorial sampling plans for preliminary computational experiments’, Technometrics, 33(2), pp. 161–174.
• Saltelli, A., Chan, K. and Scott, E.M. (eds.) (2000) Sensitivity Analysis. Chichester: Wiley.
• Saltelli, A., Tarantola, S., Campolongo, F. and Ratto, M. (2004) Sensitivity Analysis in Practice: A Guide to Assessing Scientific Models. Chichester: Wiley.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Saltelli, A. and Annoni, P. (2010) ‘How to avoid a perfunctory sensitivity analysis’, Environmental Modelling & Software, 25(12), pp. 1508–1517.
• Sobol, I.M. (2001) ‘Global sensitivity indices for nonlinear mathematical models and their Monte Carlo estimates’, Mathematics and Computers in Simulation, 55(1–3), pp. 271–280.
• Razavi, S. et al. (2021) ‘The future of sensitivity analysis: An essential discipline for systems modeling and policy support’, Environmental Modelling & Software, 137, 104954.

Back to top ↑