Interpretation, Assumptions, and Responsible Mathematical Modeling

Last Updated June 16, 2026

Interpretation, assumptions, and responsible mathematical modeling determine whether a model becomes a disciplined aid to understanding or a source of misplaced confidence. In calculus-based systems modeling, equations, parameters, rates, integrals, simulations, and visualizations do not speak for themselves. They require interpretation.

A model can be mathematically coherent and still be used irresponsibly. It can be useful for teaching but not forecasting, useful for mechanism but not decision support, useful locally but not globally, useful under one parameter range but not another, useful for one population but not another, or useful for exploration but not justification. Responsible modeling begins by saying what the model is for, what it assumes, what it omits, what evidence supports it, and where its claims must stop.

This article introduces interpretation, assumptions, and responsible mathematical modeling for calculus-based systems modeling, including model purpose, assumption records, parameter evidence, uncertainty, sensitivity, validation scope, interpretive boundaries, ethical communication, governance workflows, reproducible computation, and claim discipline.

Interpretation is not an afterthought added after computation. It is part of the modeling process from the beginning. A derivative, integral, simulation, optimization, or equilibrium has meaning only in relation to the system being represented, the assumptions being made, the data being used, the parameter ranges being tested, and the claim being advanced.

The central question is not only “What does the model output show?” It is “What assumptions produced the output, what kind of claim does it support, what evidence constrains it, who may be affected by its interpretation, and what would responsible communication require?”

Why Interpretation Matters

Interpretation matters because mathematical models are not neutral mirrors of reality. They are structured representations built for a purpose. A model selects variables, chooses boundaries, defines parameters, simplifies mechanisms, omits some details, emphasizes others, and produces outputs that must be read within context.

In calculus-based modeling, interpretation attaches meaning to derivatives, rates, integrals, equilibria, trajectories, gradients, solver outputs, uncertainty bands, and sensitivity measures. Without interpretation, a model can become a polished display of formalism detached from evidence and judgment.

Interpretation turns model output into accountable reasoning.

Back to top ↑

Assumptions as Model Infrastructure

Assumptions are not minor details. They are part of the infrastructure of a model. They define what counts as a variable, which processes matter, which processes are ignored, how time and space are represented, what data are considered relevant, and what claims the model can support.

Assumptions may be mathematical, empirical, computational, institutional, ethical, or communicative. They should be documented because they determine what the model can and cannot mean.

Responsible modeling treats assumptions as reviewable artifacts.

Back to top ↑

Model Purpose and Claim Type

A model’s interpretation depends on its purpose. A teaching model, exploratory model, mechanistic model, predictive model, optimization model, and decision-support model should not be held to the same standard or communicated in the same way.

Responsible modeling separates claim types. A model may describe a pattern without explaining it. It may explore a scenario without predicting it. It may clarify a mechanism without supporting a policy decision. It may support decision framing while remaining uncertain.

Confusing claim types is one of the most common ways mathematical models are overused.

Back to top ↑

Parameter Evidence and Meaning

Parameters are often treated as simple numbers, but they carry interpretive weight. A parameter may be measured, estimated, calibrated, borrowed, assumed, scenario-based, or synthetic. These differences matter.

A fitted parameter may help reproduce observed data without being a causal mechanism. A scenario parameter may help explore possibilities without being a forecast. A synthetic parameter may support teaching without supporting empirical claims.

Parameter interpretation is part of model responsibility.

Back to top ↑

Scope Boundaries

Scope boundaries define where a model applies. They include temporal, spatial, population, parameter, data, institutional, and decision boundaries. Without scope boundaries, even a good model can be misused.

Scope is not merely a technical detail. It protects against overgeneralization. A model built for one region, time period, population, technology, policy environment, or parameter range may not apply elsewhere.

A responsible model carries its scope boundary with its output.

Back to top ↑

Uncertainty, Sensitivity, and Robustness

Responsible interpretation requires uncertainty, sensitivity, and robustness review. Uncertainty asks what is not known. Sensitivity asks which assumptions influence outputs. Robustness asks whether conclusions remain stable across plausible variation.

A model result should not be communicated as a single definitive answer when it depends strongly on uncertain assumptions. Responsible modeling does not require certainty. It requires honest representation of uncertainty and dependence.

Responsible interpretation makes model dependence visible rather than hiding it.

Back to top ↑

Validation and Adequacy

