Sensitivity Analysis for System Interventions

Last Updated June 1, 2026

Sensitivity analysis asks a deceptively simple question: what changes when an assumption changes? In systems thinking, this question is central because interventions rarely operate in stable, fully known conditions. A policy may depend on how quickly trust recovers, how strongly demand responds, how long implementation takes, how much capacity exists, how fast a stock depletes, or how sharply a threshold behaves. If small changes in those assumptions produce large changes in outcomes, the intervention is sensitive. If the intervention still performs well across a wide range of assumptions, it is more robust.

Sensitivity analysis helps systems thinkers avoid false confidence. A model may appear to support a policy under one set of assumptions, but fail when delay is longer, demand is higher, cooperation is lower, funding is unstable, or repair is slower. A scenario may look promising until a key feedback loop is strengthened or a hidden outflow is included. An intervention may improve average outcomes while worsening conditions for a vulnerable group under stress. Sensitivity analysis makes these dependencies visible.

This article explains sensitivity analysis as a disciplined systems-thinking practice for evaluating interventions under uncertainty. It examines parameter sensitivity, assumption testing, local and global sensitivity, threshold behavior, feedback strength, implementation delay, policy robustness, distributional effects, and ethical responsibility. It also shows why sensitivity analysis is not merely a technical modeling step: it is a way to ask whether an intervention remains responsible when the system behaves differently than expected.

Why Sensitivity Analysis Matters

Sensitivity analysis matters because complex systems are full of uncertain assumptions. A model, policy, intervention, or strategy may depend on assumed rates, delays, capacities, thresholds, feedback strengths, behavioral responses, costs, participation levels, compliance rates, repair speeds, and external conditions. If those assumptions are wrong, the intervention may perform differently than expected.

In linear systems, an assumption error may produce a relatively proportional outcome error. In complex systems, the effect can be much larger. A slightly longer delay can turn stabilization into oscillation. A slightly weaker repair flow can prevent a depleted stock from recovering. A slightly higher demand growth rate can overwhelm capacity. A slightly lower trust level can reduce cooperation and trigger policy resistance. A slightly stronger reinforcing loop can shift a system from gradual change to runaway escalation.

Sensitivity analysis helps identify which assumptions matter most. Some assumptions can vary without changing the broad conclusion. Others determine whether the intervention succeeds, fails, reverses, or causes harm. A systems thinker needs to know the difference.

Sensitivity analysis is not a sign that a model is weak. It is part of responsible modeling. A model that never tests its assumptions invites overconfidence. A policy that never examines sensitivity may work only under ideal conditions. A strategy that never asks what could change may confuse a preferred future with a robust future.

In systems work, uncertainty is not an excuse for paralysis. It is a reason to test which uncertainties matter.

Back to top ↑

What Sensitivity Analysis Is

Sensitivity analysis is the study of how changes in inputs, assumptions, parameters, or model structure affect outputs. In systems thinking, it asks how intervention outcomes change when the system behaves differently than expected. The analyst varies one or more assumptions and observes how the result changes.

A simple sensitivity question might ask: what happens if implementation delay is six months instead of three? A more complex analysis might ask: what happens when demand growth, staffing capacity, public trust, repair funding, and error rates all vary together? A distributional sensitivity analysis might ask: which groups experience the greatest harm when delays increase or benefits decline?

Sensitivity analysis can be qualitative or quantitative. A qualitative version may compare causal-loop diagrams under different assumptions: high trust versus low trust, strong enforcement versus weak enforcement, early intervention versus delayed intervention. A quantitative version may vary parameter values in a simulation model and compare outcomes across many runs.

In a system intervention, the output may be backlog, trust, capacity, emissions, cost, risk, access, resilience, learning, health, legitimacy, or distributional burden. The input may be a policy parameter, behavioral assumption, feedback strength, delay length, repair rate, deterioration rate, demand growth rate, funding level, or threshold value.

Several forms of sensitivity analysis are common:

• One-at-a-time sensitivity: vary one assumption while holding others constant.
• Scenario sensitivity: compare outcomes across named scenario sets.
• Threshold sensitivity: identify the value where behavior changes sharply.
• Global sensitivity: vary many assumptions across ranges.
• Distributional sensitivity: examine how different groups are affected by assumption changes.
• Structural sensitivity: test whether adding, removing, or changing feedback loops changes conclusions.

Sensitivity analysis is not only about numbers. It is about dependency. It asks what the conclusion depends on. If a policy conclusion depends on optimistic assumptions about trust, capacity, funding, or technology, that dependency should be made visible. If a policy remains effective under pessimistic assumptions, that robustness matters.

The central question is not only “What does the model say?” It is “How easily does the model’s conclusion change?”

Back to top ↑

Assumptions, Parameters, and System Structure

Sensitivity analysis begins with assumptions. Some assumptions are numerical parameters. Others are structural choices. A parameter might be a rate, delay, probability, elasticity, cost, capacity level, or threshold. A structural assumption might define whether a feedback loop exists, whether a variable is included, whether a relationship is linear or nonlinear, or whether a cost lies inside the model boundary.

