Robustness, Fragility, and Model Dependence: How to Test Whether Model Conclusions Hold

Last Updated June 13, 2026

Robustness, fragility, and model dependence describe how strongly a mathematical model’s conclusions rely on assumptions, parameters, data choices, model structure, uncertainty ranges, and decision thresholds. A robust conclusion remains credible across plausible changes. A fragile conclusion changes under modest disturbance. A model-dependent conclusion may be defensible only under one representation, one calibration window, one metric, or one scenario.

These concepts matter because models often produce outputs that look more stable than they are. A forecast, ranking, policy recommendation, risk estimate, or threshold judgment may depend on assumptions that are easy to overlook. Robustness assessment makes those dependencies visible.

Responsible modeling therefore asks: What has to remain true for this conclusion to hold? How much disturbance can the conclusion survive? Which assumptions, structures, or data choices would reverse the result? And should the model support action if the conclusion is fragile?

Robustness is not a claim that a model is perfect. It is evidence that a conclusion is not overly dependent on one narrow modeling choice. Fragility is not always a failure, but it must be acknowledged. Model dependence is not inherently wrong, but it becomes dangerous when hidden.

Why Robustness Matters

Robustness matters because models are often used beyond the conditions under which they were built. A model may be calibrated on one dataset, validated over one period, designed around one set of assumptions, and then used to support broader claims about action, risk, policy, allocation, safety, or the future.

When model-supported conclusions are robust, users can have more confidence that the conclusion does not depend on a single fragile choice. When conclusions are fragile, users need to understand where and why. When conclusions are model-dependent, users need to know that another plausible model could lead elsewhere.

Robustness assessment helps avoid a common modeling failure: treating one clean model run as if it were a stable conclusion.

Back to top ↑

What Robustness Means

Robustness means that a model conclusion remains credible, useful, or decision-relevant under plausible changes. The exact numerical output may vary, but the main conclusion does not collapse, reverse, or become misleading.

A robust conclusion can take several forms. A predicted value may remain within an acceptable range. A ranking may remain stable. A decision may remain preferable. A threshold may not be crossed. An interpretation may remain credible across multiple assumptions or model forms.

Robustness does not require no change. It requires that changes do not undermine the conclusion being drawn from the model.

Back to top ↑

What Fragility Means

Fragility means that a model conclusion changes substantially under modest, plausible disturbance. A fragile conclusion may reverse when a parameter changes slightly, when a different data window is used, when a threshold is adjusted, when uncertainty is propagated, or when a plausible alternative model form is considered.

Fragility is not always bad. Some systems are genuinely fragile. Some decisions sit near real thresholds. Some contexts are deeply uncertain. The problem is not fragility itself, but hiding fragility behind confident model outputs.

A fragile conclusion can still be useful if communicated as fragile. It becomes risky when communicated as settled.

Back to top ↑

What Model Dependence Means

Model dependence means that a conclusion depends on the specific model used to generate it. If another plausible model produces a different conclusion, then the result is not simply a property of the system. It is partly a property of the chosen representation.

Model dependence can arise from model family, equation form, variable selection, parameterization, assumptions, data transformations, aggregation choices, or validation criteria. It can also arise from the choice of output metric or decision rule.

Model dependence is unavoidable in many serious modeling contexts. The responsible move is not to deny it, but to document it and decide whether the conclusion is still fit for purpose.

Back to top ↑

Robustness Is Not the Same as Accuracy

Accuracy describes how closely model outputs match observed or target values. Robustness describes whether conclusions remain stable under plausible changes. A model can be accurate in one validation setting but fragile under changed assumptions. A model can be less precise but more robust for decision-making.

This distinction matters because decision support often requires robustness more than narrow accuracy. A highly accurate model under one scenario may fail when conditions shift. A robust model may support safer action by performing acceptably across many plausible futures.

A model’s usefulness depends on purpose. Precision is valuable, but fragile precision can be misleading.

Back to top ↑

Sources of Model Dependence

Model dependence can enter through many design choices. Some are obvious, such as selecting a model family. Others are easy to overlook, such as choosing a calibration window, excluding outliers, setting a threshold, selecting an error metric, or transforming variables.

