Sensitivity Analysis in Systems Models: Understanding Model Robustness

Last Updated June 6, 2026

Sensitivity analysis is a methodological technique used to evaluate how changes in model parameters, assumptions, inputs, or structural choices influence simulation outcomes. Because systems models depend on estimated variables, theoretical assumptions, uncertain data, and simplifying judgments, their results are necessarily conditional rather than absolute. Sensitivity analysis provides a systematic way to examine how strongly those conditions shape model behavior, revealing which assumptions matter most, which conclusions remain robust, and which results are highly contingent on uncertain inputs.

In systems modeling, uncertainty is not a peripheral issue. It is one of the central conditions under which modeling takes place. Environmental variability, behavioral adaptation, technological change, institutional response, policy intervention, infrastructure reliability, social learning, and data limitations all introduce uncertainty into model construction and interpretation. Sensitivity analysis helps determine whether model conclusions reflect durable system structure or merely the particular parameter values chosen by the analyst.

This makes sensitivity analysis one of the core disciplines through which systems models earn credibility. A model may produce precise-looking outputs while remaining highly fragile. A small change in a growth rate, adoption threshold, service time, failure probability, feedback delay, or resource constraint may alter the entire trajectory. Sensitivity analysis tests this fragility directly.

This article explains sensitivity analysis as a core methodological practice in systems modeling. It covers uncertainty, local and global sensitivity, scenario-based sensitivity, structural sensitivity, parameter screening, variance decomposition, robustness, calibration, validation, policy applications, sustainability research, mathematical foundations, professional workflows, R and Python examples, responsible interpretation, and common pitfalls.

What Is Sensitivity Analysis?

Sensitivity analysis is the systematic study of how model outputs change when model inputs, assumptions, parameters, or structural choices are varied. It asks a simple but essential question: How much do the conclusions change when the assumptions change?

In a systems model, inputs may include growth rates, failure probabilities, service times, behavioral thresholds, climate stress levels, policy intensities, demand levels, diffusion rates, network weights, carrying capacities, feedback delays, discount rates, or intervention timing. Outputs may include cost, emissions, adoption, queue length, resilience, collapse risk, recovery time, service level, population exposure, resource depletion, or system performance.

Sensitivity analysis compares output changes against input changes. If a small change in one assumption produces a large change in outcome, the model is sensitive to that assumption. If outcomes remain stable across a wide range of plausible assumptions, the conclusion is more robust.

Sensitivity analysis shifts attention from outputs alone to the conditional structure behind those outputs. It asks not only what the model says, but why it says it and how easily that conclusion could change.

Back to top ↑

Why Sensitivity Analysis Matters

Sensitivity analysis matters because models can create false confidence. A model may show a precise number, smooth trajectory, or clean policy comparison while hiding the fact that its conclusion depends heavily on uncertain assumptions. Without sensitivity analysis, users may mistake conditional outputs for stable knowledge.

Complex systems make this problem more serious. Feedback loops, thresholds, nonlinearities, delays, adaptation, and network effects mean that small differences in assumptions can sometimes produce large differences in outcomes. A growth rate may seem modest until it compounds. A delay may seem minor until it produces policy resistance. A service-time assumption may seem technical until it creates queue collapse. A network-weight assumption may seem harmless until it determines cascade pathways.

Sensitivity analysis helps modelers and decision-makers distinguish among three kinds of findings:

• Robust findings: conclusions that remain stable across many plausible assumptions.
• Fragile findings: conclusions that change when uncertain assumptions are varied.
• Conditional findings: conclusions that hold only under clearly specified conditions.

This distinction is central to responsible systems modeling. A fragile model is not necessarily useless. It may reveal that the system itself is fragile or that more evidence is needed. But fragile results should not be communicated as settled conclusions.

Back to top ↑

The Role of Uncertainty in Systems Modeling

All models simplify reality. Parameters such as growth rates, behavioral responses, learning effects, resource availability, discount rates, infrastructure reliability, service times, adoption thresholds, and technological change must often be estimated from incomplete evidence, inferred from theory, or chosen from plausible ranges rather than known with certainty.

Sensitivity analysis addresses this problem by varying those assumptions systematically. Instead of relying on one parameterization, analysts explore ranges of plausible values to determine whether model conclusions remain stable under uncertainty.

This distinction is fundamental. A model may appear precise while still being highly fragile. Sensitivity analysis helps reveal whether the model’s conclusions are structurally meaningful or artifacts of particular assumptions. In this respect, it extends the logic developed in Why Complex Systems Require Models and Scenario Modeling and Simulation by shifting attention from model outputs alone to the stability of those outputs under uncertainty.

