Mathematical Modeling in Science: How Models Explain, Predict, and Test the Natural World

Last Updated June 13, 2026

Mathematical modeling in science uses formal representations to explain phenomena, test hypotheses, connect theory with observation, estimate hidden mechanisms, simulate complex systems, and make conditional predictions. Scientific models do not simply reproduce reality; they simplify, idealize, measure, compare, and reason about selected features of the world.

In science, a model is often a bridge between theory and evidence. It may express a physical law, represent a chemical reaction, describe population growth, simulate disease spread, estimate climate feedback, interpret astronomical observations, or test whether a proposed mechanism can plausibly generate observed behavior.

Responsible scientific modeling requires more than equations and computation. It requires clear purpose, careful assumptions, measurement discipline, calibration, validation, uncertainty analysis, sensitivity review, reproducibility, and communication of limits.

Scientific models are powerful because they make reasoning explicit. They show what is assumed, what is measured, what is inferred, what is predicted, and what remains uncertain. Their authority comes not from perfection, but from disciplined connection between mathematics, observation, theory, and review.

Why Modeling Matters in Science

Mathematical modeling matters in science because many scientific questions cannot be answered by observation alone. Scientists often need to infer hidden mechanisms, compare competing explanations, estimate quantities that cannot be directly measured, simulate processes that unfold across time or space, and test whether assumptions are consistent with evidence.

A model can clarify why a phenomenon occurs, how variables interact, what should happen under changed conditions, where uncertainty is concentrated, and what new observations would most improve understanding.

Scientific modeling makes inquiry more systematic by forcing assumptions, relationships, evidence, and uncertainty into inspectable form.

Back to top ↑

What Scientific Models Do

Scientific models serve many roles. Some models are explanatory, showing how mechanisms may produce observed behavior. Some are predictive, estimating what may happen under specified conditions. Some are diagnostic, helping identify which process is likely responsible for a pattern. Some are exploratory, testing whether a hypothesis is plausible before direct evidence is available.

The same model can also play different roles at different stages of research. A simple model may clarify concepts early, while a more detailed model may later support prediction, calibration, or experiment design.

Good scientific modeling begins by naming the model’s role. A model built for explanation should not automatically be treated as a precise forecasting tool. A model built for prediction may not reveal mechanism. A model built for exploration may not be adequate for high-stakes decision-making.

Back to top ↑

Theory, Observation, and Models

Scientific modeling sits between theory and observation. Theory gives concepts, laws, mechanisms, or hypotheses. Observation gives measurements, traces, samples, experiments, and empirical constraints. Models translate theory into formal expectations and translate observations into evidence about those expectations.

A model can show what a theory predicts, whether observations are consistent with that theory, and what evidence would count against it. It can also reveal where theory is incomplete or where measurements are insufficient.

Scientific models are strongest when they preserve this cycle. They should not be treated as detached calculations. They are part of an ongoing relationship among theory, observation, testing, and revision.

Back to top ↑

Abstraction and Idealization in Scientific Models

Scientific models simplify. They select variables, remove detail, idealize conditions, set boundaries, and represent only part of the world. This is not a defect; it is what makes scientific reasoning possible. A model that included everything would not clarify anything.

But abstraction must be governed. Scientists need to know which simplifications are harmless for the research purpose and which may distort interpretation.

The question is not whether the model is simplified. Every useful scientific model is simplified. The question is whether the simplification is appropriate for the scientific claim being made.

Back to top ↑

Mechanisms, Explanation, and Causal Reasoning

Scientific models often explain by representing mechanisms. A mechanism is a process that connects causes, interactions, constraints, or rules to observed outcomes. In physics, mechanisms may involve forces or conservation laws. In biology, mechanisms may involve selection, metabolism, regulation, growth, or transmission. In earth systems, mechanisms may involve feedback, transport, circulation, or energy balance.

Mechanistic models are valuable because they can explain why a pattern occurs, not merely that it occurs. But mechanistic models also require assumptions about what processes matter and how they interact.

A mechanistic model is not automatically correct because it sounds causal. It must be tested against evidence, checked for sensitivity, and interpreted within its domain of validity.