Model dependence should be expected, especially in complex systems. The task is to determine whether dependence is acceptable, decision-relevant, and clearly communicated.

Back to top ↑

Threshold Fragility and Decision Reversal

Threshold fragility occurs when a model output is close enough to a decision threshold that small changes can reverse the recommended action. This is one of the most important forms of fragility because it directly affects decisions.

Thresholds appear in safety standards, resource limits, public health triggers, infrastructure capacity, financial risk rules, environmental boundaries, and policy eligibility criteria. A model that appears stable in average error may still be fragile near a threshold.

Threshold fragility is not solved by reporting a single estimate. It requires reporting the distance to the threshold, uncertainty around the estimate, and the conditions under which action would change.

Back to top ↑

Structural Dependence and Competing Model Forms

Structural dependence occurs when a conclusion depends on the model form itself. This is closely related to structural uncertainty and model form error. A conclusion may be robust within one model structure but fragile across plausible structures.

For example, a linear model may suggest gradual change, while a threshold model suggests abrupt risk. A deterministic model may hide tail risk that appears in a stochastic model. An aggregate model may show stability while a disaggregate model shows subgroup harm.

Structural dependence does not always make a model useless. But it means that decision support should not rest on the authority of a single unexamined form.

Back to top ↑

Data Dependence, Calibration Windows, and Transfer

Data dependence occurs when conclusions change depending on the dataset, sample, calibration window, preprocessing choice, or validation context. A model may appear robust when tested only on familiar data but fail when transferred to another period, group, region, or stress condition.

This is especially important when models are used in changing systems. Historical data may not represent future behavior, and one subgroup’s data may not represent another group’s conditions.

Data dependence is not automatically a defect. It may reveal real context differences. But if those differences matter for action, they must be communicated.

Back to top ↑

Scenario Dependence and Future Conditions

Scenario dependence occurs when a conclusion or recommendation depends on a particular future scenario. This is common in policy, sustainability, infrastructure, climate, public health, economics, and long-range planning.

Because future conditions cannot be known with certainty, a responsible model asks whether the conclusion holds across multiple plausible futures or only within one favorable scenario.

Scenario dependence becomes a problem when a recommendation is presented as general but only holds under selected conditions.

Back to top ↑

Robustness Checks and Stress Testing

Robustness checks deliberately disturb the model. They test alternative assumptions, parameter ranges, model forms, data windows, metrics, thresholds, and scenarios. Stress testing examines performance under adverse or extreme but plausible conditions.

The goal is not to make the model immune to all change. The goal is to learn which conclusions are stable, which are fragile, and which are limited to specific modeling conditions.

Robustness checks should be designed before conclusions are finalized. Otherwise, they can become selective tests chosen to confirm what the analyst already wants to say.

Back to top ↑

Ensemble Reasoning and Model Pluralism

Ensemble reasoning uses multiple models, structures, parameterizations, or scenarios to examine whether conclusions hold across plausible representations. Model pluralism recognizes that no single model may fully capture a complex system.

Ensembles can reveal robust agreement, persistent disagreement, or conditions under which models diverge. But ensembles require governance. The included models, weights, assumptions, and summary methods shape what the ensemble communicates.

Ensemble reasoning should not convert model disagreement into a false average. Sometimes the disagreement is the most important result.

Back to top ↑

Mathematical Lens: Robustness and Fragility Across Perturbations

Let a model conclusion \(C\) depend on data \(D\), parameters \(\theta\), assumptions \(A\), model form \(m\), and decision rule \(r\):

A robustness set can define plausible perturbations around modeling choices:

A conclusion is robust if it remains stable across this set:

Fragility can be represented by the smallest disturbance that changes the conclusion:

A robust decision can also be framed by worst-case performance across plausible conditions:

These expressions show why robustness is not a vague reassurance. It is a disciplined question about how conclusions behave when the model is disturbed.

Back to top ↑

Example: Robust and Fragile Resource Decisions

Consider a resource model used to decide whether extraction should continue at the current rate. The model estimates future stock relative to a critical threshold. Different assumptions, model forms, and scenarios may change the decision.

The key result may not be “the stock will be 52 units.” The key result may be “the safety conclusion is fragile under stress and structurally dependent on whether threshold behavior is included.”

Back to top ↑

