Probabilistic and Stochastic Models: How Mathematical Models Represent Uncertainty

Last Updated June 12, 2026

Probabilistic and stochastic models represent uncertainty, randomness, variability, and incomplete knowledge within mathematical modeling. Instead of treating every quantity as fixed or perfectly known, they describe outcomes through probability distributions, random variables, stochastic processes, transition probabilities, noise terms, Bayesian updating, Monte Carlo simulation, and risk measures.

Many real systems cannot be modeled responsibly with a single deterministic value. Future demand is uncertain. Measurements contain error. Populations vary. Weather fluctuates. Financial returns move unpredictably. Disease transmission depends on chance contacts. Infrastructure failures occur under uncertain stress. Human decisions introduce variability. Probabilistic modeling provides a disciplined way to represent such uncertainty rather than hiding it behind a single forecast.

Stochastic models go further by making randomness part of the model’s structure. A stochastic model does not merely report uncertainty after the fact; it describes how random variation enters the system, how it propagates, and how it changes interpretation. This is essential for risk modeling, forecasting, simulation, inference, decision analysis, and responsible communication.

Probabilistic modeling is not a weaker form of modeling. It is often more honest. A model that reports only a single value may look precise while concealing uncertainty. A probabilistic model can show ranges, likelihoods, tails, dependence, variability, and risk. The result is not less rigorous; it is more explicit about what is known, what is uncertain, and what conclusions depend on assumptions.

Why Probabilistic Models Matter

Probabilistic models matter because uncertainty is not an inconvenience added after modeling. It is often central to the system being modeled. Observations are noisy. Future conditions are unknown. Parameters are estimated imperfectly. Outcomes vary across individuals, locations, and time. Decision-makers must act under uncertainty rather than wait for certainty.

A deterministic model may say that demand will be 1,000 units, a bridge will remain safe, a disease will infect 20 percent of a population, or a policy will save a certain amount. A probabilistic model asks how likely different outcomes are, how uncertain the estimate is, and what happens in the tails of the distribution.

Probabilistic models do not eliminate uncertainty. They organize it. They make uncertainty visible enough to reason about, test, communicate, and use in decisions.

Back to top ↑

Probabilistic Models Versus Deterministic Models

A deterministic model gives the same output whenever the same inputs and parameters are used. A probabilistic model represents one or more quantities as uncertain, random, or distributed. A stochastic model includes randomness inside the process itself.

The difference is interpretive. In a deterministic model, a result is a value. In a probabilistic model, a result is a distribution, a probability, an interval, a risk measure, or a set of possible outcomes with likelihoods.

Deterministic models remain valuable. They can be clearer, easier to analyze, and appropriate when uncertainty is small or not central to the question. Probabilistic models are needed when uncertainty changes conclusions, decisions, or responsibility.

Back to top ↑

Random Variables and Distributions

A random variable is a quantity whose value is uncertain. It may represent measurement error, future demand, random failure time, individual response, environmental variability, or uncertain model output.

A probability distribution describes possible values and their probabilities. Distributions may be discrete or continuous. They may represent counts, proportions, durations, errors, magnitudes, categories, or events.

Choosing a distribution is a modeling decision. It should be justified by data, theory, mechanism, constraints, or intended use. A distribution is not merely a convenient curve; it encodes assumptions about support, symmetry, tails, discreteness, and variation.

Back to top ↑

Expectation, Variance, and Risk Measures

Probabilistic models often summarize uncertainty using expectation, variance, quantiles, probability of exceedance, and tail risk. These summaries help interpret distributions, but each highlights different features.

The expected value is not the same as the most likely outcome. It may not even be a possible outcome. For decision support, expected value should often be paired with uncertainty intervals, risk thresholds, and tail probabilities.

Good probabilistic communication rarely relies on one summary. A model may have a reassuring average while carrying unacceptable tail risk. Responsible modeling asks which part of the distribution matters for the decision.

Back to top ↑

Conditional Probability and Updating

Conditional probability describes how the probability of one event changes when another event or piece of evidence is known.

Conditional reasoning is central to diagnosis, forecasting, inference, risk assessment, filtering, and Bayesian updating. Evidence changes what is plausible.

Conditional probability can clarify evidence, but it can also be miscommunicated. Confusing \(P(A\mid B)\) with \(P(B\mid A)\) is a common and serious error. Probabilistic models should state clearly what is being conditioned on.

