Mechanistic Explanation and the Limits of Formalism

Last Updated June 16, 2026

Mechanistic explanation and the limits of formalism help distinguish models that clarify causal structure from models that merely organize symbols. In calculus-based systems modeling, equations can describe rates, stocks, flows, feedback, delays, thresholds, and constraints. But formal structure alone does not guarantee that a model explains the world.

A model may fit data, simulate trajectories, or preserve dimensional consistency while still failing to identify a meaningful mechanism. A mechanism explains how parts, activities, processes, constraints, and interactions produce observed behavior. Formalism supports explanation when it helps reveal those relations. It becomes risky when the mathematical form is treated as explanation by itself.

This article introduces mechanistic explanation and the limits of formalism for systems modeling, including causal mechanisms, formal representation, abstraction, idealization, equation structure, parameter interpretation, model validation, explanatory scope, black-box risk, simulation limits, responsible interpretation, reproducible workflows, and model governance.

Formal models are powerful because they make assumptions explicit, compress complexity, enable calculation, and reveal implications. But formalism can also hide judgment. An elegant equation can conceal weak assumptions, missing mechanisms, poor measurement, fragile parameters, unjustified extrapolation, or a mismatch between the model’s structure and the system it claims to explain.

The central question is not only “Can this system be formalized?” It is “What mechanism does the formalism represent, what has been idealized away, what evidence supports the mechanism, and where does the explanatory claim stop?”

Why Mechanistic Explanation Matters

Mechanistic explanation matters because systems models are often asked to do more than describe patterns. They are used to explain why a system behaves as it does, why a transition occurs, why a policy produces resistance, why a threshold matters, why a feedback loop amplifies change, or why an intervention may fail.

A formal model can represent a pattern without explaining it. A mechanistic model tries to identify the organized processes that produce the pattern. In calculus-based systems modeling, mechanisms often appear through rates, flows, accumulations, delays, feedback loops, constraints, thresholds, and interactions.

Mechanistic explanation strengthens models by connecting formal structure to the processes the model is meant to represent.

Back to top ↑

What a Mechanism Is

A mechanism is an organized set of entities, activities, processes, relations, or constraints that produce a phenomenon. In systems modeling, the entities may be populations, stocks, infrastructures, institutions, agents, resources, compartments, spatial regions, or variables. The activities may be growth, diffusion, transport, exchange, decay, accumulation, learning, repair, infection, extraction, investment, or feedback.

Mechanisms are not always directly visible. They may be inferred from evidence, represented through equations, simulated computationally, tested through interventions, or compared across cases. But the model should still say what process its formal structure is intended to represent.

A mechanistic explanation should make these components visible enough for review.

Back to top ↑

Formalism and Explanation

Formalism refers to the mathematical, symbolic, or computational structure of a model. Formalism is essential in calculus-based modeling because it defines variables, functions, equations, constraints, parameters, derivatives, integrals, state spaces, and solution procedures.

But formalism is not automatically explanation. The equation becomes explanatory only when its variables, parameters, functions, and terms correspond to meaningful features of the system and when the model’s assumptions, evidence, and scope are documented.

Formalism supports explanation when it clarifies mechanism. It distorts explanation when it replaces mechanism.

Back to top ↑

When Equations Explain

Equations explain when they represent meaningful dependencies, mechanisms, constraints, or transformations. A conservation equation can explain why total mass, energy, population, or resource stock changes only through specified flows. A differential equation can explain how local rates accumulate into trajectories. A feedback equation can explain why a system stabilizes, overshoots, or oscillates.

This equation is explanatory when inflow and outflow correspond to identifiable processes. It is weaker when those terms are placeholders without evidence, measurement, or causal interpretation.

The same equation can be explanatory in one context and merely descriptive in another.

Back to top ↑

When Formalism Misleads