Both matter. A model may be sensitive to a parameter such as demand growth. But it may be even more sensitive to a structural omission, such as failing to include public trust, administrative burden, ecological limits, or workforce fatigue. A policy may look effective because the model excludes the very feedback loop that would produce resistance.

For example, a model of digital public service might include processing time and automation accuracy. If it omits appeal access, user trust, disability accommodation, language access, data error, and administrative burden, sensitivity testing of processing speed alone will be too narrow. The most important sensitivity may lie in the excluded structure.

Parameter sensitivity is easier to compute, but structural sensitivity is often more important. A precise sensitivity analysis of a narrow model can still mislead. If the model excludes the main pathway of harm, no parameter scan will repair the omission.

A strong systems sensitivity analysis therefore tests both parameter values and model structure. It asks which assumptions are uncertain, which are influential, which are ethically significant, and which are politically convenient but empirically weak.

Back to top ↑

Local and Global Sensitivity

Local sensitivity analysis examines how an output changes when one input changes slightly around a baseline value. It is useful when the analyst wants to know whether small changes near the current assumption matter. For example, if the assumed implementation delay is six months, local sensitivity might ask what happens at five months or seven months.

Global sensitivity analysis examines how outputs change when inputs vary across broader ranges, often together. It is useful when uncertainty is wide or when parameters interact. For example, demand growth, staff turnover, public trust, funding, and implementation delay may all vary together. The combined effect may be different from the sum of individual effects.

Local sensitivity can be clear and interpretable. It helps identify parameters where small errors matter. But local sensitivity may miss nonlinear effects, thresholds, and parameter interactions. A system may appear insensitive near the baseline but become highly sensitive near a threshold. A small change in trust may matter little when trust is high, but much more when trust is near collapse. A small increase in workload may be manageable when capacity is strong, but damaging when fatigue is already high.

Global sensitivity is more demanding, but it better fits complex systems. It can reveal interaction effects: delay may matter most when capacity is low; demand growth may matter most when funding is unstable; administrative burden may matter most when trust is low; climate stress may matter most when infrastructure backlog is high.

In systems thinking, local and global analysis should complement one another. Local sensitivity helps explain immediate dependencies. Global sensitivity helps reveal fragility under broader uncertainty. Structural sensitivity asks whether the whole model frame is adequate.

Back to top ↑

Uncertainty and Sensitivity Are Not the Same

Uncertainty and sensitivity are related, but they are not the same. Uncertainty concerns how well an input, assumption, or relationship is known. Sensitivity concerns how much the outcome changes when that input or assumption changes. An assumption can be highly uncertain but not very influential. Another assumption can be relatively well estimated but highly influential.

This distinction matters for priorities. If an assumption is uncertain but the model is not sensitive to it, further research may be less urgent. If an assumption is both uncertain and highly influential, it deserves attention. If an assumption is highly influential but hidden or politically convenient, the model may be fragile in a way that matters for governance.

For example, in a public benefits model, the cost per case may be uncertain, but the policy conclusion may not change much across plausible values. By contrast, the assumption about administrative burden may be both uncertain and highly influential: if burden reduces participation significantly, the policy may fail its access goals. In an infrastructure model, exact repair cost may matter less than the assumed deterioration rate or climate-stress multiplier. In a workforce model, office-supply costs may be uncertain but irrelevant, while turnover response to workload may determine whether the system collapses.

This distinction also helps with communication. Decision-makers may focus on uncertainty and conclude that nothing can be known. Sensitivity analysis shows which uncertainties actually matter. It helps move from vague concern to targeted learning: improve data here, monitor this indicator, design fallback capacity there, and avoid policies that fail under plausible variation.

Uncertainty is unavoidable. Unexamined sensitivity is optional.

Back to top ↑

Feedback Strength, Delay, and Thresholds

Systems interventions are often sensitive to feedback strength, delay, and thresholds. These features determine whether a system stabilizes, oscillates, overshoots, collapses, recovers, or resists change.

Feedback strength refers to how strongly one variable affects another through a loop. A weak reinforcing loop may produce gradual change. A strong reinforcing loop may produce rapid escalation. A weak balancing loop may fail to correct a problem. A strong balancing loop may stabilize the system or, if delayed, overcorrect. Sensitivity analysis asks how outcomes change as feedback strength varies.

Delay is often critical. A policy that works with short implementation delay may fail with long delay. A balancing loop that stabilizes with timely information may oscillate when information is late. A repair policy that succeeds when restoration begins early may fail when damage has already accumulated. Sensitivity analysis asks how much delay the system can tolerate.

Thresholds introduce sharp behavior changes. A system may be stable until a stock crosses a critical point. Trust may erode slowly and then collapse. Infrastructure may deteriorate gradually and then fail. Debt may grow gradually and then become unmanageable. Ecosystems may absorb stress and then shift regimes. Sensitivity analysis asks where these thresholds may lie and how outcomes change near them.

Feedback, delay, and threshold sensitivity are especially important for intervention timing. An intervention may be effective before a threshold and weak afterward. It may be effective with short delay and harmful with long delay. It may be effective when feedback is moderate and unstable when correction is too strong. Policy design should account for these dynamic conditions.

