Communicating Model Uncertainty: How to Explain Risk, Confidence, and Limits

Last Updated June 13, 2026

Communicating model uncertainty means explaining what a mathematical model can say, what it cannot say, how confident its outputs are, and where interpretation depends on assumptions, data quality, parameter estimates, model structure, scenarios, thresholds, or values. Uncertainty communication is not a cosmetic final step; it is part of responsible modeling practice.

A model that hides uncertainty may create false confidence. A model that overwhelms audiences with technical detail may fail to support judgment. Good uncertainty communication sits between those failures. It makes uncertainty visible, interpretable, and relevant to the model’s purpose.

The goal is not to make every reader an expert in probability theory, statistics, numerical analysis, or model validation. The goal is to help users understand what kind of confidence the model supports, what kind it does not support, and what decisions remain conditional on uncertainty.

Uncertainty communication is often where model responsibility becomes visible. A technical model can be sophisticated internally, but if its outputs are communicated as overly certain, decontextualized, or decision-ready beyond the evidence, the model can still mislead.

Why Uncertainty Communication Matters

Uncertainty communication matters because models often move from technical analysis into institutional, public, managerial, scientific, or policy settings. Once outputs leave the modeling environment, users may interpret them as forecasts, warnings, rankings, evidence, mandates, or neutral facts.

If uncertainty is hidden, a model can create false precision. If uncertainty is communicated poorly, users may misunderstand risk. If uncertainty is communicated without decision context, users may not know what to do with it. If uncertainty is communicated as pure doubt, useful evidence may be dismissed.

Communicating uncertainty well does not weaken the model. It aligns the model’s authority with the evidence and assumptions that support it.

Back to top ↑

What Communicating Model Uncertainty Means

Communicating model uncertainty means connecting technical uncertainty to interpretation. It asks what a user needs to understand in order to use the model responsibly.

This includes uncertainty sources, uncertainty magnitude, uncertainty type, uncertainty propagation, sensitivity, robustness, structural limits, validation scope, scenario assumptions, threshold risk, and the decision consequences of being wrong.

The best uncertainty communication is neither evasive nor theatrical. It states what is known, what is uncertain, why it matters, and how users should interpret the model’s claims.

Back to top ↑

Audiences, Purposes, and Decision Context

Different audiences need different uncertainty communication. A technical reviewer may need methods, assumptions, diagnostics, and validation details. A decision-maker may need the stability of a recommendation. A public audience may need plain-language explanation of confidence, risk, and limits.

The same model output should not necessarily be communicated the same way to every audience. But the underlying honesty should remain consistent.

Audience adaptation should not become selective disclosure. The level of detail can change, but uncertainty should not disappear because the audience is nontechnical.

Back to top ↑

Communicating Different Types of Uncertainty

Different uncertainty types require different communication. Data uncertainty is not structural uncertainty. Scenario uncertainty is not a prediction interval. Parameter uncertainty is not the same as decision uncertainty.

When uncertainty types are collapsed into vague language, users may misunderstand the evidence. A “range” may mean statistical interval, scenario envelope, model ensemble spread, expert judgment, or sensitivity result. The label matters.

Good communication names uncertainty precisely. It avoids turning every uncertainty into a generic caveat.

Back to top ↑

Intervals, Ranges, and Probability Statements

Intervals and ranges are common ways to communicate uncertainty, but they are often misunderstood. A confidence interval, prediction interval, credible interval, sensitivity range, scenario envelope, and model ensemble spread do not mean the same thing.

Uncertainty communication should state what the interval represents, how it was generated, and what uncertainty sources it includes or excludes.

Probability statements also need careful framing. “There is a 20 percent chance of crossing the threshold” should be accompanied by the model conditions under which that probability was produced.

Back to top ↑

Scenarios, Futures, and Deep Uncertainty

Scenario communication is especially important because users often mistake scenarios for predictions. A scenario is a structured possibility, not necessarily a forecast. Scenarios help explore how outcomes could change under different assumptions about future conditions.