Formalism misleads when mathematical precision is mistaken for explanatory authority. A model may be internally consistent but externally weak. It may be elegant but irrelevant. It may fit a curve while misrepresenting the mechanism. It may simulate complexity while hiding assumptions.

The danger is not mathematics. The danger is treating mathematical form as a substitute for causal, empirical, and interpretive discipline.

Back to top ↑

Abstraction and Idealization

All models abstract. They leave things out. They simplify. They focus attention. Idealization can be productive when it helps isolate a mechanism, derive a relation, compare regimes, or test a hypothesis. But idealization becomes risky when the omitted features are important to the claim being made.

Abstraction is not a flaw. Undocumented abstraction is.

Back to top ↑

Parameter Meaning

Parameters often carry the burden of explanation. A growth rate, recovery rate, elasticity, contact coefficient, feedback strength, diffusion coefficient, carrying capacity, or delay time may appear as a simple number, but its interpretation can be complex.

Some parameters are directly measured. Others are estimated, calibrated, inferred, borrowed from literature, chosen for demonstration, or used as synthetic teaching values. These differences matter. A fitted parameter may improve prediction without providing a clean mechanistic interpretation.

Mechanistic explanation requires parameter interpretation, not only parameter values.

Back to top ↑

Causal Structure and Model Structure

Model structure is not always causal structure. A mathematical dependency may represent definition, constraint, correlation, approximation, equilibrium condition, accounting identity, or causal influence. Confusing these relationships can lead to overclaiming.

For causal interpretation, the model should explain what intervention, process, or mechanism links cause and effect. In systems modeling, causal claims often require additional evidence: intervention data, process knowledge, experimental reasoning, historical evidence, domain theory, or validated structural assumptions.

A responsible model distinguishes formal dependence from causal dependence.

Back to top ↑

Black-Box Formalism

Black-box formalism occurs when a model produces outputs without making its mechanisms, assumptions, parameters, transformations, or limitations reviewable. Black boxes can arise from machine learning systems, large simulations, complex software stacks, proprietary models, or even simple equations whose assumptions are poorly documented.

A model does not need to be simple to be interpretable. But it does need some reviewable account of what its structure means, where its outputs come from, and how its assumptions shape its results.

Black-box risk is reduced through documentation, modular design, interpretability checks, validation, and governance review.

Back to top ↑

Validation and Explanatory Scope

Validation asks whether a model is adequate for a purpose. Explanatory scope asks what kind of explanation the model can support. A model may be useful for prediction but weak for mechanism. It may clarify a mechanism but be poor for precise forecasting. It may be educational, exploratory, diagnostic, or decision-supportive. These uses should not be conflated.

A model’s explanatory scope should be stated before its outputs are used.

Back to top ↑

Systems Modeling Interpretation

In systems modeling, mechanistic explanation helps keep formal models connected to the world they claim to represent. A system is not explained simply because a curve can be drawn or a simulation can be run. Explanation requires a credible account of how system components interact to produce behavior.

This is especially important in sustainability, climate, public health, economics, infrastructure, organizational systems, and policy modeling. Models in these domains often travel beyond technical audiences. They can shape narratives, decisions, priorities, and institutional trust. The more influential the model, the more important it is to clarify whether it is descriptive, predictive, mechanistic, exploratory, or decision-supportive.

The stronger interpretive standard is not “the model is formal.” It is: “the formal model identifies a mechanism, documents its assumptions, tests its sensitivity, states its scope, and preserves the limits of its explanatory claim.”

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Mechanistic explanation and the limits of formalism connect differential equations, causal structure, state variables, model semantics, parameter interpretation, identifiability, sensitivity analysis, validation, counterfactual reasoning, model comparison, abstraction, idealization, and computational governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for mechanistic explanation and formalism review should preserve mechanism records, variable definitions, parameter interpretations, assumption logs, evidence links, validation notes, sensitivity checks, formal claim types, explanatory scope, and governance warnings. These records should be exported into durable formats so the model’s explanatory claims can be reviewed alongside its outputs.

