Mathematical Modeling in Policy and Public Systems: How Models Support Public Decisions

Last Updated June 13, 2026

Mathematical modeling in policy and public systems uses formal representations to clarify public problems, compare policy options, evaluate tradeoffs, estimate risks, allocate resources, test scenarios, and support accountable decisions under uncertainty. Policy models connect data, assumptions, values, institutions, affected populations, costs, benefits, constraints, risks, and public consequences.

In public systems, models are rarely just technical instruments. They enter contested environments where decisions affect people, communities, budgets, infrastructure, rights, risk exposure, environmental conditions, and institutional trust. A model may inform a transportation plan, health intervention, climate policy, school allocation, disaster response, housing program, water strategy, or regulatory decision.

Responsible policy modeling requires more than mathematical correctness. It requires clear purpose, transparent assumptions, public relevance, uncertainty analysis, validation, equity review, stakeholder awareness, communication discipline, governance, and accountability for how model evidence is used.

Policy models are powerful because they make public reasoning more explicit. They can reveal what a policy assumes, which populations are affected, which constraints bind, which risks matter, and how outcomes may change under alternative futures. But their public value depends on interpretation, not just computation.

Why Modeling Matters in Policy and Public Systems

Mathematical modeling matters in policy because public decisions often involve complex systems, incomplete information, competing objectives, delayed effects, unequal consequences, limited resources, and uncertainty about the future. Observation alone cannot show what would happen under every policy alternative.

Models help public institutions compare options, test assumptions, estimate consequences, identify risks, and reason across scenarios before action is taken. They can also reveal where evidence is weak, where decisions are fragile, and where more information is needed.

Policy modeling is strongest when it improves the quality of public reasoning rather than pretending to make political or ethical judgment unnecessary.

Back to top ↑

What Policy Models Do

Policy models can describe current conditions, explain system behavior, forecast possible futures, compare interventions, estimate risk, allocate resources, or support monitoring. These roles should not be confused. A model built to explore scenarios may not be adequate for precise prediction. A model built for administrative allocation may not settle questions of legitimacy or fairness.

Good policy modeling begins by identifying the model’s role. A model output should not be allowed to travel into decisions for which it was not designed, validated, or governed.

Back to top ↑

Public Problems and System Boundaries

Public problems rarely fit neatly inside one agency, department, or dataset. Housing policy affects transportation, education, health, labor markets, land use, and public finance. Climate adaptation affects infrastructure, insurance, ecosystems, emergency management, and equity. Public health response affects hospitals, schools, workplaces, households, and trust.

Model boundaries determine what is included, excluded, aggregated, simplified, or treated as external. Boundary choices can shape policy conclusions as much as parameter estimates do.

Policy models should document boundaries clearly because boundaries are not neutral technical details. They shape public consequences.

Back to top ↑

Institutions, Values, and Objectives

Policy modeling always involves values. Even when a model appears technical, it may encode values through objectives, weights, thresholds, constraints, categories, eligibility rules, cost measures, benefit measures, and acceptable risk levels.

Institutions also shape model use. A model used inside a public agency may be constrained by law, budget, political authority, administrative capacity, procedural fairness, public transparency, and accountability requirements.

Policy models should not hide value choices behind equations. They should make those choices available for review, debate, and revision.

Back to top ↑

Data, Measurement, and Public Evidence

Policy models depend on public evidence: administrative records, surveys, sensors, case data, fiscal records, environmental measurements, census data, service records, maps, inspections, and qualitative knowledge. These data sources can be incomplete, biased, delayed, inconsistent, or shaped by institutional processes.

Public data often measure what institutions already track, not necessarily what communities experience. A model can therefore appear precise while resting on narrow or uneven evidence.

Policy modeling should treat data quality as part of public accountability. Weak data do not make modeling impossible, but they change what claims are justified.

Back to top ↑

Policy Options, Scenarios, and Counterfactuals

Policy models are often used to ask “what if?” What if funding shifts? What if demand rises? What if a program expands? What if climate risk worsens? What if a new eligibility rule changes access? What if a public health intervention begins earlier?

These questions require comparing options, scenarios, or counterfactuals. A policy option is an action that could be taken. A scenario is a plausible external condition. A counterfactual is an estimate of what would have happened under a different choice.

