Limits, Failure, and the Ethics of Modeling: How Mathematical Models Mislead, Distort, and Require Accountability

Last Updated June 13, 2026

Limits, failure, and the ethics of modeling examines why mathematical models can clarify reality while also distorting it when assumptions, boundaries, data, uncertainty, validation, incentives, or communication are mishandled. Models fail when they are used outside their domain, treated as neutral authorities, optimized for narrow objectives, detached from context, or allowed to conceal judgment behind technical form.

Every model is a selective representation. It includes some variables and excludes others. It simplifies relationships. It chooses a scale. It defines an objective. It relies on data, assumptions, and interpretation. These choices can make a model useful, but they also create limits.

Ethical modeling begins when those limits are made visible. A responsible model is not merely elegant, accurate, or efficient. It is documented, validated for its intended use, constrained by uncertainty, reviewed for harm, communicated honestly, and governed by accountable people.

The ethical problem is not that models are imperfect. All models are partial. The ethical problem begins when partial models are presented as complete, when uncertainty is hidden, when authority shifts from people to systems, or when model outputs influence decisions without adequate review.

Why Limits Matter in Mathematical Modeling

Limits matter because models gain power by leaving things out. A model can make a system intelligible only by simplifying it. It can focus attention only by narrowing attention. It can support calculation only by formalizing relationships that are otherwise messy, uncertain, contested, or incomplete.

This selectivity is not a flaw by itself. It is what makes modeling possible. But every simplification creates a responsibility: the modeler must understand what the model can support, what it cannot support, and what harm may occur if the model is used as if it were more complete than it is.

A model’s limit is not only a technical boundary. It is also an ethical boundary. Crossing that boundary can turn useful analysis into misleading authority.

Back to top ↑

What Model Failure Means

Model failure does not always mean numerical error. A model can fail by answering the wrong question, omitting a critical mechanism, fitting historical data while failing in deployment, hiding uncertainty, supporting a harmful decision, or being communicated as more certain than it is.

Some failures are computational. Others are conceptual, institutional, ethical, or communicative. A technically correct model can still fail if it is applied to the wrong context or used to justify a decision it was not designed to support.

The most dangerous failures often occur when the model is technically impressive enough to discourage questioning.

Back to top ↑

Structural Limits: Assumptions, Boundaries, and Simplification

Structural limits come from the way a model represents reality. Assumptions, boundaries, variables, equations, parameters, constraints, and objectives define what the model can see. They also define what it cannot see.

A boundary may exclude upstream causes. A time horizon may hide long-term consequences. A linear equation may miss threshold behavior. A static model may miss feedback. An aggregate model may hide unequal effects across groups.

Structural limits should be documented before the model is used. If a model’s structure is not fit for the decision, better computation will not solve the problem.

Back to top ↑

Data and Measurement Limits

Models built from data inherit the limitations of measurement. Data may be missing, biased, delayed, inconsistent, noisy, historically distorted, or shaped by institutional incentives. Even when data are abundant, they may not measure the concept the model claims to represent.

Data limits are especially important when models are used in public systems, health, AI, finance, education, environment, infrastructure, and law. A dataset may reflect who was observed, who had access, who was recorded, who was excluded, and how institutions made past decisions.

Data quality is not a narrow technical issue. It shapes who is visible, whose outcomes count, and what the model can responsibly claim.

Back to top ↑

Validation Limits and Domain of Use

Validation asks whether a model is adequate for its intended purpose. It does not prove that a model is universally correct. A model validated for one population, setting, time period, scale, or decision may fail elsewhere.

Validation has limits because real systems change, evidence is incomplete, and decisions may exceed the model’s tested domain. A model can pass historical validation while failing under new policies, new behavior, new technology, climate change, data drift, or institutional change.

Every model needs a domain-of-use statement: what the model is approved to support, where evidence is weak, and where the model should not be used.

Back to top ↑

Uncertainty, False Precision, and Overconfidence