Uncertainty does not make modeling impossible. It makes sensitivity analysis necessary.

Back to top ↑

These approaches are complementary. A strong sensitivity plan may begin with screening, proceed to local diagnostics, use global sampling for important inputs, and then test structural and scenario assumptions.

Back to top ↑

Local Sensitivity Analysis

Local sensitivity analysis asks how model output changes in response to a small change in one input near a chosen baseline. This is often the simplest form of sensitivity analysis, and it is useful for understanding marginal influence.

For example, a system dynamics model of resource depletion may vary extraction rate while holding regeneration rate and demand growth constant. A discrete event simulation may vary service time while holding arrival rate constant. A network model may vary one edge weight or failure probability. An agent-based model may vary one behavioral threshold near the calibrated baseline.

Local sensitivity is often expressed through derivatives, elasticities, or one-at-a-time percentage changes. It can help answer practical questions such as: if the service rate improves by 5 percent, how much does waiting time fall? If adoption probability increases slightly, how much faster does diffusion occur?

Local sensitivity is useful, but it should not be mistaken for a full uncertainty analysis. Complex systems may behave very differently outside the local neighborhood around a baseline.

Back to top ↑

Global Sensitivity Analysis

Global sensitivity analysis examines how uncertainty propagates when multiple inputs vary across their plausible ranges. It is especially important in complex systems because parameter effects are often nonlinear and interactive.

In a nonlinear model, the effect of one parameter may depend on the values of others. Service capacity may matter little when demand is low but matter enormously during a surge. Social influence may matter only after early adoption crosses a threshold. Climate exposure may matter only when infrastructure maintenance is deferred. A local analysis may miss these conditional effects.

Global sensitivity methods use ensembles of model runs. Parameters are sampled across specified ranges, the model is run many times, and output variation is analyzed to determine which inputs explain the most variation.

Global sensitivity is more computationally demanding than local analysis, but it is often far more appropriate for complex systems models.

Back to top ↑

Scenario-Based Sensitivity Analysis

Scenario-based sensitivity analysis evaluates how model conclusions change across structured sets of assumptions. This approach is especially useful when uncertainty is not well represented by independent parameter ranges alone.

For example, an energy model may compare rapid technology learning, delayed policy, high demand, constrained supply chain, and accelerated electrification scenarios. A public-health model may compare high-compliance, low-compliance, hospital-capacity expansion, and behavioral-fatigue scenarios. An infrastructure model may compare baseline maintenance, deferred maintenance, climate stress, and resilience investment.

Scenario-based sensitivity analysis differs from ordinary scenario modeling by focusing specifically on how dependent conclusions are on the scenario assumptions. The central question is not merely which future is more favorable, but which findings survive across plausible futures.

Scenario sensitivity is essential when uncertainty is narrative, institutional, structural, or policy-driven rather than purely numerical.

Back to top ↑

Structural Sensitivity Analysis

Structural sensitivity analysis examines whether conclusions depend on the structure of the model itself. This includes the system boundary, causal relationships, feedback loops, time delays, agent rules, network topology, event logic, spatial resolution, and aggregation choices.

This is one of the most important and most difficult forms of sensitivity analysis. Many model conclusions depend less on the exact value of a parameter than on whether the model includes a feedback loop, threshold, delay, or dependency at all.

For example, a policy model without implementation delay may overstate intervention effectiveness. A network model without dependency edges may understate cascading failure. An agent-based model without social influence may miss adoption cascades. A system dynamics model without capacity erosion may miss collapse dynamics. A discrete event simulation without priority rules may misrepresent service equity.

Structural sensitivity analysis is a reminder that model uncertainty is not only numerical. It is also conceptual.

Back to top ↑

Identifying Key Drivers of System Behavior

One of the principal aims of sensitivity analysis is to identify which assumptions or variables most strongly influence model behavior. In many complex systems, a relatively small number of parameters may account for much of the variation in outcomes.

In climate and energy models, assumptions about emissions pathways, climate sensitivity, technology learning, land-use change, and policy timing may dominate long-term projections. In economic systems, productivity growth, investment behavior, expectations, debt dynamics, and institutional response may strongly shape trajectories. In infrastructure systems, utilization rates, failure probabilities, redundancy, maintenance timing, and repair capacity may determine performance. In public health systems, contact rates, behavior, immunity, service capacity, and intervention timing may dominate outcomes.

By identifying high-leverage assumptions, sensitivity analysis helps researchers focus attention on the drivers that matter most. It also helps policymakers distinguish between conclusions that are broadly robust and those that rest on parameters that remain poorly understood.