Back to top ↑

Measurement, Data, and Calibration

Scientific models depend on measurement. Data provide constraints on model parameters, initial conditions, boundary conditions, validation targets, and uncertainty estimates. But data are not raw truth. Measurements have instruments, protocols, resolution, error, bias, sampling limits, and context.

Calibration adjusts model parameters or states so model behavior aligns with observations. Calibration can improve fit, but it does not prove that the model structure is correct. A model can be calibrated well and still be incomplete or structurally wrong.

Scientific modeling is strongest when measurement assumptions are as explicit as mathematical assumptions.

Back to top ↑

Prediction, Forecasting, and Scientific Inference

Prediction is one of the most visible uses of mathematical models in science, but prediction can mean several things. A model may predict a future value, a distribution of possible outcomes, the result of an experiment, the existence of an unobserved phenomenon, or the qualitative direction of change.

Forecasting extends prediction into time under uncertainty. Forecasts should be interpreted as conditional claims: they depend on initial conditions, assumptions, model structure, data quality, and future conditions.

Prediction is scientifically valuable when it is testable, interpretable, and connected to uncertainty. A forecast without uncertainty can create false confidence. A forecast without validation can create false authority.

Back to top ↑

Simulation and Computational Science

Many scientific models cannot be solved analytically. They require numerical methods, simulation, high-performance computing, stochastic sampling, agent-based rules, spatial grids, or iterative algorithms. Computational modeling has become central to scientific inquiry across climate science, fluid dynamics, astrophysics, molecular biology, epidemiology, neuroscience, and complex systems.

Simulation can function as a virtual laboratory. It allows researchers to explore regimes that are too expensive, dangerous, slow, fast, large, or small for direct experimentation. But simulation results are still model results. They depend on equations, discretization, numerical methods, parameters, assumptions, and code quality.

Computational power does not remove the need for scientific judgment. It increases the need for transparent workflow, validation, and uncertainty communication.

Back to top ↑

Validation and Domain of Validity

Scientific validation asks whether a model is adequate for a purpose within a domain of use. Validation does not prove a model true in an absolute sense. It builds evidence that the model is credible for certain questions, scales, conditions, and decisions.

Domain of validity is essential. A model may work under ordinary conditions but fail under extremes. It may work at one scale but not another. It may explain a mechanism qualitatively but not predict precise outcomes. It may fit historical data but fail under changed conditions.

A scientific model should be interpreted with its validation domain attached. Without that domain, model outputs can travel farther than the evidence supports.

Back to top ↑

Uncertainty and Sensitivity in Scientific Models

Scientific uncertainty comes from measurement error, parameter uncertainty, input uncertainty, stochastic variation, structural uncertainty, numerical approximation, and future conditions. Sensitivity analysis asks which inputs, parameters, assumptions, or structures most affect model outputs.

Uncertainty is not a reason to abandon modeling. It is part of scientific evidence. A model that communicates uncertainty well can be more useful than one that presents false precision.

Sensitivity analysis helps scientists prioritize what matters. It can identify the most important measurements to improve, the assumptions most likely to change conclusions, and the conditions under which a model becomes fragile.

Back to top ↑

Major Model Families in Scientific Research

Science uses many model families. The choice depends on purpose, scale, available data, theoretical knowledge, uncertainty, computational constraints, and the nature of the phenomenon.

No model family is universally best. Scientific modeling requires matching model form to question, evidence, mechanism, and uncertainty.

Back to top ↑

Disciplinary Examples

Mathematical modeling appears across nearly every scientific discipline. The models differ in form, but they share a common function: making scientific reasoning explicit enough to test, compare, simulate, and revise.

Across these fields, the scientific value of modeling comes from disciplined fit between formal representation and empirical question.

Back to top ↑

Mathematical Lens: Scientific Models as Conditional Representations

A scientific model can be represented as a formal mapping from assumptions, states, parameters, and inputs to outputs:

Observed data can be related to model output through an observation process:

Calibration estimates parameters by comparing model outputs with observations:

Scientific uncertainty can be expressed as uncertainty in outputs induced by uncertainty in data, parameters, assumptions, and model form:

Model comparison asks whether competing representations explain or predict evidence differently:

The mathematical lesson is that scientific model outputs are conditional representations. They are meaningful only when their assumptions, data relation, parameters, model form, and domain of validity are understood.

Back to top ↑

Example: Modeling Population Growth Under Resource Limits

A simple example shows how mathematical modeling supports scientific reasoning. Suppose scientists observe a population growing in a bounded environment. A purely exponential model may fit early growth, but it may fail when resources become limiting. A logistic model represents growth slowing as population approaches carrying capacity.

The logistic model is useful not because it captures everything about real populations, but because it formalizes a mechanism: growth depends on both population size and resource limitation. The model clarifies what to measure, what to test, and where assumptions may fail.

Back to top ↑

Models, Experiments, and Scientific Decision Support

Scientific models often support decisions inside research practice. They help scientists decide which hypotheses to test, which variables to measure, which experiment to run, which mechanism to investigate, which data would reduce uncertainty, and which conclusion is justified by evidence.

These are scientific decisions, even when they are not public policy decisions. They shape the path of inquiry.

Models support scientific decision-making when they sharpen inquiry rather than prematurely settle it.

Back to top ↑

Ethical Stakes of Scientific Modeling

Scientific modeling has ethical stakes because scientific models can influence public knowledge, institutional decisions, environmental management, health guidance, technology development, risk perception, and policy. Even models used primarily for research may later travel into public decision-making.

Ethical scientific modeling requires transparency about assumptions, uncertainty, limits, data quality, funding or institutional context, reproducibility, and potential consequences of interpretation.

The ethical responsibility of scientific modeling is not to avoid uncertainty. It is to represent uncertainty honestly enough that scientific claims remain proportionate to evidence.

Back to top ↑

Python Workflow: Scientific Model Register and Evidence Review

The Python workflow below creates a scientific model register, simulates a logistic population model, records uncertainty and validation diagnostics, and writes a scientific evidence review card.

# mathematical_modeling_in_science_workflow.py
# Dependency-light workflow for scientific model evidence review.

from __future__ import annotations

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


ARTICLE_ROOT = Path(__file__).resolve().parents[1]
OUTPUTS = ARTICLE_ROOT / "outputs"
TABLES = OUTPUTS / "tables"
JSON_DIR = OUTPUTS / "json"


@dataclass(frozen=True)
class ScientificModelRecord:
    key: str
    scientific_domain: str
    model_role: str
    model_family: str
    evidence_question: str
    status: str


@dataclass(frozen=True)
class PopulationScenario:
    key: str
    growth_rate: float
    carrying_capacity: float
    initial_population: float
    years: int
    observation_noise: float


def scientific_model_register() -> list[ScientificModelRecord]:
    return [
        ScientificModelRecord(
            key="mechanism_model",
            scientific_domain="ecology",
            model_role="explanation",
            model_family="differential_equation",
            evidence_question="Can resource limitation explain observed slowing growth?",
            status="active",
        ),
        ScientificModelRecord(
            key="forecast_model",
            scientific_domain="population_science",
            model_role="prediction",
            model_family="dynamic_simulation",
            evidence_question="What range of population outcomes is plausible after ten years?",
            status="review",
        ),
        ScientificModelRecord(
            key="measurement_model",
            scientific_domain="field_science",
            model_role="observation",
            model_family="statistical_error_model",
            evidence_question="How does measurement noise affect interpretation?",
            status="review",
        ),
        ScientificModelRecord(
            key="comparison_model",
            scientific_domain="scientific_inference",
            model_role="model_comparison",
            model_family="evidence_table",
            evidence_question="Does a logistic model explain observations better than exponential growth?",
            status="review",
        ),
        ScientificModelRecord(
            key="uncertainty_model",
            scientific_domain="scientific_computing",
            model_role="uncertainty_quantification",
            model_family="sensitivity_analysis",
            evidence_question="Which assumptions most affect scientific conclusions?",
            status="review",
        ),
    ]