Uncertainty is not a weakness to hide. It is information about the limits of evidence, measurement, model form, parameters, scenarios, and future conditions. Ethical modeling communicates uncertainty clearly enough for decision-makers and affected publics to understand what is known, what is not known, and what could change.

False precision occurs when model outputs appear more exact than the evidence justifies. This can happen through overly specific forecasts, narrow confidence intervals, crisp rankings, precise-looking risk scores, or dashboards that hide uncertainty behind clean design.

Overconfidence can be more harmful than error because it encourages premature certainty, weak monitoring, and unchallenged authority.

Back to top ↑

Misuse, Incentives, and Decision Failure

Models can fail because they are misused. Misuse happens when a model is applied outside its domain, used to justify a predetermined decision, optimized for the wrong objective, treated as a substitute for judgment, or detached from the institutional context in which decisions occur.

Incentives matter. Organizations may prefer models that produce simple answers, support existing priorities, reduce accountability, or create the appearance of objectivity. A model can become a shield: “the model said so.” Ethical modeling rejects that shield.

A model does not make a decision. People and institutions decide how to use model evidence. That distinction is central to modeling ethics.

Back to top ↑

Bias, Power, and Equity

Models can reproduce power because they formalize categories, measurements, objectives, and decision rules. When models are used in public systems, employment, credit, healthcare, education, policing, infrastructure, environment, or AI, their errors and burdens may not be evenly distributed.

Bias is not only a statistical property. It can arise from whose reality is measured, whose values shape the objective, who has the power to challenge the model, and who bears the cost of error.

Ethical modeling asks not only whether the model is accurate, but accurate for whom, harmful to whom, useful for whom, and accountable to whom.

Back to top ↑

Communication, Trust, and Model Authority

Model communication shapes trust. When uncertainty is hidden, assumptions are buried, and outputs are presented as final answers, trust becomes fragile. When models are communicated honestly as conditional tools, trust can be strengthened even when conclusions change.

Responsible communication does not overwhelm users with technical detail. It explains what the model does, what data it uses, what assumptions matter, how uncertain the output is, what decisions remain human, and where the model should not be used.

Trustworthy model communication should reduce misplaced certainty and increase informed judgment.

Back to top ↑

Governance and Accountability

Model governance is the set of practices that keeps models from becoming unreviewed authority. It includes documentation, version control, validation, monitoring, ethical review, risk classification, approval workflows, incident response, retirement criteria, and responsibility assignment.

Governance is especially important when models influence consequential decisions. A model that affects people, resources, safety, rights, public systems, ecological systems, or institutional priorities needs more than technical performance metrics.

Governance should not be treated as bureaucracy after the model is built. It is part of responsible modeling from the beginning.

Back to top ↑

Major Failure Modes in Modeling Practice

Model failure modes often repeat across domains. Whether the model is used in engineering, public health, ecology, policy, AI, finance, or infrastructure, many failures arise from the same patterns: unclear purpose, poor data, hidden assumptions, weak validation, overconfident communication, and missing accountability.

Failure-mode review should happen before deployment, during monitoring, after incidents, and whenever the model is reused in a new context.

Back to top ↑

Mathematical Lens: Error, Uncertainty, Loss, and Use Limits

A model can be represented as an approximation of a target system or outcome:

Model error can be expressed as the difference between observed or true outcome and model output:

Expected decision loss can be written as:

A use-limit condition can be represented as a domain constraint:

A governance constraint can be represented as:

The mathematical lesson is that model quality is not only prediction accuracy. It also includes domain validity, uncertainty, loss, constraints, and consequences.

Back to top ↑

Example: A Risk Model Used Beyond Its Evidence

Consider a risk model developed to help prioritize review in one institutional setting. It was trained on historical cases, validated on recent records, and shown to perform reasonably on average. Later, it is adopted by another institution with different populations, different data quality, different decision rules, and different consequences.