This analytical function connects closely to the broader concern with Core Principles of Systems Modeling, especially leverage, feedback, boundary judgment, nonlinearity, and interpretation.

Back to top ↑

Techniques and Computational Methods

Modern sensitivity analysis often depends on computational experimentation. Analysts run repeated simulations while varying one or more parameters across specified ranges, generating an ensemble of outcomes rather than a single deterministic trajectory.

The model becomes an experimental environment. Instead of asking only what one run produces, analysts examine how output distributions change across sampled assumptions. This is especially important in systems models where interactions among parameters produce nonlinear responses that cannot be inferred from intuition alone.

The appropriate method depends on model cost, number of parameters, degree of nonlinearity, decision context, and whether the analysis needs approximate screening or rigorous variance decomposition.

Back to top ↑

Sampling Designs for Sensitivity Analysis

Sampling design determines how the uncertainty space is explored. Poor sampling can create misleading sensitivity results, especially in high-dimensional models. If the sampled combinations are too narrow, conclusions may appear more robust than they are. If the sampled combinations are incoherent, results may be difficult to interpret.

In simple models, one-at-a-time variation may be sufficient for early diagnostics. In complex models, analysts often use Monte Carlo sampling, Latin hypercube sampling, quasi-random sequences, factorial designs, or screening designs. The goal is to cover the input space in a way that matches the purpose of the analysis.

Sampling design should be documented as part of the model evidence. Sensitivity results are only as meaningful as the uncertainty space they explore.

Back to top ↑

Interpretation and Model Robustness

Sensitivity analysis plays a central role in assessing whether model results are robust. If major conclusions remain stable across a wide range of plausible assumptions, analysts can have greater confidence that the model is capturing structural features of the system rather than arbitrary inputs. If small changes in assumptions produce large differences in outcomes, those conclusions must be treated with caution.

This does not mean that sensitivity is bad. A model may be sensitive because the real system is sensitive. In infrastructure systems, for example, service failure may genuinely depend on a narrow range of capacity conditions. In ecological systems, a threshold may genuinely separate recovery from collapse. In public policy, intervention timing may genuinely determine whether a policy succeeds or fails.

The interpretive task is therefore not to eliminate sensitivity. It is to understand it.

Sensitivity analysis helps separate structural insight from parametric fragility. It also prevents false confidence by showing that apparent precision may conceal instability underneath.

Back to top ↑

Relationship to Calibration, Validation, and Uncertainty

Sensitivity analysis is closely related to calibration, validation, and uncertainty analysis, but it is not identical to any of them.

Calibration concerns the adjustment of parameter values so model behavior aligns with empirical observations or known system patterns. Validation concerns whether the model represents the system adequately for the intended purpose. Uncertainty analysis examines the range and character of uncertainty embedded in inputs, structure, and interpretation. Sensitivity analysis asks how much conclusions change when assumptions are changed.

This makes sensitivity analysis a bridge between model construction and model interpretation. It reveals whether calibrated parameters exert disproportionate influence, whether validated behavior remains stable under perturbation, and whether uncertainty meaningfully alters the conclusions drawn from the model.

For that reason, this article sits naturally between Scenario Modeling and Simulation and later discussions of Calibration and Validation of Models and Uncertainty and Model Interpretation.

Back to top ↑

Applications in Policy and Sustainability Research

Sensitivity analysis is especially important in policy modeling because policy recommendations often depend on uncertain assumptions about systems that are themselves changing.

Climate policy, energy transitions, infrastructure planning, biodiversity management, macroeconomic forecasting, public health preparedness, urban planning, water governance, and resilience investment all rely on models whose outputs can shape real-world decisions. In such contexts, it is not enough to ask what the model predicts. One must also ask how strongly that prediction depends on uncertain assumptions.

By explicitly examining uncertainty, sensitivity analysis helps policymakers understand which findings are robust, which depend on controversial premises, and which should be treated as provisional. This transparency strengthens the credibility of model-based reasoning and supports more responsible decision-making under uncertainty.

Back to top ↑

Global Sensitivity and Complex Systems

Sensitivity analysis becomes especially important in complex systems because parameter effects are often interactive rather than isolated. In linear models, one parameter may have a relatively predictable effect. In nonlinear systems, the influence of one variable may depend on the values of many others.

Feedback loops, thresholds, adaptive response, path dependence, saturation, and network propagation can create interaction effects that local analysis alone will miss. A parameter that looks unimportant under average conditions may become decisive during stress. A policy lever that works in one scenario may fail when combined with institutional delay or capacity saturation.

