Interpretation, Approximation, and Responsible Mathematical Modeling: How Linear Algebra Results Become Accountable Evidence

Last Updated July 6, 2026

Interpretation, approximation, and responsible mathematical modeling explain how linear algebra results become meaningful, limited, and accountable. A matrix calculation can be correct without being wise. A model can be reproducible without being valid. A projection can be mathematically elegant while still exceeding the evidence, assumptions, scale, or purpose that justified it.

This article closes Part IX of the Linear Algebra for Systems Modeling series by connecting interpretation, approximation, uncertainty, residuals, sensitivity, model purpose, assumption registers, validation, evidence boundaries, abstraction, simplification, approximation error, numerical error, representation limits, scaling choices, causal caution, governance, documentation, and responsible communication.

The central modeling question is not only “What does the linear algebra output say?” It is “What can this output responsibly support, given the assumptions, approximations, diagnostics, uncertainty, and institutional context behind it?”

Linear algebra makes systems modeling possible by turning structure into vectors, matrices, transformations, subspaces, equations, decompositions, networks, and computational workflows. But the final modeling task is interpretive. The analyst must decide what the output means, where it applies, how uncertain it is, which assumptions support it, which approximations limit it, and what claims would go beyond the model.

This is where mathematical modeling becomes responsible. Responsible modeling does not mean avoiding abstraction. It means making abstraction explicit. It does not mean refusing approximation. It means stating what the approximation preserves and what it loses. It does not mean hiding uncertainty. It means connecting uncertainty to interpretation, communication, and decision-making.

Why Interpretation Matters

Interpretation matters because linear algebra outputs do not interpret themselves. A coefficient, eigenvalue, singular value, projection, residual, rank estimate, condition number, centrality score, cluster, principal component, or fitted vector becomes meaningful only when connected to the model’s purpose and assumptions.

The same numerical result can support different claims depending on context. A high residual may indicate model misspecification, measurement error, unusual behavior, subgroup structure, a structural break, or a boundary case. A low-rank approximation may reveal latent structure, but it may also suppress rare cases. A stable eigenvalue may describe a local regime, but not necessarily a future system under stress.

Interpretation is not a decorative explanation added after computation. It is part of the model’s validity.

Back to top ↑

Models as Structured Approximations

A mathematical model is a structured approximation of a system. It is not the system itself. It selects variables, boundaries, relationships, scales, units, transformations, assumptions, and outputs. It simplifies so that reasoning becomes possible.

Approximation is not failure. Every model approximates. The question is whether the approximation preserves the structure needed for the model’s purpose. A model used for rough screening can tolerate different approximations than a model used for safety-critical intervention, legal compliance, infrastructure investment, or public health planning.

Responsible modeling requires naming the approximation, explaining why it is useful, and stating what it cannot support.

Back to top ↑

From Calculation to Claim

A calculation becomes a claim only after interpretation. Linear algebra can compute a solution, projection, decomposition, factorization, residual, or score. The claim says what that output means about the system.

Different claims require different levels of evidence. “This is a useful exploratory pattern” is weaker than “this is a validated prediction.” “This coefficient is associated with the outcome” is weaker than “changing this variable will cause the outcome to change.” “This network node is central under this metric” is weaker than “this actor controls the system.”

The stronger the claim, the stronger the required evidence and the more explicit the interpretation boundary must be.

Back to top ↑

Approximation Error and Numerical Error

Approximation error and numerical error are related but distinct. Approximation error comes from representing a system with a simplified model. Numerical error comes from computation: floating-point arithmetic, algorithmic instability, conditioning, truncation, solver tolerance, or implementation limits.

A model can be numerically accurate and still be a poor approximation. It can also be a useful approximation even when small numerical uncertainty remains. Responsible interpretation distinguishes these layers.

Back to top ↑

Assumptions as Modeling Infrastructure

Assumptions are not footnotes. They are modeling infrastructure. They define why the matrix is meaningful, why the approximation is acceptable, why a solver applies, why outputs can be compared, and why conclusions are limited.