Robustness for Decision Support

Decision support should distinguish between conclusions that are stable enough to guide action and conclusions that require caution, monitoring, additional evidence, or adaptive planning. Robustness assessment helps make that distinction.

Robust decisions are not always the most efficient under one model. They are often choices that remain acceptable across uncertainty, model disagreement, and future variation.

Back to top ↑

Ethical Stakes of Fragile Model Conclusions

Fragile model conclusions have ethical stakes because model outputs can influence institutional decisions, public communication, resource allocation, safety rules, and policy priorities. If fragility is hidden, users may overtrust the model. If model dependence is suppressed, competing interpretations may disappear from view.

Ethical modeling requires communicating where a conclusion is robust, where it is fragile, and where it depends on modeling choices that could reasonably differ.

The ethical question is not whether a model is uncertain. It is whether uncertainty, fragility, and dependence are made visible enough for responsible judgment.

Back to top ↑

Python Workflow: Robustness Matrix and Fragility Review

The Python workflow below creates a robustness matrix across model forms and scenarios, flags threshold reversals, ranks fragility, and writes a robustness assessment card.

# robustness_fragility_and_model_dependence_workflow.py
# Dependency-light workflow for robustness, fragility, and model dependence.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
import csv
import json
import statistics


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


@dataclass(frozen=True)
class ModelScenario:
    key: str
    model_form: str
    scenario: str
    extraction_multiplier: float
    shock: float
    review_question: str


@dataclass(frozen=True)
class RobustnessRecord:
    key: str
    dependence_layer: str
    modeling_role: str
    review_question: str
    status: str


def scenarios() -> list[ModelScenario]:
    return [
        ModelScenario("linear_baseline", "linear_decline", "baseline", 1.0, 0.00, "Does the baseline conclusion hold?"),
        ModelScenario("linear_stress", "linear_decline", "stress", 1.25, 0.05, "Does linear structure survive stress?"),
        ModelScenario("dynamic_baseline", "logistic_recovery", "baseline", 1.0, 0.00, "Does recovery change the conclusion?"),
        ModelScenario("dynamic_stress", "logistic_recovery", "stress", 1.25, 0.05, "Does recovery remain adequate under stress?"),
        ModelScenario("threshold_baseline", "threshold_shift", "baseline", 1.0, 0.00, "Does threshold behavior change baseline interpretation?"),
        ModelScenario("threshold_stress", "threshold_shift", "stress", 1.25, 0.05, "Does stress produce threshold fragility?"),
    ]


def robustness_register() -> list[RobustnessRecord]:
    return [
        RobustnessRecord(
            key="parameter_dependence",
            dependence_layer="parameter",
            modeling_role="Reviews whether results depend on plausible parameter ranges.",
            review_question="Do parameter changes reverse the conclusion?",
            status="review",
        ),
        RobustnessRecord(
            key="structural_dependence",
            dependence_layer="model_form",
            modeling_role="Compares alternative mathematical structures.",
            review_question="Do plausible model forms disagree?",
            status="review",
        ),
        RobustnessRecord(
            key="scenario_dependence",
            dependence_layer="scenario",
            modeling_role="Reviews whether conclusions depend on future assumptions.",
            review_question="Does the recommendation hold under stress scenarios?",
            status="review",
        ),
        RobustnessRecord(
            key="threshold_fragility",
            dependence_layer="decision_threshold",
            modeling_role="Measures whether small changes reverse action.",
            review_question="How close is the output to decision reversal?",
            status="review",
        ),
        RobustnessRecord(
            key="data_dependence",
            dependence_layer="data",
            modeling_role="Reviews sensitivity to calibration windows and samples.",
            review_question="Does evidence from one context transfer responsibly?",
            status="review",
        ),
    ]