This is why global sensitivity methods are often more appropriate for complex systems research. They help reveal not only which assumptions matter, but how assumptions combine to shape trajectories, tipping points, or emergent patterns.

This point is especially relevant for models discussed elsewhere in the series, including System Dynamics Modeling, Agent-Based Modeling, Network Models, Discrete Event Simulation, and Hybrid Modeling Approaches.

Back to top ↑

Methodological Limits and Responsible Use

Although sensitivity analysis strengthens model interpretation, it does not solve every methodological problem. A model may be insensitive and still wrong if its structure is fundamentally misspecified. A model may be sensitive because it is honestly representing deep uncertainty rather than because it is poorly built. Sensitivity results therefore require interpretation rather than automatic judgment.

Analysts must choose parameter ranges carefully. If ranges are implausibly narrow, the analysis may create false confidence. If they are implausibly broad, the results may become difficult to interpret. If ranges ignore correlations among assumptions, the analysis may explore incoherent futures. If structural uncertainty is ignored, parameter sensitivity may conceal deeper model-form uncertainty.

Responsible sensitivity analysis requires theoretical justification, careful documentation, transparent ranges, reproducible code, and clear communication about what the analysis does and does not prove.

Sensitivity analysis is best understood as a discipline of interpretive rigor rather than a mere computational routine.

Back to top ↑

Mathematical Lens: Local Response, Variance Decomposition, and Uncertainty Propagation

A model output can be written as:

In local sensitivity analysis, one studies how a small perturbation in a parameter changes the output:

A normalized elasticity can be written as:

In global sensitivity analysis, the output variance is decomposed across uncertain inputs. A first-order Sobol-style sensitivity index is:

Total-effect indices extend this logic by including interactions:

This formal difference captures the methodological difference between local and global analysis. Local methods ask how the model responds near one point. Global methods ask how uncertainty propagates across the full input space.

Back to top ↑

Back to top ↑

Strengths and Limitations

Sensitivity analysis is powerful because it makes assumptions visible, testable, and contestable. It helps identify influential drivers, quantify uncertainty propagation, expose fragile conclusions, prioritize data collection, and support robust decision-making.

At the same time, sensitivity analysis has limits. It depends on the model being tested, the ranges selected, the sampling design used, and the output metrics chosen. It cannot automatically validate a model or prove that a conclusion is true. It can only show how conclusions behave under the uncertainties that were tested.

The value of sensitivity analysis lies not in generating another table of numbers, but in improving judgment about what the model can and cannot support.

Back to top ↑

R Workflow: Local and Global Sensitivity in a Nonlinear System

The R workflow below uses base R. It simulates a nonlinear growth model, performs one-at-a-time local sensitivity checks, runs a Monte Carlo global sensitivity experiment, estimates rank correlations, and writes reproducible outputs.

# sensitivity_analysis_diagnostics.R
# Base R workflow:
# local and global sensitivity in a nonlinear systems model.
#
# Suggested repository placement:
# articles/sensitivity-analysis-in-systems-models/r/sensitivity_analysis_diagnostics.R

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 <- normalizePath(getwd(), mustWork = TRUE)
}

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)

simulate_system <- function(
  growth_rate,
  carrying_capacity,
  extraction_pressure,
  recovery_delay,
  initial_state = 10,
  steps = 80
) {
  state <- numeric(steps)
  state[1] <- initial_state

  delayed_recovery <- rep(0, steps)

  for (t in 2:steps) {
    delay_index <- max(1, t - recovery_delay)
    delayed_recovery[t] <- 0.02 * state[delay_index]

    state[t] <- state[t - 1] +
      growth_rate * state[t - 1] * (1 - state[t - 1] / carrying_capacity) -
      extraction_pressure * state[t - 1] +
      delayed_recovery[t]

    state[t] <- max(state[t], 0)
  }

  data.frame(
    time = seq_len(steps),
    state = state,
    final_state = tail(state, 1),
    maximum_state = max(state),
    minimum_state = min(state)
  )
}

baseline <- list(
  growth_rate = 0.08,
  carrying_capacity = 100,
  extraction_pressure = 0.025,
  recovery_delay = 5
)

# One-at-a-time local sensitivity
local_growth <- data.frame()
for (value in seq(0.04, 0.12, length.out = 41)) {
  result <- simulate_system(
    growth_rate = value,
    carrying_capacity = baseline$carrying_capacity,
    extraction_pressure = baseline$extraction_pressure,
    recovery_delay = baseline$recovery_delay
  )
  local_growth <- rbind(local_growth, data.frame(
    parameter = "growth_rate",
    value = value,
    final_state = tail(result$state, 1)
  ))
}