An assumption register should record representation assumptions, mathematical assumptions, data assumptions, numerical assumptions, validation assumptions, interpretation assumptions, and governance assumptions. This makes the model reviewable instead of opaque.

Assumptions make modeling possible. Documentation makes assumptions accountable.

Back to top ↑

Uncertainty and Sensitivity

Uncertainty asks how much confidence we should place in model outputs. Sensitivity asks how outputs change when inputs, assumptions, parameters, representation choices, or computation settings change.

A responsible workflow does not only report a single output. It asks whether that output is stable under reasonable alternatives. If a conclusion changes when scaling changes, when one feature is removed, when a boundary shifts, when a tolerance changes, or when a nonlinear alternative is tested, the conclusion should be communicated with caution.

Sensitivity analysis helps distinguish robust structure from fragile conclusions.

Back to top ↑

Validation and Evidence Boundaries

Validation asks whether a model works for its intended purpose. Evidence boundaries define where that validation applies. A model validated for one system, scale, period, population, data source, or operating regime may not be validated for another.

Validation is not a single checkbox. It is a layered argument about whether a model is fit for a particular purpose.

Back to top ↑

Residuals, Diagnostics, and Model Adequacy

Diagnostics examine whether the model’s simplifications are adequate. Residuals are especially important because they reveal what the model failed to capture. But diagnostics also include condition numbers, rank checks, singular values, convergence logs, sparsity patterns, reconstruction error, outlier review, subgroup behavior, and validation performance.

Diagnostics do not eliminate judgment. They make judgment better informed.

Back to top ↑

Scale, Representation, and Meaning

Interpretation depends on representation and scale. A result in raw units has one meaning. A result in standardized coordinates has another. A normalized vector compares direction rather than magnitude. A row-stochastic matrix compares distributions or transition probabilities. A low-rank approximation compares compressed structure, not every original detail.

Responsible interpretation should always answer: What are the rows? What are the columns? What do entries mean? What do zeros mean? What units were used? Was the matrix centered, scaled, normalized, thresholded, aggregated, or transformed? What meaning changed because of those choices?

Interpretation should follow the transformed representation, not the analyst’s memory of the original system.

Back to top ↑

Causal Caution and Decision Support

Linear algebra often supports decision-making: allocation, prioritization, forecasting, optimization, ranking, recommendation, resilience analysis, or risk assessment. But decision support is not the same as decision authority.

A matrix model can inform judgment, but it should not erase judgment. It can show constraints, tradeoffs, sensitivity, and structure. It cannot by itself determine values, priorities, legal duties, ethical obligations, institutional accountability, or acceptable risk.

Responsible decision support keeps the model in the toolkit, not in control.

Back to top ↑

Documentation and Auditability

Documentation preserves the modeling record. Auditability makes the workflow reviewable by others. A responsible linear algebra workflow should not only provide code and outputs; it should preserve assumptions, data provenance, transformations, diagnostics, validation evidence, generated artifacts, limitations, and review status.

Auditability is a form of responsibility. It allows others to inspect how mathematical outputs became claims.

Back to top ↑

Governance and Accountability

Model governance asks how models are reviewed, maintained, communicated, used, challenged, updated, and retired. In public-interest systems modeling, governance matters because model outputs can shape decisions affecting infrastructure, resources, risk, policy, organizations, communities, and knowledge systems.

Accountability requires more than technical correctness. It requires clarity about responsibility: who built the model, who reviewed it, who uses it, what decision it supports, what uncertainty remains, who can question it, and what happens when conditions change.

Responsible mathematical modeling treats governance as part of the workflow, not as an afterthought.

Back to top ↑

Responsible Communication

Responsible communication translates mathematical results without inflating them. It explains what the model shows, why the result matters, how uncertain it is, what assumptions support it, what diagnostics say, what alternatives were considered, and what the result cannot prove.