Validation is not a single stamp of truth. It is an assessment of whether a model is adequate for a specified purpose, domain, and claim. A model can be adequate for teaching and inadequate for forecasting. It can be adequate for exploratory reasoning and inadequate for policy optimization. It can be adequate locally and inadequate globally.

Verification, validation, uncertainty quantification, sensitivity analysis, and peer review all support responsible interpretation, but none eliminate judgment. A model’s adequacy should be described in relation to its purpose.

Validation should narrow claims, not inflate them.

Back to top ↑

Communication and Public Meaning

Mathematical models often move beyond technical settings. They appear in reports, dashboards, policy documents, media narratives, public briefings, institutional planning, and strategic decisions. Responsible communication matters because audiences may interpret a model output as more certain, objective, or authoritative than it is.

A responsible model communication should identify the model’s purpose, assumptions, uncertainty, tested ranges, key limitations, and claim boundary in language that can be understood by its intended audience.

Responsible communication protects both the audience and the model from misuse.

Back to top ↑

Model Governance Records

Model governance records preserve the information needed to review, reproduce, interpret, and challenge a model. They should travel with the model outputs, not remain hidden in notebooks, scripts, assumptions, or memory.

Governance records make responsible interpretation auditable.

Back to top ↑

Systems Modeling Interpretation

In systems modeling, responsible interpretation is essential because models often describe complex systems with feedback, delay, thresholds, uncertainty, nonlinear behavior, institutional structure, and human consequences. A model can clarify a system while also simplifying it. That simplification must be visible.

Responsible mathematical modeling does not require avoiding formal models. It requires using formal models with interpretive discipline. A model should help clarify assumptions, expose dependence, test alternatives, identify mechanisms, and communicate uncertainty. It should not be used to conceal judgment, overstate precision, or remove accountability from decisions.

The stronger interpretive standard is not “the model is mathematical.” It is: “the model’s purpose, assumptions, evidence, uncertainty, sensitivity, validation scope, and claim boundaries are documented clearly enough that the result can be reviewed responsibly.”

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Interpretation, assumptions, and responsible mathematical modeling connect model semantics, parameter identifiability, uncertainty quantification, sensitivity analysis, numerical verification, validation, model comparison, causal interpretation, optimization ethics, decision analysis, and reproducible computation.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for responsible mathematical modeling should preserve purpose records, assumption records, parameter evidence, data status, solver diagnostics, sensitivity checks, robustness classifications, validation scope, communication warnings, and claim boundaries. These records should be exported into durable formats so interpretation can be reviewed alongside model outputs.

The companion repository for this article uses a multi-language scaffold to show how responsible modeling records can be documented, validated, and governed through Python, R, Haskell, SQL, Canvas artifacts, advanced audit reports, and reusable calculator scripts.

Back to top ↑

Python Workflow: Responsible Modeling Audit

The Python workflow below builds purpose records, assumption records, parameter records, claim-boundary records, and governance warnings for a responsible modeling review.

from __future__ import annotations

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


@dataclass(frozen=True)
class PurposeRecord:
    model_name: str
    purpose_type: str
    supported_use: str
    unsupported_use: str
    warning: str


@dataclass(frozen=True)
class AssumptionRecord:
    assumption_name: str
    assumption_type: str
    description: str
    evidence_status: str
    risk_if_hidden: str


@dataclass(frozen=True)
class ClaimBoundaryRecord:
    claim_type: str
    permitted_claim: str
    prohibited_claim: str
    required_evidence: str
    governance_status: str


def build_purpose_records() -> list[PurposeRecord]:
    return [
        PurposeRecord(
            model_name="synthetic_logistic_growth",
            purpose_type="teaching",
            supported_use="illustrates growth, saturation, and carrying capacity",
            unsupported_use="empirical forecast for a real population",
            warning="Synthetic teaching models should not be communicated as empirical evidence."
        ),
        PurposeRecord(
            model_name="scenario_sweep",
            purpose_type="exploratory",
            supported_use="compares behavior across plausible parameter scenarios",
            unsupported_use="single-point prediction",
            warning="Scenario outputs should not be confused with forecasts."
        ),
        PurposeRecord(
            model_name="decision_support_model",
            purpose_type="decision support",
            supported_use="frames tradeoffs under documented assumptions",
            unsupported_use="replacement for judgment or accountability",
            warning="Models inform decisions; they do not remove responsibility from decision makers."
        )
    ]