The companion repository for this article uses a multi-language scaffold to show how mechanism records, formal representation records, explanatory-scope tables, SQL governance registries, Haskell typed records, Canvas artifacts, generated reports, and calculator scripts can support responsible mathematical interpretation.

Back to top ↑

Python Workflow: Mechanism and Formalism Audit

The Python workflow below builds mechanism records, formal representation records, explanatory claim records, and governance warnings for a systems modeling review.

from __future__ import annotations

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


@dataclass(frozen=True)
class MechanismRecord:
    mechanism_name: str
    represented_process: str
    entities: str
    activities: str
    evidence_status: str
    warning: str


@dataclass(frozen=True)
class FormalRepresentationRecord:
    formal_element: str
    symbol_or_structure: str
    model_role: str
    interpretation_requirement: str
    warning: str


@dataclass(frozen=True)
class ExplanationClaimRecord:
    claim_type: str
    supported_use: str
    evidence_need: str
    scope_limit: str
    governance_status: str


def build_mechanism_records() -> list[MechanismRecord]:
    return [
        MechanismRecord(
            mechanism_name="stock_flow_accumulation",
            represented_process="stock changes through inflow and outflow",
            entities="stock, inflow, outflow",
            activities="accumulation, depletion, replacement",
            evidence_status="synthetic teaching example",
            warning="A stock-flow equation is mechanistic only when flows represent real processes."
        ),
        MechanismRecord(
            mechanism_name="balancing_feedback",
            represented_process="state-dependent adjustment limits growth or change",
            entities="state variable, feedback coefficient, constraint",
            activities="adjustment, saturation, stabilization",
            evidence_status="formal teaching example",
            warning="Feedback parameters require process interpretation and evidence."
        ),
        MechanismRecord(
            mechanism_name="threshold_transition",
            represented_process="behavior changes after a critical value is crossed",
            entities="state variable, threshold, response rule",
            activities="activation, failure, transition",
            evidence_status="scenario-based example",
            warning="Threshold claims require careful scope and uncertainty notes."
        )
    ]


def build_formal_records() -> list[FormalRepresentationRecord]:
    return [
        FormalRepresentationRecord(
            formal_element="differential_equation",
            symbol_or_structure="dx/dt = f(x,t,theta)",
            model_role="describes state change over time",
            interpretation_requirement="identify what process f represents",
            warning="A rate equation without process interpretation may be descriptive only."
        ),
        FormalRepresentationRecord(
            formal_element="parameter",
            symbol_or_structure="theta",
            model_role="controls model behavior",
            interpretation_requirement="record unit, source, range, and mechanism meaning",
            warning="Calibrated parameters are not automatically causal quantities."
        ),
        FormalRepresentationRecord(
            formal_element="constraint",
            symbol_or_structure="x <= K",
            model_role="bounds system behavior",
            interpretation_requirement="explain whether K is physical, institutional, ecological, or assumed",
            warning="Constraints can hide strong assumptions."
        )
    ]


def build_claim_records() -> list[ExplanationClaimRecord]:
    return [
        ExplanationClaimRecord(
            claim_type="mechanistic",
            supported_use="explains how an organized process can produce behavior",
            evidence_need="process evidence, structural plausibility, sensitivity review",
            scope_limit="applies only where the mechanism and assumptions hold",
            governance_status="review"
        ),
        ExplanationClaimRecord(
            claim_type="predictive",
            supported_use="forecasts output under specified conditions",
            evidence_need="validation data and uncertainty assessment",
            scope_limit="limited to validated domain and time horizon",
            governance_status="review"
        ),
        ExplanationClaimRecord(
            claim_type="exploratory",
            supported_use="investigates possible system behavior",
            evidence_need="clear scenario assumptions and limitation notes",
            scope_limit="not a confirmed mechanism or forecast",
            governance_status="active"
        )
    ]


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)