Good communication protects both the usefulness and the limits of the model.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Responsible mathematical modeling connects approximation theory, residual analysis, condition diagnostics, sensitivity testing, validation, uncertainty, model form, representation choices, numerical stability, and interpretation boundaries.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for interpretation, approximation, and responsible mathematical modeling should document model purpose, data provenance, matrix construction, scaling choices, approximation form, assumptions, diagnostics, residuals, condition checks, validation evidence, sensitivity results, uncertainty notes, claim type, interpretation boundaries, governance review, and responsible-use warnings.

The companion repository treats interpretation as an auditable layer of the modeling workflow. Python, R, Julia, SQL, Haskell, C, C++, Fortran, Rust, Go, notebooks, schemas, generated outputs, Canvas artifacts, advanced reports, and calculators each support a different layer of responsible modeling review.

For this article, the computational examples create a responsible modeling audit record. The workflow classifies the claim type, separates approximation and numerical uncertainty, records validation status, flags interpretation limits, and exports a governance-ready report.

Back to top ↑

Python Workflow: Responsible Modeling Audit

The Python workflow below creates a compact responsible modeling audit. It records claim type, approximation status, diagnostic status, uncertainty sources, validation status, interpretation boundary, and governance warning.

from __future__ import annotations

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


@dataclass(frozen=True)
class ResponsibleModelingAudit:
    workflow_name: str
    model_purpose: str
    claim_type: str
    approximation_form: str
    representation_status: str
    numerical_status: str
    diagnostic_status: str
    validation_status: str
    uncertainty_sources: str
    sensitivity_status: str
    interpretation_boundary: str
    governance_warning: str
    responsible_use_statement: str


def build_audit() -> ResponsibleModelingAudit:
    return ResponsibleModelingAudit(
        workflow_name="responsible_modeling_audit",
        model_purpose="interpret_linear_algebra_output_for_systems_modeling",
        claim_type="exploratory_decision_support_not_causal_proof",
        approximation_form="linear_or_low_rank_approximation_with_explicit_assumptions",
        representation_status="rows_columns_units_zeros_scaling_and_boundaries_documented",
        numerical_status="residuals_conditioning_solver_tolerance_and_reproducibility_checked",
        diagnostic_status="residuals_sensitivity_and_alternative_representations_reviewed",
        validation_status="validated_only_for_stated_data_range_operating_context_and_model_purpose",
        uncertainty_sources="data_uncertainty_model_uncertainty_numerical_uncertainty_interpretive_uncertainty",
        sensitivity_status="conclusions_compared_across_reasonable_representation_scaling_and_model_form_variants",
        interpretation_boundary=(
            "Outputs support structured interpretation within the stated assumptions, "
            "not universal claims, causal proof, or unreviewed decision authority."
        ),
        governance_warning=(
            "Model use requires documented assumptions, validation evidence, review status, "
            "uncertainty communication, and stop-use conditions."
        ),
        responsible_use_statement=(
            "Use the model as an interpretive and diagnostic aid. Do not use it as the sole basis "
            "for high-stakes decisions without domain review, uncertainty disclosure, and accountability."
        ),
    )


