What Is Mathematical Modeling? How Formal Models Translate Reality Into Structure

Last Updated June 11, 2026

Mathematical modeling is the disciplined translation of real-world phenomena into formal representations that can be examined, tested, simulated, interpreted, and revised. A model may use equations, inequalities, functions, probability distributions, algorithms, graphs, optimization routines, numerical methods, or computational simulations. What makes it a mathematical model is not merely the presence of symbols. It is the act of representing a situation through quantities, relationships, assumptions, constraints, and logical structure.

A mathematical model is not reality itself. It is a selective representation built for a purpose. It chooses what to include, what to simplify, what to ignore, what to measure, what to hold constant, and what relationships to make explicit. This selectivity is not a weakness. It is what allows a model to clarify a question, reveal structure, compare scenarios, estimate consequences, identify trade-offs, and support responsible decisions.

This article introduces mathematical modeling as a process rather than a single technique. It explains why models are built, how they simplify, what components they usually contain, how mathematical structure connects to evidence and computation, and why uncertainty and responsibility must be part of modeling practice from the beginning. Later articles in this series examine abstraction, assumptions, variables, functional relationships, differential equations, stochastic models, optimization, simulation, calibration, validation, sensitivity analysis, uncertainty, applications, ethics, and model governance.

Why Mathematical Modeling Matters

Mathematical modeling matters because many important questions cannot be answered by observation alone. A scientist may need to understand how a biological population changes over time. An engineer may need to predict whether a structure will remain safe under stress. A public health team may need to compare intervention scenarios before a disease spreads further. A city may need to estimate flood risk under different infrastructure choices. A climate analyst may need to explore long-term pathways under uncertain emissions, land use, and technological change.

In each case, direct experimentation may be impossible, expensive, unethical, incomplete, or too slow. Mathematical modeling offers a disciplined way to reason about such questions before all outcomes are known. It allows analysts to represent mechanisms, test assumptions, compare alternatives, evaluate constraints, and explore consequences under controlled formal conditions.

Models also matter because they make reasoning inspectable. A vague claim can be difficult to challenge. A model, by contrast, can be examined. Its variables can be questioned. Its assumptions can be listed. Its parameters can be estimated. Its outputs can be compared with data. Its uncertainty can be tested. Its conclusions can be revised. The model gives thought a structure that can be shared, criticized, and improved.

Mathematical modeling is therefore not limited to mathematics classrooms. It is a central practice in applied mathematics, physics, biology, chemistry, environmental science, economics, public health, engineering, artificial intelligence, operations research, risk analysis, and policy design. Wherever structured reasoning must connect evidence, abstraction, computation, and decision-making, modeling becomes important.

Back to top ↑

What Mathematical Modeling Means

Mathematical modeling is the process of constructing a formal representation of selected features of a real, imagined, experimental, or conceptual system so that the system can be reasoned about mathematically. The model may describe physical motion, disease spread, market behavior, ecological change, energy demand, transportation flow, machine learning prediction, material stress, climate dynamics, or institutional capacity.

A useful working definition is:

This definition separates modeling from mere calculation. A calculation answers a defined numerical question. A model helps define the structure of the question itself. It asks what should be represented, what can be simplified, which variables matter, which assumptions are acceptable, which relationships are plausible, which outputs are meaningful, and how results should be judged.

For example, computing the area of a rectangle is a calculation. Modeling the spread of a wildfire, the reliability of an aircraft component, the stability of an electrical grid, the growth of a tumor, or the effect of a policy intervention requires a formal representation of interacting quantities, assumptions, mechanisms, constraints, uncertainty, and evidence.

Mathematical modeling is also iterative. The first model is rarely the final model. As the model is analyzed, compared with data, tested under scenarios, reviewed by experts, or interpreted for decision-making, weaknesses become visible. The model is then revised. This cycle of formulation, analysis, assessment, and revision is central to modeling practice.

Back to top ↑

Models Are Not Reality

