Model Interpretation and Decision-Making: How Mathematical Models Support

Last Updated June 13, 2026

Model interpretation and decision-making connect mathematical model outputs to judgment, action, policy, design, planning, and institutional responsibility. A model does not make a decision by itself; people interpret its outputs within a purpose, evidence base, uncertainty range, value context, and consequence structure.

This distinction matters because model outputs can appear more decisive than they are. A forecast, score, probability, ranking, optimization result, or threshold estimate may seem to point directly to action. But the path from model result to decision always includes interpretation.

Responsible model interpretation asks what the result means, what it depends on, how uncertain it is, whether it is valid for the decision context, who may be affected, and what kind of judgment remains outside the model.

Model interpretation is not a passive reading of numbers. It is an active process of translating outputs into meaning. Decision-making is not an automatic consequence of the model. It is a responsibility that combines evidence, uncertainty, values, tradeoffs, and consequences.

Why Model Interpretation Matters

Model interpretation matters because models rarely speak for themselves. A model output may be a number, probability, simulation trajectory, rank ordering, optimized solution, risk estimate, confidence interval, uncertainty band, or scenario comparison. None of these automatically tells users what should be done.

Interpretation connects the model result to the real question. It asks whether the result is credible, relevant, uncertain, decision-changing, sensitive to assumptions, and appropriate for the intended use.

The same output can support different interpretations depending on purpose. A model result that is good enough for screening may be insufficient for high-stakes allocation. A result useful for exploration may not be appropriate for automatic decision rules.

Back to top ↑

What Model Interpretation Means

Model interpretation means explaining what model outputs imply within the model’s purpose, assumptions, evidence, uncertainty, and limits. It is not simply reading a value from a chart. It is translating a formal result into a meaningful claim.

Good interpretation answers several questions: what does the model say, why does it say it, how reliable is the result, what does it depend on, what does it exclude, and what kind of decision support is justified?

Interpretation is responsible when it preserves the conditions under which the model output was produced.

Back to top ↑

Model Outputs Are Not Decisions

A model output is evidence. A decision is a commitment to action. Between them stand interpretation, uncertainty, values, consequences, feasibility, law, ethics, institutional authority, and human judgment.

This difference is especially important when model outputs are used in automated systems, policy dashboards, risk scoring, resource allocation, or optimization workflows. If the model output is treated as the decision, accountability can become unclear.

A model can inform the decision without owning it. Responsible decision-making keeps that boundary clear.

Back to top ↑

Purpose, Context, and Fitness for Use

A model must be interpreted relative to its purpose. The same model may be useful for exploration, unsuitable for prediction, acceptable for screening, insufficient for high-stakes decisions, or appropriate only within a narrow validation domain.

Fitness for use asks whether the model’s structure, data, assumptions, uncertainty assessment, validation evidence, and communication are adequate for the decision context.

Model interpretation should always ask: useful for what, under what assumptions, for whom, and with what consequences?

Back to top ↑

Evidence, Uncertainty, and Judgment

Model-based decision-making combines evidence and judgment. Evidence comes from data, model structure, validation, diagnostics, uncertainty analysis, and domain knowledge. Judgment enters through purpose, values, thresholds, tradeoffs, risk tolerance, institutional authority, and consequences.

Problems arise when judgment is hidden inside the model or when model evidence is dismissed as merely subjective. Responsible interpretation separates empirical evidence from value judgment while showing how they interact.

A model can clarify judgment, but it does not eliminate it.

Back to top ↑

Thresholds, Triggers, and Action Rules

Many model-supported decisions depend on thresholds. A probability may trigger review. A forecast may cross a safety line. A stock level may activate conservation. A risk score may determine eligibility. A capacity estimate may trigger infrastructure response.

Thresholds are not purely technical. They often include values, consequences, legal standards, institutional policy, or risk tolerance. A model may estimate distance to a threshold, but it does not by itself determine whether the threshold is appropriate.

Threshold interpretation should make action rules explicit. Otherwise, technical outputs can silently become policy decisions.