Under deep uncertainty, analysts may not be able to assign reliable probabilities to futures, model forms, or values. In those cases, communication should emphasize robustness, vulnerability, adaptation, and decision pathways rather than a single expected outcome.

Scenario communication should help users compare futures without pretending that uncertainty has been eliminated.

Back to top ↑

Sensitivity, Robustness, and Fragility Communication

Sensitivity analysis identifies which inputs, parameters, or assumptions most influence model outputs. Robustness testing asks whether conclusions remain stable across plausible changes. Fragility analysis identifies where small changes can reverse interpretation or action.

These results should be communicated as part of the model’s evidence, not buried in an appendix that decision-makers never read.

Communicating robustness and fragility helps prevent users from confusing a single model run with a stable conclusion.

Back to top ↑

Communicating Structural Uncertainty

Structural uncertainty is difficult to communicate because it concerns the model’s form rather than a number inside the model. Users may be comfortable hearing that a parameter is uncertain but less comfortable hearing that the model structure itself may be incomplete.

Yet structural uncertainty is often one of the most important limitations. A model can fit data well and still omit a mechanism, use the wrong equation, aggregate away subgroup differences, or fail under regime change.

Structural uncertainty should be communicated plainly, not buried under technical language. Users need to know when the model’s representation is itself a source of uncertainty.

Back to top ↑

Threshold Risk and Decision Reversal

Many model outputs matter because they relate to thresholds. A forecast may be above or below a safety standard. A risk estimate may trigger intervention. A resource projection may cross a depletion boundary. A public health indicator may activate a response.

When uncertainty surrounds a threshold, communication should focus on the chance or plausibility of crossing the threshold, the distance from the threshold, the consequences of being wrong, and whether additional evidence could change the decision.

Threshold communication connects uncertainty to action. It helps users understand whether uncertainty is merely descriptive or decision-changing.

Back to top ↑

Visual Communication of Uncertainty

Visual communication can make uncertainty more understandable, but it can also mislead. A clear visual should show uncertainty without implying more precision than exists.

Common visual tools include uncertainty bands, fan charts, error bars, probability distributions, scenario envelopes, threshold lines, tornado charts, robustness matrices, and ensemble spreads.

Good uncertainty visuals should be labeled, proportionate, and tied to interpretation. They should not decorate uncertainty; they should clarify it.

Back to top ↑

Plain-Language Framing Without Oversimplification

Plain language does not mean vague language. Good plain-language uncertainty communication uses ordinary words while preserving the structure of the evidence.

Instead of saying “the model is uncertain,” explain what is uncertain, why it matters, and whether it changes the conclusion. Instead of saying “results may vary,” explain which assumptions most affect the result.

Plain language should reduce confusion, not reduce truth.

Back to top ↑

Model Limits, Use Cases, and Use-Limit Statements

A use-limit statement tells users where model outputs are appropriate and where they should not be treated as decisive evidence. This is especially important when model outputs may be copied, summarized, reused, or interpreted by people who did not build the model.

Use limits should be specific. A vague statement such as “use with caution” is less helpful than a statement that identifies validation domain, excluded uncertainties, threshold fragility, or structural limitations.

Use-limit statements are not disclaimers for legal cover. They are part of responsible model interpretation.

Back to top ↑

Mathematical Lens: From Output to Communicated Claim

A model output can be written as a function of data, parameters, assumptions, model form, and scenario conditions:

A communicated model claim should not treat \(Y\) as unconditional. It should communicate the conditions under which the output is meaningful:

A threshold-relevant uncertainty statement may focus on the probability or plausibility of crossing a decision boundary:

A robustness communication can state whether the conclusion remains stable across plausible perturbations:

The mathematical lesson is simple: model outputs are conditional. Responsible communication makes those conditions visible.

Back to top ↑

Example: Communicating a Resource Model Under Uncertainty

Consider a resource model that estimates future stock under extraction. A central estimate says the stock will remain above the minimum threshold after ten years. Without uncertainty communication, this might be summarized as “the system remains safe.”