Back to top ↑

Stochastic Processes

A stochastic process is a collection of random variables indexed by time, space, or another ordered structure. It describes how uncertainty evolves.

Stochastic processes are used when the path matters, not just a final random outcome. They can represent random walks, queues, failures, epidemics, financial returns, weather sequences, population dynamics, or uncertain demand.

Stochastic processes require attention to time dependence, memory, stationarity, transition structure, and correlation. A model that treats all random values as independent may miss the most important structure in the system.

Back to top ↑

Markov Models and Transition Probabilities

A Markov model represents transitions among states where the next state depends on the current state. In a simple Markov chain, the future is conditionally independent of the past given the present state.

Transition probabilities can be arranged in a transition matrix:

Markov models are useful because they are structured and interpretable. Their risk is oversimplifying memory. If history matters beyond the current state, the Markov assumption must be revised or expanded through additional state variables.

Back to top ↑

Stochastic Dynamics and Noise Terms

Stochastic dynamics combine systematic structure with random variation. A deterministic recurrence might be written as:

A stochastic recurrence adds noise:

Noise is not always measurement error. It may represent real variation, unresolved processes, random shocks, environmental fluctuation, individual differences, or structural uncertainty.

Noise terms should be interpreted and validated. Adding randomness does not automatically make a model realistic. The distribution, dependence, scale, and role of noise should match the system and evidence.

Back to top ↑

Monte Carlo Simulation and Uncertainty Propagation

Monte Carlo simulation uses repeated random sampling to propagate uncertainty through a model. Instead of evaluating one input value, the model samples many possible input values and examines the resulting output distribution.

The collection of outputs approximates the uncertainty distribution of the model result.

Monte Carlo simulation is powerful because it can handle complex models. Its weakness is that results depend on input distributions, dependence assumptions, sample size, and model structure. Simulation can quantify uncertainty only for uncertainty that has been represented.

Back to top ↑

Bayesian Modeling and Parameter Uncertainty

Bayesian modeling treats unknown quantities as uncertain and updates beliefs using evidence. It is especially useful when parameter uncertainty matters, data are limited, prior knowledge is relevant, or decision-making requires full uncertainty distributions.

In symbolic form:

Bayesian models can improve transparency about uncertainty, but they also require careful communication. Priors are not a weakness when stated and tested; hidden assumptions are the weakness.

Back to top ↑

Dependence, Correlation, and Joint Uncertainty

Many probabilistic models fail because they assume independence when variables are related. Dependence means that knowing one quantity changes what is plausible about another.

When independence does not hold, joint uncertainty matters. Weather, demand, infrastructure stress, economic shocks, disease transmission, and human behavior often move together.

Dependence should be documented and tested. In many risk models, assuming independence is not conservative; it can be dangerously optimistic.

Back to top ↑

Mathematical Lens: Models as Probability Structures

A probabilistic model can be understood as a structured probability statement. Instead of producing one output, it defines a distribution over possible outcomes.

If parameters are uncertain, the predictive distribution integrates over parameter uncertainty:

For stochastic state evolution:

For simulation-based modeling:

This mathematical lens shows that probabilistic modeling is not just “adding uncertainty.” It defines what is random, what is conditioned on, how uncertainty propagates, and what probability statement the model is making.

Back to top ↑

Example: Probabilistic Resource-Risk Model

Consider a resource system in which future demand is uncertain. A deterministic model might use a single demand value. A probabilistic model treats demand as a random variable.

Suppose available supply \(S\) is also uncertain:

The shortage risk is:

A decision-maker may care not only about whether shortage occurs, but also how severe it is:

This example shows why probability changes interpretation. The question is no longer only “what is the shortage?” It becomes “how likely is shortage, how severe could it be, under which assumptions, and how should decisions respond?”

Back to top ↑

Calibration, Validation, Sensitivity, and Uncertainty

Probabilistic models require validation methods that evaluate uncertainty, not only central predictions. A model can have a good average forecast but poor uncertainty intervals. It can produce intervals that are too narrow, probabilities that are miscalibrated, or tails that underestimate severe outcomes.

A probabilistic model should be judged by whether its uncertainty statements are useful and credible. The goal is not simply to produce wider intervals. It is to represent uncertainty in a way that matches the evidence and supports responsible interpretation.

