When Continuous Models Mislead

Last Updated June 16, 2026

Continuous models mislead when smooth mathematical structure is mistaken for the structure of the world. Calculus-based systems models are powerful because they represent change through rates, accumulation, flows, fields, differential equations, feedback, optimization, and approximation. But the same smoothness that makes continuous models useful can also hide discontinuities, thresholds, institutional breaks, discrete events, measurement limits, and model-scope failures.

A continuous model may clarify a process, approximate a trend, or reveal a mechanism. It may also exaggerate precision, smooth away conflict, imply false stability, conceal fragile assumptions, or project beyond the domain where its equations make sense. The issue is not that continuous models are wrong by default. The issue is that their assumptions must be visible, tested, bounded, and interpreted responsibly.

This article introduces how continuous models can mislead in systems modeling, including false smoothness, hidden thresholds, equilibrium bias, extrapolation risk, averaging effects, fragile parameters, solver artifacts, missing mechanisms, model-scope drift, institutional discontinuities, black-box simulation, and responsible governance.

Continuous models are often built because continuous mathematics is useful. It lets analysts represent rates, derivatives, integrals, gradients, flows, fields, and long-run dynamics with precision. Yet many real systems contain discrete choices, abrupt policy changes, institutional constraints, technological shifts, ecological thresholds, reporting discontinuities, social conflict, capacity limits, and behavioral adaptation.

The central question is not “Are continuous models useful?” They are. The stronger question is: “Where does continuity help, where does it distort, and what safeguards keep smooth mathematical form from becoming false confidence?”

Why Continuous Models Can Mislead

Continuous models can mislead because they often translate a complex system into smooth mathematical relationships. That translation may be appropriate when the target process is approximately continuous at the relevant scale. It may be misleading when the target process is governed by jumps, thresholds, choices, constraints, or structural breaks.

The misleading effect often comes from overextension. A continuous approximation built for a limited domain may be used outside its range. A fitted curve may be treated as mechanism. A smooth trajectory may be presented as a forecast rather than a scenario. A numerical output may look more precise than the assumptions allow.

Continuous models are most useful when they are treated as structured approximations rather than as self-validating representations.

Back to top ↑

False Smoothness

False smoothness occurs when a model represents change as gradual even though the real system may change abruptly. A continuous curve can hide shocks, collapses, policy shifts, institutional decisions, failures, delays, reporting changes, or behavioral transitions.

Smoothness is often useful as an approximation. But the approximation must match the question. If the question concerns threshold crossing, disruption, failure, or crisis, smoothing may remove the very phenomenon being studied.

A smooth model should be reviewed for the discontinuities it may be concealing.

Back to top ↑

Hidden Thresholds and Regime Change

Many systems behave differently after a critical value is crossed. Continuous equations can represent thresholds, but they can also hide them when the analyst uses a smooth function that averages across regimes.

Thresholds matter in climate feedback, epidemiology, infrastructure stress, resource depletion, financial instability, organizational overload, public trust, and ecological systems. If the model does not represent threshold behavior, its outputs may look stable while the real system is close to transition.

A continuous model that does not examine thresholds may understate fragility.

Back to top ↑

Equilibrium Bias

Continuous models often make equilibrium analysis tractable. Equilibria are useful because they identify possible steady states. But focusing too heavily on equilibrium can mislead when the transition path, timing, delay, overshoot, instability, or distributional effect matters more than the final state.

Equilibrium analysis can create a false sense of resolution. A system may have a stable equilibrium but experience unacceptable damage before reaching it. It may have an equilibrium that is mathematically stable but politically, ethically, or institutionally unacceptable. It may have multiple equilibria, path dependence, or hysteresis.

Equilibrium is a mathematical condition, not a complete interpretation.

Back to top ↑

Averaging Away Heterogeneity

Continuous models often rely on aggregate variables: average concentration, average demand, average behavior, average exposure, average income, average risk, average speed, or average response. Aggregation can clarify broad patterns, but it can also erase variation that matters.

In systems modeling, heterogeneity often changes outcomes. Different agents, regions, groups, nodes, institutions, or ecosystems may respond differently to the same process. A continuous aggregate can hide local overload, vulnerability, exclusion, clustering, network position, or adaptive behavior.

Aggregation is useful when the average is meaningful for the question. It is misleading when the distribution is the phenomenon.

Back to top ↑

Extrapolation and Domain Drift