def simulate(form: str, extraction_multiplier: float, shock: float, years: int = 10) -> float:
    stock = 80.0
    carrying_capacity = 120.0
    growth_rate = 0.08
    extraction_rate = 0.12 * extraction_multiplier
    fixed_loss = 5.8 * extraction_multiplier
    critical_threshold = 55.0

    for _ in range(years):
        if form == "linear_decline":
            stock = max(0.0, stock - fixed_loss - shock * stock)
        elif form == "logistic_recovery":
            growth = growth_rate * stock * (1.0 - stock / carrying_capacity)
            extraction = extraction_rate * stock
            stock = max(0.0, stock + growth - extraction - shock * stock)
        elif form == "threshold_shift":
            if stock < critical_threshold:
                stock = max(0.0, stock - 1.6 * extraction_rate * stock - shock * stock)
            else:
                stock = max(0.0, stock - extraction_rate * stock - shock * stock)
        else:
            raise ValueError(f"Unknown model form: {form}")

    return round(stock, 8)


def robustness_rows(items: list[ModelScenario], threshold: float = 45.0) -> list[dict[str, object]]:
    rows = []
    for item in items:
        output = simulate(item.model_form, item.extraction_multiplier, item.shock)
        rows.append({
            **asdict(item),
            "projected_stock": output,
            "below_threshold": output < threshold,
            "distance_to_threshold": round(output - threshold, 8),
            "fragility_class": "fragile" if abs(output - threshold) <= 5 else "stable_margin",
        })
    return rows


def robustness_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    outputs = [float(row["projected_stock"]) for row in rows]
    threshold_flags = [bool(row["below_threshold"]) for row in rows]
    fragile_count = sum(1 for row in rows if row["fragility_class"] == "fragile")

    return {
        "mean_output": round(statistics.mean(outputs), 8),
        "min_output": round(min(outputs), 8),
        "max_output": round(max(outputs), 8),
        "robustness_spread": round(max(outputs) - min(outputs), 8),
        "threshold_disagreement": len(set(threshold_flags)) > 1,
        "fragile_case_count": fragile_count,
        "scenario_count": len(rows),
    }