Policy modeling should avoid presenting one baseline as destiny. Public decisions often require robust performance across plausible futures, not only the best estimate under today’s assumptions.

Back to top ↑

Risk, Tradeoffs, and Constraints

Public decisions involve tradeoffs. A policy may reduce one risk while increasing another. It may save money in one agency while shifting burden to households, communities, or future budgets. It may optimize average outcomes while worsening outcomes for a vulnerable group.

Models can clarify tradeoffs, but they cannot decide which tradeoffs are legitimate. That responsibility remains public, institutional, legal, and ethical.

Policy models should make tradeoffs visible enough for public reasoning, not bury them inside technical assumptions.

Back to top ↑

Equity, Distribution, and Stakeholders

Policy models must ask not only “what is the average effect?” but also “who is affected, how, and under what conditions?” Distribution matters because public systems often serve populations with unequal exposure, resources, access, vulnerability, and political power.

An intervention that improves the average outcome may still worsen inequity. A risk score that improves aggregate accuracy may still produce unacceptable subgroup errors. A resource-allocation model that appears efficient may overlook communities with weaker data visibility.

Equity review should not be an afterthought. In public systems, distribution is part of model interpretation.

Back to top ↑

Uncertainty, Robustness, and Deep Uncertainty

Policy modeling often operates under deep uncertainty: future conditions may be unknown, probabilities may be contested, values may differ, and systems may change in response to policy itself. In these settings, a single forecast can be misleading.

Robust policy modeling asks which options remain acceptable across plausible futures, assumptions, model structures, and value priorities. The goal is not always to find the policy that performs best under one prediction. It may be to find a policy that avoids unacceptable failure across many futures.

Uncertainty should not be hidden to make policy seem decisive. It should be communicated clearly enough that decision-makers understand what kind of judgment remains.

Back to top ↑

Validation and Use Limits in Public Systems

Policy models need validation, but validation in public systems is often difficult. Public systems change. Interventions interact. Data are imperfect. Outcomes are delayed. Contexts differ across places and populations. A model that worked in one city, program, or time period may not transfer cleanly to another.

Validation should therefore be tied to use. A model may be adequate for exploring scenarios, insufficient for resource allocation, and inappropriate for automated eligibility decisions.

A policy model should always carry a use-limit statement. Public models are especially risky when outputs circulate without context.

Back to top ↑

Communication and Public Trust

Policy models affect public trust because they can influence visible decisions: eligibility, resource distribution, emergency response, infrastructure investment, regulation, school planning, public health guidance, and environmental management. Communication must therefore be clear, honest, and proportionate.

Public communication should explain what the model does, what it does not do, what assumptions matter, what uncertainty remains, what decisions are human or institutional, and how affected people can challenge or review model-supported decisions.

Trustworthy communication does not make uncertainty disappear. It makes the role of model evidence understandable and accountable.

Back to top ↑

Major Model Families in Policy and Public Systems

Policy and public systems use many model families. The right model depends on the public question, available evidence, decision time horizon, institutional constraints, and consequences of error.

No model family is universally appropriate. Policy modeling requires matching model form to public purpose, evidence, uncertainty, legitimacy, and governance needs.

Back to top ↑

Mathematical Lens: Policy Models as Decision-Support Representations

A policy model can be represented as a mapping from policy option, population, context, assumptions, and uncertainty to projected public outcomes:

Policy comparison often evaluates multiple options:

A constrained public decision may be written as:

Risk can be represented as probability multiplied by consequence:

Distributional review asks whether outcomes differ across groups or places:

The mathematical lesson is that policy models are not neutral calculators. Their outputs depend on policy definitions, constraints, values, population structure, assumptions, and uncertainty.

Back to top ↑

Example: Resource Allocation Under Public Constraints

Consider a public agency deciding how to allocate a limited prevention budget across neighborhoods. The model estimates expected need, cost, projected benefit, implementation capacity, and equity priority. The agency wants to maximize public benefit without exceeding the budget and without worsening distributional inequity.

The model can clarify feasible allocations and expected consequences. It cannot, by itself, settle what counts as fair, which tradeoffs are acceptable, or how public authority should be exercised.