In systems thinking, sensitivity analysis is therefore not just parameter testing. It is behavior testing. It asks which dynamic features control the pattern.

Back to top ↑

Robustness, Fragility, and Intervention Design

A robust intervention performs reasonably well across a range of plausible conditions. A fragile intervention works only under narrow assumptions. Sensitivity analysis helps distinguish the two. This distinction is especially important in public policy, sustainability, infrastructure, health, technology governance, and institutional reform because conditions rarely match ideal assumptions.

Fragile interventions often depend on optimism. They assume stable funding, high compliance, strong trust, quick implementation, low resistance, accurate data, smooth technology adoption, and no major shocks. If any assumption fails, the intervention weakens. Robust interventions are designed for variation. They include buffers, monitoring, adaptation, distributional safeguards, feedback correction, and fallback capacity.

For example, a digital-service reform may be fragile if it assumes all users have internet access, digital literacy, language access, disability accommodation, trust, and error-free data. A more robust intervention would include assisted access, appeal pathways, human review, multilingual support, monitoring, error correction, and burden tracking. It would perform better when assumptions fail.

Robustness does not mean a policy is perfect in every future. It means the policy avoids unacceptable failure across plausible conditions. In some systems, the best intervention is not the one with the highest outcome under optimistic assumptions, but the one that performs acceptably across uncertainty.

Sensitivity analysis supports better intervention design by revealing where the policy needs protection. If outcomes are highly sensitive to implementation delay, reduce delay or build interim safeguards. If outcomes are sensitive to trust, include trust repair. If outcomes are sensitive to demand, build scalable capacity. If outcomes are sensitive to distributional burden, redesign access and monitor affected groups.

Robustness is not a technical luxury. In complex systems, it is a responsibility.

Back to top ↑

Distributional Sensitivity: Who Is Most Affected?

Distributional sensitivity asks how assumption changes affect different groups, places, institutions, ecosystems, or generations. A model may show that an intervention is not very sensitive on average while being highly sensitive for a vulnerable subgroup. If only aggregate outcomes are measured, that fragility remains hidden.

For example, a public benefits policy may appear stable when average processing delay increases from two weeks to four weeks. But households with no savings may experience severe harm from the delay. A transportation policy may show modest average travel-time sensitivity while disabled riders, shift workers, or low-income neighborhoods experience large effects. A climate adaptation policy may reduce average flood risk while leaving certain communities highly sensitive to extreme rainfall.

Distributional sensitivity is especially important when buffers are unequal. People with savings, flexible work, secure housing, insurance, transportation, healthcare access, and legal support can absorb delays and shocks more easily. People without those buffers are more sensitive to the same system change. A small administrative delay can be minor for one household and catastrophic for another.

Distributional sensitivity asks:

• Which groups are most affected when assumptions change?
• Who has buffers?
• Who lacks buffers?
• Which outcomes are stable in the aggregate but unstable for some groups?
• Which policy assumptions depend on unpaid labor, care work, or community support?
• What harms appear only when the model is disaggregated?
• What safeguards are needed for those most sensitive to failure?

This matters ethically because average robustness can hide unequal fragility. A system can be resilient for powerful groups and fragile for marginalized groups. A policy can work for people with resources and fail for people facing accumulated burden. Sensitivity analysis should therefore test not only whether the intervention works, but for whom it works under stress.

Distributional sensitivity turns uncertainty into a justice question.

Back to top ↑

Ethics, Power, and Assumption Testing

Sensitivity analysis has ethical stakes because assumptions carry power. Some assumptions make harm visible. Others hide it. Some assumptions favor institutional convenience. Others center affected people. Some assumptions make future harm appear small by using short time horizons. Others reveal accumulated costs over generations.

Power often determines which assumptions are tested. A model may test cost variation but not administrative burden. It may test technology performance but not appeal failure. It may test compliance rates but not trust. It may test construction cost but not displacement. It may test emissions reductions but not ecological damage outside the boundary. Sensitivity analysis should challenge these choices.

An ethical sensitivity analysis asks which assumptions could produce harm if wrong. If a policy assumes high access and access is lower, who is excluded? If a technology assumes low error and errors are higher, who is harmed? If a climate plan assumes moderate rainfall and rainfall is extreme, who floods? If a workforce plan assumes low turnover and turnover rises, who absorbs the overload? If a public agency assumes trust and trust is low, who is blamed for nonparticipation?

Ethical sensitivity analysis asks:

• Which assumptions protect the preferred policy?
• Which assumptions hide burden or harm?
• Whose experience should define plausible parameter ranges?
• Which groups are most exposed when assumptions fail?
• What assumption failure would create unacceptable harm?
• What early-warning indicators should be monitored?
• What repair obligations arise if sensitive assumptions prove wrong?
• Who has authority to challenge the model?

Sensitivity analysis should not become a technical ritual that legitimizes predetermined decisions. It should be a method of accountability. It should reveal where decisions depend on uncertain claims and where safeguards are needed before harm occurs.

In responsible systems work, the most important sensitivity may not be the one that produces the largest numerical change. It may be the one that exposes preventable harm to people with the least power to absorb it.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