The model may still produce scores. The interface may still work. The output may still look precise. But the evidence supporting the model has changed.

The ethical response is not simply to improve the algorithm. The institution must revalidate the model, review data meaning, test subgroup performance, define use limits, preserve human review, document accountability, and monitor outcomes after deployment.

Back to top ↑

Ethical Responsibilities Across the Model Lifecycle

Modeling ethics is not a final checklist. It applies across the full lifecycle: problem framing, data collection, model design, estimation, validation, communication, deployment, monitoring, revision, and retirement.

The central ethical question is not “Is the model perfect?” It is “Is the model being used responsibly, within evidence, with accountability for consequences?”

Back to top ↑

Python Workflow: Model Failure Register and Ethics Review

The Python workflow below creates a model failure register, scores risks across severity, likelihood, detectability, uncertainty, equity concern, and accountability gap, then writes a governance review card.

# limits_failure_and_the_ethics_of_modeling_workflow.py
# Dependency-light workflow for model failure and ethics 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 ModelFailureRecord:
    key: str
    failure_mode: str
    model_stage: str
    ethical_issue: str
    likely_cause: str
    review_status: str


@dataclass(frozen=True)
class ModelRiskCase:
    key: str
    model_name: str
    intended_use: str
    severity: float
    likelihood: float
    detectability_gap: float
    uncertainty_level: float
    equity_concern: float
    accountability_gap: float


def failure_register() -> list[ModelFailureRecord]:
    return [
        ModelFailureRecord(
            key="boundary_failure",
            failure_mode="important system effects excluded",
            model_stage="design",
            ethical_issue="hidden consequences",
            likely_cause="narrow boundary or scale choice",
            review_status="review",
        ),
        ModelFailureRecord(
            key="data_bias",
            failure_mode="training or evidence data are unrepresentative",
            model_stage="data",
            ethical_issue="unequal error and exclusion",
            likely_cause="measurement, selection, or historical bias",
            review_status="review",
        ),
        ModelFailureRecord(
            key="validation_gap",
            failure_mode="model used beyond tested domain",
            model_stage="validation",
            ethical_issue="unsupported decision authority",
            likely_cause="scope creep or weak approval process",
            review_status="review",
        ),
        ModelFailureRecord(
            key="false_precision",
            failure_mode="outputs communicated as more certain than evidence supports",
            model_stage="communication",
            ethical_issue="overconfidence and public misunderstanding",
            likely_cause="missing uncertainty communication",
            review_status="review",
        ),
        ModelFailureRecord(
            key="accountability_gap",
            failure_mode="no clear owner for decisions or harms",
            model_stage="governance",
            ethical_issue="responsibility shifting",
            likely_cause="missing model owner or decision owner",
            review_status="revise",
        ),
    ]


def risk_cases() -> list[ModelRiskCase]:
    return [
        ModelRiskCase("exploratory_model", "Exploratory planning model", "learning and scenario discussion", 0.35, 0.35, 0.25, 0.60, 0.30, 0.25),
        ModelRiskCase("allocation_model", "Resource allocation model", "prioritizing scarce resources", 0.85, 0.55, 0.55, 0.65, 0.75, 0.70),
        ModelRiskCase("public_dashboard", "Public risk dashboard", "communicating population risk", 0.70, 0.50, 0.45, 0.80, 0.55, 0.60),
        ModelRiskCase("automated_score", "Automated scoring model", "triggering institutional action", 0.90, 0.60, 0.70, 0.60, 0.80, 0.85),
    ]


def ethical_risk_score(case: ModelRiskCase) -> float:
    score = (
        1.8 * case.severity
        + 1.3 * case.likelihood
        + 1.2 * case.detectability_gap
        + 1.1 * case.uncertainty_level
        + 1.5 * case.equity_concern
        + 1.6 * case.accountability_gap
    )
    return round(score, 8)