Back to top ↑

Model Governance and Institutional Accountability

Policy models require governance because they operate inside institutions. Governance defines who owns the model, who reviews it, who approves use, how assumptions are documented, how outputs are communicated, how challenges are handled, and when the model must be updated.

Without governance, model-supported decisions can become difficult to challenge. Responsibility may shift from decision-makers to analysts, from analysts to software, or from software to “the data.” Responsible governance keeps accountability attached to people and institutions.

Governance is not external to policy modeling. It is part of responsible modeling practice in public systems.

Back to top ↑

Ethical Stakes of Policy Modeling

Policy models have ethical stakes because they can influence public resources, access, burdens, rights, exposure to risk, institutional treatment, and democratic legitimacy. They can help reveal inequity, but they can also reproduce it if data, assumptions, metrics, or thresholds are flawed.

Ethical policy modeling requires transparency, proportionality, contestability, humility, and accountability. Public models should not be used to obscure value judgments or narrow political responsibility.

The ethical goal is not to avoid modeling. It is to use models in ways that strengthen public reasoning, expose assumptions, and preserve accountability.

Back to top ↑

Python Workflow: Policy Model Register and Option Review

The Python workflow below creates a policy model register, evaluates policy options under budget, benefit, risk, feasibility, and equity criteria, flags review obligations, and writes a policy decision-support review card.

# mathematical_modeling_in_policy_and_public_systems_workflow.py
# Dependency-light workflow for policy model and public-system 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 PolicyModelRecord:
    key: str
    policy_domain: str
    model_role: str
    model_family: str
    public_question: str
    status: str


@dataclass(frozen=True)
class PolicyOption:
    key: str
    option_name: str
    projected_benefit: float
    total_cost: float
    implementation_feasibility: float
    equity_score: float
    uncertainty_width: float
    public_risk: float


def policy_model_register() -> list[PolicyModelRecord]:
    return [
        PolicyModelRecord(
            key="problem_model",
            policy_domain="public_systems",
            model_role="problem_framing",
            model_family="systems_map",
            public_question="What drivers and boundaries define the public problem?",
            status="active",
        ),
        PolicyModelRecord(
            key="forecast_model",
            policy_domain="public_planning",
            model_role="forecasting",
            model_family="scenario_forecast",
            public_question="What demand or risk is plausible under future conditions?",
            status="review",
        ),
        PolicyModelRecord(
            key="allocation_model",
            policy_domain="resource_allocation",
            model_role="option_comparison",
            model_family="constrained_decision_model",
            public_question="Which option balances benefit, cost, feasibility, and equity?",
            status="review",
        ),
        PolicyModelRecord(
            key="equity_model",
            policy_domain="public_accountability",
            model_role="distributional_review",
            model_family="equity_diagnostic",
            public_question="How are benefits and burdens distributed across groups or places?",
            status="review",
        ),
        PolicyModelRecord(
            key="governance_model",
            policy_domain="institutional_governance",
            model_role="model_governance",
            model_family="review_register",
            public_question="Who owns the model, decision, update process, and public challenge pathway?",
            status="review",
        ),
    ]


def policy_options() -> list[PolicyOption]:
    return [
        PolicyOption("baseline", "Maintain current services", 42.0, 18.0, 0.86, 0.52, 18.0, 0.42),
        PolicyOption("targeted_prevention", "Targeted prevention program", 68.0, 32.0, 0.74, 0.78, 22.0, 0.30),
        PolicyOption("broad_expansion", "Broad service expansion", 81.0, 49.0, 0.58, 0.69, 28.0, 0.34),
        PolicyOption("adaptive_pathway", "Adaptive pathway with monitoring triggers", 73.0, 38.0, 0.70, 0.82, 16.0, 0.24),
    ]