local_capacity <- data.frame()
for (value in seq(60, 140, length.out = 41)) {
  result <- simulate_system(
    growth_rate = baseline$growth_rate,
    carrying_capacity = value,
    extraction_pressure = baseline$extraction_pressure,
    recovery_delay = baseline$recovery_delay
  )
  local_capacity <- rbind(local_capacity, data.frame(
    parameter = "carrying_capacity",
    value = value,
    final_state = tail(result$state, 1)
  ))
}

local_extraction <- data.frame()
for (value in seq(0.005, 0.060, length.out = 41)) {
  result <- simulate_system(
    growth_rate = baseline$growth_rate,
    carrying_capacity = baseline$carrying_capacity,
    extraction_pressure = value,
    recovery_delay = baseline$recovery_delay
  )
  local_extraction <- rbind(local_extraction, data.frame(
    parameter = "extraction_pressure",
    value = value,
    final_state = tail(result$state, 1)
  ))
}

local_results <- rbind(local_growth, local_capacity, local_extraction)

# Global Monte Carlo sensitivity
set.seed(42)
n_runs <- 800

global_results <- data.frame(
  run_id = seq_len(n_runs),
  growth_rate = runif(n_runs, 0.04, 0.12),
  carrying_capacity = runif(n_runs, 60, 140),
  extraction_pressure = runif(n_runs, 0.005, 0.060),
  recovery_delay = sample(1:12, n_runs, replace = TRUE)
)

global_results$final_state <- NA
global_results$maximum_state <- NA
global_results$minimum_state <- NA

for (i in seq_len(nrow(global_results))) {
  result <- simulate_system(
    growth_rate = global_results$growth_rate[i],
    carrying_capacity = global_results$carrying_capacity[i],
    extraction_pressure = global_results$extraction_pressure[i],
    recovery_delay = global_results$recovery_delay[i]
  )

  global_results$final_state[i] <- tail(result$state, 1)
  global_results$maximum_state[i] <- max(result$state)
  global_results$minimum_state[i] <- min(result$state)
}

rank_summary <- data.frame(
  parameter = c("growth_rate", "carrying_capacity", "extraction_pressure", "recovery_delay"),
  spearman_correlation = c(
    cor(global_results$growth_rate, global_results$final_state, method = "spearman"),
    cor(global_results$carrying_capacity, global_results$final_state, method = "spearman"),
    cor(global_results$extraction_pressure, global_results$final_state, method = "spearman"),
    cor(global_results$recovery_delay, global_results$final_state, method = "spearman")
  )
)

rank_summary$absolute_correlation <- abs(rank_summary$spearman_correlation)
rank_summary <- rank_summary[order(-rank_summary$absolute_correlation), ]

write.csv(local_results, file.path(tables_dir, "r_local_sensitivity.csv"), row.names = FALSE)
write.csv(global_results, file.path(tables_dir, "r_global_sensitivity_runs.csv"), row.names = FALSE)
write.csv(rank_summary, file.path(tables_dir, "r_sensitivity_rank_summary.csv"), row.names = FALSE)

png(file.path(figures_dir, "r_local_growth_sensitivity.png"), width = 1000, height = 700)
plot(
  local_growth$value,
  local_growth$final_state,
  type = "l",
  lwd = 2,
  xlab = "Growth Rate",
  ylab = "Final State",
  main = "Local Sensitivity to Growth Rate"
)
grid()
dev.off()

png(file.path(figures_dir, "r_global_sensitivity_scatter.png"), width = 1000, height = 700)
plot(
  global_results$growth_rate,
  global_results$final_state,
  pch = 16,
  cex = 0.6,
  xlab = "Growth Rate",
  ylab = "Final State",
  main = "Global Sensitivity: Growth Rate and Final State"
)
grid()
dev.off()

print(rank_summary)
cat("R sensitivity analysis diagnostics complete.\n")

This workflow demonstrates why sensitivity analysis must move beyond one run. The model is treated as an experimental object whose conclusions are tested across parameter uncertainty.

Back to top ↑

Python Workflow: Monte Carlo, Stratified Sampling, and Sensitivity Ranking

The Python workflow below uses only the standard library. It compares Monte Carlo sampling with a simple Latin-hypercube-style stratified design, simulates a nonlinear system, estimates rank-based sensitivity, and writes reproducible outputs.