A mathematical model is not the system it represents. It is a formal lens. The lens may be useful for one purpose and inadequate for another. A traffic model may estimate congestion under alternative road designs, but it may not capture the lived experience of commuting. A climate model may represent atmospheric and oceanic processes, but it still depends on scenario assumptions about emissions, land use, policy, and technology. A public health model may clarify intervention timing, but it cannot remove ethical judgment from public decisions.

Every model simplifies. It may treat space as a grid, people as agents, material as continuous, uncertainty as a distribution, behavior as rational, demand as elastic, time as discrete, or the system boundary as fixed. These simplifications make analysis possible, but they also define the limits of what the model can say.

Good modeling does not pretend that simplification is neutral. It documents simplification. It explains why a boundary was chosen, why a variable was included, why a relationship was assumed, why a parameter was fixed, and why a particular output matters. A model becomes more credible when its limits are visible.

This is one reason mathematical modeling requires judgment. The technical structure of a model is inseparable from choices about purpose, evidence, scale, audience, and use. A model that is mathematically elegant but poorly matched to its question may be less useful than a simpler model whose assumptions are transparent and whose purpose is clear.

Back to top ↑

The Modeling Cycle

Mathematical modeling is best understood as a cycle of inquiry. The modeler begins with a question, abstracts the situation, formulates mathematical relationships, analyzes or simulates the model, compares results with evidence or expectations, interprets the findings, and revises the model. The cycle may repeat many times.

The cycle is not always linear. A modeler may discover during simulation that a time step is too large. A comparison with data may reveal that a parameter cannot be estimated reliably. A stakeholder may explain that the output does not answer the decision question. A units check may expose a structural error. A sensitivity analysis may show that the model’s main conclusion depends almost entirely on one uncertain assumption.

This iterative quality is one of the strengths of mathematical modeling. The model becomes a disciplined workspace where assumptions, evidence, structure, and interpretation can be examined together.

Back to top ↑

Core Components of a Mathematical Model

Mathematical models vary widely, but most include several recognizable components. These components help distinguish a model from a loose analogy, diagram, or informal explanation.

These components are interdependent. Changing a model boundary may require new variables. Changing an assumption may alter the mathematical relationship. Changing the purpose may alter the output. Changing the available data may alter which parameters can be estimated. Model design is therefore an integrated process rather than a checklist of separate technical decisions.

Back to top ↑

Model Purpose: Explanation, Prediction, Simulation, Optimization, and Decision Support

The structure of a mathematical model should depend on its purpose. A model designed to explain a mechanism may differ from a model designed to forecast near-term outcomes. A model designed to optimize a design may differ from a model designed to compare policy scenarios. A model designed for education may simplify aggressively. A model designed for safety-critical engineering may require extensive verification, validation, uncertainty quantification, documentation, and review.

Problems arise when a model built for one purpose is used as if it served another. A simplified teaching model may not be adequate for public policy. A short-term forecasting model may not explain mechanism. A model calibrated to historical data may fail under structural change. A model that optimizes a narrow objective may ignore values, harms, or constraints that were never represented in the formal structure.

The responsible question is not only whether a model is correct. It is whether the model is adequate for a specific purpose, under stated assumptions, with known limitations, and with consequences understood if the model is wrong.

Back to top ↑

Mathematical Representation and Formal Structure

Mathematical representation is the act of turning a situation into quantities and relationships. The same situation can be represented in different ways depending on the modeling purpose. A transportation system may be represented as a network, a queue, a flow model, an optimization problem, an agent-based simulation, or a set of differential equations. Each representation reveals different features.

Choosing a representation is a modeling decision. It determines which questions become easy to ask, which become difficult, and which disappear from view. Mathematical skill is needed to work within a representation, but judgment is needed to choose the representation in the first place.

Back to top ↑

Mathematical Lens: A Model as a Structured Representation

One way to understand a mathematical model is to treat it as a structured representation of a question. The model connects purpose, boundary, assumptions, variables, parameters, relationships, constraints, evidence, and interpretation.