Continuous models are often used beyond the domain where they were built. A fitted trend may be extended into the future. A local approximation may be used globally. A smooth relationship may be assumed to hold after conditions change. This is extrapolation risk.

Domain drift occurs when the system changes while the model’s assumptions remain fixed. This can happen through technology, regulation, climate conditions, institutional behavior, data collection, economic structure, social norms, or infrastructure capacity.

A model should state where it applies, when it should be revisited, and what conditions would invalidate its use.

Back to top ↑

Parameter Fragility

Continuous models may depend strongly on parameters. A small change in a growth rate, delay, threshold, diffusion coefficient, elasticity, carrying capacity, or feedback strength can change the model’s conclusion. When important parameters are uncertain, model outputs should be interpreted cautiously.

Parameter fragility is especially concerning when the parameter is poorly measured, calibrated only for fit, borrowed from another domain, or chosen for demonstration. A model can appear stable because the analyst has not tested the parameter range where it becomes fragile.

Robust interpretation requires knowing which parameters matter and how much.

Back to top ↑

Solver Artifacts and Numerical Confidence

Numerical solvers can make continuous models look more reliable than they are. A smooth plot, dense time series, or polished simulation can hide time-step dependence, stiffness, convergence failure, interpolation artifacts, discretization error, or unstable numerical behavior.

Numerical workflows should record solver method, step size, tolerance, convergence status, warnings, rejected steps, stiffness indicators, and reproducibility metadata. Without these records, a continuous model can become a black box wrapped in mathematical language.

Numerical success is a diagnostic condition, not an interpretive guarantee.

Back to top ↑

Missing Mechanisms

A continuous model may fit observed behavior while omitting the mechanism that actually matters. This is especially common when a model uses a convenient functional form, smooth trend, or aggregate equation without explaining the process behind it.

Missing mechanisms may include behavioral adaptation, political decision points, institutional resistance, network effects, resource constraints, spatial barriers, learning, social trust, technology substitution, enforcement capacity, or conflict. If the missing mechanism controls the outcome, the continuous model can mislead even when its mathematics are correct.

A model’s formal adequacy depends on the question it is asked to answer.

Back to top ↑

Institutional and Social Discontinuities

Continuous models can struggle with institutional and social discontinuities because these often arise from rules, decisions, coordination failures, conflict, legitimacy shifts, enforcement changes, or political events. These processes may not follow smooth mathematical change.

This does not mean institutional or social systems cannot be modeled. It means the model must be clear about whether continuity is an approximation, whether discrete events are represented, and whether decision rules are included.

Continuous models can support institutional analysis, but only when institutional discontinuities are not smoothed into invisibility.

Back to top ↑

Systems Modeling Interpretation

In systems modeling, continuous models are most trustworthy when their assumptions are explicit and their limitations are treated as part of the analysis. A smooth model may be the right tool for accumulation, diffusion, growth, decay, transport, optimization, or field dynamics. It may be the wrong tool for discrete failure, institutional decision, structural rupture, or threshold behavior unless those features are represented.

This distinction matters in climate, health, infrastructure, economics, ecology, finance, urban systems, organizations, and public policy. Continuous models often travel from technical workflows into public explanation. Their curves can shape decisions, priorities, budgets, narratives, and institutional trust.

The stronger interpretive standard is not “the continuous model ran successfully.” It is: “the model’s continuity assumptions, thresholds, parameter ranges, solver diagnostics, omitted mechanisms, validation scope, and claim boundaries have been documented and reviewed.”

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. The risks of continuous models connect local approximation, differentiability assumptions, smoothness, structural breaks, discontinuities, singularities, bifurcations, stiffness, discretization, sensitivity, identifiability, model misspecification, numerical stability, validation, and governance.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for continuous model review should preserve continuity assumptions, threshold checks, structural-break notes, parameter ranges, solver settings, numerical diagnostics, scope warnings, omitted-mechanism records, and claim boundaries. These records should be exported into durable formats so smooth output can be reviewed alongside its assumptions and limitations.

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

Back to top ↑

Python Workflow: Continuous Model Risk Audit

The Python workflow below builds continuity assumption records, model risk records, solver diagnostic records, and governance warnings for a continuous model review.

from __future__ import annotations

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


@dataclass(frozen=True)
class ContinuityAssumptionRecord:
    assumption_name: str
    model_element: str
    assumption_description: str
    review_question: str
    warning: str


@dataclass(frozen=True)
class MisleadingContinuityRisk:
    risk_name: str
    risk_pattern: str
    possible_consequence: str
    governance_response: str
    status: str