mechanisms = build_mechanism_records()
formal_records = build_formal_records()
claims = build_claim_records()

write_csv(output_dir / "tables" / "mechanism_records.csv", mechanisms)
write_csv(output_dir / "tables" / "formal_representation_records.csv", formal_records)
write_csv(output_dir / "tables" / "explanation_claim_records.csv", claims)

audit = {
    "mechanism_records": [asdict(record) for record in mechanisms],
    "formal_representation_records": [asdict(record) for record in formal_records],
    "explanation_claim_records": [asdict(record) for record in claims],
    "interpretation_warning": "Formal structure supports explanation only when mechanism, evidence, and scope are documented."
}

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

report_lines = [
    "# Mechanism and Formalism Audit",
    "",
    "## Mechanism Records"
]

for record in mechanisms:
    report_lines.append(
        f"- **{record.mechanism_name}**: {record.represented_process}. Evidence: {record.evidence_status}. {record.warning}"
    )

report_lines.append("")
report_lines.append("## Formal Representation Records")

for record in formal_records:
    report_lines.append(
        f"- **{record.formal_element}** ({record.symbol_or_structure}): {record.model_role}. Requirement: {record.interpretation_requirement}. {record.warning}"
    )

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

for record in claims:
    report_lines.append(
        f"- **{record.claim_type}**: {record.supported_use}. Scope: {record.scope_limit}. Status: {record.governance_status}."
    )

report_lines.append("")
report_lines.append("Formal structure supports explanation only when mechanism, evidence, and scope are documented.")

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

print("Wrote mechanism and formalism audit outputs.")

This workflow keeps mechanism, formal structure, evidence status, explanatory scope, and governance warnings connected to the model record.

Back to top ↑

R Workflow: Mechanism Evidence Table

The R workflow below builds a compact evidence table for mechanism and formalism review.

mechanism_records <- data.frame(
  mechanism_name = c(
    "stock_flow_accumulation",
    "balancing_feedback",
    "threshold_transition"
  ),
  represented_process = c(
    "stock changes through inflow and outflow",
    "state-dependent adjustment limits growth or change",
    "behavior changes after a critical value is crossed"
  ),
  evidence_status = c(
    "synthetic teaching example",
    "formal teaching example",
    "scenario-based example"
  ),
  warning = c(
    "A stock-flow equation is mechanistic only when flows represent real processes.",
    "Feedback parameters require process interpretation and evidence.",
    "Threshold claims require careful scope and uncertainty notes."
  )
)

claim_records <- data.frame(
  claim_type = c("mechanistic", "predictive", "exploratory"),
  supported_use = c(
    "explains how an organized process can produce behavior",
    "forecasts output under specified conditions",
    "investigates possible system behavior"
  ),
  evidence_need = c(
    "process evidence and structural plausibility",
    "validation data and uncertainty assessment",
    "clear scenario assumptions and limitation notes"
  ),
  scope_limit = c(
    "applies only where mechanism and assumptions hold",
    "limited to validated domain and time horizon",
    "not a confirmed mechanism or forecast"
  )
)

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

write.csv(
  mechanism_records,
  "outputs/tables/r_mechanism_records.csv",
  row.names = FALSE
)

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

print(mechanism_records)
print(claim_records)

This workflow separates mechanism claims, predictive claims, and exploratory claims so formal outputs are not overinterpreted.

Back to top ↑

Haskell Workflow: Typed Mechanism Records

Haskell can represent mechanisms, formal structures, and explanation claims as typed records that preserve interpretation and governance status.

module Main where

data ClaimType
  = Mechanistic
  | Predictive
  | Exploratory
  | Descriptive
  | DecisionSupport
  deriving (Show, Eq)

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

data MechanismRecord = MechanismRecord
  { mechanismName :: String
  , representedProcess :: String
  , entities :: String
  , activities :: String
  , evidenceStatus :: String
  , mechanismWarning :: String
  } deriving (Show, Eq)