def evaluate_risk_case(case: ModelRiskCase) -> dict[str, object]:
    score = ethical_risk_score(case)
    if score >= 6.0:
        review_class = "high_ethics_review_required"
    elif score >= 4.0:
        review_class = "governance_review_required"
    else:
        review_class = "standard_review"

    return {
        **asdict(case),
        "ethical_risk_score": score,
        "review_class": review_class,
        "requires_use_limit_statement": True,
        "requires_human_decision_owner": case.accountability_gap >= 0.40,
        "requires_equity_review": case.equity_concern >= 0.50,
    }


def failure_priority(record: ModelFailureRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.review_status.lower(),
        4.0,
    )
    text = f"{record.failure_mode} {record.ethical_issue} {record.likely_cause}".lower()
    for term in ["accountability", "bias", "validation", "uncertainty", "boundary", "precision"]:
        if term in text:
            score += 1.0
    return round(score, 8)


def ethics_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    if not rows:
        raise ValueError("Ethics summary requires at least one model risk case.")
    scores = [float(row["ethical_risk_score"]) for row in rows]
    high_review = sum(1 for row in rows if row["review_class"] == "high_ethics_review_required")
    highest = max(rows, key=lambda row: float(row["ethical_risk_score"]))
    return {
        "highest_risk_model": highest["model_name"],
        "mean_ethical_risk_score": round(statistics.mean(scores), 8),
        "max_ethical_risk_score": round(max(scores), 8),
        "min_ethical_risk_score": round(min(scores), 8),
        "high_ethics_review_count": high_review,
        "case_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:
    failures = failure_register()
    cases = risk_cases()

    failure_rows = [
        {**asdict(record), "failure_priority": failure_priority(record)}
        for record in failures
    ]

    risk_rows = [evaluate_risk_case(case) for case in cases]

    write_csv(TABLES / "model_failure_register.csv", failure_rows)
    write_csv(TABLES / "model_ethics_risk_review.csv", risk_rows)

    write_json(JSON_DIR / "model_ethics_governance_card.json", {
        "article": "Limits, Failure, and the Ethics of Modeling",
        "ethics_summary": ethics_summary(risk_rows),
        "failure_register": failure_rows,
        "risk_review": risk_rows,
        "use_limit": "This workflow supports model ethics review and failure-mode analysis; it does not certify a model for consequential deployment or replace domain, legal, institutional, stakeholder, or ethical review.",
        "diagnostic_checks": [
            "model purpose is explicit",
            "failure modes are registered",
            "uncertainty and false precision are reviewed",
            "equity concern is scored",
            "accountability gap is scored",
            "use limits and decision ownership are required",
        ],
    })

    print("Model ethics and failure workflow complete.")
    print(f"Ethics summary: {ethics_summary(risk_rows)}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats model failure as something that can be registered, scored, reviewed, and governed. It does not wait for harm before asking where the model may fail.

Back to top ↑

R Workflow: Failure-Mode Summary and Governance Queue

The R workflow below reviews generated model ethics outputs, ranks risk cases, summarizes high-review items, and creates a base R ethical-risk plot.

# limits_failure_and_the_ethics_of_modeling_review.R
# Base R workflow for model failure and ethics 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)

failure_path <- file.path(tables_dir, "model_failure_register.csv")
risk_path <- file.path(tables_dir, "model_ethics_risk_review.csv")

if (!file.exists(failure_path) || !file.exists(risk_path)) {
  stop("Missing model ethics outputs. Run the Python workflow first.")
}

failures <- read.csv(failure_path, stringsAsFactors = FALSE)
risks <- read.csv(risk_path, stringsAsFactors = FALSE)

failures$failure_priority <- as.numeric(failures$failure_priority)
risks$ethical_risk_score <- as.numeric(risks$ethical_risk_score)

failures <- failures[order(-failures$failure_priority), ]
risks <- risks[order(-risks$ethical_risk_score), ]

high_review_count <- sum(risks$review_class == "high_ethics_review_required")

summary_table <- data.frame(
  highest_risk_model = risks$model_name[1],
  mean_ethical_risk_score = mean(risks$ethical_risk_score),
  max_ethical_risk_score = max(risks$ethical_risk_score),
  min_ethical_risk_score = min(risks$ethical_risk_score),
  high_ethics_review_count = high_review_count,
  case_count = nrow(risks)
)

write.csv(
  failures,
  file.path(tables_dir, "r_model_failure_governance_queue.csv"),
  row.names = FALSE
)

write.csv(
  risks,
  file.path(tables_dir, "r_model_ethics_risk_ranking.csv"),
  row.names = FALSE
)

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

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

barplot(
  risks$ethical_risk_score,
  names.arg = risks$key,
  las = 2,
  ylab = "Ethical risk score",
  main = "Model Ethics Risk Scores"
)

dev.off()

print(failures)
print(summary_table)
print(risks)

The R layer supports governance review by preserving the failure queue, risk ranking, high-review count, and model ethics summary.

Back to top ↑

Haskell Workflow: Typed Model Ethics Records

Haskell is useful here because ethical model categories should remain distinct. Data failure is not validation failure. Uncertainty is not communication. Governance is not performance. A model output is not a decision.

{-# OPTIONS_GHC -Wall #-}

module Main where

data ModelStage
  = Framing
  | DataReview
  | Design
  | Validation
  | Communication
  | Deployment
  | Monitoring
  | Governance
  deriving (Eq, Show)

data FailureMode
  = BoundaryFailure
  | DataBias
  | ValidationGap
  | FalsePrecision
  | ScopeCreep
  | AccountabilityGap
  deriving (Eq, Show)

data EthicalIssue
  = HiddenConsequences
  | UnequalError
  | UnsupportedAuthority
  | Overconfidence
  | Misuse
  | ResponsibilityShifting
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresRevision
  | Retire
  deriving (Eq, Show)

data ModelEthicsRecord = ModelEthicsRecord
  { key :: String
  , stage :: ModelStage
  , failureMode :: FailureMode
  , ethicalIssue :: EthicalIssue
  , useLimitRequired :: Bool
  , status :: ReviewStatus
  } deriving (Eq, Show)

ethicsRegister :: [ModelEthicsRecord]
ethicsRegister =
  [ ModelEthicsRecord "boundary_failure" Design BoundaryFailure HiddenConsequences True RequiresReview
  , ModelEthicsRecord "data_bias" DataReview DataBias UnequalError True RequiresReview
  , ModelEthicsRecord "validation_gap" Validation ValidationGap UnsupportedAuthority True RequiresReview
  , ModelEthicsRecord "false_precision" Communication FalsePrecision Overconfidence True RequiresReview
  , ModelEthicsRecord "scope_creep" Deployment ScopeCreep Misuse True RequiresRevision
  , ModelEthicsRecord "accountability_gap" Governance AccountabilityGap ResponsibilityShifting True RequiresRevision
  ]

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

main :: IO ()
main = do
  putStrLn "Typed model ethics records:"
  mapM_ print ethicsRegister

  putStrLn "\nModel ethics records requiring review:"
  mapM_ print (filter needsReview ethicsRegister)

This typed layer supports model ethics by keeping lifecycle stage, failure mode, ethical issue, use-limit requirement, and review status 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 model failure registers, ethics risk scoring, governance queues, use-limit statements, accountability review, typed Haskell model ethics records, and responsible modeling workflows.

Back to top ↑

A Practical Method for Ethical Modeling

Ethical modeling is a disciplined practice. It does not require pretending that models can be perfect. It requires making model limits visible and ensuring that decisions remain accountable.

The goal is to keep modeling practice aligned with evidence, humility, transparency, and responsibility.

Back to top ↑

Common Pitfalls

Ethical failures in modeling often arise when technical achievement is mistaken for responsible use. A model can be sophisticated, fast, accurate on a benchmark, and still ethically unfit for a decision.

• Model realism illusion: forgetting that the model is a selective representation, not the system itself.
• Metric tunnel vision: optimizing what is easy to measure while ignoring what matters.
• Proxy substitution: treating a measurable proxy as if it were the real concept.
• Historical laundering: reproducing past institutional decisions as if they were objective truth.
• Validation overreach: using evidence from one context to justify another.
• False precision: communicating exact-looking numbers without uncertainty.
• Scope creep: letting a model spread into decisions it was never approved to support.
• Equity omission: reviewing aggregate performance while ignoring unequal harm.
• Automation bias: allowing users to defer to model output without meaningful review.
• Accountability evasion: treating the model as the decision-maker.

These pitfalls can be reduced through documentation, validation, challenge processes, equity review, monitoring, use-limit statements, and clear human decision ownership.

Back to top ↑

Conclusion: Models Need Limits, Review, and Human Responsibility

Mathematical models are powerful because they make complex realities more understandable. They also become dangerous when their limits are hidden, their assumptions are forgotten, their uncertainty is suppressed, or their outputs are treated as decisions.

Model failure is not only a technical event. It can be a failure of framing, evidence, communication, governance, ethics, and accountability. A model can be wrong by being used in the wrong way, in the wrong place, for the wrong purpose, or with the wrong level of authority.

Responsible modeling does not require rejecting models. It requires keeping models in their proper role: tools for structured reasoning, not substitutes for judgment.

The ethical standard is clear. Models should clarify assumptions, expose uncertainty, support review, reveal tradeoffs, improve decision quality, and remain accountable to the people and systems they affect.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• Assumptions, Simplification, and Model Design
• Model Boundaries, Scale, and Scope
• Validation and Model Assessment
• Overfitting, Underfitting, and Model Generalization
• Diagnostics, Residuals, and Model Error
• Uncertainty in Mathematical Models
• Communicating Model Uncertainty
• Model Interpretation and Decision-Making
• Model Governance and Accountability

Back to top ↑

Further Reading

• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Douglas, H. (2009) Science, Policy, and the Value-Free Ideal. Pittsburgh: University of Pittsburgh Press.
• Jasanoff, S. (2004) States of Knowledge: The Co-Production of Science and Social Order. London: Routledge.
• Morgan, M.G. and Henrion, M. (1990) Uncertainty: A Guide to Dealing with Uncertainty in Quantitative Risk and Policy Analysis. Cambridge: Cambridge University Press.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown.
• Porter, T.M. (1995) Trust in Numbers: The Pursuit of Objectivity in Science and Public Life. Princeton: Princeton University Press.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484.
• Sarewitz, D. (2016) ‘Saving science’, The New Atlantis, 49, pp. 4–40.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press.
• Winner, L. (1980) ‘Do artifacts have politics?’, Daedalus, 109(1), pp. 121–136.

Back to top ↑

References

• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Douglas, H. (2009) Science, Policy, and the Value-Free Ideal. Pittsburgh: University of Pittsburgh Press.
• Jasanoff, S. (2004) States of Knowledge: The Co-Production of Science and Social Order. London: Routledge.
• Morgan, M.G. and Henrion, M. (1990) Uncertainty: A Guide to Dealing with Uncertainty in Quantitative Risk and Policy Analysis. Cambridge: Cambridge University Press.
• O’Neil, C. (2016) Weapons of Math Destruction: How Big Data Increases Inequality and Threatens Democracy. New York: Crown.
• Porter, T.M. (1995) Trust in Numbers: The Pursuit of Objectivity in Science and Public Life. Princeton: Princeton University Press.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484.
• Sarewitz, D. (2016) ‘Saving science’, The New Atlantis, 49, pp. 4–40.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press.
• Winner, L. (1980) ‘Do artifacts have politics?’, Daedalus, 109(1), pp. 121–136.

Back to top ↑