@dataclass(frozen=True)
class SolverDiagnosticRecord:
    diagnostic_name: str
    diagnostic_role: str
    required_record: str
    warning: str


def build_continuity_assumptions() -> list[ContinuityAssumptionRecord]:
    return [
        ContinuityAssumptionRecord(
            assumption_name="smooth_state_change",
            model_element="state trajectory x(t)",
            assumption_description="state changes gradually over modeled time",
            review_question="Are shocks, events, or thresholds possible?",
            warning="Smooth output does not prove smooth system behavior."
        ),
        ContinuityAssumptionRecord(
            assumption_name="continuous_rate_function",
            model_element="dx/dt = f(x,t,theta)",
            assumption_description="rate can be represented as a continuous function",
            review_question="Does the process change through discrete decisions or regime switches?",
            warning="Rate continuity should be justified at the modeled scale."
        ),
        ContinuityAssumptionRecord(
            assumption_name="aggregate_representative_variable",
            model_element="mean state or average exposure",
            assumption_description="aggregate variable represents the system adequately",
            review_question="Does heterogeneity matter for the claim?",
            warning="Averages can hide local stress, inequality, or bottlenecks."
        )
    ]


def build_risk_records() -> list[MisleadingContinuityRisk]:
    return [
        MisleadingContinuityRisk(
            risk_name="false_smoothness",
            risk_pattern="smooth curve hides structural breaks",
            possible_consequence="threshold, failure, or event dynamics are missed",
            governance_response="test for breaks and document discontinuities",
            status="review"
        ),
        MisleadingContinuityRisk(
            risk_name="equilibrium_bias",
            risk_pattern="steady-state result is overinterpreted",
            possible_consequence="transition cost, overshoot, delay, or distributional effect is hidden",
            governance_response="analyze trajectories and stability, not only equilibria",
            status="review"
        ),
        MisleadingContinuityRisk(
            risk_name="solver_confidence",
            risk_pattern="successful computation is mistaken for validation",
            possible_consequence="numerical artifacts appear as model insight",
            governance_response="record solver method, tolerance, convergence, and warnings",
            status="review"
        )
    ]


def build_solver_diagnostics() -> list[SolverDiagnosticRecord]:
    return [
        SolverDiagnosticRecord(
            diagnostic_name="step_size_check",
            diagnostic_role="tests whether results change under smaller time steps",
            required_record="time step, method, output difference",
            warning="Large time steps can miss fast dynamics or threshold crossing."
        ),
        SolverDiagnosticRecord(
            diagnostic_name="stiffness_check",
            diagnostic_role="flags fast and slow dynamics that challenge numerical methods",
            required_record="solver type, stiffness warning, rejected steps",
            warning="Stiff systems require solver-specific diagnostics."
        ),
        SolverDiagnosticRecord(
            diagnostic_name="convergence_check",
            diagnostic_role="records whether numerical solution converged",
            required_record="convergence flag, tolerance, iteration count",
            warning="A plotted output can hide convergence failure."
        )
    ]


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)

assumptions = build_continuity_assumptions()
risks = build_risk_records()
diagnostics = build_solver_diagnostics()

write_csv(output_dir / "tables" / "continuity_assumption_records.csv", assumptions)
write_csv(output_dir / "tables" / "misleading_continuity_risks.csv", risks)
write_csv(output_dir / "tables" / "solver_diagnostic_records.csv", diagnostics)

audit = {
    "continuity_assumptions": [asdict(record) for record in assumptions],
    "misleading_continuity_risks": [asdict(record) for record in risks],
    "solver_diagnostics": [asdict(record) for record in diagnostics],
    "interpretation_warning": "Continuous models are approximations whose smooth assumptions, solver settings, and claim boundaries must be reviewed."
}

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

report_lines = [
    "# Continuous Model Risk Audit",
    "",
    "## Continuity Assumptions"
]

for record in assumptions:
    report_lines.append(
        f"- **{record.assumption_name}** ({record.model_element}): {record.assumption_description}. Review: {record.review_question}. {record.warning}"
    )

report_lines.append("")
report_lines.append("## Misleading Continuity Risks")

for record in risks:
    report_lines.append(
        f"- **{record.risk_name}**: {record.risk_pattern}. Consequence: {record.possible_consequence}. Response: {record.governance_response}."
    )

report_lines.append("")
report_lines.append("## Solver Diagnostics")