Sensitivity analysis can be performed with simple calculations, parameter sweeps, scenario comparison, Monte Carlo simulation, global sensitivity indices, threshold searches, distributional comparisons, and structural model tests. The level of mathematical detail should match the decision context. A high-stakes intervention requires stronger testing than an exploratory learning model.

A basic sensitivity measure is:

A local derivative form is:

A one-at-a-time parameter sweep can be represented as:

A Monte Carlo sensitivity workflow can be represented as:

A threshold search can be represented as:

A distributional sensitivity measure can be represented as:

Computational sensitivity analysis should be documented clearly. Parameter ranges should be justified. Synthetic data should be labeled. Assumptions should be visible. Results should be explained in terms of system behavior, not only numbers. The point is to understand where conclusions are strong, where they are fragile, and where better evidence or safer policy design is needed.

Back to top ↑

Python Workflow: Sensitivity, Threshold, Robustness, and Distributional Diagnostics

The Python workflow below turns sensitivity analysis into a small reproducible systems model. It runs one-at-a-time sensitivity tests, threshold searches, scenario comparisons, and deterministic Monte Carlo-style sampling. The script uses only the Python standard library, writes CSV outputs relative to the article folder, and is designed as a clear starting point for companion repository work.

# sensitivity_analysis_system_interventions_workflow.py
# Dependency-light workflow for one-at-a-time sensitivity, threshold search,
# Monte Carlo-style deterministic sampling, robustness comparison,
# and distributional sensitivity diagnostics.
# Writes outputs relative to the article root.

from __future__ import annotations

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

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


@dataclass
class InterventionAssumptions:
    name: str
    demand_growth: float
    implementation_delay: float
    trust_repair_rate: float
    capacity_investment: float
    burden_reduction: float
    feedback_strength: float
    vulnerable_buffer: float
    monitoring_quality: float
    accountability: float
    stress_pressure: float


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


def simulate(assumption: InterventionAssumptions, periods: int = 48) -> dict[str, float | str]:
    backlog = 48.0 + assumption.demand_growth * 20.0
    capacity = 40.0 + assumption.capacity_investment * 24.0
    trust = 38.0 + assumption.trust_repair_rate * 24.0
    administrative_burden = 52.0 - assumption.burden_reduction * 18.0
    vulnerable_group_harm = 36.0 + assumption.stress_pressure * 18.0 - assumption.vulnerable_buffer * 12.0
    institutional_learning = 30.0 + assumption.monitoring_quality * 20.0
    backlog_history: list[float] = [backlog]

    delay_steps = max(0, int(round(assumption.implementation_delay * 8.0)))

    for _period in range(periods):
        delayed_index = max(0, len(backlog_history) - 1 - delay_steps)
        perceived_backlog = backlog_history[delayed_index]

        demand_inflow = clamp(
            assumption.demand_growth * 17.0
            + assumption.stress_pressure * 12.0
            + max(0.0, 55.0 - trust) * 0.09
            + administrative_burden * 0.05,
            0.0,
            100.0,
        )

        service_outflow = clamp(
            capacity * 0.22
            + assumption.capacity_investment * 12.0
            + assumption.accountability * 7.0
            - assumption.implementation_delay * 4.0
            - max(0.0, vulnerable_group_harm - 60.0) * 0.05,
            0.0,
            100.0,
        )

        repair_flow = clamp(
            assumption.trust_repair_rate * 12.0
            + assumption.burden_reduction * 14.0
            + assumption.feedback_strength * max(0.0, perceived_backlog - 50.0) * 0.12
            + institutional_learning * 0.08
            - assumption.implementation_delay * 3.0,
            0.0,
            100.0,
        )

        backlog = clamp(
            backlog
            + demand_inflow * 0.18
            - service_outflow * 0.15
            - repair_flow * 0.09,
            0.0,
            120.0,
        )

        capacity = clamp(
            capacity
            + assumption.capacity_investment * 1.6
            + assumption.accountability * 1.0
            - max(0.0, backlog - 70.0) * 0.04
            - assumption.stress_pressure * 0.6,
            0.0,
            100.0,
        )

        administrative_burden = clamp(
            administrative_burden
            + assumption.stress_pressure * 1.2
            + max(0.0, backlog - capacity) * 0.04
            - assumption.burden_reduction * 1.8
            - assumption.accountability * 0.8,
            0.0,
            100.0,
        )

        trust = clamp(
            trust
            + assumption.trust_repair_rate * 1.5
            + assumption.accountability * 1.3
            + max(0.0, service_outflow - demand_inflow) * 0.04
            - administrative_burden * 0.035
            - vulnerable_group_harm * 0.035,
            0.0,
            100.0,
        )

        vulnerable_group_harm = clamp(
            vulnerable_group_harm
            + assumption.stress_pressure * 1.6
            + administrative_burden * 0.055
            + max(0.0, backlog - 60.0) * 0.055
            - assumption.vulnerable_buffer * 1.8
            - assumption.accountability * 0.9,
            0.0,
            100.0,
        )

        institutional_learning = clamp(
            institutional_learning
            + assumption.monitoring_quality * 1.5
            + assumption.feedback_strength * 1.0
            + assumption.accountability * 1.2
            - assumption.implementation_delay * 0.7
            - max(0.0, vulnerable_group_harm - 60.0) * 0.04,
            0.0,
            100.0,
        )

        backlog_history.append(backlog)

    fragility_index = clamp(
        backlog * 0.20
        + administrative_burden * 0.16
        + vulnerable_group_harm * 0.24
        + assumption.implementation_delay * 10.0
        + assumption.stress_pressure * 8.0
        - capacity * 0.12
        - trust * 0.10
        - institutional_learning * 0.08,
        0.0,
        100.0,
    )

    intervention_score = clamp(
        capacity * 0.20
        + trust * 0.20
        + institutional_learning * 0.18
        + assumption.vulnerable_buffer * 12.0
        + assumption.accountability * 10.0
        - backlog * 0.18
        - administrative_burden * 0.14
        - vulnerable_group_harm * 0.18
        - fragility_index * 0.10,
        0.0,
        100.0,
    )

    return {
        "scenario": assumption.name,
        "intervention_score": round(intervention_score, 3),
        "fragility_index": round(fragility_index, 3),
        "backlog": round(backlog, 3),
        "capacity": round(capacity, 3),
        "trust": round(trust, 3),
        "administrative_burden": round(administrative_burden, 3),
        "vulnerable_group_harm": round(vulnerable_group_harm, 3),
        "institutional_learning": round(institutional_learning, 3),
    }