def build_assumption_records() -> list[AssumptionRecord]:
    return [
        AssumptionRecord(
            assumption_name="continuous_growth",
            assumption_type="mathematical",
            description="state changes continuously over modeled time",
            evidence_status="teaching assumption",
            risk_if_hidden="smooth model may hide shocks, thresholds, or discrete events"
        ),
        AssumptionRecord(
            assumption_name="fixed_parameter_values",
            assumption_type="empirical",
            description="parameters remain fixed across the scenario",
            evidence_status="synthetic assumption",
            risk_if_hidden="output appears more certain than parameter evidence supports"
        ),
        AssumptionRecord(
            assumption_name="solver_configuration",
            assumption_type="computational",
            description="numerical method and tolerance are adequate for the model",
            evidence_status="requires diagnostic record",
            risk_if_hidden="numerical artifact may appear as model insight"
        ),
        AssumptionRecord(
            assumption_name="objective_function_weights",
            assumption_type="normative",
            description="optimization weights reflect a chosen priority structure",
            evidence_status="requires stakeholder and governance review",
            risk_if_hidden="value judgments are hidden inside mathematics"
        )
    ]


def build_claim_boundary_records() -> list[ClaimBoundaryRecord]:
    return [
        ClaimBoundaryRecord(
            claim_type="descriptive",
            permitted_claim="the model summarizes a specified structure or dataset",
            prohibited_claim="the model proves a mechanism",
            required_evidence="definition of variables, data source, and scope",
            governance_status="active"
        ),
        ClaimBoundaryRecord(
            claim_type="mechanistic",
            permitted_claim="the model represents a plausible process under stated assumptions",
            prohibited_claim="the mechanism is proven solely by formal structure",
            required_evidence="process evidence, parameter interpretation, and sensitivity review",
            governance_status="review"
        ),
        ClaimBoundaryRecord(
            claim_type="predictive",
            permitted_claim="the model forecasts within validated domain and time horizon",
            prohibited_claim="the model predicts outside validation scope",
            required_evidence="validation data, uncertainty, and robustness analysis",
            governance_status="review"
        )
    ]


def write_csv(path: Path, records: list) -> None:
    rows = [asdict(record) for record in records]
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


output_dir = Path("outputs")
(output_dir / "tables").mkdir(parents=True, exist_ok=True)
(output_dir / "json").mkdir(parents=True, exist_ok=True)
(output_dir / "reports").mkdir(parents=True, exist_ok=True)

purposes = build_purpose_records()
assumptions = build_assumption_records()
claim_boundaries = build_claim_boundary_records()

write_csv(output_dir / "tables" / "purpose_records.csv", purposes)
write_csv(output_dir / "tables" / "assumption_records.csv", assumptions)
write_csv(output_dir / "tables" / "claim_boundary_records.csv", claim_boundaries)

audit = {
    "purpose_records": [asdict(record) for record in purposes],
    "assumption_records": [asdict(record) for record in assumptions],
    "claim_boundary_records": [asdict(record) for record in claim_boundaries],
    "interpretation_warning": "Mathematical modeling is responsible only when purpose, assumptions, evidence, uncertainty, and claim boundaries are documented."
}

(output_dir / "json" / "responsible_modeling_audit.json").write_text(
    json.dumps(audit, indent=2),
    encoding="utf-8"
)

report_lines = [
    "# Responsible Mathematical Modeling Audit",
    "",
    "## Purpose Records"
]

for record in purposes:
    report_lines.append(
        f"- **{record.model_name}** ({record.purpose_type}): supports {record.supported_use}; does not support {record.unsupported_use}. {record.warning}"
    )

report_lines.append("")
report_lines.append("## Assumption Records")

for record in assumptions:
    report_lines.append(
        f"- **{record.assumption_name}** ({record.assumption_type}): {record.description}. Evidence: {record.evidence_status}. Risk if hidden: {record.risk_if_hidden}."
    )

report_lines.append("")
report_lines.append("## Claim Boundary Records")

for record in claim_boundaries:
    report_lines.append(
        f"- **{record.claim_type}**: permitted: {record.permitted_claim}; prohibited: {record.prohibited_claim}; status: {record.governance_status}."
    )

report_lines.append("")
report_lines.append("Mathematical modeling is responsible only when purpose, assumptions, evidence, uncertainty, and claim boundaries are documented.")

(output_dir / "reports" / "responsible_modeling_audit.md").write_text(
    "\n".join(report_lines) + "\n",
    encoding="utf-8"
)

print("Wrote responsible modeling audit outputs.")

This workflow keeps model purpose, assumptions, evidence status, and claim boundaries attached to the model record.