for record in diagnostics:
    report_lines.append(
        f"- **{record.diagnostic_name}**: {record.diagnostic_role}. Required record: {record.required_record}. {record.warning}"
    )

report_lines.append("")
report_lines.append("Continuous models are approximations whose smooth assumptions, solver settings, and claim boundaries must be reviewed.")

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

print("Wrote continuous model risk audit outputs.")

This workflow keeps smoothness assumptions, risk patterns, solver diagnostics, and warnings attached to the model record.

Back to top ↑

R Workflow: Misleading Smoothness Table

The R workflow below builds a compact review table for false smoothness, threshold risk, equilibrium bias, and solver-confidence risk.

risk_records <- data.frame(
  risk_name = c(
    "false_smoothness",
    "hidden_threshold",
    "equilibrium_bias",
    "aggregation_risk",
    "solver_confidence"
  ),
  risk_pattern = c(
    "smooth curve hides structural break",
    "critical transition is omitted or smoothed",
    "steady state is overinterpreted",
    "average hides heterogeneity",
    "successful computation is mistaken for validation"
  ),
  possible_consequence = c(
    "failure or shock dynamics are missed",
    "fragility is understated",
    "transition costs and delays are hidden",
    "local stress or inequality is hidden",
    "numerical artifact appears as insight"
  ),
  governance_response = c(
    "test for breaks and document discontinuities",
    "run threshold and scenario checks",
    "analyze trajectories and stability",
    "inspect distributions and subgroups",
    "record solver method, tolerance, convergence, and warnings"
  )
)

risk_records$review_status <- c("review", "review", "review", "review", "review")

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

write.csv(
  risk_records,
  "outputs/tables/r_continuous_model_risk_records.csv",
  row.names = FALSE
)

print(risk_records)

This workflow provides a lightweight risk register for continuous-model interpretation.

Back to top ↑

Haskell Workflow: Typed Misuse Records

Haskell can represent continuity assumptions, risk patterns, and governance status as typed records.

module Main where

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

data ContinuityAssumption = ContinuityAssumption
  { assumptionName :: String
  , modelElement :: String
  , assumptionDescription :: String
  , reviewQuestion :: String
  , assumptionWarning :: String
  } deriving (Show, Eq)

data ContinuousModelRisk = ContinuousModelRisk
  { riskName :: String
  , riskPattern :: String
  , possibleConsequence :: String
  , governanceResponse :: String
  , riskStatus :: RiskStatus
  } deriving (Show, Eq)

assumptions :: [ContinuityAssumption]
assumptions =
  [ ContinuityAssumption
      "smooth_state_change"
      "state trajectory x(t)"
      "state changes gradually over modeled time"
      "Are shocks, events, or thresholds possible?"
      "Smooth output does not prove smooth system behavior."
  , ContinuityAssumption
      "continuous_rate_function"
      "dx/dt = f(x,t,theta)"
      "rate can be represented as a continuous function"
      "Does the process change through discrete decisions or regime switches?"
      "Rate continuity should be justified at the modeled scale."
  ]

risks :: [ContinuousModelRisk]
risks =
  [ ContinuousModelRisk
      "false_smoothness"
      "smooth curve hides structural breaks"
      "threshold, failure, or event dynamics are missed"
      "test for breaks and document discontinuities"
      Review
  , ContinuousModelRisk
      "equilibrium_bias"
      "steady-state result is overinterpreted"
      "transition cost, overshoot, delay, or distributional effect is hidden"
      "analyze trajectories and stability, not only equilibria"
      Review
  , ContinuousModelRisk
      "solver_confidence"
      "successful computation is mistaken for validation"
      "numerical artifacts appear as model insight"
      "record solver method, tolerance, convergence, and warnings"
      Review
  ]

main :: IO ()
main = do
  putStrLn "Continuity assumptions:"
  mapM_ print assumptions
  putStrLn ""
  putStrLn "Continuous model risks:"
  mapM_ print risks

The typed workflow keeps misuse warnings attached to the model structures that create them.

Back to top ↑

SQL Workflow: Continuous Model Governance Registry

SQL can preserve continuity assumptions, misleading-smoothness risks, solver diagnostics, and claim-boundary records for repository-level review.

CREATE TABLE continuous_model_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 continuous_model_governance_registry VALUES
(
  'continuity_assumption',
  'Continuity assumption',
  'Documents which variables, rates, or fields are treated as smooth.',
  'Makes the model approximation explicit.',
  'Smooth mathematical output does not prove smooth system behavior.'
);