data FormalRecord = FormalRecord
  { formalElement :: String
  , symbolOrStructure :: String
  , modelRole :: String
  , interpretationRequirement :: String
  , formalWarning :: String
  } deriving (Show, Eq)

data ExplanationClaim = ExplanationClaim
  { claimType :: ClaimType
  , supportedUse :: String
  , evidenceNeed :: String
  , scopeLimit :: String
  , governanceStatus :: GovernanceStatus
  } deriving (Show, Eq)

mechanismRecords :: [MechanismRecord]
mechanismRecords =
  [ MechanismRecord
      "stock_flow_accumulation"
      "stock changes through inflow and outflow"
      "stock, inflow, outflow"
      "accumulation, depletion, replacement"
      "synthetic teaching example"
      "A stock-flow equation is mechanistic only when flows represent real processes."
  , MechanismRecord
      "balancing_feedback"
      "state-dependent adjustment limits growth or change"
      "state variable, feedback coefficient, constraint"
      "adjustment, saturation, stabilization"
      "formal teaching example"
      "Feedback parameters require process interpretation and evidence."
  ]

formalRecords :: [FormalRecord]
formalRecords =
  [ FormalRecord
      "differential_equation"
      "dx/dt = f(x,t,theta)"
      "describes state change over time"
      "identify what process f represents"
      "A rate equation without process interpretation may be descriptive only."
  , FormalRecord
      "parameter"
      "theta"
      "controls model behavior"
      "record unit, source, range, and mechanism meaning"
      "Calibrated parameters are not automatically causal quantities."
  ]

claims :: [ExplanationClaim]
claims =
  [ ExplanationClaim
      Mechanistic
      "explains how an organized process can produce behavior"
      "process evidence, structural plausibility, sensitivity review"
      "applies only where the mechanism and assumptions hold"
      Review
  , ExplanationClaim
      Exploratory
      "investigates possible system behavior"
      "clear scenario assumptions and limitation notes"
      "not a confirmed mechanism or forecast"
      Active
  ]

main :: IO ()
main = do
  putStrLn "Mechanism records:"
  mapM_ print mechanismRecords
  putStrLn ""
  putStrLn "Formal records:"
  mapM_ print formalRecords
  putStrLn ""
  putStrLn "Explanation claims:"
  mapM_ print claims

The typed workflow helps prevent formal outputs from being detached from mechanism, evidence, and scope.

Back to top ↑

SQL Workflow: Explanation Governance Registry

SQL can preserve mechanism records, formal representation records, explanation claim types, and governance warnings for repository-level review.

CREATE TABLE explanation_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 explanation_governance_registry VALUES
(
  'mechanism_record',
  'Mechanism record',
  'Documents the process, entities, activities, organization, and evidence status.',
  'Connects formal structure to how a system produces behavior.',
  'A formal model without mechanism documentation may be descriptive only.'
);

INSERT INTO explanation_governance_registry VALUES
(
  'formal_representation',
  'Formal representation',
  'Documents equations, variables, parameters, constraints, and computational steps.',
  'Makes model structure explicit and reviewable.',
  'Formal consistency does not guarantee explanatory validity.'
);

INSERT INTO explanation_governance_registry VALUES
(
  'parameter_interpretation',
  'Parameter interpretation',
  'Documents parameter source, unit, range, evidence status, and model role.',
  'Prevents fitted constants from being mistaken for causal mechanisms.',
  'Calibrated parameters are not automatically causal quantities.'
);

INSERT INTO explanation_governance_registry VALUES
(
  'causal_claim',
  'Causal claim',
  'States whether the model is making a causal or mechanistic assertion.',
  'Separates formal dependence from causal dependence.',
  'Functional dependence does not automatically imply causal explanation.'
);