Back to top ↑

R Workflow: Assumption and Claim Table

The R workflow below builds a compact assumption and claim-boundary table for responsible model review.

assumption_records <- data.frame(
  assumption_name = c(
    "continuous_growth",
    "fixed_parameter_values",
    "solver_configuration",
    "objective_function_weights"
  ),
  assumption_type = c(
    "mathematical",
    "empirical",
    "computational",
    "normative"
  ),
  description = c(
    "state changes continuously over modeled time",
    "parameters remain fixed across the scenario",
    "numerical method and tolerance are adequate for the model",
    "optimization weights reflect a chosen priority structure"
  ),
  risk_if_hidden = c(
    "smooth model may hide shocks, thresholds, or discrete events",
    "output appears more certain than parameter evidence supports",
    "numerical artifact may appear as model insight",
    "value judgments are hidden inside mathematics"
  )
)

claim_records <- data.frame(
  claim_type = c("descriptive", "mechanistic", "predictive", "decision_support"),
  permitted_claim = c(
    "summarizes a specified structure or dataset",
    "represents a plausible process under stated assumptions",
    "forecasts within validated domain and time horizon",
    "frames tradeoffs under documented assumptions"
  ),
  prohibited_claim = c(
    "proves a mechanism",
    "proves causality solely by formal structure",
    "predicts outside validation scope",
    "replaces judgment or accountability"
  ),
  governance_status = c("active", "review", "review", "review")
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)

write.csv(
  assumption_records,
  "outputs/tables/r_assumption_records.csv",
  row.names = FALSE
)

write.csv(
  claim_records,
  "outputs/tables/r_claim_boundary_records.csv",
  row.names = FALSE
)

print(assumption_records)
print(claim_records)

This workflow separates assumptions from claims so outputs can be interpreted in relation to the evidence and scope that support them.

Back to top ↑

Haskell Workflow: Typed Responsibility Records

Haskell can represent model purpose, assumptions, and claim boundaries as typed records.

module Main where

data PurposeType
  = Teaching
  | Exploratory
  | Mechanistic
  | Predictive
  | Optimization
  | DecisionSupport
  deriving (Show, Eq)

data AssumptionType
  = Mathematical
  | Empirical
  | Computational
  | Boundary
  | MechanisticAssumption
  | Normative
  deriving (Show, Eq)

data GovernanceStatus
  = Active
  | Review
  | Revise
  | Archive
  deriving (Show, Eq)

data PurposeRecord = PurposeRecord
  { modelName :: String
  , purposeType :: PurposeType
  , supportedUse :: String
  , unsupportedUse :: String
  , purposeWarning :: String
  } deriving (Show, Eq)

data AssumptionRecord = AssumptionRecord
  { assumptionName :: String
  , assumptionType :: AssumptionType
  , assumptionDescription :: String
  , evidenceStatus :: String
  , riskIfHidden :: String
  } deriving (Show, Eq)

data ClaimBoundary = ClaimBoundary
  { claimType :: String
  , permittedClaim :: String
  , prohibitedClaim :: String
  , requiredEvidence :: String
  , governanceStatus :: GovernanceStatus
  } deriving (Show, Eq)

purposeRecords :: [PurposeRecord]
purposeRecords =
  [ PurposeRecord
      "synthetic_logistic_growth"
      Teaching
      "illustrates growth, saturation, and carrying capacity"
      "empirical forecast for a real population"
      "Synthetic teaching models should not be communicated as empirical evidence."
  , PurposeRecord
      "scenario_sweep"
      Exploratory
      "compares behavior across plausible parameter scenarios"
      "single-point prediction"
      "Scenario outputs should not be confused with forecasts."
  ]

assumptionRecords :: [AssumptionRecord]
assumptionRecords =
  [ AssumptionRecord
      "continuous_growth"
      Mathematical
      "state changes continuously over modeled time"
      "teaching assumption"
      "smooth model may hide shocks, thresholds, or discrete events"
  , AssumptionRecord
      "objective_function_weights"
      Normative
      "optimization weights reflect a chosen priority structure"
      "requires stakeholder and governance review"
      "value judgments are hidden inside mathematics"
  ]

claimBoundaries :: [ClaimBoundary]
claimBoundaries =
  [ ClaimBoundary
      "descriptive"
      "the model summarizes a specified structure or dataset"
      "the model proves a mechanism"
      "definition of variables, data source, and scope"
      Active
  , ClaimBoundary
      "predictive"
      "the model forecasts within validated domain and time horizon"
      "the model predicts outside validation scope"
      "validation data, uncertainty, and robustness analysis"
      Review
  ]