Back to top ↑

Tradeoffs, Values, and Objectives

Decision-making requires tradeoffs. Models can help quantify tradeoffs, but they cannot make all tradeoffs legitimate. An optimization model may minimize cost, but that does not mean cost is the only relevant value. A risk model may prioritize safety, but that does not settle questions of equity, feasibility, rights, or public trust.

Interpretation should therefore expose the objective function, constraints, weights, and excluded values behind model-supported recommendations.

Good model interpretation does not hide value judgments behind formulas. It makes tradeoffs available for review.

Back to top ↑

Scenarios, Options, and Decision Pathways

Models often support decisions by comparing scenarios and options. A scenario represents a possible future condition. An option represents a possible action. A decision pathway describes how action may adapt as evidence changes over time.

This is especially important under uncertainty. The best decision may not be the option that performs best under one baseline forecast. It may be the option that remains acceptable across multiple plausible futures.

Scenario interpretation should avoid treating one future as inevitable. Decision pathways make uncertainty operational by linking future observations to revised action.

Back to top ↑

Risk, Consequences, and Asymmetric Error

Decision-making depends not only on what is likely, but on what happens if the model is wrong. Errors are often asymmetric. Underestimating flood risk may be worse than overestimating it. Over-allocating resources may be less harmful than failing to protect a vulnerable population. False positives and false negatives may carry different consequences.

Model interpretation should therefore connect uncertainty to consequences. A decision cannot be evaluated responsibly by accuracy alone.

When consequences are asymmetric, decision thresholds should reflect more than predictive performance. They should reflect the cost and distribution of being wrong.

Back to top ↑

Robustness, Fragility, and Decision Stability

Model interpretation for decision-making should ask whether the decision is robust or fragile. A decision is robust when it remains defensible across plausible uncertainty, scenarios, model forms, or parameter ranges. A decision is fragile when modest changes reverse the recommendation.

Fragile decisions may still be necessary, but they require stronger communication, monitoring, and accountability.

Decision stability is often more important than a single best estimate. A model that reveals fragility supports better judgment than a model that hides it.

Back to top ↑

Stakeholders, Governance, and Accountability

Models used for decisions affect people, institutions, resources, environments, and future conditions. Interpretation should therefore include stakeholder context and governance. Who is affected? Who benefits? Who bears risk? Who can challenge the result? Who is responsible for monitoring and updating?

Governance matters because model-supported decisions can diffuse responsibility. Analysts may say the model produced the result. Decision-makers may say they followed the model. Institutions may treat outputs as neutral. Responsible governance keeps accountability visible.

Model interpretation is accountable when it documents not only what the model says, but how its evidence is authorized for use.

Back to top ↑

Communicating Model Interpretation

Model interpretation must be communicated clearly. Technical users may need assumptions, diagnostics, equations, validation evidence, and reproducible workflows. Decision-makers may need risk, thresholds, options, consequences, and use limits. Public audiences may need plain-language explanations of what is known, what is uncertain, and what decisions remain human responsibilities.

Good communication preserves the conditional nature of model evidence without making the result unusable.

Back to top ↑

Mathematical Lens: From Model Output to Decision Rule

A model output can be written as:

A decision rule maps model output and context into action:

A threshold-based decision may be written as:

A decision with expected utility can be represented as:

A robust decision rule asks how decisions perform across plausible conditions:

The mathematical lesson is that model outputs become decisions only through a rule, and that rule contains assumptions, values, thresholds, and consequences.

Back to top ↑

Example: Resource Allocation Under Model Uncertainty

Consider a model that estimates whether a regional resource stock will remain above a critical threshold after ten years. The model produces a central projection of 52 units, with plausible uncertainty from 38 to 66 units. The threshold is 45 units.

A weak interpretation would say, “The model predicts 52, so the resource is safe.” A responsible interpretation would examine uncertainty, thresholds, consequences, options, and monitoring.

The model does not dictate the policy. It clarifies that a no-risk conclusion would be irresponsible. The decision may involve staged action, monitoring triggers, stakeholder consultation, and updated evidence.