def population_scenarios() -> list[PopulationScenario]:
    return [
        PopulationScenario("baseline", 0.28, 500.0, 40.0, 20, 0.03),
        PopulationScenario("lower_growth", 0.18, 500.0, 40.0, 20, 0.03),
        PopulationScenario("higher_growth", 0.38, 500.0, 40.0, 20, 0.03),
        PopulationScenario("lower_capacity", 0.28, 350.0, 40.0, 20, 0.03),
        PopulationScenario("higher_capacity", 0.28, 700.0, 40.0, 20, 0.03),
    ]


def logistic_population(initial: float, growth_rate: float, carrying_capacity: float, years: int) -> list[dict[str, float]]:
    values: list[dict[str, float]] = []
    population = initial

    for year in range(years + 1):
        values.append({"year": float(year), "population": round(population, 8)})
        population = population + growth_rate * population * (1.0 - population / carrying_capacity)

    return values


def scenario_summary(scenario: PopulationScenario) -> dict[str, object]:
    trajectory = logistic_population(
        initial=scenario.initial_population,
        growth_rate=scenario.growth_rate,
        carrying_capacity=scenario.carrying_capacity,
        years=scenario.years,
    )
    final_population = trajectory[-1]["population"]
    midpoint = scenario.carrying_capacity / 2.0
    crosses_midpoint = any(point["population"] >= midpoint for point in trajectory)

    return {
        **asdict(scenario),
        "final_population": round(final_population, 8),
        "carrying_capacity_half": round(midpoint, 8),
        "crosses_capacity_midpoint": crosses_midpoint,
        "trajectory_points": len(trajectory),
    }


def scientific_priority(record: ScientificModelRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.model_role} {record.model_family} {record.evidence_question}".lower()
    for term in ["uncertainty", "measurement", "comparison", "prediction", "evidence", "mechanism"]:
        if term in text:
            score += 1.0
    return round(score, 3)


def evidence_summary(rows: list[dict[str, object]]) -> dict[str, object]:
    finals = [float(row["final_population"]) for row in rows]
    return {
        "mean_final_population": round(statistics.mean(finals), 8),
        "min_final_population": round(min(finals), 8),
        "max_final_population": round(max(finals), 8),
        "scenario_spread": round(max(finals) - min(finals), 8),
        "scenario_count": len(rows),
    }


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError(f"No rows supplied for {path}")
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8") as handle:
        json.dump(payload, handle, indent=2, sort_keys=True)


def main() -> None:
    records = scientific_model_register()
    scenarios = population_scenarios()

    register_rows = [
        {**asdict(record), "scientific_priority": scientific_priority(record)}
        for record in records
    ]

    scenario_rows = [scenario_summary(scenario) for scenario in scenarios]
    baseline_trajectory = logistic_population(40.0, 0.28, 500.0, 20)

    write_csv(TABLES / "scientific_model_register.csv", register_rows)
    write_csv(TABLES / "population_scenario_summary.csv", scenario_rows)
    write_csv(TABLES / "baseline_population_trajectory.csv", baseline_trajectory)

    write_json(JSON_DIR / "scientific_model_evidence_card.json", {
        "article": "Mathematical Modeling in Science",
        "evidence_summary": evidence_summary(scenario_rows),
        "scientific_model_register": register_rows,
        "scenario_summary": scenario_rows,
        "use_limit": "This workflow demonstrates scientific model interpretation; results are illustrative and should not be treated as empirical findings.",
        "diagnostic_checks": [
            "model purpose is stated",
            "scientific domain is named",
            "model family is identified",
            "scenario spread is reported",
            "measurement uncertainty is acknowledged",
            "validation and domain of validity remain explicit",
        ],
    })

    print("Scientific modeling workflow complete.")
    print(f"Evidence summary: {evidence_summary(scenario_rows)}")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow treats scientific modeling as evidence infrastructure. It records model purpose, scientific domain, model family, evidence question, uncertainty, scenario spread, and use limits.

Back to top ↑

R Workflow: Model Evidence Summary and Diagnostic Review

The R workflow below reviews generated scientific-model outputs, ranks scientific model records by priority, summarizes population scenarios, and creates a base R trajectory plot.

# mathematical_modeling_in_science_review.R
# Base R workflow for scientific model evidence review.