main :: IO ()
main = do
  putStrLn "Purpose records:"
  mapM_ print purposeRecords
  putStrLn ""
  putStrLn "Assumption records:"
  mapM_ print assumptionRecords
  putStrLn ""
  putStrLn "Claim boundaries:"
  mapM_ print claimBoundaries

The typed workflow helps prevent unsupported claims from being mixed with supported model uses.

Back to top ↑

SQL Workflow: Responsible Modeling Governance Registry

SQL can preserve model purpose, assumption, parameter, validation, and claim-boundary records for repository-level review.

CREATE TABLE responsible_modeling_governance_registry (
    registry_key TEXT PRIMARY KEY,
    registry_name TEXT NOT NULL,
    analytical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'purpose_record',
  'Purpose record',
  'Documents whether the model is teaching, exploratory, mechanistic, predictive, optimization-oriented, or decision-supportive.',
  'Aligns interpretation with intended use.',
  'A model should not be used for claims outside its stated purpose.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'assumption_record',
  'Assumption record',
  'Documents mathematical, empirical, computational, boundary, mechanistic, and normative assumptions.',
  'Makes model dependence visible.',
  'Hidden assumptions can create false confidence.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'parameter_record',
  'Parameter record',
  'Documents parameter value, unit, source, range, evidence status, and uncertainty.',
  'Prevents parameter values from becoming unexamined authority.',
  'A parameter value without evidence status is incomplete.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'validation_scope',
  'Validation scope',
  'Defines the evidence domain, purpose, and range of model adequacy.',
  'Limits model use to tested or justified domains.',
  'Validation is purpose-specific, not universal.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'communication_warning',
  'Communication warning',
  'Flags overprecision, scenario confusion, hidden values, or audience mismatch.',
  'Supports responsible public interpretation.',
  'A model result can be technically correct and still miscommunicated.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'claim_boundary',
  'Claim boundary',
  'Defines what the model can and cannot responsibly support.',
  'Prevents overclaiming, scope drift, and unsupported decision authority.',
  'Model conclusions should not exceed evidence, scope, and purpose.'
);

SELECT
    registry_name,
    analytical_role,
    systems_modeling_role,
    review_warning
FROM responsible_modeling_governance_registry
ORDER BY registry_key;

This registry connects purpose, assumptions, parameters, validation, communication warnings, and claim boundaries to governance review.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports model purpose records, assumption tables, parameter evidence records, validation-scope notes, communication warnings, SQL governance tables, Haskell typed records, generated reports, advanced audit logic, Canvas artifacts, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Responsible mathematical modeling does not mean avoiding uncertainty or refusing to model complex systems. It means treating model outputs as structured, conditional, reviewable claims. A model can clarify without proving. It can support decisions without replacing judgment. It can estimate without guaranteeing. It can simplify without pretending nothing important was omitted.

Responsible use requires documentation. Preserve model purpose, assumptions, variables, parameters, units, data status, validation scope, uncertainty, sensitivity, solver diagnostics, communication warnings, and claim boundaries. Treat mathematical form as part of an accountable reasoning process, not as a shield against critique.

The central question is not only “What does the model say?” It is “What does the model responsibly allow us to say, under what assumptions, with what evidence, and with what limits?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• When Continuous Models Mislead
• Mechanistic Explanation and the Limits of Formalism
• Sensitivity, Robustness, and Parameter Dependence
• Model Governance and Accountability
• Assumptions, Simplification, and Model Design
• Model Boundaries, Scale, and Scope
• Validation and Model Assessment
• Communicating Uncertainty in Model Results
• Model Interpretation and Decision-Making

Back to top ↑

Further Reading