def write_outputs(output_dir: Path) -> None:
    (output_dir / "tables").mkdir(parents=True, exist_ok=True)
    (output_dir / "json").mkdir(parents=True, exist_ok=True)
    (output_dir / "reports").mkdir(parents=True, exist_ok=True)

    audit = build_audit()
    row = asdict(audit)

    with (output_dir / "tables" / "responsible_modeling_audit.csv").open(
        "w", newline="", encoding="utf-8"
    ) as handle:
        writer = csv.DictWriter(handle, fieldnames=list(row.keys()))
        writer.writeheader()
        writer.writerow(row)

    (output_dir / "json" / "responsible_modeling_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )

    report = [
        "# Responsible Modeling Audit",
        "",
        f"- Workflow: {audit.workflow_name}",
        f"- Model purpose: {audit.model_purpose}",
        f"- Claim type: {audit.claim_type}",
        f"- Approximation form: {audit.approximation_form}",
        f"- Representation status: {audit.representation_status}",
        f"- Numerical status: {audit.numerical_status}",
        f"- Diagnostic status: {audit.diagnostic_status}",
        f"- Validation status: {audit.validation_status}",
        f"- Uncertainty sources: {audit.uncertainty_sources}",
        f"- Sensitivity status: {audit.sensitivity_status}",
        "",
        f"**Interpretation boundary:** {audit.interpretation_boundary}",
        "",
        f"**Governance warning:** {audit.governance_warning}",
        "",
        f"**Responsible use statement:** {audit.responsible_use_statement}",
    ]

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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Responsible modeling audit complete.")

This workflow makes interpretation boundaries and governance warnings part of the generated artifact, not informal commentary left outside the repository.

Back to top ↑

R Workflow: Approximation and Interpretation Review

R can support the same audit by exporting a structured record of approximation form, validation status, uncertainty, interpretation boundary, and responsible-use statement.

audit_record <- data.frame(
  workflow_name = "responsible_modeling_audit",
  model_purpose = "interpret_linear_algebra_output_for_systems_modeling",
  claim_type = "exploratory_decision_support_not_causal_proof",
  approximation_form = "linear_or_low_rank_approximation_with_explicit_assumptions",
  representation_status = "rows_columns_units_zeros_scaling_and_boundaries_documented",
  numerical_status = "residuals_conditioning_solver_tolerance_and_reproducibility_checked",
  diagnostic_status = "residuals_sensitivity_and_alternative_representations_reviewed",
  validation_status = "validated_only_for_stated_data_range_operating_context_and_model_purpose",
  uncertainty_sources = paste(
    "data_uncertainty",
    "model_uncertainty",
    "numerical_uncertainty",
    "interpretive_uncertainty",
    sep = ";"
  ),
  sensitivity_status = paste(
    "conclusions_compared_across_reasonable_representation_scaling",
    "and_model_form_variants"
  ),
  interpretation_boundary = paste(
    "Outputs support structured interpretation within the stated assumptions,",
    "not universal claims, causal proof, or unreviewed decision authority."
  ),
  governance_warning = paste(
    "Model use requires documented assumptions, validation evidence, review status,",
    "uncertainty communication, and stop-use conditions."
  ),
  responsible_use_statement = paste(
    "Use the model as an interpretive and diagnostic aid.",
    "Do not use it as the sole basis for high-stakes decisions without domain review,",
    "uncertainty disclosure, and accountability."
  )
)

dir.create("outputs/tables", recursive = TRUE, showWarnings = FALSE)
write.csv(
  audit_record,
  "outputs/tables/r_responsible_modeling_audit.csv",
  row.names = FALSE
)

print(audit_record)

This R workflow keeps approximation, validation, interpretation, and governance in the same record as the computational output.

Back to top ↑

Haskell Workflow: Typed Responsible Modeling Record

Haskell can represent responsible interpretation as a typed record, preserving claim type, validation status, uncertainty sources, interpretation boundary, and responsible-use statement.

module Main where

data ResponsibleModelingAudit = ResponsibleModelingAudit
  { workflowName :: String
  , modelPurpose :: String
  , claimType :: String
  , approximationForm :: String
  , representationStatus :: String
  , numericalStatus :: String
  , diagnosticStatus :: String
  , validationStatus :: String
  , uncertaintySources :: String
  , sensitivityStatus :: String
  , interpretationBoundary :: String
  , governanceWarning :: String
  , responsibleUseStatement :: String
  } deriving (Show)

buildAudit :: ResponsibleModelingAudit
buildAudit =
  ResponsibleModelingAudit
    "responsible_modeling_audit"
    "interpret_linear_algebra_output_for_systems_modeling"
    "exploratory_decision_support_not_causal_proof"
    "linear_or_low_rank_approximation_with_explicit_assumptions"
    "rows_columns_units_zeros_scaling_and_boundaries_documented"
    "residuals_conditioning_solver_tolerance_and_reproducibility_checked"
    "residuals_sensitivity_and_alternative_representations_reviewed"
    "validated_only_for_stated_data_range_operating_context_and_model_purpose"
    "data_uncertainty;model_uncertainty;numerical_uncertainty;interpretive_uncertainty"
    "conclusions_compared_across_reasonable_representation_scaling_and_model_form_variants"
    "Outputs support structured interpretation within the stated assumptions, not universal claims, causal proof, or unreviewed decision authority."
    "Model use requires documented assumptions, validation evidence, review status, uncertainty communication, and stop-use conditions."
    "Use the model as an interpretive and diagnostic aid. Do not use it as the sole basis for high-stakes decisions without domain review, uncertainty disclosure, and accountability."

main :: IO ()
main =
  print buildAudit

The typed record helps prevent responsible-use warnings from being separated from the model artifact itself.

Back to top ↑

SQL Workflow: Responsible Modeling Governance Registry

SQL can document interpretation and governance assumptions when models support reports, dashboards, repositories, audits, or institutional decision systems.

CREATE TABLE responsible_modeling_governance_registry (
    governance_key TEXT PRIMARY KEY,
    governance_name TEXT NOT NULL,
    modeling_role TEXT NOT NULL,
    review_requirement TEXT NOT NULL,
    responsible_use_warning TEXT NOT NULL
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'model_purpose',
  'Model purpose',
  'Defines why the model exists and what decision or interpretation it supports.',
  'State whether the model is exploratory, predictive, explanatory, diagnostic, optimization-oriented, or governance-supporting.',
  'A model built for exploration should not be used as final decision authority without further validation.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'claim_type',
  'Claim type',
  'Distinguishes descriptive, predictive, explanatory, causal, and decision-support claims.',
  'Match claim strength to evidence strength.',
  'Do not communicate stronger claims than the model can support.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'approximation_boundary',
  'Approximation boundary',
  'Defines what the model preserves and what it simplifies.',
  'Document linearity, low-rank, aggregation, scaling, or state-space approximation choices.',
  'Approximation is useful only when its losses are visible.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'uncertainty_sources',
  'Uncertainty sources',
  'Separates data, model, numerical, sampling, and interpretive uncertainty.',
  'Report uncertainty sources alongside outputs.',
  'A precise number can still be uncertain if assumptions or data are fragile.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'validation_status',
  'Validation status',
  'Records where the model has been checked and where it has not.',
  'Preserve validation evidence, reference cases, residual diagnostics, and operating ranges.',
  'Validation in one context does not automatically transfer to another.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'sensitivity_review',
  'Sensitivity review',
  'Tests whether conclusions depend on data, assumptions, scaling, representation, or model form.',
  'Compare reasonable alternative workflows when conclusions matter.',
  'Fragile conclusions should be communicated with caution.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'interpretation_boundary',
  'Interpretation boundary',
  'Defines what outputs can and cannot responsibly mean.',
  'Attach interpretation limits to generated reports and decision-support artifacts.',
  'Do not let computational output exceed the model evidence.'
);

INSERT INTO responsible_modeling_governance_registry VALUES
(
  'accountability_path',
  'Accountability path',
  'Defines who reviews, maintains, challenges, updates, and retires the model.',
  'Assign ownership, review status, revision procedures, and stop-use conditions.',
  'A model without accountability should not silently guide consequential decisions.'
);

SELECT
    governance_name,
    modeling_role,
    review_requirement,
    responsible_use_warning
FROM responsible_modeling_governance_registry
ORDER BY governance_key;

This registry keeps interpretation, approximation, validation, uncertainty, sensitivity, and accountability connected to the model workflow.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports responsible modeling audits, approximation records, interpretation boundaries, uncertainty sources, validation status, sensitivity review, governance tables, generated artifacts, advanced audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Linear algebra is powerful because it gives structure to complexity. It can solve systems, reveal dependence, expose instability, compare states, project into subspaces, decompose high-dimensional data, analyze networks, approximate dynamics, and support reproducible computation.

Its limits are equally important. Linear algebra does not decide what counts as evidence. It does not guarantee that a representation is adequate. It does not make approximations harmless. It does not transform association into causation. It does not eliminate uncertainty. It does not make governance unnecessary. A mathematically correct result can still be misused when interpretation outruns assumptions.

Responsible mathematical modeling means keeping computation, approximation, evidence, uncertainty, validation, and interpretation together. The goal is not to weaken mathematical modeling. The goal is to make it more trustworthy: clear about what it shows, honest about what it omits, reproducible in how it was built, and accountable in how it is used.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Representation Choices and Model Assumptions
• Scaling, Normalization, and Comparative Structure
• When Linear Models Clarify and When They Distort
• Numerical Stability and Conditioning
• Reproducible Linear Algebra Workflows with Notebooks and Documentation
• Decomposition Workflows for Systems Analysis
• Scientific Computing Workflows for Linear Algebra
• Overdetermined Systems and Least Squares Thinking
• Singular Value Decomposition
• Principal Component Analysis
• Machine Learning and Linear Algebra
• Optimization, Gradients, and Matrix Structure
• Systems Modeling
• Mathematical Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley. Available at: https://www.wiley.com/en-us/Empirical+Model+Building+and+Response+Surfaces-p-9780471810339.
• Demmel, J.W. (1997) Applied Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611971446.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Hastie, T., Tibshirani, R. and Friedman, J. (2009) The Elements of Statistical Learning. 2nd edn. New York: Springer. Available at: https://hastie.su.domains/ElemStatLearn/.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing. Available at: https://www.chelseagreen.com/product/thinking-in-systems/.
• National Academies of Sciences, Engineering, and Medicine (2019) Reproducibility and Replicability in Science. Washington, DC: National Academies Press. Available at: https://doi.org/10.17226/25303.
• Pearl, J. (2009) Causality: Models, Reasoning, and Inference. 2nd edn. Cambridge: Cambridge University Press. Available at: https://doi.org/10.1017/CBO9780511803161.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Available at: https://doi.org/10.1002/9780470725184.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484. Available at: https://doi.org/10.1038/d41586-020-01812-9.
• Strang, G. (2019) Linear Algebra and Learning from Data. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/learningfromdata/.

Back to top ↑

References

• Box, G.E.P. and Draper, N.R. (1987) Empirical Model-Building and Response Surfaces. New York: Wiley. Available at: https://www.wiley.com/en-us/Empirical+Model+Building+and+Response+Surfaces-p-9780471810339.
• Demmel, J.W. (1997) Applied Numerical Linear Algebra. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9781611971446.
• Higham, N.J. (2002) Accuracy and Stability of Numerical Algorithms. 2nd edn. Philadelphia, PA: SIAM. Available at: https://epubs.siam.org/doi/book/10.1137/1.9780898718027.
• Hastie, T., Tibshirani, R. and Friedman, J. (2009) The Elements of Statistical Learning. 2nd edn. New York: Springer. Available at: https://hastie.su.domains/ElemStatLearn/.
• Meadows, D.H. (2008) Thinking in Systems: A Primer. White River Junction, VT: Chelsea Green Publishing. Available at: https://www.chelseagreen.com/product/thinking-in-systems/.
• National Academies of Sciences, Engineering, and Medicine (2019) Reproducibility and Replicability in Science. Washington, DC: National Academies Press. Available at: https://doi.org/10.17226/25303.
• Pearl, J. (2009) Causality: Models, Reasoning, and Inference. 2nd edn. Cambridge: Cambridge University Press. Available at: https://doi.org/10.1017/CBO9780511803161.
• Saltelli, A. et al. (2008) Global Sensitivity Analysis: The Primer. Chichester: Wiley. Available at: https://doi.org/10.1002/9780470725184.
• Saltelli, A. et al. (2020) ‘Five ways to ensure that models serve society: a manifesto’, Nature, 582, pp. 482–484. Available at: https://doi.org/10.1038/d41586-020-01812-9.
• Strang, G. (2019) Linear Algebra and Learning from Data. Wellesley, MA: Wellesley-Cambridge Press. Available at: https://math.mit.edu/~gs/learningfromdata/.

Back to top ↑