args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

register_path <- file.path(tables_dir, "scientific_model_register.csv")
scenario_path <- file.path(tables_dir, "population_scenario_summary.csv")
trajectory_path <- file.path(tables_dir, "baseline_population_trajectory.csv")

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

register <- read.csv(register_path, stringsAsFactors = FALSE)
scenarios <- read.csv(scenario_path, stringsAsFactors = FALSE)
trajectory <- read.csv(trajectory_path, stringsAsFactors = FALSE)

register$scientific_priority <- as.numeric(register$scientific_priority)
scenarios$final_population <- as.numeric(scenarios$final_population)
trajectory$year <- as.numeric(trajectory$year)
trajectory$population <- as.numeric(trajectory$population)

register <- register[order(-register$scientific_priority), ]

scenario_summary <- data.frame(
  mean_final_population = mean(scenarios$final_population),
  min_final_population = min(scenarios$final_population),
  max_final_population = max(scenarios$final_population),
  scenario_spread = max(scenarios$final_population) - min(scenarios$final_population),
  scenario_count = nrow(scenarios)
)

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

write.csv(
  scenario_summary,
  file.path(tables_dir, "r_population_scenario_summary.csv"),
  row.names = FALSE
)

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

plot(
  trajectory$year,
  trajectory$population,
  type = "l",
  xlab = "Year",
  ylab = "Population",
  main = "Baseline Logistic Population Trajectory"
)

dev.off()

print(register)
print(scenario_summary)

The R layer supports scientific review by preserving model roles, evidence questions, scenario spread, and baseline trajectory diagnostics.

Back to top ↑

Haskell Workflow: Typed Scientific Model Records

Haskell is useful here because scientific model roles should remain distinct. Explanation is not prediction. Measurement is not mechanism. Calibration is not validation. Simulation is not direct observation.