def one_at_a_time(base: InterventionAssumptions, delta: float = 0.10) -> list[dict[str, object]]:
    base_result = simulate(base)
    base_score = float(base_result["intervention_score"])
    parameters = [
        "demand_growth",
        "implementation_delay",
        "trust_repair_rate",
        "capacity_investment",
        "burden_reduction",
        "feedback_strength",
        "vulnerable_buffer",
        "monitoring_quality",
        "accountability",
        "stress_pressure",
    ]
    rows: list[dict[str, object]] = []

    for parameter in parameters:
        for direction in (-1, 1):
            current = getattr(base, parameter)
            revised_value = max(0.0, min(1.0, current + direction * delta))
            revised = replace(
                base,
                name=f"{base.name} {parameter} {direction * delta:+.2f}",
                **{parameter: revised_value},
            )
            result = simulate(revised)
            score = float(result["intervention_score"])
            rows.append({
                "parameter": parameter,
                "delta": direction * delta,
                "base_value": current,
                "revised_value": revised_value,
                "base_intervention_score": round(base_score, 3),
                "revised_intervention_score": round(score, 3),
                "score_change": round(score - base_score, 3),
                "absolute_score_change": round(abs(score - base_score), 3),
            })

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


def threshold_search(base: InterventionAssumptions, parameter: str, critical_score: float = 50.0) -> list[dict[str, object]]:
    rows: list[dict[str, object]] = []
    for step in range(0, 21):
        value = step / 20
        revised = replace(base, name=f"threshold {parameter} {value:.2f}", **{parameter: value})
        result = simulate(revised)
        rows.append({
            "parameter": parameter,
            "tested_value": round(value, 2),
            "intervention_score": result["intervention_score"],
            "fragility_index": result["fragility_index"],
            "below_critical_score": float(result["intervention_score"]) < critical_score,
        })
    return rows


def monte_carlo_sample(base: InterventionAssumptions, runs: int = 250, seed: int = 42) -> list[dict[str, object]]:
    random.seed(seed)
    rows: list[dict[str, object]] = []
    fields = [
        "demand_growth",
        "implementation_delay",
        "trust_repair_rate",
        "capacity_investment",
        "burden_reduction",
        "feedback_strength",
        "vulnerable_buffer",
        "monitoring_quality",
        "accountability",
        "stress_pressure",
    ]

    for run_id in range(1, runs + 1):
        values = {}
        for field in fields:
            center = getattr(base, field)
            spread = 0.18 if field in {"demand_growth", "implementation_delay", "stress_pressure"} else 0.14
            values[field] = max(0.0, min(1.0, random.uniform(center - spread, center + spread)))
        sampled = replace(base, name=f"sample_{run_id:03d}", **values)
        result = simulate(sampled)
        rows.append({
            "run_id": run_id,
            **{field: round(values[field], 3) for field in fields},
            **result,
        })

    return rows