#!/usr/bin/env python3
"""
Sensitivity analysis workflow.

Dependency-light workflow demonstrating:

1. Nonlinear systems simulation
2. One-at-a-time local sensitivity
3. Monte Carlo sampling
4. Latin-hypercube-style stratified sampling
5. Rank-based sensitivity diagnostics
6. Validation checks

All data are synthetic.
"""

from __future__ import annotations

from pathlib import Path
import csv
import math
import random
from statistics import mean


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


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", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def simulate_system(
    growth_rate: float,
    carrying_capacity: float,
    extraction_pressure: float,
    recovery_delay: int,
    initial_state: float = 10.0,
    steps: int = 80,
) -> dict[str, float]:
    state_values = [initial_state]

    for time in range(1, steps):
        delayed_index = max(0, time - recovery_delay)
        delayed_recovery = 0.02 * state_values[delayed_index]

        previous = state_values[-1]
        next_state = (
            previous
            + growth_rate * previous * (1 - previous / carrying_capacity)
            - extraction_pressure * previous
            + delayed_recovery
        )

        state_values.append(max(0.0, next_state))

    return {
        "final_state": state_values[-1],
        "maximum_state": max(state_values),
        "minimum_state": min(state_values),
        "mean_state": mean(state_values),
    }


def rank(values: list[float]) -> list[float]:
    sorted_pairs = sorted((value, index) for index, value in enumerate(values))
    ranks = [0.0] * len(values)

    for rank_position, (_value, index) in enumerate(sorted_pairs, start=1):
        ranks[index] = float(rank_position)

    return ranks


def pearson(x_values: list[float], y_values: list[float]) -> float:
    x_mean = mean(x_values)
    y_mean = mean(y_values)

    numerator = sum((x - x_mean) * (y - y_mean) for x, y in zip(x_values, y_values))
    x_denom = math.sqrt(sum((x - x_mean) ** 2 for x in x_values))
    y_denom = math.sqrt(sum((y - y_mean) ** 2 for y in y_values))

    if x_denom == 0 or y_denom == 0:
        return 0.0

    return numerator / (x_denom * y_denom)


def spearman(x_values: list[float], y_values: list[float]) -> float:
    return pearson(rank(x_values), rank(y_values))


def local_sensitivity() -> list[dict[str, object]]:
    baseline = {
        "growth_rate": 0.08,
        "carrying_capacity": 100.0,
        "extraction_pressure": 0.025,
        "recovery_delay": 5,
    }

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

    for parameter, values in {
        "growth_rate": [0.04 + i * (0.08 / 40) for i in range(41)],
        "carrying_capacity": [60 + i * (80 / 40) for i in range(41)],
        "extraction_pressure": [0.005 + i * (0.055 / 40) for i in range(41)],
        "recovery_delay": list(range(1, 13)),
    }.items():
        for value in values:
            settings = dict(baseline)
            settings[parameter] = int(value) if parameter == "recovery_delay" else value
            result = simulate_system(**settings)

            rows.append({
                "analysis_type": "local_one_at_a_time",
                "parameter": parameter,
                "value": round(float(value), 6),
                "final_state": round(result["final_state"], 6),
                "maximum_state": round(result["maximum_state"], 6),
                "mean_state": round(result["mean_state"], 6),
            })

    return rows


def monte_carlo_sample(n_runs: int, seed: int) -> list[dict[str, object]]:
    rng = random.Random(seed)
    rows: list[dict[str, object]] = []

    for run_id in range(1, n_runs + 1):
        row = {
            "sample_type": "monte_carlo",
            "run_id": run_id,
            "growth_rate": rng.uniform(0.04, 0.12),
            "carrying_capacity": rng.uniform(60, 140),
            "extraction_pressure": rng.uniform(0.005, 0.060),
            "recovery_delay": rng.randint(1, 12),
        }
        rows.append(row)

    return rows