INSERT INTO explanation_governance_registry VALUES
(
  'validation_scope',
  'Validation scope',
  'Defines the evidence domain, purpose, and range of model adequacy.',
  'Aligns model use with evidence and intended purpose.',
  'A model can be valid for one purpose and invalid for another.'
);

INSERT INTO explanation_governance_registry VALUES
(
  'claim_boundary',
  'Claim boundary',
  'Defines what kind of explanation, prediction, or decision support is justified.',
  'Prevents formal outputs from being overinterpreted.',
  'Formal structure supports explanation only when mechanism, evidence, and scope are documented.'
);

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

This registry connects mechanism records, formal representation, parameter interpretation, causal claims, validation scope, 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 mechanism records, formal representation records, explanation claim tables, parameter interpretation notes, validation-scope records, 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

Mechanistic explanation strengthens mathematical modeling, but it also requires humility. A model may represent a plausible mechanism without proving that mechanism. A formal system may be internally coherent while failing externally. A parameter may fit data without carrying causal meaning. A simulation may generate realistic-looking behavior without explaining the real system.

Responsible use requires documentation. Preserve mechanism records, formal definitions, variable meanings, parameter sources, units, evidence status, assumption logs, validation scope, sensitivity checks, black-box warnings, and claim boundaries. Treat formalism as a tool for disciplined explanation, not as a substitute for evidence, interpretation, or judgment.

The central question is not only “Does the formal model work?” It is “What does the model explain, what has it merely represented, what has it idealized away, and what claims would exceed its evidence?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• Sensitivity, Robustness, and Parameter Dependence
• When Continuous Models Mislead
• Interpretation, Assumptions, and Responsible Mathematical Modeling
• Model Governance and Accountability
• Model Assumptions and Boundary Judgment
• When Systems Models Clarify and When They Distort
• Calibration and Validation of Models
• Model Comparison and Ensemble Reasoning
• Ethics, Power, and Systems Modeling

Back to top ↑

Further Reading

• Machamer, P., Darden, L. and Craver, C.F. (2000) ‘Thinking about mechanisms’, Philosophy of Science, 67(1), pp. 1–25. Link
• Glennan, S. (2017) The New Mechanical Philosophy. Oxford: Oxford University Press. Link
• Craver, C.F. (2007) Explaining the Brain: Mechanisms and the Mosaic Unity of Neuroscience. Oxford: Oxford University Press. Link
• Bechtel, W. (2007) Mental Mechanisms: Philosophical Perspectives on Cognitive Neuroscience. New York: Psychology Press. Link
• Woodward, J. (2003) Making Things Happen: A Theory of Causal Explanation. Oxford: Oxford University Press. Link
• Pearl, J. (2009) Causality: Models, Reasoning, and Inference. 2nd edn. Cambridge: Cambridge University Press. Link
• Morgan, M.S. and Morrison, M. (eds.) (1999) Models as Mediators: Perspectives on Natural and Social Science. Cambridge: Cambridge University Press. 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
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago, IL: University of Chicago Press. Link
• Levins, R. (1966) ‘The strategy of model building in population biology’, American Scientist, 54(4), pp. 421–431. 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
• 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
• 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

Back to top ↑

References

• Bechtel, W. (2007) Mental Mechanisms: Philosophical Perspectives on Cognitive Neuroscience. New York: Psychology Press. Link
• Cartwright, N. (1983) How the Laws of Physics Lie. Oxford: Oxford University Press. Link
• Craver, C.F. (2007) Explaining the Brain: Mechanisms and the Mosaic Unity of Neuroscience. 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
• Glennan, S. (2017) The New Mechanical Philosophy. Oxford: Oxford University Press. Link
• Levins, R. (1966) ‘The strategy of model building in population biology’, American Scientist, 54(4), pp. 421–431. Link
• Machamer, P., Darden, L. and Craver, C.F. (2000) ‘Thinking about mechanisms’, Philosophy of Science, 67(1), pp. 1–25. 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 (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
• 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
• 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 ↑