def summarize_monte_carlo(rows: list[dict[str, object]]) -> list[dict[str, object]]:
    scores = [float(row["intervention_score"]) for row in rows]
    fragility = [float(row["fragility_index"]) for row in rows]
    vulnerable_harm = [float(row["vulnerable_group_harm"]) for row in rows]
    sorted_scores = sorted(scores)
    n = len(sorted_scores)

    return [{
        "run_count": n,
        "mean_intervention_score": round(mean(scores), 3),
        "sd_intervention_score": round(pstdev(scores), 3),
        "min_intervention_score": round(min(scores), 3),
        "p10_intervention_score": round(sorted_scores[max(0, int(0.10 * n) - 1)], 3),
        "median_intervention_score": round(sorted_scores[n // 2], 3),
        "max_intervention_score": round(max(scores), 3),
        "mean_fragility_index": round(mean(fragility), 3),
        "mean_vulnerable_group_harm": round(mean(vulnerable_harm), 3),
        "share_below_critical_score": round(sum(score < 50.0 for score in scores) / n, 3),
    }]


def scenario_comparison() -> list[dict[str, object]]:
    scenarios = [
        InterventionAssumptions("optimistic implementation", 0.38, 0.22, 0.74, 0.76, 0.72, 0.70, 0.72, 0.76, 0.74, 0.28),
        InterventionAssumptions("baseline reform", 0.50, 0.42, 0.58, 0.62, 0.58, 0.56, 0.54, 0.62, 0.60, 0.42),
        InterventionAssumptions("high-delay stress", 0.66, 0.76, 0.42, 0.48, 0.38, 0.42, 0.36, 0.44, 0.42, 0.72),
        InterventionAssumptions("justice-centered robust design", 0.44, 0.30, 0.78, 0.74, 0.82, 0.72, 0.86, 0.82, 0.84, 0.36),
    ]
    return [simulate(scenario) for scenario in scenarios]


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 main() -> None:
    base = InterventionAssumptions("baseline reform", 0.50, 0.42, 0.58, 0.62, 0.58, 0.56, 0.54, 0.62, 0.60, 0.42)

    oat_rows = one_at_a_time(base)
    threshold_delay = threshold_search(base, "implementation_delay")
    threshold_trust = threshold_search(base, "trust_repair_rate")
    mc_rows = monte_carlo_sample(base)
    mc_summary = summarize_monte_carlo(mc_rows)
    scenarios = scenario_comparison()

    write_csv(TABLES / "sensitivity_one_at_a_time.csv", oat_rows)
    write_csv(TABLES / "sensitivity_threshold_delay.csv", threshold_delay)
    write_csv(TABLES / "sensitivity_threshold_trust.csv", threshold_trust)
    write_csv(TABLES / "sensitivity_monte_carlo_runs.csv", mc_rows)
    write_csv(TABLES / "sensitivity_monte_carlo_summary.csv", mc_summary)
    write_csv(TABLES / "sensitivity_scenario_comparison.csv", scenarios)

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


if __name__ == "__main__":
    main()

The workflow is intentionally simple enough to inspect. It shows how intervention performance can depend on demand growth, implementation delay, trust repair, capacity investment, burden reduction, feedback strength, vulnerable-group buffers, monitoring quality, accountability, and stress pressure. It also demonstrates why sensitivity analysis should include distributional harm, not only average performance. The model is synthetic and illustrative; it supports disciplined inquiry rather than replacing domain expertise, stakeholder evidence, or ethical judgment.

Back to top ↑

R Workflow: Sensitivity Summary and Intervention Visualization

The R workflow reads the Python-generated sensitivity outputs, ranks influential assumptions, summarizes scenario performance, and exports base R plots for parameter importance, scenario scores, Monte Carlo-style outcome distributions, and threshold behavior. It uses only base R so it remains portable across simple local environments.

# sensitivity_analysis_system_interventions_diagnostics.R
# Base R workflow for sensitivity summary and intervention visualization.

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)
}

oat_path <- file.path(tables_dir, "sensitivity_one_at_a_time.csv")
mc_path <- file.path(tables_dir, "sensitivity_monte_carlo_runs.csv")
scenario_path <- file.path(tables_dir, "sensitivity_scenario_comparison.csv")
delay_path <- file.path(tables_dir, "sensitivity_threshold_delay.csv")
trust_path <- file.path(tables_dir, "sensitivity_threshold_trust.csv")

required <- c(oat_path, mc_path, scenario_path, delay_path, trust_path)
missing <- required[!file.exists(required)]

if (length(missing) > 0) {
  stop(paste("Missing sensitivity workflow outputs. Run the Python workflow first:", paste(missing, collapse = ", ")))
}

oat <- read.csv(oat_path, stringsAsFactors = FALSE)
mc <- read.csv(mc_path, stringsAsFactors = FALSE)
scenarios <- read.csv(scenario_path, stringsAsFactors = FALSE)
delay_threshold <- read.csv(delay_path, stringsAsFactors = FALSE)
trust_threshold <- read.csv(trust_path, stringsAsFactors = FALSE)

ranked <- oat[order(oat$absolute_score_change, decreasing = TRUE), ]

parameter_summary <- aggregate(
  absolute_score_change ~ parameter,
  data = oat,
  FUN = mean
)

names(parameter_summary)[2] <- "mean_absolute_score_change"
parameter_summary <- parameter_summary[order(parameter_summary$mean_absolute_score_change, decreasing = TRUE), ]

scenario_summary <- scenarios[, c(
  "scenario",
  "intervention_score",
  "fragility_index",
  "backlog",
  "trust",
  "administrative_burden",
  "vulnerable_group_harm"
)]

scenario_summary$diagnostic <- ifelse(
  scenario_summary$intervention_score >= 65 & scenario_summary$fragility_index <= 35,
  "robust intervention performance",
  ifelse(
    scenario_summary$fragility_index >= 55,
    "high fragility under scenario assumptions",
    ifelse(
      scenario_summary$vulnerable_group_harm >= 60,
      "distributional harm requires safeguards",
      "partial performance; monitor sensitive assumptions"
    )
  )
)