Back to top ↑

Responsible Decision Support

Responsible decision support uses models to improve judgment without pretending that models replace judgment. It clarifies options, uncertainty, thresholds, tradeoffs, risks, and consequences. It makes model assumptions visible enough for review.

A model supports decision-making best when it improves the quality of questions, not merely the precision of answers.

Back to top ↑

Ethical Stakes of Model-Based Decisions

Model-based decisions have ethical stakes because they can affect access, safety, exposure, opportunity, resources, rights, and public trust. Interpretation therefore cannot be separated from consequences.

Ethical interpretation requires asking whether uncertainty has been communicated, whether affected groups are visible, whether tradeoffs are explicit, whether use limits are stated, and whether decisions remain accountable to human and institutional review.

Ethical model interpretation does not stop at technical correctness. It asks whether the model is being used responsibly within a decision system.

Back to top ↑

Python Workflow: Interpretation Register and Decision Review

The Python workflow below creates an interpretation register, evaluates decision options under uncertainty, flags threshold fragility, and writes a decision-support review card.

# model_interpretation_and_decision_making_workflow.py
# Dependency-light workflow for model interpretation and decision review.

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 InterpretationRecord:
    key: str
    interpretation_layer: str
    model_role: str
    decision_question: str
    status: str


@dataclass(frozen=True)
class DecisionOption:
    key: str
    option_name: str
    expected_stock: float
    lower_bound: float
    upper_bound: float
    implementation_burden: float
    consequence_if_wrong: float
    description: str


def interpretation_register() -> list[InterpretationRecord]:
    return [
        InterpretationRecord(
            key="output_meaning",
            interpretation_layer="result",
            model_role="Explains what the output represents.",
            decision_question="What claim is being made from the model output?",
            status="active",
        ),
        InterpretationRecord(
            key="uncertainty_meaning",
            interpretation_layer="uncertainty",
            model_role="Connects uncertainty range to interpretation.",
            decision_question="Could uncertainty change the decision?",
            status="review",
        ),
        InterpretationRecord(
            key="threshold_review",
            interpretation_layer="decision_threshold",
            model_role="Reviews proximity to action boundary.",
            decision_question="Does the result cross or approach the threshold?",
            status="review",
        ),
        InterpretationRecord(
            key="value_tradeoff",
            interpretation_layer="values",
            model_role="Documents tradeoffs and objectives.",
            decision_question="Which values are represented or excluded?",
            status="review",
        ),
        InterpretationRecord(
            key="governance_review",
            interpretation_layer="governance",
            model_role="Documents decision ownership and use limits.",
            decision_question="Who owns the decision and monitoring plan?",
            status="review",
        ),
    ]


def decision_options() -> list[DecisionOption]:
    return [
        DecisionOption(
            key="no_action",
            option_name="No immediate action",
            expected_stock=52.0,
            lower_bound=38.0,
            upper_bound=66.0,
            implementation_burden=1.0,
            consequence_if_wrong=9.0,
            description="Continue current behavior and monitor informally.",
        ),
        DecisionOption(
            key="monitoring",
            option_name="Formal monitoring",
            expected_stock=54.0,
            lower_bound=42.0,
            upper_bound=68.0,
            implementation_burden=3.0,
            consequence_if_wrong=6.0,
            description="Increase measurement and update model if trigger values appear.",
        ),
        DecisionOption(
            key="moderate_intervention",
            option_name="Moderate intervention",
            expected_stock=60.0,
            lower_bound=50.0,
            upper_bound=72.0,
            implementation_burden=5.0,
            consequence_if_wrong=4.0,
            description="Reduce extraction moderately while preserving adaptive monitoring.",
        ),
        DecisionOption(
            key="strong_intervention",
            option_name="Strong intervention",
            expected_stock=68.0,
            lower_bound=58.0,
            upper_bound=78.0,
            implementation_burden=8.0,
            consequence_if_wrong=2.0,
            description="Reduce extraction aggressively to maximize safety margin.",
        ),
    ]