This schematic notation is not a universal formula. It is a reminder that a model is more than a mathematical expression. A model includes a purpose, a boundary, assumptions, formal structure, evidence, and interpretation. If any one of these is weak, the model’s usefulness is limited.

A compact model may express an output \(y\) as a function of input \(x\) and parameters \(\theta\):

Mathematical modeling begins when these choices are made explicit.

Back to top ↑

A Simple Example: Modeling Change Over Time

Consider a quantity that changes over time. The quantity might represent population, temperature, inventory, capital, pollutant concentration, disease prevalence, battery charge, or stored water. A model begins by naming the state variable:

A simple continuous-time model might state that the rate of change of \(x\) is proportional to its current value:

This model is simple, but its assumptions are strong. It assumes that the proportional rate of change remains constant and that no resource limits, feedback effects, external shocks, or structural changes alter the process.

A more constrained model might include a carrying capacity \(K\):

In a discrete-time setting, the same general idea might be written as:

The modeling lesson is that mathematical form is not neutral. Exponential growth, logistic growth, and discrete simulation encode different assumptions about mechanism, limits, and time. Choosing among them is a modeling decision, not merely a technical preference.

Back to top ↑

Assessment, Validation, and Adequacy

Model assessment asks whether a model is adequate for its intended purpose. This is different from asking whether the model is universally true. No model captures everything. A model may be adequate for rough scenario comparison but inadequate for safety-critical design. It may be useful for teaching but inadequate for forecasting. It may match historical data but fail under new conditions.

Assessment usually includes several distinct activities:

A model can pass one assessment and fail another. Code may be verified while the model structure is inappropriate. Parameters may fit data while the model overfits noise. A forecast may be accurate in ordinary conditions but fragile under regime change. Responsible modeling treats assessment as a set of purpose-specific questions, not as a single stamp of correctness.

Back to top ↑

Uncertainty and Sensitivity

Uncertainty is not an afterthought in mathematical modeling. It is part of the model’s meaning. Inputs may be uncertain. Measurements may contain error. Parameters may be estimated imperfectly. The mathematical structure may be wrong. Future scenarios may be unknown. Human behavior may change. Boundary choices may exclude important influences. Numerical methods may introduce approximation error.

Sensitivity analysis asks how conclusions change when uncertain inputs, parameters, assumptions, or structures change. It helps identify which features matter most. A model conclusion that remains stable across plausible assumptions is more robust than one that collapses when a single uncertain parameter changes slightly.

Uncertainty should be communicated carefully. A single number may be easy to understand, but it can hide the range of plausible outcomes. A responsible model often reports intervals, scenarios, assumptions, diagnostics, and limitations alongside central estimates.

Back to top ↑

Applications Across Science, Engineering, Policy, and Complex Systems

Mathematical modeling appears wherever people need structured reasoning about systems, change, uncertainty, and decisions. The same broad modeling logic appears across many domains, even when the mathematical forms differ.

These domains use different mathematical tools, but they share a common challenge: how to represent a complex situation in a formal way that is useful, transparent, and fit for purpose.

Back to top ↑

Mathematics, Computation, and Modeling

Modern mathematical modeling often combines analytic reasoning with computation. Some models can be solved exactly. Many cannot. Computational modeling allows analysts to approximate solutions, simulate behavior, compare scenarios, propagate uncertainty, estimate parameters, and visualize results.

A simple computational modeling workflow can be represented as:

For mathematicians and engineers, strong computational modeling practice may include symbolic derivation, dimensional checks, nondimensionalization, numerical stability analysis, solver comparison, parameter sweeps, residual diagnostics, convergence tests, uncertainty propagation, and reproducible notebooks.

Computation does not make a model automatically more credible. It can make a weak model look sophisticated. The purpose of computation is to make the model more inspectable, testable, and useful, not to hide judgment behind technical complexity.

Back to top ↑