def robustness_risk_score(record: RobustnessRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.dependence_layer} {record.modeling_role} {record.review_question}".lower()
    for term in ["threshold", "scenario", "model", "parameter", "data", "stress", "reverse"]:
        if term in text:
            score += 1.0
    return round(score, 3)


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 supplied for {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 write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        json.dump(payload, handle, indent=2, sort_keys=True)


def main() -> None:
    items = scenarios()
    records = robustness_register()
    rows = robustness_rows(items)
    summary = robustness_summary(rows)

    register_rows = [
        {**asdict(record), "robustness_risk_score": robustness_risk_score(record)}
        for record in records
    ]

    write_csv(TABLES / "robustness_matrix.csv", rows)
    write_csv(TABLES / "robustness_register.csv", register_rows)

    write_json(JSON_DIR / "robustness_fragility_assessment_card.json", {
        "article": "Robustness, Fragility, and Model Dependence",
        "robustness_summary": summary,
        "robustness_matrix": rows,
        "robustness_register": register_rows,
        "use_limit": "Robustness conclusions depend on the perturbations, model forms, thresholds, and scenarios included in the review.",
        "diagnostic_checks": [
            "model forms are varied",
            "stress scenarios are included",
            "threshold disagreement is flagged",
            "fragility classes are reported",
            "model dependence is not hidden",
            "decision interpretation accounts for robustness evidence",
        ],
    })

    print("Robustness and fragility workflow complete.")
    print(f"Summary: {summary}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow makes robustness review reproducible. It records scenario-model combinations, threshold disagreement, fragile cases, dependence layers, and a decision-oriented assessment card.

Back to top ↑

R Workflow: Robustness Summary and Fragility Ranking

The R workflow below reviews generated robustness outputs, ranks fragile cases, summarizes threshold disagreement, and creates a base R comparison plot.

# robustness_fragility_and_model_dependence_review.R
# Base R workflow for robustness summary and fragility ranking.

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

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)

matrix_path <- file.path(tables_dir, "robustness_matrix.csv")
register_path <- file.path(tables_dir, "robustness_register.csv")

if (!file.exists(matrix_path) || !file.exists(register_path)) {
  stop("Missing robustness outputs. Run the Python workflow first.")
}

matrix_data <- read.csv(matrix_path, stringsAsFactors = FALSE)
register <- read.csv(register_path, stringsAsFactors = FALSE)

matrix_data$projected_stock <- as.numeric(matrix_data$projected_stock)
matrix_data$distance_to_threshold <- as.numeric(matrix_data$distance_to_threshold)
matrix_data$absolute_threshold_distance <- abs(matrix_data$distance_to_threshold)

matrix_data <- matrix_data[order(matrix_data$absolute_threshold_distance), ]

summary_table <- data.frame(
  mean_output = mean(matrix_data$projected_stock),
  min_output = min(matrix_data$projected_stock),
  max_output = max(matrix_data$projected_stock),
  robustness_spread = max(matrix_data$projected_stock) - min(matrix_data$projected_stock),
  threshold_disagreement = length(unique(matrix_data$below_threshold)) > 1,
  fragile_case_count = sum(matrix_data$fragility_class == "fragile"),
  scenario_count = nrow(matrix_data)
)

register$priority <- ifelse(
  register$robustness_risk_score >= 8,
  "high",
  ifelse(register$robustness_risk_score >= 6, "medium", "low")
)

write.csv(
  matrix_data,
  file.path(tables_dir, "r_fragility_ranking.csv"),
  row.names = FALSE
)

write.csv(
  summary_table,
  file.path(tables_dir, "r_robustness_summary.csv"),
  row.names = FALSE
)

write.csv(
  register,
  file.path(tables_dir, "r_robustness_review_queue.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "r_robustness_matrix_plot.png"), width = 1100, height = 750)

barplot(
  matrix_data$projected_stock,
  names.arg = matrix_data$key,
  las = 2,
  ylab = "Projected stock",
  main = "Robustness Matrix: Output by Model and Scenario"
)
abline(h = 45, lty = 2)

dev.off()

print(summary_table)
print(matrix_data)
print(register)

The R layer supports review by preserving fragility rankings, threshold proximity, robustness spread, and review priorities.

Back to top ↑

Haskell Workflow: Typed Robustness Records

Haskell is useful here because robustness categories should remain distinct. Parameter dependence is not structural dependence. Scenario dependence is not data dependence. Threshold fragility is not ordinary output variation.

{-# OPTIONS_GHC -Wall #-}

module Main where

data DependenceLayer
  = ParameterDependence
  | StructuralDependence
  | ScenarioDependence
  | ThresholdFragility
  | DataDependence
  | MetricDependence
  | Governance
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresStressTest
  | RequiresComparison
  | Revise
  deriving (Eq, Show)

data RobustnessRecord = RobustnessRecord
  { key :: String
  , layer :: DependenceLayer
  , modelingRole :: String
  , reviewFocus :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

robustnessRegister :: [RobustnessRecord]
robustnessRegister =
  [ RobustnessRecord
      "parameter_dependence"
      ParameterDependence
      "Reviews whether conclusions depend on parameter ranges."
      "Do parameter changes reverse the conclusion?"
      RequiresReview
  , RobustnessRecord
      "structural_dependence"
      StructuralDependence
      "Compares alternative mathematical structures."
      "Do plausible model forms disagree?"
      RequiresComparison
  , RobustnessRecord
      "scenario_dependence"
      ScenarioDependence
      "Reviews whether conclusions depend on future assumptions."
      "Does the recommendation hold under stress?"
      RequiresStressTest
  , RobustnessRecord
      "threshold_fragility"
      ThresholdFragility
      "Measures whether small changes reverse action."
      "How close is the output to decision reversal?"
      RequiresReview
  , RobustnessRecord
      "data_dependence"
      DataDependence
      "Reviews sensitivity to calibration windows and samples."
      "Does evidence transfer responsibly?"
      RequiresReview
  ]

needsReview :: RobustnessRecord -> Bool
needsReview item =
  case status item of
    Active -> False
    _ -> True

main :: IO ()
main = do
  putStrLn "Typed robustness records:"
  mapM_ print robustnessRegister

  putStrLn "\nRobustness records requiring review:"
  mapM_ print (filter needsReview robustnessRegister)

This typed layer supports robustness governance by keeping dependence layers, stress tests, threshold fragility, model comparison, and review obligations conceptually separate.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It contains article-specific code, data, documentation, notebooks, schemas, and generated outputs for robustness matrices, fragility rankings, threshold disagreement, model-dependence registers, scenario stress tests, typed Haskell robustness records, and responsible decision-support workflows.

Back to top ↑

A Practical Method for Robustness and Fragility Assessment

Robustness and fragility assessment should disturb the model systematically. The goal is not to prove that one preferred conclusion is safe. The goal is to learn where the conclusion holds, where it weakens, and where it reverses.

This method turns robustness from a vague reassurance into a reviewable practice. It reveals the conditions under which a model-supported conclusion deserves confidence.

Back to top ↑

Common Pitfalls

Robustness assessment can fail when it is selective, narrow, or used as a rhetorical shield rather than an honest test of dependency.

• Testing only easy assumptions: avoiding the assumptions most likely to change the conclusion.
• Using narrow perturbation ranges: making a fragile conclusion appear stable.
• Ignoring model form: checking parameters while assuming the structure is unquestionable.
• Ignoring thresholds: reporting average output stability while action can reverse.
• Suppressing adverse scenarios: showing robustness only under favorable futures.
• Averaging away disagreement: using ensemble averages that hide divergent model behavior.
• Confusing accuracy with robustness: treating validation fit as proof of stability.
• No dependency register: leaving users unaware of what the result depends on.
• No use-limit statement: allowing fragile conclusions to travel beyond evidence.
• Overclaiming after one check: calling a conclusion robust without testing key dependencies.

These pitfalls can be reduced through documented perturbations, robustness matrices, threshold fragility review, model-form comparison, stress testing, ensemble transparency, and clear communication of dependency and limits.

Back to top ↑

Conclusion: Strong Models Reveal Their Dependencies

Robustness, fragility, and model dependence are central to responsible mathematical modeling because they show how conclusions behave under disturbance. A model-supported claim is stronger when it survives plausible changes. It is weaker, or at least more limited, when it depends on one narrow assumption, dataset, structure, scenario, or threshold.

Fragility does not mean a model is useless. It means the model’s conclusion should be communicated with care. Model dependence does not mean a model is wrong. It means the conclusion is partly shaped by representation and should not be mistaken for an unconditioned fact about the world.

Robustness assessment helps analysts avoid false confidence, reveal hidden dependency, preserve competing interpretations, and support decisions that remain accountable under uncertainty. It is not an optional final check. It is part of what makes modeling honest.

Strong models do not pretend to be independent of assumptions. They show their dependencies clearly enough for users to reason responsibly.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Assumptions, Simplification, and Model Design
• Model Boundaries, Scale, and Scope
• Sensitivity Analysis and Robustness
• Uncertainty in Mathematical Models
• Structural Uncertainty and Model Form Error
• Model Comparison and Selection
• Diagnostics, Residuals, and Model Error
• Communicating Model Uncertainty
• Model Interpretation and Decision-Making

Back to top ↑

Further Reading

• Bankes, S. (1993) ‘Exploratory modeling for policy analysis’, Operations Research, 41(3), pp. 435–449.
• Ben-Haim, Y. (2006) Info-Gap Decision Theory: Decisions Under Severe Uncertainty. 2nd edn. London: Academic Press.
• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Chatfield, C. (1995) ‘Model uncertainty, data mining and statistical inference’, Journal of the Royal Statistical Society: Series A, 158(3), pp. 419–466.
• Draper, D. (1995) ‘Assessment and propagation of model uncertainty’, Journal of the Royal Statistical Society: Series B, 57(1), pp. 45–97.
• 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.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Walker, W.E. et al. (2013) ‘Deep uncertainty’, Encyclopedia of Operations Research and Management Science. New York: Springer.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press.

Back to top ↑

References

• Bankes, S. (1993) ‘Exploratory modeling for policy analysis’, Operations Research, 41(3), pp. 435–449.
• Ben-Haim, Y. (2006) Info-Gap Decision Theory: Decisions Under Severe Uncertainty. 2nd edn. London: Academic Press.
• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Chatfield, C. (1995) ‘Model uncertainty, data mining and statistical inference’, Journal of the Royal Statistical Society: Series A, 158(3), pp. 419–466.
• Draper, D. (1995) ‘Assessment and propagation of model uncertainty’, Journal of the Royal Statistical Society: Series B, 57(1), pp. 45–97.
• 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.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Walker, W.E. et al. (2013) ‘Deep uncertainty’, Encyclopedia of Operations Research and Management Science. New York: Springer.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press.

Back to top ↑