def latin_hypercube_style_sample(n_runs: int, seed: int) -> list[dict[str, object]]:
    rng = random.Random(seed)

    strata = [(i + rng.random()) / n_runs for i in range(n_runs)]

    growth_values = [0.04 + value * (0.12 - 0.04) for value in strata]
    capacity_values = [60 + value * (140 - 60) for value in strata]
    extraction_values = [0.005 + value * (0.060 - 0.005) for value in strata]
    delay_values = [1 + int(value * 12) for value in strata]

    rng.shuffle(capacity_values)
    rng.shuffle(extraction_values)
    rng.shuffle(delay_values)

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

    for index in range(n_runs):
        rows.append({
            "sample_type": "latin_hypercube_style",
            "run_id": index + 1,
            "growth_rate": growth_values[index],
            "carrying_capacity": capacity_values[index],
            "extraction_pressure": extraction_values[index],
            "recovery_delay": max(1, min(12, delay_values[index])),
        })

    return rows


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

    for row in samples:
        result = simulate_system(
            growth_rate=float(row["growth_rate"]),
            carrying_capacity=float(row["carrying_capacity"]),
            extraction_pressure=float(row["extraction_pressure"]),
            recovery_delay=int(row["recovery_delay"]),
        )

        rows.append({
            "sample_type": row["sample_type"],
            "run_id": row["run_id"],
            "growth_rate": round(float(row["growth_rate"]), 6),
            "carrying_capacity": round(float(row["carrying_capacity"]), 6),
            "extraction_pressure": round(float(row["extraction_pressure"]), 6),
            "recovery_delay": int(row["recovery_delay"]),
            "final_state": round(result["final_state"], 6),
            "maximum_state": round(result["maximum_state"], 6),
            "minimum_state": round(result["minimum_state"], 6),
            "mean_state": round(result["mean_state"], 6),
        })

    return rows


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

    for sample_type in sorted(set(str(row["sample_type"]) for row in rows)):
        subset = [row for row in rows if row["sample_type"] == sample_type]
        final_states = [float(row["final_state"]) for row in subset]

        for parameter in ["growth_rate", "carrying_capacity", "extraction_pressure", "recovery_delay"]:
            values = [float(row[parameter]) for row in subset]
            coefficient = spearman(values, final_states)

            results.append({
                "sample_type": sample_type,
                "parameter": parameter,
                "spearman_correlation": round(coefficient, 6),
                "absolute_correlation": round(abs(coefficient), 6),
                "direction": "positive" if coefficient >= 0 else "negative",
            })

    return sorted(results, key=lambda row: (row["sample_type"], -float(row["absolute_correlation"])))