Python Workflow: Building and Testing a Simple Mathematical Model

The Python workflow below implements a simple logistic growth model, compares scenarios, writes outputs, and performs a basic sensitivity check. It is intentionally dependency-light and designed for a companion repository folder such as articles/what-is-mathematical-modeling/python/.

# what_is_mathematical_modeling_workflow.py
# Dependency-light mathematical modeling workflow:
# formulation, simulation, scenario comparison, and sensitivity testing.

from __future__ import annotations

from dataclasses import dataclass, replace
from pathlib import Path
import csv
from statistics import mean

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


@dataclass(frozen=True)
class LogisticModel:
    name: str
    initial_state: float
    growth_rate: float
    carrying_capacity: float
    time_step: float
    steps: int


def validate_model(model: LogisticModel) -> None:
    if model.initial_state < 0:
        raise ValueError("initial_state must be nonnegative.")
    if model.carrying_capacity <= 0:
        raise ValueError("carrying_capacity must be positive.")
    if model.time_step <= 0:
        raise ValueError("time_step must be positive.")
    if model.steps < 1:
        raise ValueError("steps must be at least 1.")


def simulate(model: LogisticModel) -> list[dict[str, float | str | int]]:
    validate_model(model)

    x = float(model.initial_state)
    rows: list[dict[str, float | str | int]] = []

    for step in range(model.steps + 1):
        time = step * model.time_step

        rows.append({
            "scenario": model.name,
            "step": step,
            "time": round(time, 6),
            "state": round(x, 6),
            "growth_rate": model.growth_rate,
            "carrying_capacity": model.carrying_capacity,
        })

        dxdt = model.growth_rate * x * (1.0 - x / model.carrying_capacity)
        x = x + dxdt * model.time_step

    return rows


def summarize(rows: list[dict[str, float | str | int]]) -> dict[str, float | str]:
    final_row = rows[-1]
    states = [float(row["state"]) for row in rows]

    return {
        "scenario": str(final_row["scenario"]),
        "final_state": round(float(final_row["state"]), 6),
        "mean_state": round(mean(states), 6),
        "min_state": round(min(states), 6),
        "max_state": round(max(states), 6),
    }


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        raise ValueError("No rows supplied.")

    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 run_scenarios() -> None:
    base = LogisticModel(
        name="baseline",
        initial_state=10.0,
        growth_rate=0.35,
        carrying_capacity=100.0,
        time_step=0.1,
        steps=200,
    )

    scenarios = [
        base,
        replace(base, name="low_growth", growth_rate=0.20),
        replace(base, name="high_growth", growth_rate=0.50),
        replace(base, name="lower_capacity", carrying_capacity=70.0),
        replace(base, name="higher_capacity", carrying_capacity=140.0),
    ]

    all_rows: list[dict[str, object]] = []
    summary_rows: list[dict[str, object]] = []

    for scenario in scenarios:
        rows = simulate(scenario)
        all_rows.extend(rows)
        summary_rows.append(summarize(rows))

    write_csv(TABLES / "logistic_growth_timeseries.csv", all_rows)
    write_csv(TABLES / "logistic_growth_summary.csv", summary_rows)

    print("Mathematical modeling workflow complete.")
    print(TABLES / "logistic_growth_timeseries.csv")
    print(TABLES / "logistic_growth_summary.csv")


if __name__ == "__main__":
    run_scenarios()

This workflow is simple enough to inspect but still expresses core modeling ideas: state variables, parameters, assumptions, scenario comparison, outputs, and diagnostics. A more advanced engineering version could add solver comparisons, nondimensionalization, tolerance checks, uncertainty propagation, and automated tests.

Back to top ↑

R Workflow: Scenario Comparison and Diagnostic Summary

The R workflow below reads the Python-generated outputs, summarizes scenario behavior, and creates basic visualizations. It uses base R so that the workflow remains portable across simple environments.