A better communication would distinguish the central estimate, uncertainty range, threshold risk, sensitivity drivers, structural limitations, and decision relevance.

The improved communication does not reject the model. It makes the model usable without overstating what it proves.

Back to top ↑

Uncertainty Communication for Decision Support

Decision support requires communication that distinguishes evidence, uncertainty, judgment, and action. A model may provide strong evidence that one option is likely better under baseline assumptions, but weak evidence that it remains best under stress, structural uncertainty, or value disagreement.

Good communication helps decision-makers see whether uncertainty calls for action, caution, monitoring, adaptation, more evidence, or a different decision framework.

Decision-support communication should not pretend that the model makes the decision. It should clarify what the model contributes to judgment.

Back to top ↑

Ethical Stakes of Uncertainty Communication

Uncertainty communication has ethical stakes because model outputs can affect public trust, resource distribution, safety decisions, health policy, infrastructure planning, environmental governance, and institutional accountability.

If uncertainty is hidden, affected people may be denied a fair understanding of risk. If uncertainty is exaggerated, evidence may be ignored. If uncertainty is selectively communicated, decision-makers may be steered toward a preferred conclusion without seeing alternatives.

Ethical uncertainty communication is not merely accurate. It is accountable to the people and decisions affected by the model’s use.

Back to top ↑

Python Workflow: Uncertainty Communication Card and Review Queue

The Python workflow below creates an uncertainty communication card, audience-specific summaries, a use-limit statement, and a review queue for model uncertainty communication.

# communicating_model_uncertainty_workflow.py
# Dependency-light workflow for model uncertainty communication.

from __future__ import annotations

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


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


@dataclass(frozen=True)
class CommunicationRecord:
    key: str
    communication_layer: str
    audience: str
    message_goal: str
    plain_language_statement: str
    status: str


@dataclass(frozen=True)
class UncertaintyMessage:
    key: str
    uncertainty_type: str
    technical_statement: str
    plain_language_statement: str
    decision_relevance: str


def communication_records() -> list[CommunicationRecord]:
    return [
        CommunicationRecord(
            key="central_result",
            communication_layer="result",
            audience="decision_maker",
            message_goal="State the baseline model result without overstating certainty.",
            plain_language_statement="The baseline model projects the system above the minimum threshold, but the result is conditional on current assumptions.",
            status="active",
        ),
        CommunicationRecord(
            key="uncertainty_range",
            communication_layer="uncertainty",
            audience="public",
            message_goal="Explain plausible output variation.",
            plain_language_statement="Across plausible model settings, outcomes cover a range rather than a single exact number.",
            status="review",
        ),
        CommunicationRecord(
            key="threshold_risk",
            communication_layer="decision_threshold",
            audience="decision_maker",
            message_goal="Explain whether uncertainty could reverse action.",
            plain_language_statement="Some plausible runs cross the action threshold, so the decision should be treated as fragile.",
            status="review",
        ),
        CommunicationRecord(
            key="structural_limit",
            communication_layer="model_limit",
            audience="technical_reviewer",
            message_goal="State model-form limitations.",
            plain_language_statement="The model does not fully represent behavioral adaptation or regime change.",
            status="review",
        ),
        CommunicationRecord(
            key="use_limit",
            communication_layer="governance",
            audience="future_user",
            message_goal="Prevent use outside the evidence base.",
            plain_language_statement="This model supports risk comparison and monitoring, not automatic action outside the validated domain.",
            status="review",
        ),
    ]