def evaluate_policy_option(option: PolicyOption, budget_limit: float = 40.0) -> dict[str, object]:
    budget_violation = option.total_cost > budget_limit
    uncertainty_penalty = 0.22 * option.uncertainty_width
    risk_penalty = 30.0 * option.public_risk
    feasibility_bonus = 18.0 * option.implementation_feasibility
    equity_bonus = 24.0 * option.equity_score
    budget_penalty = 14.0 if budget_violation else 0.0

    public_value_score = (
        option.projected_benefit
        + feasibility_bonus
        + equity_bonus
        - option.total_cost
        - uncertainty_penalty
        - risk_penalty
        - budget_penalty
    )

    review_class = "requires_budget_review" if budget_violation else "within_budget"
    if option.equity_score < 0.65:
        review_class = "requires_equity_review"
    if option.public_risk > 0.38:
        review_class = "requires_risk_review"

    return {
        **asdict(option),
        "budget_limit": budget_limit,
        "budget_margin": round(budget_limit - option.total_cost, 8),
        "budget_violation": budget_violation,
        "public_value_score": round(public_value_score, 8),
        "review_class": review_class,
    }


def policy_priority(record: PolicyModelRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.model_role} {record.model_family} {record.public_question}".lower()
    for term in ["equity", "governance", "allocation", "risk", "uncertainty", "public", "decision"]:
        if term in text:
            score += 1.0
    return round(score, 8)