{-# OPTIONS_GHC -Wall #-}

module Main where

data ScientificDomain
  = Physics
  | Chemistry
  | Biology
  | Ecology
  | EarthSystems
  | Epidemiology
  | ScientificComputing
  deriving (Eq, Show)

data ModelRole
  = Explanation
  | Prediction
  | Measurement
  | Simulation
  | ModelComparison
  | UncertaintyQuantification
  deriving (Eq, Show)

data ModelFamily
  = Algebraic
  | DifferentialEquation
  | Statistical
  | Stochastic
  | Network
  | Spatial
  | Computational
  deriving (Eq, Show)

data ReviewStatus
  = Active
  | RequiresReview
  | RequiresValidation
  | RequiresUncertaintyReview
  | Revise
  deriving (Eq, Show)

data ScientificModelRecord = ScientificModelRecord
  { key :: String
  , domain :: ScientificDomain
  , role :: ModelRole
  , family :: ModelFamily
  , evidenceQuestion :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

scientificRegister :: [ScientificModelRecord]
scientificRegister =
  [ ScientificModelRecord
      "mechanism_model"
      Ecology
      Explanation
      DifferentialEquation
      "Can resource limitation explain observed slowing growth?"
      Active
  , ScientificModelRecord
      "forecast_model"
      Biology
      Prediction
      Computational
      "What range of population outcomes is plausible after ten years?"
      RequiresUncertaintyReview
  , ScientificModelRecord
      "measurement_model"
      ScientificComputing
      Measurement
      Statistical
      "How does measurement noise affect interpretation?"
      RequiresReview
  , ScientificModelRecord
      "comparison_model"
      ScientificComputing
      ModelComparison
      Statistical
      "Does a logistic model explain observations better than exponential growth?"
      RequiresValidation
  ]

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

main :: IO ()
main = do
  putStrLn "Typed scientific model records:"
  mapM_ print scientificRegister

  putStrLn "\nScientific model records requiring review:"
  mapM_ print (filter needsReview scientificRegister)

This typed layer supports scientific modeling governance by keeping domains, model roles, model families, evidence questions, and review obligations distinct.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It contains article-specific code, data, documentation, notebooks, schemas, and generated outputs for scientific model registers, population growth simulation, evidence review, scenario summaries, uncertainty notes, typed Haskell scientific model records, and responsible scientific modeling workflows.

Back to top ↑

A Practical Method for Mathematical Modeling in Science

Scientific modeling should be structured enough to support review, revision, and reproducibility. The goal is not only to produce a result, but to make the scientific reasoning behind the result inspectable.

This method keeps scientific models connected to inquiry rather than detached from evidence. It also makes model claims easier to revise when better observations, theories, or methods become available.

Back to top ↑

Common Pitfalls

Scientific modeling can fail when models are treated as more complete, precise, or general than they are. Many failures come not from modeling itself, but from overinterpretation.

• Confusing model with reality: treating a representation as if it captured the whole system.
• Unclear purpose: using an explanatory model as if it were a validated forecasting model.
• Hidden idealization: failing to communicate simplifying assumptions.
• Calibration as validation: treating fit to known data as proof of scientific adequacy.
• Ignoring measurement error: assuming observations are exact and directly comparable to model variables.
• Overlooking structural uncertainty: varying parameters while ignoring alternative mechanisms or model forms.
• No domain of validity: allowing the model to be used beyond the conditions where it was tested.
• Irreproducible workflow: producing scientific claims without accessible code, data, assumptions, or versioning.
• False precision: reporting exact-looking outputs without uncertainty or sensitivity.
• Weak communication: failing to distinguish what the model shows from what remains uncertain.

These pitfalls can be reduced through model documentation, uncertainty analysis, validation, reproducibility, comparison with alternatives, and careful communication of scope and limits.

Back to top ↑

Conclusion: Scientific Models Make Inquiry More Explicit

Mathematical modeling is central to scientific inquiry because it makes theory, evidence, mechanism, uncertainty, and prediction more explicit. Scientific models help researchers ask sharper questions, compare explanations, design experiments, simulate complex processes, and reason about what cannot be directly observed.

But models do not replace scientific judgment. They depend on abstraction, assumptions, data, calibration, validation, uncertainty analysis, and interpretation. Their credibility comes from the discipline with which those dependencies are made visible.

A strong scientific model does not claim to be the world. It shows how selected features of the world can be represented, tested, compared, and revised. It makes inquiry more transparent.

Used responsibly, mathematical modeling helps science move between observation and explanation without pretending that uncertainty has disappeared. That is why modeling remains one of the most important tools for understanding complex natural systems.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• The Modeling Process: From World to Formal Representation
• Abstraction and Representation in Mathematical Models
• Assumptions, Simplification, and Model Design
• Calibration, Estimation, and Parameter Fitting
• Validation and Model Assessment
• Simulation and Computational Modeling
• Uncertainty in Mathematical Models
• Communicating Model Uncertainty
• Mathematical Modeling in Engineering

Back to top ↑

Further Reading

• Beven, K. (2009) Environmental Modelling: An Uncertain Future? London: Routledge.
• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press.
• 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.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Levins, R. (1966) ‘The strategy of model building in population biology’, American Scientist, 54(4), pp. 421–431.
• Morgan, M.S. and Morrison, M. (eds.) (1999) Models as Mediators: Perspectives on Natural and Social Science. Cambridge: Cambridge University Press.
• Weisberg, M. (2013) Simulation and Similarity: Using Models to Understand the World. Oxford: Oxford University Press.
• Humphreys, P. (2004) Extending Ourselves: Computational Science, Empiricism, and Scientific Method. Oxford: Oxford University Press.

Back to top ↑

References

• Beven, K. (2009) Environmental Modelling: An Uncertain Future? London: Routledge.
• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley.
• Humphreys, P. (2004) Extending Ourselves: Computational Science, Empiricism, and Scientific Method. Oxford: Oxford University Press.
• Levins, R. (1966) ‘The strategy of model building in population biology’, American Scientist, 54(4), pp. 421–431.
• Morgan, M.S. and Morrison, M. (eds.) (1999) Models as Mediators: Perspectives on Natural and Social Science. Cambridge: Cambridge University Press.
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press.
• 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.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley.
• Weisberg, M. (2013) Simulation and Similarity: Using Models to Understand the World. Oxford: Oxford University Press.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press.

Back to top ↑