Back to top ↑

Ethical Stakes of Probabilistic Modeling

Probabilistic models can improve decision-making by making uncertainty visible. They can also create ethical problems if probabilities are misinterpreted, uncertainty is hidden, risk is averaged away, or vulnerable groups are exposed to tail outcomes that aggregate models obscure.

Responsible probabilistic modeling communicates uncertainty without using uncertainty as an excuse for inaction. A low-probability outcome may still matter if consequences are severe, irreversible, or unequally distributed.

Back to top ↑

Python Workflow: Probabilistic Simulation and Risk Diagnostics

The Python workflow below uses dependency-light Monte Carlo simulation to model uncertain demand, uncertain supply, shortage probability, expected shortage, tail risk, and a probability model register.

# probabilistic_stochastic_models_workflow.py
# Dependency-light workflow for probabilistic simulation and risk diagnostics.

from __future__ import annotations

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


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


@dataclass(frozen=True)
class ProbabilityModelRecord:
    key: str
    model_component: str
    distribution_or_rule: str
    interpretation: str
    review_question: str
    status: str


@dataclass(frozen=True)
class RiskScenario:
    name: str
    demand_mu: float
    demand_sigma: float
    supply_mean: float
    supply_sd: float
    reserve: float
    simulations: int
    seed: int


def probability_register() -> list[ProbabilityModelRecord]:
    return [
        ProbabilityModelRecord(
            key="demand_distribution",
            model_component="random_variable",
            distribution_or_rule="D ~ Lognormal(mu, sigma)",
            interpretation="Demand is positive and right-skewed.",
            review_question="Is the tail behavior justified by evidence?",
            status="review",
        ),
        ProbabilityModelRecord(
            key="supply_distribution",
            model_component="random_variable",
            distribution_or_rule="S ~ Normal(mean, sd), truncated at zero",
            interpretation="Supply varies around a planned level.",
            review_question="Is normal uncertainty plausible near zero?",
            status="review",
        ),
        ProbabilityModelRecord(
            key="shortage_amount",
            model_component="derived_risk",
            distribution_or_rule="Q = max(0, D - S - reserve)",
            interpretation="Shortage is positive when demand exceeds available supply and reserve.",
            review_question="Are shortage amount and shortage probability both reported?",
            status="active",
        ),
        ProbabilityModelRecord(
            key="tail_risk",
            model_component="risk_measure",
            distribution_or_rule="quantile(Q, 0.95)",
            interpretation="High-end shortage risk is summarized by a tail quantile.",
            review_question="Is tail risk used alongside expected shortage?",
            status="active",
        ),
    ]


def validate_scenario(scenario: RiskScenario) -> None:
    if scenario.demand_sigma <= 0:
        raise ValueError("demand_sigma must be positive.")
    if scenario.supply_mean <= 0:
        raise ValueError("supply_mean must be positive.")
    if scenario.supply_sd <= 0:
        raise ValueError("supply_sd must be positive.")
    if scenario.reserve < 0:
        raise ValueError("reserve must be nonnegative.")
    if scenario.simulations < 100:
        raise ValueError("simulations must be at least 100.")


def quantile(values: list[float], probability: float) -> float:
    if not values:
        raise ValueError("Cannot compute quantile of empty list.")
    ordered = sorted(values)
    index = min(len(ordered) - 1, max(0, round(probability * (len(ordered) - 1))))
    return ordered[index]


def simulate_risk(scenario: RiskScenario) -> tuple[list[dict[str, object]], dict[str, object]]:
    validate_scenario(scenario)
    rng = random.Random(scenario.seed)

    rows: list[dict[str, object]] = []
    shortages: list[float] = []

    for run in range(1, scenario.simulations + 1):
        demand = rng.lognormvariate(scenario.demand_mu, scenario.demand_sigma)
        supply = max(0.0, rng.gauss(scenario.supply_mean, scenario.supply_sd))
        available = supply + scenario.reserve
        shortage = max(0.0, demand - available)

        rows.append({
            "scenario": scenario.name,
            "run": run,
            "demand": round(demand, 8),
            "supply": round(supply, 8),
            "reserve": round(scenario.reserve, 8),
            "available_supply": round(available, 8),
            "shortage": round(shortage, 8),
            "shortage_event": shortage > 0,
        })
        shortages.append(shortage)

    shortage_events = [value > 0 for value in shortages]
    summary = {
        "scenario": scenario.name,
        "simulations": scenario.simulations,
        "shortage_probability": round(sum(shortage_events) / scenario.simulations, 8),
        "expected_shortage": round(mean(shortages), 8),
        "shortage_sd": round(pstdev(shortages), 8),
        "shortage_q50": round(quantile(shortages, 0.50), 8),
        "shortage_q90": round(quantile(shortages, 0.90), 8),
        "shortage_q95": round(quantile(shortages, 0.95), 8),
        "shortage_q99": round(quantile(shortages, 0.99), 8),
        "max_shortage": round(max(shortages), 8),
    }

    return rows, summary