INSERT INTO continuous_model_governance_registry VALUES
(
  'threshold_check',
  'Threshold check',
  'Tests whether behavior changes near critical values.',
  'Prevents regime changes from being smoothed away.',
  'A model without threshold review may understate fragility.'
);

INSERT INTO continuous_model_governance_registry VALUES
(
  'equilibrium_review',
  'Equilibrium review',
  'Examines whether steady-state analysis hides transition dynamics.',
  'Separates equilibrium existence from path safety and stability.',
  'An equilibrium is a mathematical condition, not a complete interpretation.'
);

INSERT INTO continuous_model_governance_registry VALUES
(
  'aggregation_review',
  'Aggregation review',
  'Checks whether averages hide important heterogeneity.',
  'Protects against misleading aggregate interpretation.',
  'An average can hide local stress, inequality, or bottlenecks.'
);

INSERT INTO continuous_model_governance_registry VALUES
(
  'solver_diagnostic',
  'Solver diagnostic',
  'Records numerical method, tolerance, convergence status, and warnings.',
  'Separates computed output from validated explanation.',
  'A successful solver run does not prove model validity.'
);

INSERT INTO continuous_model_governance_registry VALUES
(
  'claim_boundary',
  'Claim boundary',
  'Defines where the continuous approximation can be responsibly used.',
  'Prevents smooth models from being overextended.',
  'Continuous model claims must be tied to scope, evidence, and diagnostics.'
);

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

This registry connects continuity assumptions, thresholds, equilibria, aggregation, solver diagnostics, 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 continuity assumption records, misleading-smoothness risk tables, threshold checks, equilibrium review notes, aggregation warnings, solver diagnostics, 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

Continuous models are indispensable in science, engineering, economics, climate analysis, public health, infrastructure, and systems modeling. Their limits do not make them useless. Their limits make governance necessary. A continuous model can clarify rates, accumulation, feedback, and constraints while still failing if it hides discontinuities, omits mechanisms, extrapolates beyond scope, or masks numerical artifacts.

Responsible use requires documentation. Preserve continuity assumptions, variables, parameters, units, thresholds, structural-break checks, sensitivity ranges, solver settings, convergence diagnostics, heterogeneity notes, omitted mechanisms, validation scope, and claim boundaries. Treat smooth model output as a structured argument that requires evidence, not as a final authority.

The central question is not only “Does the continuous model produce a curve?” It is “What does that curve assume, what does it hide, what range supports it, and what claims would exceed the model’s evidence?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• Mechanistic Explanation and the Limits of Formalism
• Interpretation, Assumptions, and Responsible Mathematical Modeling
• Sensitivity, Robustness, and Parameter Dependence
• Scaling, Units, and Nondimensionalization
• Continuity, Discontinuity, and Structural Breaks
• Bifurcation and Qualitative Change
• Chaos and Sensitivity to Initial Conditions
• Stability, Error, and Convergence in Numerical Modeling
• Model Governance and Accountability

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
• Levins, R. (1966) ‘The strategy of model building in population biology’, American Scientist, 54(4), pp. 421–431. Link
• Sterman, J.D. (2002) System Dynamics: Systems Thinking and Modeling for a Complex World. Cambridge, MA: Massachusetts Institute of Technology. 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
• 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
• Morgan, M.S. and Morrison, M. (eds.) (1999) Models as Mediators: Perspectives on Natural and Social Science. Cambridge: Cambridge University Press. Link
• Beven, K. (2012) Rainfall-Runoff Modelling: The Primer. 2nd edn. Chichester: Wiley-Blackwell. 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
• LeVeque, R.J. (2007) Finite Difference Methods for Ordinary and Partial Differential Equations: Steady-State and Time-Dependent Problems. Philadelphia, PA: SIAM. Link
• Strogatz, S.H. (2018) Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry, and Engineering. 2nd edn. Boca Raton, FL: CRC 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
• LeVeque, R.J. (2007) Finite Difference Methods for Ordinary and Partial Differential Equations: Steady-State and Time-Dependent Problems. Philadelphia, PA: SIAM. 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
• 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
• Sterman, J.D. (2002) System Dynamics: Systems Thinking and Modeling for a Complex World. Cambridge, MA: Massachusetts Institute of Technology. Link
• Strogatz, S.H. (2018) Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry, and Engineering. 2nd edn. Boca Raton, FL: CRC Press. Link
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago, IL: University of Chicago Press. Link

Back to top ↑