# what_is_mathematical_modeling_diagnostics.R
# Base R workflow for scenario comparison and modeling diagnostics.

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")

if (!dir.exists(tables_dir)) {
  dir.create(tables_dir, recursive = TRUE)
}

if (!dir.exists(figures_dir)) {
  dir.create(figures_dir, recursive = TRUE)
}

timeseries_path <- file.path(tables_dir, "logistic_growth_timeseries.csv")
summary_path <- file.path(tables_dir, "logistic_growth_summary.csv")

if (!file.exists(timeseries_path)) {
  stop(paste("Missing", timeseries_path, "Run the Python workflow first."))
}

data <- read.csv(timeseries_path, stringsAsFactors = FALSE)

scenario_summary <- aggregate(
  state ~ scenario,
  data = data,
  FUN = function(x) c(
    final = tail(x, 1),
    mean = mean(x),
    min = min(x),
    max = max(x)
  )
)

scenario_summary <- do.call(data.frame, scenario_summary)
names(scenario_summary) <- c(
  "scenario",
  "final_state",
  "mean_state",
  "min_state",
  "max_state"
)

write.csv(
  scenario_summary,
  summary_path,
  row.names = FALSE
)

png(file.path(figures_dir, "logistic_growth_scenarios.png"), width = 1200, height = 700)

plot(
  NA,
  xlim = range(data$time),
  ylim = range(data$state),
  xlab = "Time",
  ylab = "State",
  main = "Logistic Growth Scenario Comparison"
)

for (scenario_name in unique(data$scenario)) {
  subset_data <- data[data$scenario == scenario_name, ]
  lines(subset_data$time, subset_data$state, lwd = 2)
}

legend(
  "bottomright",
  legend = unique(data$scenario),
  lwd = 2,
  cex = 0.8,
  bty = "n"
)

grid()
dev.off()

print(scenario_summary)

The R workflow supports the article’s methodological point: a mathematical model should not produce only one answer. It should help compare assumptions, examine outputs, detect sensitivity, and support interpretation.

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 formal model design, bounded-growth simulation, scenario comparison, calibration, residual diagnostics, sensitivity analysis, uncertainty propagation, validation notes, and multi-language computational modeling workflows.

Back to top ↑

A Practical Method for Starting a Mathematical Model

A mathematical model should begin with disciplined framing. The method below can be used before choosing equations or writing code.

This method helps prevent a common modeling error: beginning with an equation before understanding the question. Equations matter, but model purpose comes first.

Back to top ↑

Common Pitfalls

Mathematical models can mislead when their formality is mistaken for certainty. The most common failures are not only technical. They are failures of framing, interpretation, documentation, and use.

• Equation-first modeling: choosing a familiar equation before defining the modeling purpose.
• Hidden assumptions: treating assumptions as minor footnotes rather than part of model architecture.
• Boundary blindness: ignoring what the model excludes or externalizes.
• False precision: reporting exact-looking outputs when uncertainty is large.
• Overfitting: matching observed data closely while losing general usefulness.
• Underfitting: simplifying so much that important structure disappears.
• Unit inconsistency: combining quantities in ways that are dimensionally invalid.
• Calibration without validation: assuming parameter fit proves model adequacy.
• Single-scenario thinking: relying on one baseline rather than comparing plausible alternatives.
• Model-as-decision fallacy: treating model output as if it replaces human judgment, ethics, or institutional responsibility.

These pitfalls do not mean models should be avoided. They mean models should be built, tested, documented, and communicated with care.

Back to top ↑

Why Mathematical Modeling Requires Judgment

Mathematical modeling is powerful because it makes selected features of a situation formal enough to analyze. It can reveal structure, test assumptions, compare scenarios, estimate consequences, optimize choices, and support decisions under uncertainty. But the same power can mislead when models hide assumptions, exclude important realities, overstate certainty, or shift responsibility from people to technical systems.