def policy_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    if not rows:
        raise ValueError("Policy summary requires at least one option.")
    scores = [float(row["public_value_score"]) for row in rows]
    violations = sum(1 for row in rows if bool(row["budget_violation"]))
    best = max(rows, key=lambda row: float(row["public_value_score"]))
    return {
        "best_scored_option": best["option_name"],
        "mean_public_value_score": round(statistics.mean(scores), 8),
        "max_public_value_score": round(max(scores), 8),
        "min_public_value_score": round(min(scores), 8),
        "budget_violation_count": violations,
        "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 = policy_model_register()
    options = policy_options()

    register_rows = [
        {**asdict(record), "policy_priority": policy_priority(record)}
        for record in records
    ]
    option_rows = [evaluate_policy_option(option) for option in options]

    write_csv(TABLES / "policy_model_register.csv", register_rows)
    write_csv(TABLES / "policy_option_review.csv", option_rows)

    write_json(JSON_DIR / "policy_decision_support_card.json", {
        "article": "Mathematical Modeling in Policy and Public Systems",
        "policy_summary": policy_summary(option_rows),
        "policy_model_register": register_rows,
        "policy_option_review": option_rows,
        "use_limit": "This workflow supports policy option review and public reasoning; it does not automate public decisions or replace legal, ethical, stakeholder, and institutional judgment.",
        "diagnostic_checks": [
            "policy purpose is stated",
            "model role is separated from decision authority",
            "budget constraints are explicit",
            "equity score is reviewed",
            "public risk is reviewed",
            "uncertainty width is reported",
            "governance and accountability remain required",
        ],
    })

    print("Policy and public systems workflow complete.")
    print(f"Policy summary: {policy_summary(option_rows)}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats policy modeling as public evidence infrastructure. It records model purpose, options, budget constraints, uncertainty, equity, risk, review class, governance needs, and use limits.

Back to top ↑

R Workflow: Policy Option Summary and Equity Review

The R workflow below reviews generated policy outputs, ranks policy options, summarizes budget and equity review needs, and creates a base R option-score plot.

# mathematical_modeling_in_policy_and_public_systems_review.R
# Base R workflow for policy option and public-system 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)

register_path <- file.path(tables_dir, "policy_model_register.csv")
option_path <- file.path(tables_dir, "policy_option_review.csv")

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

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

register$policy_priority <- as.numeric(register$policy_priority)
options$public_value_score <- as.numeric(options$public_value_score)
options$equity_score <- as.numeric(options$equity_score)
options$public_risk <- as.numeric(options$public_risk)
options$total_cost <- as.numeric(options$total_cost)
options$budget_margin <- as.numeric(options$budget_margin)

register <- register[order(-register$policy_priority), ]
options <- options[order(-options$public_value_score), ]

budget_values <- tolower(as.character(options$budget_violation))
budget_violation_count <- sum(budget_values %in% c("true", "1", "yes"))
equity_review_count <- sum(options$equity_score < 0.65)

summary_table <- data.frame(
  best_scored_option = options$option_name[1],
  mean_public_value_score = mean(options$public_value_score),
  max_public_value_score = max(options$public_value_score),
  min_public_value_score = min(options$public_value_score),
  budget_violation_count = budget_violation_count,
  equity_review_count = equity_review_count,
  option_count = nrow(options)
)

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

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

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

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

barplot(
  options$public_value_score,
  names.arg = options$key,
  las = 2,
  ylab = "Public value score",
  main = "Policy Option Scores Under Public-System Review"
)

dev.off()

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

The R layer supports public review by preserving option rankings, budget margins, equity scores, risk scores, review classes, and model-priority records.

Back to top ↑

Haskell Workflow: Typed Policy Model Records

Haskell is useful here because policy model categories should remain distinct. Forecasting is not governance. Allocation is not legitimacy. Equity review is not the same as aggregate optimization. A model output is not a public decision.

{-# OPTIONS_GHC -Wall #-}

module Main where

data PolicyDomain
  = PublicSystems
  | PublicPlanning
  | ResourceAllocation
  | PublicAccountability
  | InstitutionalGovernance
  deriving (Eq, Show)

data PolicyModelRole
  = ProblemFraming
  | Forecasting
  | OptionComparison
  | DistributionalReview
  | ModelGovernance
  | PublicCommunication
  deriving (Eq, Show)

data PolicyModelFamily
  = SystemsMap
  | ScenarioForecast
  | ConstrainedDecisionModel
  | EquityDiagnostic
  | ReviewRegister
  | ImpactEvaluation
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresEquityReview
  | RequiresGovernanceReview
  | Revise
  deriving (Eq, Show)

data PolicyModelRecord = PolicyModelRecord
  { key :: String
  , domain :: PolicyDomain
  , role :: PolicyModelRole
  , family :: PolicyModelFamily
  , publicQuestion :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

policyRegister :: [PolicyModelRecord]
policyRegister =
  [ PolicyModelRecord
      "problem_model"
      PublicSystems
      ProblemFraming
      SystemsMap
      "What drivers and boundaries define the public problem?"
      Active
  , PolicyModelRecord
      "forecast_model"
      PublicPlanning
      Forecasting
      ScenarioForecast
      "What demand or risk is plausible under future conditions?"
      RequiresReview
  , PolicyModelRecord
      "allocation_model"
      ResourceAllocation
      OptionComparison
      ConstrainedDecisionModel
      "Which option balances benefit, cost, feasibility, and equity?"
      RequiresReview
  , PolicyModelRecord
      "equity_model"
      PublicAccountability
      DistributionalReview
      EquityDiagnostic
      "How are benefits and burdens distributed across groups or places?"
      RequiresEquityReview
  , PolicyModelRecord
      "governance_model"
      InstitutionalGovernance
      ModelGovernance
      ReviewRegister
      "Who owns the model, decision, update process, and challenge pathway?"
      RequiresGovernanceReview
  ]

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

main :: IO ()
main = do
  putStrLn "Typed policy model records:"
  mapM_ print policyRegister

  putStrLn "\nPolicy model records requiring review:"
  mapM_ print (filter needsReview policyRegister)

This typed layer supports policy model governance by keeping public domains, model roles, model families, public questions, and review obligations 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 policy model registers, public option review, budget constraints, equity diagnostics, risk summaries, governance records, typed Haskell policy model records, and responsible public-system modeling workflows.

Back to top ↑

A Practical Method for Mathematical Modeling in Policy

Policy modeling should be structured enough to support public review, institutional accountability, and revision. The goal is not simply to produce a recommendation, but to clarify options, evidence, uncertainty, values, consequences, and responsibility.

This method keeps policy models tied to public responsibility. It prevents technical outputs from replacing democratic, legal, ethical, and institutional judgment.

Back to top ↑

Common Pitfalls

Policy modeling can fail when models are treated as neutral, complete, or authoritative beyond their evidence. Many failures come from hidden assumptions, weak governance, or poor communication rather than mathematics alone.

• False neutrality: presenting value-laden objectives as purely technical choices.
• Boundary blindness: ignoring populations, places, institutions, or outcomes outside the model.
• Average-only analysis: improving aggregate outcomes while hiding distributional harm.
• Proxy confusion: treating an available measurement as if it were the true public outcome.
• Baseline determinism: treating one forecast as the future rather than a conditional scenario.
• Optimization overreach: using a model-selected option without reviewing legitimacy, feasibility, or equity.
• Weak validation: applying a model in a public context where it has not been tested.
• No use-limit statement: letting model outputs travel into inappropriate decisions.
• No challenge pathway: preventing affected people from questioning model-supported decisions.
• Decision laundering: blaming the model for a public choice that institutions must own.

These pitfalls can be reduced through clear purpose, public documentation, uncertainty communication, equity review, validation, stakeholder awareness, and explicit governance.

Back to top ↑

Conclusion: Policy Models Should Strengthen Public Reasoning

Mathematical modeling is valuable in policy and public systems because it makes public reasoning more explicit. It helps institutions compare options, evaluate constraints, test scenarios, estimate risks, allocate resources, and understand consequences before action is taken.

But policy models do not replace public judgment. They depend on boundaries, data, assumptions, values, metrics, institutional authority, and governance. Their outputs should be interpreted as evidence for decision-making, not as decisions themselves.

A strong policy model does not hide uncertainty or values. It makes them visible. It shows what is known, what is assumed, what is uncertain, who may be affected, and what decision-makers must still own.

Used responsibly, mathematical modeling can strengthen public systems by improving transparency, accountability, robustness, and public reasoning under complexity.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Model Purpose: Explanation, Prediction, Control, and Decision Support
• Model Interpretation and Decision-Making
• Scenario Modeling and Simulation
• Optimization Models and Objective Functions
• Uncertainty in Mathematical Models
• Communicating Model Uncertainty
• Robustness, Fragility, and Model Dependence
• Mathematical Modeling in Engineering
• Limits, Failure, and the Ethics of Modeling

Back to top ↑

Further Reading

• Bardach, E. and Patashnik, E.M. (2020) A Practical Guide for Policy Analysis: The Eightfold Path to More Effective Problem Solving. 6th edn. Washington, DC: CQ Press.
• Dunn, W.N. (2018) Public Policy Analysis: An Integrated Approach. 6th edn. New York: Routledge.
• Hammond, J.S., Keeney, R.L. and Raiffa, H. (1999) Smart Choices: A Practical Guide to Making Better Decisions. Boston: Harvard Business School Press.
• Hogwood, B.W. and Gunn, L.A. (1984) Policy Analysis for the Real World. Oxford: Oxford University Press.
• Keeney, R.L. (1992) Value-Focused Thinking: A Path to Creative Decisionmaking. Cambridge, MA: Harvard 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.
• MacRae, D. and Whittington, D. (1997) Expert Advice for Policy Choice: Analysis and Discourse. Washington, DC: Georgetown University Press.
• Morgan, M.G. and Henrion, M. (1990) Uncertainty: A Guide to Dealing with Uncertainty in Quantitative Risk and Policy Analysis. Cambridge: Cambridge University Press.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Stone, D. (2012) Policy Paradox: The Art of Political Decision Making. 3rd edn. New York: W.W. Norton.

Back to top ↑

References

• Bardach, E. and Patashnik, E.M. (2020) A Practical Guide for Policy Analysis: The Eightfold Path to More Effective Problem Solving. 6th edn. Washington, DC: CQ Press.
• Dunn, W.N. (2018) Public Policy Analysis: An Integrated Approach. 6th edn. New York: Routledge.
• Hammond, J.S., Keeney, R.L. and Raiffa, H. (1999) Smart Choices: A Practical Guide to Making Better Decisions. Boston: Harvard Business School Press.
• Hogwood, B.W. and Gunn, L.A. (1984) Policy Analysis for the Real World. Oxford: Oxford University Press.
• Keeney, R.L. (1992) Value-Focused Thinking: A Path to Creative Decisionmaking. Cambridge, MA: Harvard 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.
• MacRae, D. and Whittington, D. (1997) Expert Advice for Policy Choice: Analysis and Discourse. Washington, DC: Georgetown University Press.
• Morgan, M.G. and Henrion, M. (1990) Uncertainty: A Guide to Dealing with Uncertainty in Quantitative Risk and Policy Analysis. Cambridge: Cambridge University Press.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Stone, D. (2012) Policy Paradox: The Art of Political Decision Making. 3rd edn. New York: W.W. Norton.

Back to top ↑