• Oreskes, N., Shrader-Frechette, K. and Belitz, K. (1994) ‘Verification, validation, and confirmation of numerical models in the earth sciences’, Science, 263(5147), pp. 641–646. Link
• Saltelli, A., Bammer, G., Bruno, I., Charters, E., Di Fiore, M., Didier, E., Espeland, W.N., Kay, J., Lo Piano, S., Mayo, D., Pielke Jr, R., Portaluri, T., Porter, T.M., Puy, A., Rafols, I., Ravetz, J.R., Reinert, E., Sarewitz, D., Stark, P.B., Stirling, A., van der Sluijs, J. and Vineis, P. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484. Link
• National Research Council (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: The National Academies Press. Link
• National Research Council (2007) Models in Environmental Regulatory Decision Making. Washington, DC: The National Academies Press. Link
• Frigg, R. and Hartmann, S. (2020) ‘Models in science’, in Zalta, E.N. (ed.) The Stanford Encyclopedia of Philosophy. Stanford, CA: Metaphysics Research Lab, Stanford University. Link
• Frigg, R. and Nguyen, J. (2020) ‘Scientific representation’, in Zalta, E.N. (ed.) The Stanford Encyclopedia of Philosophy. Stanford, CA: Metaphysics Research Lab, Stanford University. Link
• Morgan, M.S. and Morrison, M. (eds.) (1999) Models as Mediators: Perspectives on Natural and Social Science. Cambridge: Cambridge University Press. Link
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago, IL: University of Chicago Press. Link
• Cartwright, N. (1983) How the Laws of Physics Lie. Oxford: Oxford University Press. Link
• Levins, R. (1966) ‘The strategy of model building in population biology’, American Scientist, 54(4), pp. 421–431. Link
• Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D., Saisana, M. and Tarantola, S. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Link
• Pianosi, F., Beven, K., Freer, J., Hall, J.W., Rougier, J., Stephenson, D.B. and Wagener, T. (2016) ‘Sensitivity analysis of environmental models: A systematic review with practical workflow’, Environmental Modelling & Software, 79, pp. 214–232. Link
• Beven, K. (2012) Rainfall-Runoff Modelling: The Primer. 2nd edn. Chichester: Wiley-Blackwell. Link
• Pearl, J. (2009) Causality: Models, Reasoning, and Inference. 2nd edn. Cambridge: Cambridge University Press. Link
• Woodward, J. (2003) Making Things Happen: A Theory of Causal Explanation. Oxford: Oxford University Press. Link

Back to top ↑

References

• Beven, K. (2012) Rainfall-Runoff Modelling: The Primer. 2nd edn. Chichester: Wiley-Blackwell. Link
• Cartwright, N. (1983) How the Laws of Physics Lie. Oxford: Oxford University Press. Link
• Frigg, R. and Hartmann, S. (2020) ‘Models in science’, in Zalta, E.N. (ed.) The Stanford Encyclopedia of Philosophy. Stanford, CA: Metaphysics Research Lab, Stanford University. Link
• Frigg, R. and Nguyen, J. (2020) ‘Scientific representation’, in Zalta, E.N. (ed.) The Stanford Encyclopedia of Philosophy. Stanford, CA: Metaphysics Research Lab, Stanford University. Link
• Levins, R. (1966) ‘The strategy of model building in population biology’, American Scientist, 54(4), pp. 421–431. Link
• Morgan, M.S. and Morrison, M. (eds.) (1999) Models as Mediators: Perspectives on Natural and Social Science. Cambridge: Cambridge University Press. Link
• National Research Council (2007) Models in Environmental Regulatory Decision Making. Washington, DC: The National Academies Press. Link
• National Research Council (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: The National Academies Press. Link
• Oreskes, N., Shrader-Frechette, K. and Belitz, K. (1994) ‘Verification, validation, and confirmation of numerical models in the earth sciences’, Science, 263(5147), pp. 641–646. Link
• Pearl, J. (2009) Causality: Models, Reasoning, and Inference. 2nd edn. Cambridge: Cambridge University Press. Link
• Pianosi, F., Beven, K., Freer, J., Hall, J.W., Rougier, J., Stephenson, D.B. and Wagener, T. (2016) ‘Sensitivity analysis of environmental models: A systematic review with practical workflow’, Environmental Modelling & Software, 79, pp. 214–232. Link
• Saltelli, A., Bammer, G., Bruno, I., Charters, E., Di Fiore, M., Didier, E., Espeland, W.N., Kay, J., Lo Piano, S., Mayo, D., Pielke Jr, R., Portaluri, T., Porter, T.M., Puy, A., Rafols, I., Ravetz, J.R., Reinert, E., Sarewitz, D., Stark, P.B., Stirling, A., van der Sluijs, J. and Vineis, P. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484. Link
• Saltelli, A., Ratto, M., Andres, T., Campolongo, F., Cariboni, J., Gatelli, D., Saisana, M. and Tarantola, S. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Link
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago, IL: University of Chicago Press. Link
• Woodward, J. (2003) Making Things Happen: A Theory of Causal Explanation. Oxford: Oxford University Press. Link

Back to top ↑