def evaluate_option(option: DecisionOption, threshold: float = 45.0) -> dict[str, object]:
    crosses_threshold = option.lower_bound < threshold
    threshold_margin = option.expected_stock - threshold
    robustness_class = "robust" if option.lower_bound >= threshold else "fragile"
    decision_score = (
        option.expected_stock
        - 0.8 * option.implementation_burden
        - 1.2 * option.consequence_if_wrong
        - (8.0 if crosses_threshold else 0.0)
    )

    return {
        **asdict(option),
        "threshold": threshold,
        "threshold_margin": round(threshold_margin, 3),
        "crosses_threshold_under_uncertainty": crosses_threshold,
        "robustness_class": robustness_class,
        "decision_score": round(decision_score, 3),
    }


def interpretation_priority(record: InterpretationRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.interpretation_layer} {record.model_role} {record.decision_question}".lower()
    for term in ["threshold", "decision", "uncertainty", "values", "governance", "owner"]:
        if term in text:
            score += 1.0
    return round(score, 3)


def decision_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    scores = [float(row["decision_score"]) for row in rows]
    fragile_count = sum(1 for row in rows if row["robustness_class"] == "fragile")
    best = max(rows, key=lambda row: float(row["decision_score"]))

    return {
        "best_scored_option": best["option_name"],
        "mean_score": round(statistics.mean(scores), 3),
        "max_score": round(max(scores), 3),
        "min_score": round(min(scores), 3),
        "fragile_option_count": fragile_count,
        "option_count": len(rows),
    }


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 = interpretation_register()
    options = decision_options()

    register_rows = [
        {**asdict(record), "interpretation_priority": interpretation_priority(record)}
        for record in records
    ]
    option_rows = [evaluate_option(option) for option in options]
    summary = decision_summary(option_rows)

    write_csv(TABLES / "interpretation_register.csv", register_rows)
    write_csv(TABLES / "decision_option_review.csv", option_rows)

    write_json(JSON_DIR / "decision_support_review_card.json", {
        "article": "Model Interpretation and Decision-Making",
        "decision_summary": summary,
        "interpretation_register": register_rows,
        "decision_options": option_rows,
        "use_limit": "This workflow supports interpretation and decision review; it does not automate the final decision.",
        "diagnostic_checks": [
            "model output is separated from decision",
            "threshold risk is reviewed",
            "uncertainty is connected to action",
            "tradeoffs are documented",
            "decision ownership remains human or institutional",
            "monitoring and update triggers are required",
        ],
    })

    print("Model interpretation and decision workflow complete.")
    print(f"Decision summary: {summary}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats interpretation as a reviewable bridge between model output and decision. It documents output meaning, uncertainty, thresholds, values, governance, decision options, fragility, and use limits.

Back to top ↑

R Workflow: Decision Summary and Threshold Review

The R workflow below reviews generated decision outputs, ranks options by decision score, summarizes fragile options, and creates a base R option-comparison plot.

# model_interpretation_and_decision_making_review.R
# Base R workflow for decision summary and threshold 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)

options_path <- file.path(tables_dir, "decision_option_review.csv")
register_path <- file.path(tables_dir, "interpretation_register.csv")

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

options <- read.csv(options_path, stringsAsFactors = FALSE)
register <- read.csv(register_path, stringsAsFactors = FALSE)

options$decision_score <- as.numeric(options$decision_score)
options$threshold_margin <- as.numeric(options$threshold_margin)
options$implementation_burden <- as.numeric(options$implementation_burden)
options$consequence_if_wrong <- as.numeric(options$consequence_if_wrong)

options <- options[order(-options$decision_score), ]

summary_table <- data.frame(
  best_scored_option = options$option_name[1],
  max_score = max(options$decision_score),
  min_score = min(options$decision_score),
  fragile_option_count = sum(options$robustness_class == "fragile"),
  option_count = nrow(options)
)

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

write.csv(
  options,
  file.path(tables_dir, "r_decision_option_ranking.csv"),
  row.names = FALSE
)

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

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

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

barplot(
  options$decision_score,
  names.arg = options$key,
  las = 2,
  ylab = "Decision score",
  main = "Decision Option Scores Under Model Interpretation Review"
)

dev.off()

print(summary_table)
print(options)
print(register)

The R layer supports decision review by preserving option rankings, threshold margins, fragility classes, and interpretation priorities.

Back to top ↑

Haskell Workflow: Typed Interpretation Records

Haskell is useful here because interpretation layers should remain distinct. A model output is not a decision. A threshold is not a value judgment by itself. A use-limit statement is not an uncertainty interval.

{-# OPTIONS_GHC -Wall #-}

module Main where

data InterpretationLayer
  = OutputMeaning
  | UncertaintyMeaning
  | ThresholdReview
  | ValueTradeoff
  | GovernanceReview
  | Communication
  deriving (Eq, Show)

data DecisionRole
  = Evidence
  | ReviewRequired
  | HumanJudgmentRequired
  | GovernanceRequired
  deriving (Eq, Show)

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

data InterpretationRecord = InterpretationRecord
  { key :: String
  , layer :: InterpretationLayer
  , decisionRole :: DecisionRole
  , reviewFocus :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

interpretationRegister :: [InterpretationRecord]
interpretationRegister =
  [ InterpretationRecord
      "output_meaning"
      OutputMeaning
      Evidence
      "What claim is being made from the model output?"
      Active
  , InterpretationRecord
      "uncertainty_meaning"
      UncertaintyMeaning
      ReviewRequired
      "Could uncertainty change the decision?"
      RequiresReview
  , InterpretationRecord
      "threshold_review"
      ThresholdReview
      ReviewRequired
      "Does the result cross or approach the threshold?"
      RequiresDecisionContext
  , InterpretationRecord
      "value_tradeoff"
      ValueTradeoff
      HumanJudgmentRequired
      "Which values are represented or excluded?"
      RequiresDecisionContext
  , InterpretationRecord
      "governance_review"
      GovernanceReview
      GovernanceRequired
      "Who owns the decision and monitoring plan?"
      RequiresGovernance
  ]

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

main :: IO ()
main = do
  putStrLn "Typed interpretation records:"
  mapM_ print interpretationRegister

  putStrLn "\nInterpretation records requiring review:"
  mapM_ print (filter needsReview interpretationRegister)

This typed layer supports decision governance by keeping output meaning, uncertainty, thresholds, values, communication, and governance 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 interpretation registers, decision-option review, threshold analysis, uncertainty-to-action summaries, typed Haskell interpretation records, decision-support cards, and responsible governance workflows.

Back to top ↑

A Practical Method for Model Interpretation and Decision-Making

Model interpretation should be structured enough to audit. The goal is to keep output, uncertainty, values, thresholds, and decision authority visible.

This method keeps model interpretation from collapsing into either blind model-following or vague judgment. It makes the bridge between model and decision explicit.

Back to top ↑

Common Pitfalls

Model interpretation can fail when outputs are treated as self-explanatory, when values are hidden, or when decisions are presented as if the model made them automatically.

• Output realism: treating a model output as direct reality rather than a conditional result.
• Decision laundering: using the model to avoid owning a value-laden decision.
• Hidden thresholds: allowing action rules to remain implicit.
• Ignoring uncertainty: interpreting only the central estimate.
• Confusing accuracy with decision adequacy: assuming predictive performance settles action.
• Ignoring asymmetric error: treating false positives and false negatives as equally costly.
• Over-optimizing one metric: selecting the best score while ignoring consequences or robustness.
• Suppressing model disagreement: hiding alternative structures or scenarios.
• No use-limit statement: letting model outputs travel beyond validation and purpose.
• No accountability pathway: failing to identify who reviews, approves, monitors, and revises model-supported decisions.

These pitfalls can be reduced through interpretation registers, threshold review, uncertainty communication, option comparison, tradeoff documentation, stakeholder review, and explicit governance.

Back to top ↑

Conclusion: Models Support Decisions; They Do Not Replace Judgment

Model interpretation and decision-making are connected, but they are not the same. A model can clarify evidence, estimate consequences, compare scenarios, expose uncertainty, and support better judgment. It cannot by itself determine values, assign responsibility, settle contested tradeoffs, or own the consequences of action.

Responsible interpretation keeps the model’s conditional nature visible. It explains what the output means, what it depends on, how uncertain it is, whether it is robust, and how it relates to thresholds, options, values, and consequences.

Decision-making then combines model evidence with human and institutional judgment. That judgment should be explicit, reviewable, and accountable.

The strongest model-supported decisions are not those that pretend to remove judgment. They are those that improve judgment by making evidence, uncertainty, tradeoffs, and responsibility clearer.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Model Purpose: Explanation, Prediction, Control, and Decision Support
• Validation and Model Assessment
• Sensitivity Analysis and Robustness
• Uncertainty in Mathematical Models
• Structural Uncertainty and Model Form Error
• Robustness, Fragility, and Model Dependence
• Communicating Model Uncertainty
• Mathematical Modeling in Policy and Public Systems
• Limits, Failure, and the Ethics of Modeling

Back to top ↑

Further Reading

• Clemen, R.T. and Reilly, T. (2013) Making Hard Decisions with DecisionTools. 3rd edn. Mason, OH: Cengage Learning.
• Edwards, W., Miles, R.F. and von Winterfeldt, D. (eds.) (2007) Advances in Decision Analysis: From Foundations to Applications. Cambridge: Cambridge University Press.
• Hammond, J.S., Keeney, R.L. and Raiffa, H. (1999) Smart Choices: A Practical Guide to Making Better Decisions. Boston: Harvard Business School Press.
• Keeney, R.L. (1992) Value-Focused Thinking: A Path to Creative Decisionmaking. Cambridge, MA: Harvard University Press.
• Keeney, R.L. and Raiffa, H. (1993) Decisions with Multiple Objectives: Preferences and Value Tradeoffs. Cambridge: Cambridge University Press.
• 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.
• Morgan, M.G. and Henrion, M. (1990) Uncertainty: A Guide to Dealing with Uncertainty in Quantitative Risk and Policy Analysis. Cambridge: Cambridge University Press.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• Phillips, L.D. (1984) ‘A theory of requisite decision models’, Acta Psychologica, 56(1–3), pp. 29–48.
• Raiffa, H. (1968) Decision Analysis: Introductory Lectures on Choices Under Uncertainty. Reading, MA: Addison-Wesley.

Back to top ↑

References

• Clemen, R.T. and Reilly, T. (2013) Making Hard Decisions with DecisionTools. 3rd edn. Mason, OH: Cengage Learning.
• Edwards, W., Miles, R.F. and von Winterfeldt, D. (eds.) (2007) Advances in Decision Analysis: From Foundations to Applications. Cambridge: Cambridge University Press.
• Hammond, J.S., Keeney, R.L. and Raiffa, H. (1999) Smart Choices: A Practical Guide to Making Better Decisions. Boston: Harvard Business School Press.
• Keeney, R.L. (1992) Value-Focused Thinking: A Path to Creative Decisionmaking. Cambridge, MA: Harvard University Press.
• Keeney, R.L. and Raiffa, H. (1993) Decisions with Multiple Objectives: Preferences and Value Tradeoffs. Cambridge: Cambridge University Press.
• 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.
• Morgan, M.G. and Henrion, M. (1990) Uncertainty: A Guide to Dealing with Uncertainty in Quantitative Risk and Policy Analysis. Cambridge: Cambridge University Press.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• Phillips, L.D. (1984) ‘A theory of requisite decision models’, Acta Psychologica, 56(1–3), pp. 29–48.
• Raiffa, H. (1968) Decision Analysis: Introductory Lectures on Choices Under Uncertainty. Reading, MA: Addison-Wesley.

Back to top ↑