mc_summary <- data.frame(
  run_count = nrow(mc),
  mean_intervention_score = mean(mc$intervention_score),
  sd_intervention_score = sd(mc$intervention_score),
  min_intervention_score = min(mc$intervention_score),
  median_intervention_score = median(mc$intervention_score),
  max_intervention_score = max(mc$intervention_score),
  share_below_critical_score = mean(mc$intervention_score < 50)
)

write.csv(ranked, file.path(tables_dir, "sensitivity_one_at_a_time_ranked_r.csv"), row.names = FALSE)
write.csv(parameter_summary, file.path(tables_dir, "sensitivity_parameter_summary_r.csv"), row.names = FALSE)
write.csv(scenario_summary, file.path(tables_dir, "sensitivity_scenario_summary_r.csv"), row.names = FALSE)
write.csv(mc_summary, file.path(tables_dir, "sensitivity_monte_carlo_summary_r.csv"), row.names = FALSE)

png(file.path(figures_dir, "sensitivity_parameter_importance.png"), width = 1200, height = 700)
barplot(
  parameter_summary$mean_absolute_score_change,
  names.arg = parameter_summary$parameter,
  las = 2,
  ylab = "Mean absolute score change",
  main = "Parameter Importance from One-at-a-Time Sensitivity"
)
grid()
dev.off()

png(file.path(figures_dir, "scenario_scores.png"), width = 1200, height = 700)
barplot(
  scenario_summary$intervention_score,
  names.arg = scenario_summary$scenario,
  las = 2,
  ylab = "Intervention score",
  main = "Intervention Score by Scenario"
)
grid()
dev.off()

png(file.path(figures_dir, "monte_carlo_score_distribution.png"), width = 1200, height = 700)
hist(
  mc$intervention_score,
  breaks = 20,
  xlab = "Intervention score",
  main = "Monte Carlo-Style Sensitivity Distribution"
)
grid()
dev.off()

png(file.path(figures_dir, "implementation_delay_threshold.png"), width = 1200, height = 700)
plot(
  delay_threshold$tested_value,
  delay_threshold$intervention_score,
  type = "l",
  lwd = 2,
  xlab = "Implementation delay assumption",
  ylab = "Intervention score",
  main = "Threshold Search: Implementation Delay"
)
abline(h = 50, lty = 2)
grid()
dev.off()

png(file.path(figures_dir, "trust_repair_threshold.png"), width = 1200, height = 700)
plot(
  trust_threshold$tested_value,
  trust_threshold$intervention_score,
  type = "l",
  lwd = 2,
  xlab = "Trust repair assumption",
  ylab = "Intervention score",
  main = "Threshold Search: Trust Repair"
)
abline(h = 50, lty = 2)
grid()
dev.off()

print(parameter_summary)
print(scenario_summary)
print(mc_summary)

This workflow supports the article’s central methodological claim: interventions should be tested against changing assumptions before they are treated as robust. The R outputs help readers see which assumptions drive outcomes, where thresholds appear, and which scenarios require redesign or safeguards.

Back to top ↑

GitHub Repository

The companion repository for this article should help readers perform sensitivity analysis for system interventions, including parameter sweeps, uncertainty ranges, robustness testing, threshold searches, distributional sensitivity, structural sensitivity, and policy comparison using synthetic datasets and reproducible workflows.

articles/sensitivity-analysis-for-system-interventions/
├── python/
│   ├── sensitivity_analysis_system_interventions_workflow.py
│   ├── one_at_a_time_sensitivity.py
│   ├── parameter_sweep_workflow.py
│   ├── monte_carlo_sensitivity.py
│   ├── threshold_search.py
│   ├── robustness_comparison.py
│   ├── distributional_sensitivity.py
│   ├── structural_sensitivity_notes.py
│   ├── validation_checks.py
│   └── run_all_sensitivity_workflows.py
├── r/
│   ├── sensitivity_analysis_system_interventions_diagnostics.R
│   ├── sensitivity_plots.R
│   ├── parameter_sweep_tables.R
│   ├── uncertainty_band_visualization.R
│   ├── robustness_summary.R
│   ├── threshold_visualization.R
│   ├── distributional_sensitivity_summary.R
│   └── run_all_sensitivity_workflows.R
├── julia/
│   ├── global_sensitivity_simulation.jl
│   ├── nonlinear_threshold_sensitivity.jl
│   └── robustness_scan.jl
├── sql/
│   ├── schema_sensitivity_parameters.sql
│   ├── schema_parameter_ranges.sql
│   ├── schema_intervention_scenarios.sql
│   ├── schema_sensitivity_runs.sql
│   ├── schema_distributional_outputs.sql
│   └── schema_robustness_results.sql
├── rust/
│   └── sensitivity_diagnostics_cli.rs
├── go/
│   └── parameter_sweep_runner.go
├── cpp/
│   ├── efficient_parameter_sweep.cpp
│   └── threshold_scan.cpp
├── fortran/
│   └── recurrence_sensitivity_model.f90
├── c/
│   └── low_level_sensitivity_engine.c
├── docs/
│   ├── modeling_principles.md
│   ├── article_notes.md
│   ├── sensitivity_analysis_framework.md
│   ├── assumptions_register.md
│   ├── ethics_and_distribution_notes.md
│   ├── assumptions_and_limitations.md
│   └── responsible_use.md
├── data/
│   ├── synthetic_sensitivity_parameters.csv
│   ├── synthetic_parameter_ranges.csv
│   ├── synthetic_intervention_scenarios.csv
│   ├── synthetic_sensitivity_runs.csv
│   ├── synthetic_distributional_outputs.csv
│   └── synthetic_robustness_results.csv
├── outputs/
│   ├── figures/
│   └── tables/
└── notebooks/
    ├── python_sensitivity_analysis_walkthrough.ipynb
    └── r_sensitivity_visualization_placeholder.ipynb