A model is useful when it is fit for purpose. That means the question is clear, the boundary is justified, the assumptions are visible, the variables and parameters are meaningful, the mathematical structure is appropriate, the computation is checked, the uncertainty is communicated, and the interpretation remains connected to the real-world context.

The most responsible modelers do not ask only, “Can this be modeled?” They ask, “What is the model for? What does it clarify? What does it hide? What evidence supports it? How uncertain is it? Who will use it? What happens if it is wrong?”

Mathematical modeling is therefore both technical and interpretive. It belongs to mathematics, engineering, science, computation, and decision-making. It also belongs to responsible public reasoning. A model does not replace judgment. At its best, it disciplines judgment by making assumptions, relationships, evidence, and uncertainty visible.

Back to top ↑

Related Articles

• The Modeling Process: From World to Formal Representation
• Abstraction and Representation in Mathematical Models
• Assumptions, Simplification, and Model Design
• Variables, Parameters, and Constraints
• Functional Relationships and Mathematical Structure
• Differential Equations and Dynamic Models
• Simulation and Computational Modeling
• Validation and Model Assessment

Back to top ↑

Further Reading

• Garfunkel, S. and Montgomery, M. (eds.) (2019) GAIMME: Guidelines for Assessment and Instruction in Mathematical Modeling Education. 2nd edn. Philadelphia: Society for Industrial and Applied Mathematics. Available at: https://www.siam.org/publications/reports/guidelines-for-assessment-and-instruction-in-mathematical-modeling-education/
• COMAP (n.d.) Mathematical Modeling Handbook. Consortium for Mathematics and Its Applications. Available at: https://www.comap.com/membership/member-resources/item/mathematical-modeling-handbook
• National Research Council (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: National Academies Press. Available at: https://doi.org/10.17226/13395
• NASA (2024) NASA-STD-7009B: Standard for Models and Simulations. Washington, DC: National Aeronautics and Space Administration. Available at: https://standards.nasa.gov/sites/default/files/standards/NASA/B/1/NASA-STD-7009B-Final-3-5-2024.pdf
• U.S. Environmental Protection Agency (2009) Guidance on the Development, Evaluation, and Application of Environmental Models. Washington, DC: EPA. Available at: https://www.epa.gov/measurements-modeling/guidance-development-evaluation-and-application-environmental-models
• ASME (n.d.) Verification, Validation and Uncertainty Quantification Standards. American Society of Mechanical Engineers. Available at: https://www.asme.org/codes-standards/publications-information/verification-validation-uncertainty
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/verification-and-validation-in-scientific-computing/05CA1F8F3CCB5AE5445FDF55239A0183
• 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. Available at: https://doi.org/10.1002/9780470725184
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia: Society for Industrial and Applied Mathematics. Available at: https://doi.org/10.1137/1.9780898718027
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer. Available at: https://doi.org/10.1007/b98885
• Tarantola, A. (2005) Inverse Problem Theory and Methods for Model Parameter Estimation. Philadelphia: Society for Industrial and Applied Mathematics. Available at: https://doi.org/10.1137/1.9780898717921
• Aster, R.C., Borchers, B. and Thurber, C.H. (2019) Parameter Estimation and Inverse Problems. 3rd edn. Amsterdam: Elsevier. Available at: https://www.elsevier.com/books/parameter-estimation-and-inverse-problems/aster/978-0-12-804651-7
• Banks, H.T. and Tran, H.T. (2009) Mathematical and Experimental Modeling of Physical and Biological Processes. Boca Raton: CRC Press. Available at: https://doi.org/10.1201/9781420073386
• Murray, J.D. (2002) Mathematical Biology I: An Introduction. 3rd edn. New York: Springer. Available at: https://doi.org/10.1007/b98868
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.

Back to top ↑

References

• Aster, R.C., Borchers, B. and Thurber, C.H. (2019) Parameter Estimation and Inverse Problems. 3rd edn. Amsterdam: Elsevier. Available at: https://www.elsevier.com/books/parameter-estimation-and-inverse-problems/aster/978-0-12-804651-7
• ASME (n.d.) Verification, Validation and Uncertainty Quantification Standards. New York: American Society of Mechanical Engineers. Available at: https://www.asme.org/codes-standards/publications-information/verification-validation-uncertainty
• Banks, H.T. and Tran, H.T. (2009) Mathematical and Experimental Modeling of Physical and Biological Processes. Boca Raton: CRC Press. Available at: https://doi.org/10.1201/9781420073386
• Box, G.E.P. (1976) ‘Science and statistics’, Journal of the American Statistical Association, 71(356), pp. 791–799. Available at: https://doi.org/10.1080/01621459.1976.10480949
• COMAP (n.d.) Mathematical Modeling Handbook. Bedford, MA: Consortium for Mathematics and Its Applications. Available at: https://www.comap.com/membership/member-resources/item/mathematical-modeling-handbook
• Epstein, J.M. (2008) ‘Why model?’, Journal of Artificial Societies and Social Simulation, 11(4), 12. Available at: https://www.jasss.org/11/4/12.html
• Garfunkel, S. and Montgomery, M. (eds.) (2019) GAIMME: Guidelines for Assessment and Instruction in Mathematical Modeling Education. 2nd edn. Philadelphia: Society for Industrial and Applied Mathematics. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611975741
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia: Society for Industrial and Applied Mathematics. Available at: https://doi.org/10.1137/1.9780898718027
• Morgan, M.G. and Henrion, M. (1990) Uncertainty: A Guide to Dealing with Uncertainty in Quantitative Risk and Policy Analysis. Cambridge: Cambridge University Press.
• Murray, J.D. (2002) Mathematical Biology I: An Introduction. 3rd edn. New York: Springer. Available at: https://doi.org/10.1007/b98868
• NASA (2024) NASA-STD-7009B: Standard for Models and Simulations. Washington, DC: National Aeronautics and Space Administration. Available at: https://standards.nasa.gov/sites/default/files/standards/NASA/B/1/NASA-STD-7009B-Final-3-5-2024.pdf
• National Research Council (2012) Assessing the Reliability of Complex Models: Mathematical and Statistical Foundations of Verification, Validation, and Uncertainty Quantification. Washington, DC: National Academies Press. Available at: https://doi.org/10.17226/13395
• NIST (2020) A Summary of Industrial Verification, Validation, and Uncertainty Quantification Procedures in Computational Fluid Dynamics. Gaithersburg, MD: National Institute of Standards and Technology. Available at: https://nvlpubs.nist.gov/nistpubs/ir/2020/NIST.IR.8298.pdf
• Oberkampf, W.L. and Roy, C.J. (2010) Verification and Validation in Scientific Computing. Cambridge: Cambridge University Press. Available at: https://www.cambridge.org/core/books/verification-and-validation-in-scientific-computing/05CA1F8F3CCB5AE5445FDF55239A0183
• Quarteroni, A., Sacco, R. and Saleri, F. (2007) Numerical Mathematics. 2nd edn. Berlin: Springer. Available at: https://doi.org/10.1007/b98885
• 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. Available at: https://doi.org/10.1002/9780470725184
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill.
• Tarantola, A. (2005) Inverse Problem Theory and Methods for Model Parameter Estimation. Philadelphia: Society for Industrial and Applied Mathematics. Available at: https://doi.org/10.1137/1.9780898717921
• U.S. Environmental Protection Agency (2009) Guidance on the Development, Evaluation, and Application of Environmental Models. Washington, DC: EPA. Available at: https://www.epa.gov/measurements-modeling/guidance-development-evaluation-and-application-environmental-models
• Yeo, D.H. (2020) A Summary of Industrial Verification, Validation, and Uncertainty Quantification Procedures in Computational Fluid Dynamics. NIST IR 8298. Gaithersburg, MD: National Institute of Standards and Technology. Available at: https://doi.org/10.6028/NIST.IR.8298

Back to top ↑