def probability_risk_score(record: ProbabilityModelRecord) -> float:
    score = {"active": 1.0, "review": 5.0, "revise": 8.0, "archive": 2.0}.get(
        record.status.lower(),
        4.0,
    )
    text = f"{record.model_component} {record.distribution_or_rule} {record.review_question}".lower()
    for term in ["tail", "distribution", "shortage", "risk", "normal", "probability", "evidence"]:
        if term in text:
            score += 1.0
    return round(score, 3)


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:
    scenarios = [
        RiskScenario("baseline", 4.50, 0.25, 95.0, 8.0, 5.0, 5000, 101),
        RiskScenario("high_variability", 4.50, 0.45, 95.0, 12.0, 5.0, 5000, 102),
        RiskScenario("low_reserve", 4.50, 0.25, 95.0, 8.0, 0.0, 5000, 103),
        RiskScenario("stress_demand", 4.65, 0.35, 90.0, 10.0, 5.0, 5000, 104),
    ]

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

    for scenario in scenarios:
        rows, summary = simulate_risk(scenario)
        all_rows.extend(rows)
        summary_rows.append(summary)

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

    write_csv(TABLES / "probabilistic_simulation_runs.csv", all_rows)
    write_csv(TABLES / "probabilistic_risk_summary.csv", summary_rows)
    write_csv(TABLES / "probability_model_register.csv", register_rows)

    write_json(JSON_DIR / "probabilistic_model_audit_card.json", {
        "article": "Probabilistic and Stochastic Models",
        "probability_model_register": register_rows,
        "scenario_summaries": summary_rows,
        "audit_checks": [
            "distribution choices are justified",
            "tail risk is reported",
            "shortage probability and severity are separated",
            "random seed and simulation count are documented",
            "uncertainty is communicated as conditional on assumptions",
        ],
    })

    print("Probabilistic and stochastic models workflow complete.")
    print(f"Wrote outputs to {OUTPUTS}")


if __name__ == "__main__":
    main()

This workflow separates shortage probability from shortage severity. That distinction matters because a scenario with low probability but severe shortage may require different planning than a scenario with frequent but minor shortages.

Back to top ↑

R Workflow: Distribution Review and Uncertainty Diagnostics

The R workflow below reviews probabilistic simulation outputs, classifies scenarios by risk, and creates a distribution plot for shortage outcomes.

# probabilistic_stochastic_models_review.R
# Base R workflow for distribution review and uncertainty 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")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

runs_path <- file.path(tables_dir, "probabilistic_simulation_runs.csv")
summary_path <- file.path(tables_dir, "probabilistic_risk_summary.csv")
register_path <- file.path(tables_dir, "probability_model_register.csv")

if (!file.exists(runs_path) || !file.exists(summary_path)) {
  stop("Missing probabilistic outputs. Run the Python workflow first.")
}

runs <- read.csv(runs_path, stringsAsFactors = FALSE)
summary_data <- read.csv(summary_path, stringsAsFactors = FALSE)

summary_data$risk_review <- ifelse(
  summary_data$shortage_probability >= 0.25 | summary_data$shortage_q95 > 20,
  "high review priority",
  ifelse(
    summary_data$shortage_probability >= 0.10 | summary_data$shortage_q90 > 10,
    "moderate review priority",
    "routine monitoring"
  )
)

write.csv(
  summary_data,
  file.path(tables_dir, "r_probabilistic_risk_review_summary.csv"),
  row.names = FALSE
)