def validate(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    checks = {
        "final_state": (0.0, 10000.0),
        "maximum_state": (0.0, 10000.0),
        "minimum_state": (0.0, 10000.0),
        "mean_state": (0.0, 10000.0),
    }

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

    for sample_type in sorted(set(str(row["sample_type"]) for row in rows)):
        subset = [row for row in rows if row["sample_type"] == sample_type]

        for metric, (low, high) in checks.items():
            values = [float(row[metric]) for row in subset]
            validation_rows.append({
                "sample_type": sample_type,
                "metric": metric,
                "minimum_value": round(min(values), 6),
                "maximum_value": round(max(values), 6),
                "target_low": low,
                "target_high": high,
                "passed": min(values) >= low and max(values) <= high,
            })

    return validation_rows


def main() -> None:
    local_rows = local_sensitivity()

    samples = []
    samples.extend(monte_carlo_sample(n_runs=600, seed=42))
    samples.extend(latin_hypercube_style_sample(n_runs=300, seed=43))

    global_rows = evaluate_samples(samples)
    ranking_rows = sensitivity_ranking(global_rows)
    validation_rows = validate(global_rows)

    write_csv(TABLES / "python_local_sensitivity.csv", local_rows)
    write_csv(TABLES / "python_global_sensitivity_runs.csv", global_rows)
    write_csv(TABLES / "python_sensitivity_rank_summary.csv", ranking_rows)
    write_csv(TABLES / "python_sensitivity_validation.csv", validation_rows)

    print("Sensitivity analysis workflow complete.")
    print(TABLES / "python_sensitivity_rank_summary.csv")


if __name__ == "__main__":
    main()

This workflow is intentionally dependency-light but professionally useful. It preserves run-level metadata, separates local and global analysis, compares sampling designs, ranks influential parameters, and writes validation diagnostics.

Back to top ↑

GitHub Repository

Back to top ↑

Ethics and Responsible Use

Sensitivity analysis is not only a technical practice. It is also an ethical practice because it affects how uncertainty is communicated to decision-makers and the public.

A model used to justify infrastructure investment, climate policy, health preparedness, resource allocation, or service design can influence real people and institutions. If uncertainty is hidden, decisions may be made with false confidence. If sensitivity is exaggerated without context, useful models may be dismissed. Responsible sensitivity analysis helps balance these risks by making conditionality clear.

A responsible sensitivity analysis should make the model more honest, not merely more elaborate.

Back to top ↑

Common Pitfalls

Sensitivity analysis can be misused when it is treated as a checkbox rather than a disciplined inquiry into model fragility, robustness, and uncertainty.

Good sensitivity analysis makes uncertainty more visible, not more decorative.

Back to top ↑

Conclusion

Sensitivity analysis is one of the most important methodological disciplines in systems modeling because it shows whether model conclusions survive uncertainty or collapse under it. It reveals which parameters matter most, which findings are robust across plausible assumptions, and which outputs are highly contingent on narrow specifications.

For complex systems research, that role is indispensable. Models are useful not simply because they generate outputs, but because they help analysts reason responsibly about systems whose parameters, behaviors, structures, and future conditions remain uncertain. Sensitivity analysis is one of the principal ways that such reasoning becomes transparent, contestable, and methodologically disciplined.

A model that has not been tested against uncertainty remains incomplete as evidence. Sensitivity analysis does not remove uncertainty, but it shows where uncertainty matters, where it does not, and where better knowledge would most improve judgment.

In that sense, sensitivity analysis is not an appendix to systems modeling. It is one of the foundations of responsible model interpretation.

Back to top ↑

Related Articles

• What Is Systems Modeling?
• Why Complex Systems Require Models
• Core Principles of Systems Modeling
• Scenario Modeling and Simulation
• Calibration and Validation of Models
• Uncertainty and Model Interpretation
• Model Comparison and Ensemble Reasoning
• Stress Testing and Robustness Analysis
• System Dynamics Modeling
• Agent-Based Modeling
• Network Models
• Discrete Event Simulation

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. Available at: EPA HERO record.
• Pianosi, F., Beven, K., Freer, J., Hall, J.W., Rougier, J., Stephenson, D.B. and Wagener, T. (2016) ‘Sensitivity analysis of environmental models: A systematic review with practical workflow’, Environmental Modelling & Software, 79, pp. 214–232. Available at: https://doi.org/10.1016/j.envsoft.2016.02.008.
• SALib. Sensitivity Analysis Library in Python. Available at: https://salib.readthedocs.io/.
• SALib. Basics. Available at: https://salib.readthedocs.io/en/latest/user_guide/basics.html.
• Mastrandrea, M.D. et al. (2010) Guidance Note for Lead Authors of the IPCC Fifth Assessment Report on Consistent Treatment of Uncertainties. Available at: IPCC Uncertainty Guidance Note.
• Helton, J.C. and Davis, F.J. (2003) ‘Latin hypercube sampling and the propagation of uncertainty in analyses of complex systems’, Reliability Engineering & System Safety, 81(1), pp. 23–69.
• 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. et al. (2019) ‘Why so many published sensitivity analyses are false: A systematic review of sensitivity analysis practices’, Environmental Modelling & Software, 114, pp. 29–39.
• MIT OpenCourseWare. Sensitivity Analysis. Available at: MIT OCW.
• MIT System Dynamics Group. Home. Available at: https://systemdynamics.mit.edu/.
• Santa Fe Institute. What Is Complex Systems Science? Available at: https://www.santafe.edu/what-is-complex-systems-science.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.

Back to top ↑

References

• Helton, J.C. and Davis, F.J. (2003) ‘Latin hypercube sampling and the propagation of uncertainty in analyses of complex systems’, Reliability Engineering & System Safety, 81(1), pp. 23–69.
• Mastrandrea, M.D. et al. (2010) Guidance Note for Lead Authors of the IPCC Fifth Assessment Report on Consistent Treatment of Uncertainties. Available at: https://www.ipcc.ch/site/assets/uploads/2017/08/AR5_Uncertainty_Guidance_Note.pdf.
• MIT OpenCourseWare. (n.d.) Sensitivity Analysis. Available at: https://ocw.mit.edu/courses/15-988-system-dynamics-self-study-fall-1998-spring-1999/resources/sensitivityanalysis/.
• Pianosi, F., Beven, K., Freer, J., Hall, J.W., Rougier, J., Stephenson, D.B. and Wagener, T. (2016) ‘Sensitivity analysis of environmental models: A systematic review with practical workflow’, Environmental Modelling & Software, 79, pp. 214–232. Available at: https://doi.org/10.1016/j.envsoft.2016.02.008.
• SALib. (n.d.) Sensitivity Analysis Library in Python. Available at: https://salib.readthedocs.io/.
• SALib. (n.d.) Basics. Available at: https://salib.readthedocs.io/en/latest/user_guide/basics.html.
• 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. Available at: https://hero.epa.gov/reference/1065450/.
• Saltelli, A. et al. (2019) ‘Why so many published sensitivity analyses are false: A systematic review of sensitivity analysis practices’, Environmental Modelling & Software, 114, pp. 29–39.
• 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.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.

Back to top ↑