This repository structure supports the article’s central argument: interventions should be tested against changing assumptions. The data/ folder separates parameters, ranges, intervention scenarios, sensitivity runs, distributional outputs, and robustness results. The python/ and r/ folders support one-at-a-time analysis, parameter sweeps, Monte Carlo simulation, threshold search, robustness comparison, uncertainty visualization, and distributional sensitivity. The julia folder supports global sensitivity and nonlinear threshold examples. The sql folder defines schemas for parameters, ranges, scenarios, runs, outputs, and robustness results. The lower-level language folders provide scaffolds for diagnostics, sweep execution, recurrence modeling, threshold scanning, and low-level simulation.

Back to top ↑

Back to top ↑

Back to top ↑

Why Sensitivity Analysis Changes Intervention

Sensitivity analysis changes intervention because it makes dependency visible. It shows what a policy assumes, where it is fragile, which uncertainties matter, which groups are most exposed, and what conditions could cause failure or harm. In complex systems, this is essential. Interventions rarely operate under ideal assumptions. They enter systems shaped by feedback, delay, adaptation, capacity limits, unequal buffers, and changing environments.

A good intervention is not simply one that works in a preferred model. It is one that remains responsible across plausible uncertainty. Sensitivity analysis helps identify whether a policy is robust, whether safeguards are needed, whether more evidence is required, whether early-warning indicators should be monitored, and whether the intervention should be redesigned before implementation.

This matters for sustainability, public health, infrastructure, artificial intelligence, organizational systems, education, climate adaptation, economic policy, and public administration. In each domain, assumptions can fail. Sensitivity analysis asks what happens when they do.

To test sensitivity is to practice humility. It acknowledges that systems are uncertain, but it refuses to let uncertainty become an excuse for careless action. It turns uncertainty into a disciplined search for robustness, responsibility, and repair.

Back to top ↑

Related Articles

• Scenario Modeling in Systems Thinking
• System Dynamics and Simulation Modeling
• Stocks, Flows, and the Architecture of Change
• Stock-Flow Thinking in Social Systems
• Dynamic Complexity and Policy Resistance
• Delayed Feedback and Policy Timing
• Overshoot, Collapse, and Correction
• Leverage Points and Places to Intervene in a System

Further Reading

• Sterman, John D. Business Dynamics: Systems Thinking and Modeling for a Complex World. Irwin/McGraw-Hill.
• Saltelli, Andrea, Ratto, Marco, Andres, Terry, Campolongo, Francesca, Cariboni, Jessica, Gatelli, Debora, Saisana, Michaela, and Tarantola, Stefano. Global Sensitivity Analysis: The Primer. Wiley.
• Saltelli, Andrea et al. “Why So Many Published Sensitivity Analyses Are False: A Systematic Review of Sensitivity Analysis Practices.” Environmental Modelling & Software.
• Saltelli, Andrea and Funtowicz, Silvio. “When All Models Are Wrong.” Issues in Science and Technology.
• Meadows, Donella H. Thinking in Systems: A Primer. Chelsea Green Publishing.
• Lempert, Robert J., Popper, Steven W., and Bankes, Steven C. Shaping the Next One Hundred Years: New Methods for Quantitative, Long-Term Policy Analysis. RAND Corporation.
• Walker, Warren E., Lempert, Robert J., and Kwakkel, Jan H. “Deep Uncertainty.” In Encyclopedia of Operations Research and Management Science.
• Herman, Jonathan D., Reed, Patrick M., Zeff, Harrison B., and Characklis, Gregory W. “How Should Robustness Be Defined for Water Systems Planning under Change?” Journal of Water Resources Planning and Management.

Back to top ↑

References

• Herman, J.D., Reed, P.M., Zeff, H.B. and Characklis, G.W. (2015) “How Should Robustness Be Defined for Water Systems Planning under Change?” Journal of Water Resources Planning and Management, 141(10).
• 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
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing. Available at: https://www.chelseagreen.com/product/thinking-in-systems/
• 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. and Funtowicz, S. (2014) “When All Models Are Wrong.” Issues in Science and Technology, 30(2), pp. 79–85.
• 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.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Walker, W.E., Lempert, R.J. and Kwakkel, J.H. (2013) “Deep Uncertainty.” In Gass, S.I. and Fu, M.C. (eds.) Encyclopedia of Operations Research and Management Science. Boston: Springer.

Back to top ↑