if (file.exists(register_path)) {
  register <- read.csv(register_path, stringsAsFactors = FALSE)

  register$priority <- ifelse(
    register$probability_risk_score >= 8,
    "high",
    ifelse(register$probability_risk_score >= 6, "medium", "low")
  )

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

png(file.path(figures_dir, "r_shortage_distribution_histogram.png"), width = 1100, height = 720)

hist(
  runs$shortage,
  breaks = 40,
  xlab = "Shortage",
  main = "Distribution of Simulated Shortage Outcomes"
)

grid()
dev.off()

print(summary_data)

The R layer emphasizes distribution review. It helps prevent probabilistic models from being reduced to a single average when probabilities, quantiles, and tail risks matter.

Back to top ↑

Haskell Workflow: Typed Probability Model Records

Haskell is useful for this article because probabilistic model components should not collapse into one informal category. Random variables, distributions, parameters, risk measures, evidence, and simulation settings play different roles.

{-# OPTIONS_GHC -Wall #-}

module Main where

data ProbabilityComponent
  = RandomVariable
  | DistributionChoice
  | ParameterUncertainty
  | DerivedRiskMeasure
  | ConditionalStatement
  | SimulationSetting
  | ValidationDiagnostic
  deriving (Eq, Show)

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

data ProbabilityRecord = ProbabilityRecord
  { key :: String
  , component :: ProbabilityComponent
  , expression :: String
  , interpretation :: String
  , reviewFocus :: String
  , status :: ReviewStatus
  } deriving (Eq, Show)

probabilityRegister :: [ProbabilityRecord]
probabilityRegister =
  [ ProbabilityRecord
      "demand_distribution"
      RandomVariable
      "D ~ Lognormal(mu, sigma)"
      "Demand is positive and right-skewed."
      "Tail behavior and evidence."
      RequiresReview
  , ProbabilityRecord
      "supply_distribution"
      DistributionChoice
      "S ~ Normal(mean, sd), truncated at zero"
      "Supply varies around a planned level."
      "Support and truncation."
      RequiresReview
  , ProbabilityRecord
      "shortage_amount"
      DerivedRiskMeasure
      "Q = max(0, D - S - reserve)"
      "Shortage is positive when demand exceeds available supply."
      "Severity and probability."
      Active
  , ProbabilityRecord
      "simulation_count"
      SimulationSetting
      "M"
      "Monte Carlo sample size."
      "Stability of estimated risk."
      RequiresSensitivityTest
  ]

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

main :: IO ()
main = do
  putStrLn "Typed probability model records:"
  mapM_ print probabilityRegister

  putStrLn "\nProbability records requiring review:"
  mapM_ print (filter needsReview probabilityRegister)

This typed layer supports model governance by making uncertainty roles explicit before probabilistic outputs are interpreted as evidence or decision support.

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 probability model registers, Monte Carlo simulation, stochastic risk diagnostics, distribution review, typed Haskell probability records, validation planning, and reproducible engineering/statistical workflows.

Back to top ↑

A Practical Method for Probabilistic Model Design

Probabilistic model design should begin by asking what is uncertain and why. The model should distinguish real variability, measurement error, parameter uncertainty, structural uncertainty, future uncertainty, and decision-relevant risk.

This method helps prevent uncertainty from being treated as decorative error bars. It connects probabilistic modeling to purpose, evidence, distributional assumptions, dependence, simulation, validation, and responsible interpretation.

Back to top ↑

Common Pitfalls

Probabilistic models can fail even when they appear statistically sophisticated. Many failures arise from unclear probability statements, unjustified distributions, hidden dependence assumptions, or weak communication.

• False precision: reporting narrow intervals without validating uncertainty.
• Distribution by convenience: choosing a normal distribution because it is familiar rather than appropriate.
• Ignoring support: allowing impossible negative values for quantities that cannot be negative.
• Mean-only reporting: presenting expected values while hiding tail risk.
• Independence by default: assuming variables are independent when they share drivers.
• Confusing variability and uncertainty: mixing real system variation with lack of knowledge.
• Misreading conditional probability: confusing \(P(A\mid B)\) with \(P(B\mid A)\).
• Opaque prior assumptions: using Bayesian priors without documenting or testing them.
• Simulation without validation: generating thousands of runs from weak assumptions.
• Probability without consequence: discussing likelihood while ignoring severity, vulnerability, and irreversibility.

These pitfalls can be reduced through uncertainty registers, distribution review, dependence mapping, calibration checks, tail-risk reporting, sensitivity analysis, transparent priors, and careful communication.

Back to top ↑

Conclusion: Probability Makes Uncertainty Visible

Probabilistic and stochastic models make uncertainty visible. They represent random variables, distributions, stochastic processes, conditional probabilities, transition structures, noise, parameter uncertainty, and risk measures so that uncertainty can be reasoned about rather than hidden.

The value of probabilistic modeling is not that it makes uncertainty disappear. It does the opposite: it gives uncertainty structure. It helps modelers ask which outcomes are plausible, how likely they are, how severe they could be, how uncertainty propagates, and how decisions should respond.

But probabilistic models require discipline. Distribution choices must be justified. Probability statements must be clear. Dependence must be considered. Simulations must be reproducible. Intervals must be validated. Tail risk must be communicated. A probabilistic model can be honest and useful only when its assumptions and limits are visible.

Randomness is not a failure of modeling. Often, it is part of what must be modeled. Used responsibly, probabilistic and stochastic models help replace false certainty with structured uncertainty, better judgment, and more accountable decision support.

Back to top ↑

Related Articles

• What Is Mathematical Modeling?
• The Modeling Process: From World to Formal Representation
• Variables, Parameters, and Constraints
• Functional Relationships and Mathematical Structure
• Differential Equations and Dynamic Models
• Discrete Models and Recurrence Relations
• Optimization Models and Objective Functions
• Monte Carlo Simulation and Uncertainty Propagation
• Uncertainty in Mathematical Models
• Model Interpretation and Decision-Making

Back to top ↑

Further Reading

• Blitzstein, J.K. and Hwang, J. (2019) Introduction to Probability. 2nd edn. Boca Raton, FL: CRC Press.
• Grinstead, C.M. and Snell, J.L. (1997) Introduction to Probability. Providence, RI: American Mathematical Society. Available at: https://math.dartmouth.edu/~prob/prob/prob.pdf
• Ross, S.M. (2014) Introduction to Probability Models. 11th edn. Amsterdam: Academic Press.
• Durrett, R. (2019) Probability: Theory and Examples. 5th edn. Cambridge: Cambridge University Press.
• Gelman, A., Carlin, J.B., Stern, H.S., Dunson, D.B., Vehtari, A. and Rubin, D.B. (2013) Bayesian Data Analysis. 3rd edn. Boca Raton, FL: CRC Press.
• Jaynes, E.T. (2003) Probability Theory: The Logic of Science. Cambridge: Cambridge University Press.
• Robert, C.P. and Casella, G. (2004) Monte Carlo Statistical Methods. 2nd edn. New York: Springer.
• 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.
• 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
• National Academies of Sciences, Engineering, and Medicine (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://nap.nationalacademies.org/catalog/13395/assessing-the-reliability-of-complex-models-mathematical-and-statistical-foundations

Back to top ↑

References

• Blitzstein, J.K. and Hwang, J. (2019) Introduction to Probability. 2nd edn. Boca Raton, FL: CRC Press.
• Durrett, R. (2019) Probability: Theory and Examples. 5th edn. Cambridge: Cambridge University Press.
• 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
• Gelman, A., Carlin, J.B., Stern, H.S., Dunson, D.B., Vehtari, A. and Rubin, D.B. (2013) Bayesian Data Analysis. 3rd edn. Boca Raton, FL: CRC Press.
• Grinstead, C.M. and Snell, J.L. (1997) Introduction to Probability. Providence, RI: American Mathematical Society. Available at: https://math.dartmouth.edu/~prob/prob/prob.pdf
• Jaynes, E.T. (2003) Probability Theory: The Logic of Science. Cambridge: Cambridge University Press.
• National Academies of Sciences, Engineering, and Medicine (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://nap.nationalacademies.org/catalog/13395/assessing-the-reliability-of-complex-models-mathematical-and-statistical-foundations
• 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
• Robert, C.P. and Casella, G. (2004) Monte Carlo Statistical Methods. 2nd edn. New York: Springer.
• Ross, S.M. (2014) Introduction to Probability Models. 11th edn. Amsterdam: Academic Press.
• 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.

Back to top ↑