def uncertainty_messages() -> list[UncertaintyMessage]:
    return [
        UncertaintyMessage(
            key="parameter_uncertainty",
            uncertainty_type="parameter",
            technical_statement="Parameter estimates vary across plausible calibration ranges.",
            plain_language_statement="Some model inputs are estimated rather than known exactly.",
            decision_relevance="Better evidence about sensitive parameters could change confidence.",
        ),
        UncertaintyMessage(
            key="scenario_uncertainty",
            uncertainty_type="scenario",
            technical_statement="Outputs differ across named future conditions.",
            plain_language_statement="These scenarios explore different possible futures, not guaranteed forecasts.",
            decision_relevance="The decision should be tested across adverse and baseline futures.",
        ),
        UncertaintyMessage(
            key="structural_uncertainty",
            uncertainty_type="model_form",
            technical_statement="Alternative model forms produce different threshold behavior.",
            plain_language_statement="Another plausible model structure could lead to a different conclusion.",
            decision_relevance="Model disagreement should be preserved in the decision summary.",
        ),
        UncertaintyMessage(
            key="threshold_fragility",
            uncertainty_type="decision_threshold",
            technical_statement="Some plausible model runs cross the action threshold.",
            plain_language_statement="The recommendation could change if conditions move slightly.",
            decision_relevance="Use monitoring, buffer, or adaptive response.",
        ),
    ]


def communication_priority(record: CommunicationRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.communication_layer} {record.audience} {record.message_goal}".lower()
    for term in ["threshold", "decision", "limit", "public", "governance", "uncertainty"]:
        if term in text:
            score += 1.0
    return round(score, 3)


def build_communication_card(
    records: list[CommunicationRecord],
    messages: list[UncertaintyMessage],
) -> dict[str, object]:
    return {
        "article": "Communicating Model Uncertainty",
        "core_principle": "Model outputs are conditional claims; communication should make uncertainty, assumptions, limits, and decision relevance visible.",
        "communication_records": [
            {**asdict(record), "communication_priority": communication_priority(record)}
            for record in records
        ],
        "uncertainty_messages": [asdict(message) for message in messages],
        "use_limit_statement": "This model supports interpretation and decision support only within its stated assumptions, validation domain, uncertainty assessment, and use context.",
        "audience_guidance": {
            "technical_reviewer": "Provide methods, assumptions, diagnostics, validation scope, and reproducibility materials.",
            "decision_maker": "Emphasize threshold risk, robustness, fragility, consequences, and monitoring needs.",
            "public": "Use plain-language ranges, scenario labels, and clear limits without false certainty.",
            "future_user": "State use limits, update triggers, and uncertainty sources that require monitoring.",
        },
        "diagnostic_checks": [
            "uncertainty sources are named",
            "intervals and ranges are labeled",
            "scenarios are not misrepresented as forecasts",
            "threshold risk is communicated",
            "structural uncertainty is not hidden",
            "use limits are stated",
        ],
    }


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:
    records = communication_records()
    messages = uncertainty_messages()

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

    write_csv(TABLES / "communication_review_queue.csv", record_rows)
    write_csv(TABLES / "uncertainty_messages.csv", [asdict(message) for message in messages])
    write_json(JSON_DIR / "uncertainty_communication_card.json", build_communication_card(records, messages))

    print("Model uncertainty communication workflow complete.")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats uncertainty communication as a governed modeling artifact. It creates audience-specific records, plain-language statements, uncertainty messages, use limits, and review priorities.

Back to top ↑

R Workflow: Communication Summary and Audience Review

The R workflow below reviews communication outputs, ranks communication records by priority, and creates a basic audience summary table.

# communicating_model_uncertainty_review.R
# Base R workflow for uncertainty communication review.

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)

queue_path <- file.path(tables_dir, "communication_review_queue.csv")
messages_path <- file.path(tables_dir, "uncertainty_messages.csv")

if (!file.exists(queue_path) || !file.exists(messages_path)) {
  stop("Missing communication outputs. Run the Python workflow first.")
}

queue <- read.csv(queue_path, stringsAsFactors = FALSE)
messages <- read.csv(messages_path, stringsAsFactors = FALSE)

queue$communication_priority <- as.numeric(queue$communication_priority)
queue <- queue[order(-queue$communication_priority), ]

audience_summary <- aggregate(
  communication_priority ~ audience,
  data = queue,
  FUN = mean
)

names(audience_summary)[2] <- "mean_communication_priority"

write.csv(
  queue,
  file.path(tables_dir, "r_communication_review_queue.csv"),
  row.names = FALSE
)

write.csv(
  messages,
  file.path(tables_dir, "r_uncertainty_message_review.csv"),
  row.names = FALSE
)

write.csv(
  audience_summary,
  file.path(tables_dir, "r_audience_summary.csv"),
  row.names = FALSE
)

png(file.path(figures_dir, "r_communication_priority_by_audience.png"), width = 1000, height = 700)

barplot(
  audience_summary$mean_communication_priority,
  names.arg = audience_summary$audience,
  las = 2,
  ylab = "Mean communication priority",
  main = "Uncertainty Communication Priority by Audience"
)

dev.off()

print(queue)
print(messages)
print(audience_summary)

The R layer supports communication review by preserving audience priorities, message clarity, and uncertainty communication records.

Back to top ↑

Haskell Workflow: Typed Communication Records

Haskell is useful here because communication categories should remain distinct. A technical uncertainty statement is not a public explanation. A use-limit statement is not a probability interval. A scenario message is not a prediction.

{-# OPTIONS_GHC -Wall #-}

module Main where

data CommunicationLayer
  = CentralResult
  | UncertaintyRange
  | ScenarioMessage
  | ThresholdRisk
  | StructuralLimit
  | UseLimit
  | Governance
  deriving (Eq, Show)

data Audience
  = TechnicalReviewer
  | DecisionMaker
  | PublicAudience
  | DomainExpert
  | FutureUser
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresPlainLanguage
  | RequiresDecisionContext
  | Revise
  deriving (Eq, Show)

data CommunicationRecord = CommunicationRecord
  { key :: String
  , layer :: CommunicationLayer
  , audience :: Audience
  , messageGoal :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

communicationRegister :: [CommunicationRecord]
communicationRegister =
  [ CommunicationRecord
      "central_result"
      CentralResult
      DecisionMaker
      "State the baseline result without overstating certainty."
      Active
  , CommunicationRecord
      "uncertainty_range"
      UncertaintyRange
      PublicAudience
      "Explain plausible output variation in plain language."
      RequiresPlainLanguage
  , CommunicationRecord
      "scenario_message"
      ScenarioMessage
      PublicAudience
      "Clarify that scenarios are plausible futures, not guaranteed forecasts."
      RequiresPlainLanguage
  , CommunicationRecord
      "threshold_risk"
      ThresholdRisk
      DecisionMaker
      "Explain whether uncertainty could reverse action."
      RequiresDecisionContext
  , CommunicationRecord
      "structural_limit"
      StructuralLimit
      TechnicalReviewer
      "State model-form limitations."
      RequiresReview
  , CommunicationRecord
      "use_limit"
      UseLimit
      FutureUser
      "Prevent use beyond validation domain."
      RequiresReview
  ]

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

main :: IO ()
main = do
  putStrLn "Typed communication records:"
  mapM_ print communicationRegister

  putStrLn "\nCommunication records requiring review:"
  mapM_ print (filter needsReview communicationRegister)

This typed layer supports communication governance by keeping audience, message goal, uncertainty type, decision context, and use limits distinct.

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 uncertainty communication cards, plain-language model statements, audience-specific summaries, use-limit statements, threshold-risk communication, typed Haskell communication records, and responsible decision-support workflows.

Back to top ↑

A Practical Method for Communicating Model Uncertainty

Uncertainty communication should be designed intentionally. It should not be improvised after the model has already been interpreted as certain.

This method turns uncertainty communication into a modeling responsibility rather than a final editorial task.

Back to top ↑

Common Pitfalls

Uncertainty communication can fail when it hides uncertainty, exaggerates uncertainty, or disconnects uncertainty from interpretation and action.

• False precision: communicating exact numbers without uncertainty ranges or assumptions.
• Vague caveats: saying “uncertainty exists” without naming sources or consequences.
• Unlabeled intervals: showing ranges without explaining what they represent.
• Scenario confusion: presenting scenarios as forecasts.
• Hidden structural uncertainty: communicating parameter ranges while ignoring model-form limits.
• Threshold blindness: failing to say whether uncertainty changes action.
• Technical exclusion: presenting uncertainty only in language that specialists understand.
• Overcorrection into doubt: making useful model evidence sound meaningless.
• No use-limit statement: allowing outputs to travel beyond validation and purpose.
• Selective uncertainty: communicating only uncertainty that supports a preferred conclusion.

These pitfalls can be reduced through plain-language summaries, labeled intervals, scenario explanation, robustness communication, structural limitation notes, threshold-risk statements, audience review, and explicit use limits.

Back to top ↑

Conclusion: Communicate Uncertainty as Part of the Evidence

Communicating model uncertainty is not an admission that modeling has failed. It is part of what makes modeling credible. A model that communicates uncertainty clearly is more honest, more useful, and more accountable than a model that hides its limits behind precise-looking outputs.

Good uncertainty communication explains what is known, what is uncertain, what assumptions matter, what conclusions are robust, what conclusions are fragile, what thresholds may be crossed, and where the model should not be used as decisive evidence.

The purpose is not to overwhelm users with caveats. It is to give them the right level of confidence for the right purpose. That means turning uncertainty into interpretation, decision relevance, and responsible judgment.

Model outputs are conditional claims. Communicating model uncertainty makes those conditions visible enough for people, institutions, and decision-makers to act with proportionate confidence.

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
• Robustness, Fragility, and Model Dependence
• Validation and Model Assessment
• Model Interpretation and Decision-Making
• Limits, Failure, and the Ethics of Modeling

Back to top ↑

Further Reading

• Gigerenzer, G. (2002) Calculated Risks: How to Know When Numbers Deceive You. New York: Simon & Schuster.
• Hullman, J. (2020) ‘Why authors do not visualize uncertainty’, IEEE Transactions on Visualization and Computer Graphics, 26(1), pp. 130–139.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux.
• Kay, M., Kola, T., Hullman, J.R. and Munson, S.A. (2016) ‘When-ish is my bus? User-centered visualizations of uncertainty in everyday, mobile predictive systems’, Proceedings of the 2016 CHI Conference on Human Factors in Computing Systems, pp. 5092–5103.
• 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.
• National Research Council (2013) Communicating Science Effectively: A Research Agenda. Washington, DC: National Academies Press.
• 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.
• Spiegelhalter, D. (2017) ‘Risk and uncertainty communication’, Annual Review of Statistics and Its Application, 4, pp. 31–60.
• Tufte, E.R. (2001) The Visual Display of Quantitative Information. 2nd edn. Cheshire, CT: Graphics Press.

Back to top ↑

References

• Gigerenzer, G. (2002) Calculated Risks: How to Know When Numbers Deceive You. New York: Simon & Schuster.
• Hullman, J. (2020) ‘Why authors do not visualize uncertainty’, IEEE Transactions on Visualization and Computer Graphics, 26(1), pp. 130–139.
• Kahneman, D. (2011) Thinking, Fast and Slow. New York: Farrar, Straus and Giroux.
• Kay, M., Kola, T., Hullman, J.R. and Munson, S.A. (2016) ‘When-ish is my bus? User-centered visualizations of uncertainty in everyday, mobile predictive systems’, Proceedings of the 2016 CHI Conference on Human Factors in Computing Systems, pp. 5092–5103.
• 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.
• National Research Council (2013) Communicating Science Effectively: A Research Agenda. Washington, DC: National Academies Press.
• 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.
• Spiegelhalter, D. (2017) ‘Risk and uncertainty communication’, Annual Review of Statistics and Its Application, 4, pp. 31–60.
• Tufte, E.R. (2001) The Visual Display of Quantitative Information. 2nd edn. Cheshire, CT: Graphics Press.

Back to top ↑