When Linear Models Clarify and When They Distort: How Linear Algebra Supports and Limits Systems Modeling

Last Updated July 6, 2026

When linear models clarify and when they distort explains why linear algebra can be both powerful and misleading in systems modeling. Linear models clarify when relationships are approximately additive, proportional, stable, locally smooth, decomposable, or interpretable through superposition. They distort when systems involve thresholds, feedback, saturation, path dependence, strategic behavior, nonlinear interactions, changing regimes, hidden variables, or structural breaks.

This article continues Part IX of the Linear Algebra for Systems Modeling series by connecting linear approximation, additivity, proportionality, superposition, residual diagnostics, local linearization, misspecification, interaction effects, nonlinear dynamics, thresholds, saturation, feedback loops, aggregation, extrapolation, causal interpretation, validation, scale sensitivity, assumption review, and responsible mathematical modeling.

The central modeling question is not only “Can this system be represented with a linear model?” It is “What does the linear representation clarify, what does it hide, and how would we know the difference?”

Linear models are among the most useful tools in mathematical modeling because they make structure visible. They can show dependence, balance, flow, sensitivity, approximation, rank, constraint, projection, decomposition, and change. They are often the first serious language for turning a complex system into a computable form.

But the same clarity can become distortion. A line can summarize a trend while hiding thresholds. A matrix can describe average relationships while concealing feedback. A linear approximation can help near one operating point while failing under stress. A least-squares fit can reduce error while misrepresenting mechanism. A simple model can be useful, but simplicity is never free.

Why Linear Models Clarify and Distort

Linear models clarify because they make relationships explicit. They express how outputs depend on inputs, how systems of equations balance, how networks connect, how transformations act, how changes propagate, and how approximation can reduce complexity.

They distort when the model’s mathematical form becomes mistaken for the system itself. Many systems are not globally additive, proportional, independent, stable, or reversible. They may include feedback, delay, scarcity, congestion, thresholds, interactions, incentives, adaptation, nonlinear dynamics, or changing rules. A linear model may still be useful, but only when its limits are visible.

The responsible question is not whether linear models are good or bad. It is whether the linear structure fits the modeling purpose, evidence, scale, and interpretation boundary.

Back to top ↑

What Linear Models Assume

A linear model assumes that relationships can be represented through sums, scalar multiples, matrix transformations, or affine shifts. In its simplest form, a linear model maps inputs to outputs through a matrix or coefficient vector.

These assumptions are often useful. They are also strong. A linear form says that doubling an input doubles its contribution, that separate effects can be added, and that coefficients remain stable across the modeled range unless the model is explicitly local or piecewise.

Linear assumptions are not automatically wrong. They are modeling commitments that must be matched to the purpose of the analysis.

Back to top ↑

When Linearity Clarifies

Linearity clarifies when the system can be meaningfully approximated by additive or proportional structure. This often happens when relationships are small, local, stable, averaged, regulated, constrained, or intentionally designed to be linear.

Linear models also clarify when the goal is not perfect mechanism but useful structure: ranking sensitivity, estimating first-order effects, decomposing variation, checking constraints, projecting onto subspaces, solving approximate systems, or building a baseline for comparison.

A linear model is often best understood as a disciplined simplification: not the whole system, but a clear lens on one part of it.

Back to top ↑

When Linearity Distorts

Linearity distorts when it suppresses the structure that matters most. In many systems, the difference between safe and unsafe, stable and unstable, fair and unfair, efficient and overloaded, or resilient and fragile is not a constant slope. It may depend on thresholds, interactions, adaptation, feedback, constraints, scarcity, history, or context.

Linear distortion is especially dangerous when the model appears precise. Clean coefficients, low residuals, elegant matrices, and reproducible code do not prove that the representation is adequate.

Back to top ↑

Additivity and Superposition

Additivity means that separate contributions can be summed. Superposition means that the response to combined inputs equals the sum of responses to each input separately. These ideas are central to linear systems.

When superposition holds approximately, linear models can clarify how effects combine. When superposition fails, the combined effect may be greater than, less than, or different from the sum of individual effects.

Superposition is a powerful clarifying assumption. It should not be silently imposed on systems where combined effects are structurally different from separate effects.

Back to top ↑

Proportionality and Scale

Proportionality means that effects scale consistently. If input doubles, contribution doubles. This is useful in many engineering, accounting, allocation, and first-order approximation contexts. It becomes misleading when effects are nonlinear across scale.

Systems often violate proportionality. Doubling traffic does not merely double congestion near capacity. Doubling emissions does not simply double climate risk in all ranges. Doubling spending does not always double outcomes. Doubling training data does not always double model quality. Marginal effects can increase, diminish, reverse, or depend on context.

Proportionality is often useful locally and risky globally. The modeled range matters.

Back to top ↑

Local Linearization

Many nonlinear systems can be approximated locally by linear models. This is one of the most important reasons linear algebra appears throughout science, engineering, economics, machine learning, optimization, and systems modeling.

Local linearization clarifies behavior near an operating point. It supports sensitivity analysis, control, optimization, stability analysis, and small-perturbation reasoning. But local validity does not imply global validity.

A local linear model can be mathematically excellent and still become misleading when used outside its neighborhood of validity.

Back to top ↑

Residuals and Misspecification

Residuals measure what the linear model does not explain. They are not just errors to be minimized. They are diagnostic evidence about whether the model form is adequate.

Random-looking residuals may support the linear approximation. Systematic residual patterns may reveal curvature, thresholds, omitted variables, interactions, heterogeneity, measurement problems, or regime shifts.

Residual diagnostics are a bridge between computation and judgment. They help identify whether linear clarity is becoming linear distortion.

Back to top ↑

Interactions and Nonlinear Effects

Interactions occur when the effect of one variable depends on another. A purely additive linear model may miss this dependence. Interaction terms can be added to a linear regression framework, but the representation is no longer simply a sum of independent original variables.

Interactions are common in systems modeling. Infrastructure risk can depend on both exposure and maintenance. Public health outcomes can depend on both contact rates and vulnerability. Economic response can depend on both demand and capacity. Machine learning errors can depend on both feature distribution and subgroup membership.

Interactions do not make linear algebra irrelevant. They require more careful representation, diagnostics, and interpretation.

Back to top ↑

Thresholds, Saturation, and Regimes

Thresholds and saturation are common sources of linear distortion. A system may behave approximately linearly until a capacity limit, tipping point, legal boundary, physical constraint, or institutional threshold is crossed.

Saturation occurs when additional input produces smaller effects. Threshold behavior occurs when effects change sharply after a boundary. Regime change occurs when the governing relationship changes across conditions.

When thresholds or regimes matter, a single global line may be less honest than a simpler piecewise or local model with explicit boundaries.

Back to top ↑

Feedback and Dynamic Systems

Linear algebra can represent dynamic systems through state-transition matrices. This can clarify stability, growth, decay, modes, and long-run behavior. But feedback systems can also become nonlinear, adaptive, delayed, or regime-dependent.

This is useful when transition rules are stable. It distorts when the transition matrix changes with state, history, policy, behavior, capacity, adaptation, or external shocks.

Dynamic linear models are powerful, but they should be paired with regime checks, sensitivity analysis, and validation against observed system behavior.

Back to top ↑

Aggregation and Average Effects

Linear models often summarize average effects. This can clarify broad structure, but averages can hide heterogeneity. A linear coefficient may describe the average relationship while misrepresenting specific subgroups, regions, periods, sectors, or network positions.

Aggregation can also create apparent linearity. At a high level, nonlinear local patterns may appear smooth. At a low level, a simple average may hide distinct mechanisms. The choice of aggregation can therefore determine whether the model clarifies or distorts.

Averages are useful, but they should not be mistaken for universal behavior.

Back to top ↑

Extrapolation and Model Boundaries

Linear models are often most dangerous outside the range where they were fit, validated, or theoretically justified. Extrapolation assumes that the same relationship continues beyond observed evidence.

Extrapolation risk is especially high in systems with capacity limits, nonlinear response, changing behavior, policy intervention, climate extremes, economic shocks, infrastructure stress, public health thresholds, or distribution shift.

Every linear model should have an interpretation boundary. Without a boundary, clarity becomes overconfidence.

Back to top ↑

Causal Interpretation and Linear Form

A linear model can represent association, prediction, approximation, constraint, or transformation. It does not automatically represent causality. A coefficient is causal only under additional assumptions about intervention, identification, confounding, measurement, timing, and model design.

Linear form can make causal claims appear simple. But the world may contain omitted variables, selection effects, feedback, reverse causality, measurement error, and policy responses. Responsible interpretation distinguishes predictive usefulness from causal evidence.

Linear equations can support causal modeling, but linearity is not a substitute for causal design.

Back to top ↑

Diagnostic Judgment

Good linear modeling requires diagnostics, not just fitting. Diagnostics examine whether the model clarifies the intended structure or distorts it. This includes residuals, validation checks, sensitivity tests, subgroup review, scale review, out-of-sample performance, uncertainty, domain plausibility, and assumption registers.

Diagnostic judgment is how linear algebra becomes accountable systems modeling rather than merely elegant computation.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Linear models clarify through vector spaces, matrices, projections, least squares, subspaces, rank, decomposition, local approximation, residuals, and superposition. They distort when these structures are interpreted beyond their assumptions.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for linear model clarification and distortion should document model purpose, matrix construction, feature meaning, scaling choices, fitted coefficients, residual diagnostics, curvature checks, interaction checks, threshold checks, subgroup review, validation evidence, extrapolation flags, sensitivity comparisons, uncertainty, and interpretation boundaries.

The companion repository treats linearity as an auditable modeling assumption. 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 linearity review, residual analysis, misspecification diagnostics, and responsible interpretation.

For this article, the computational examples fit a simple linear model to a small synthetic system with nonlinear curvature. The workflow compares a linear fit with residual patterns, records distortion warnings, and exports a model review report.

Back to top ↑

Python Workflow: Linearity Distortion Audit

The Python workflow below fits a simple linear model to a synthetic system where the true relationship has curvature. It computes residuals, checks residual pattern, records distortion risk, and exports a model audit.

from __future__ import annotations

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


@dataclass(frozen=True)
class LinearityDistortionAudit:
    workflow_name: str
    model_purpose: str
    fitted_intercept: float
    fitted_slope: float
    residual_sum_squares: float
    max_absolute_residual: float
    residual_sign_pattern: str
    curvature_warning: str
    extrapolation_warning: str
    interpretation_warning: str


def mean(values: list[float]) -> float:
    return sum(values) / len(values)


def fit_simple_linear_model(x: list[float], y: list[float]) -> tuple[float, float]:
    x_mean = mean(x)
    y_mean = mean(y)
    numerator = sum((xi - x_mean) * (yi - y_mean) for xi, yi in zip(x, y))
    denominator = sum((xi - x_mean) ** 2 for xi in x)
    if abs(denominator) < 1e-15:
        raise ValueError("Cannot fit slope when all x values are identical.")
    slope = numerator / denominator
    intercept = y_mean - slope * x_mean
    return intercept, slope


def sign_pattern(values: list[float]) -> str:
    signs = []
    for value in values:
        if value > 1e-9:
            signs.append("+")
        elif value < -1e-9:
            signs.append("-")
        else:
            signs.append("0")
    return "".join(signs)


def build_audit() -> LinearityDistortionAudit:
    # Synthetic system: the true relationship includes curvature.
    # A linear model is useful as a baseline but should not be treated as global truth.
    x = [0.0, 1.0, 2.0, 3.0, 4.0]
    y = [1.0 + 0.7 * xi + 0.35 * xi * xi for xi in x]

    intercept, slope = fit_simple_linear_model(x, y)
    fitted = [intercept + slope * xi for xi in x]
    residuals = [yi - fi for yi, fi in zip(y, fitted)]

    rss = sum(r * r for r in residuals)
    max_abs = max(abs(r) for r in residuals)
    pattern = sign_pattern(residuals)

    curvature_warning = (
        "Residuals show a structured sign pattern consistent with curvature. "
        "The linear fit is useful as a baseline but risks distortion if interpreted as the system mechanism."
    )

    return LinearityDistortionAudit(
        workflow_name="linearity_distortion_audit",
        model_purpose="baseline_linear_approximation_for_system_behavior",
        fitted_intercept=round(intercept, 12),
        fitted_slope=round(slope, 12),
        residual_sum_squares=round(rss, 12),
        max_absolute_residual=round(max_abs, 12),
        residual_sign_pattern=pattern,
        curvature_warning=curvature_warning,
        extrapolation_warning="Do not extrapolate the fitted line beyond the observed operating range without additional validation.",
        interpretation_warning=(
            "Linear models clarify first-order structure, but residuals, thresholds, interactions, "
            "feedback, aggregation, and causal assumptions must be reviewed before using results for decisions."
        ),
    )


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" / "linearity_distortion_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" / "linearity_distortion_audit.json").write_text(
        json.dumps(row, indent=2, sort_keys=True),
        encoding="utf-8",
    )

    report = [
        "# Linearity Distortion Audit",
        "",
        f"- Workflow: {audit.workflow_name}",
        f"- Model purpose: {audit.model_purpose}",
        f"- Fitted intercept: {audit.fitted_intercept}",
        f"- Fitted slope: {audit.fitted_slope}",
        f"- Residual sum of squares: {audit.residual_sum_squares}",
        f"- Max absolute residual: {audit.max_absolute_residual}",
        f"- Residual sign pattern: {audit.residual_sign_pattern}",
        "",
        audit.curvature_warning,
        "",
        audit.extrapolation_warning,
        "",
        audit.interpretation_warning,
    ]

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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Linearity distortion audit complete.")

This workflow does not reject the linear model. It shows how to preserve the model’s usefulness while documenting where distortion risk begins.

Back to top ↑

R Workflow: Residual and Curvature Diagnostics

R can support the same audit by fitting a linear model, recording residual structure, and exporting interpretation warnings.

x <- c(0, 1, 2, 3, 4)

# Synthetic system with curvature.
y <- 1.0 + 0.7 * x + 0.35 * x^2

linear_fit <- lm(y ~ x)
fitted_values <- fitted(linear_fit)
residuals_linear <- residuals(linear_fit)

sign_pattern <- paste(
  ifelse(residuals_linear > 1e-9, "+",
    ifelse(residuals_linear < -1e-9, "-", "0")
  ),
  collapse = ""
)

audit_record <- data.frame(
  workflow_name = "linearity_distortion_audit",
  model_purpose = "baseline_linear_approximation_for_system_behavior",
  fitted_intercept = coef(linear_fit)[1],
  fitted_slope = coef(linear_fit)[2],
  residual_sum_squares = sum(residuals_linear^2),
  max_absolute_residual = max(abs(residuals_linear)),
  residual_sign_pattern = sign_pattern,
  curvature_warning = paste(
    "Residuals show a structured sign pattern consistent with curvature.",
    "The linear fit is useful as a baseline but risks distortion if interpreted",
    "as the system mechanism."
  ),
  extrapolation_warning = paste(
    "Do not extrapolate the fitted line beyond the observed operating range",
    "without additional validation."
  ),
  interpretation_warning = paste(
    "Linear models clarify first-order structure, but residuals, thresholds,",
    "interactions, feedback, aggregation, and causal assumptions must be reviewed",
    "before using results for decisions."
  )
)

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

print(audit_record)

This R workflow treats residuals as modeling evidence rather than merely fit statistics.

Back to top ↑

Haskell Workflow: Typed Linearity Review

Haskell can represent linearity review as a typed record, keeping model purpose, fitted coefficients, residual pattern, and interpretation warnings attached to the workflow output.

module Main where

data LinearityDistortionAudit = LinearityDistortionAudit
  { workflowName :: String
  , modelPurpose :: String
  , fittedIntercept :: Double
  , fittedSlope :: Double
  , residualSumSquares :: Double
  , maxAbsoluteResidual :: Double
  , residualSignPattern :: String
  , curvatureWarning :: String
  , extrapolationWarning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: LinearityDistortionAudit
buildAudit =
  LinearityDistortionAudit
    "linearity_distortion_audit"
    "baseline_linear_approximation_for_system_behavior"
    0.3
    2.1
    0.98
    0.7
    "+--+"
    "Residuals show a structured sign pattern consistent with curvature. The linear fit is useful as a baseline but risks distortion if interpreted as the system mechanism."
    "Do not extrapolate the fitted line beyond the observed operating range without additional validation."
    "Linear models clarify first-order structure, but residuals, thresholds, interactions, feedback, aggregation, and causal assumptions must be reviewed before using results for decisions."

main :: IO ()
main =
  print buildAudit

The typed record makes the warning part of the model artifact, not a separate informal caveat.

Back to top ↑

SQL Workflow: Linear Model Governance Registry

SQL can document linearity assumptions when matrix workflows support reports, dashboards, repositories, audits, or institutional decision systems.

CREATE TABLE linear_model_governance_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    modeling_role TEXT NOT NULL,
    distortion_risk TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO linear_model_governance_registry VALUES
(
  'additivity',
  'Additivity',
  'Allows separate effects to be summed in one model.',
  'Interactions or feedback can make combined effects different from the sum of individual effects.',
  'Review interaction terms, subgroup residuals, and mechanism assumptions.'
);

INSERT INTO linear_model_governance_registry VALUES
(
  'proportionality',
  'Proportionality',
  'Assumes effects scale consistently with input magnitude.',
  'Saturation, thresholds, scarcity, or overload can change marginal effects.',
  'Check whether the model is local, global, or extrapolated.'
);

INSERT INTO linear_model_governance_registry VALUES
(
  'coefficient_stability',
  'Coefficient stability',
  'Assumes relationships remain stable over the modeled range.',
  'Regime shifts, time variation, policy changes, or behavioral adaptation can change coefficients.',
  'Validate across periods, scenarios, and operating regimes.'
);

INSERT INTO linear_model_governance_registry VALUES
(
  'local_approximation',
  'Local approximation',
  'Uses a linear model to approximate behavior near an operating point.',
  'Local accuracy can be mistaken for global validity.',
  'State the operating range and check approximation error.'
);

INSERT INTO linear_model_governance_registry VALUES
(
  'residual_diagnostics',
  'Residual diagnostics',
  'Uses unexplained structure as evidence about model adequacy.',
  'Ignoring structured residuals can hide curvature, thresholds, or missing variables.',
  'Inspect residual patterns before interpreting coefficients.'
);

INSERT INTO linear_model_governance_registry VALUES
(
  'aggregation',
  'Aggregation and average effects',
  'Summarizes broad structure through average relationships.',
  'Averages can hide subgroup, spatial, temporal, or network heterogeneity.',
  'Review disaggregated behavior and subgroup errors.'
);

INSERT INTO linear_model_governance_registry VALUES
(
  'extrapolation',
  'Extrapolation',
  'Uses a fitted relationship outside the observed or validated range.',
  'Predictions may cross thresholds, constraints, or regimes not represented in the model.',
  'Flag out-of-range predictions and require additional validation.'
);

INSERT INTO linear_model_governance_registry VALUES
(
  'causal_interpretation',
  'Causal interpretation',
  'Interprets coefficients as effects of changing inputs.',
  'Association can be mistaken for causal mechanism.',
  'Separate prediction, association, mechanism, and causal identification.'
);

SELECT
    assumption_name,
    modeling_role,
    distortion_risk,
    review_warning
FROM linear_model_governance_registry
ORDER BY assumption_key;

This registry keeps linear model clarity tied to additivity, proportionality, coefficient stability, local approximation, residual diagnostics, aggregation, extrapolation, and causal interpretation.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports linearity audits, residual diagnostics, curvature checks, model boundary records, extrapolation flags, governance tables, generated artifacts, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Linear models are powerful because they make systems legible. They can identify first-order relationships, summarize dependence, expose constraints, support approximation, produce interpretable baselines, and make high-dimensional structure computable. They are often the right place to begin serious systems modeling.

Their limits are equally important. A linear model can turn an interaction into an average coefficient, a threshold into a trend, feedback into a static relationship, a local approximation into a global claim, an association into an apparent cause, and a complex system into a deceptively clean equation. The danger is not linearity itself. The danger is forgetting what linearity assumes.

Responsible use requires documenting model purpose, operating range, assumptions, residual diagnostics, validation evidence, scaling choices, subgroup behavior, extrapolation limits, causal interpretation boundaries, and distortion risks. Linear models clarify best when they are treated as structured approximations that must remain accountable to the system they simplify.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Representation Choices and Model Assumptions
• Scaling, Normalization, and Comparative Structure
• Interpretation, Approximation, and Responsible Mathematical Modeling
• Functions, Variables, and Mathematical Representation
• Derivatives and Rates of Change
• Linear Transformations and System Change
• Overdetermined Systems and Least Squares Thinking
• Numerical Stability and Conditioning
• Decomposition Workflows for Systems Analysis
• Machine Learning and Linear Algebra
• Optimization, Gradients, and Matrix Structure
• State Transition Models and System Dynamics
• 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.
• Draper, N.R. and Smith, H. (1998) Applied Regression Analysis. 3rd edn. New York: Wiley. Available at: https://www.wiley.com/en-us/Applied+Regression+Analysis%2C+3rd+Edition-p-9780471170822.
• Gelman, A., Hill, J. and Vehtari, A. (2020) Regression and Other Stories. Cambridge: Cambridge University Press. Available at: https://avehtari.github.io/ROS-Examples/.
• 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/.
• 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.
• 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/.
• 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.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill. Available at: https://web.mit.edu/jsterman/www/BusDyn2.html.
• 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.
• Draper, N.R. and Smith, H. (1998) Applied Regression Analysis. 3rd edn. New York: Wiley. Available at: https://www.wiley.com/en-us/Applied+Regression+Analysis%2C+3rd+Edition-p-9780471170822.
• Gelman, A., Hill, J. and Vehtari, A. (2020) Regression and Other Stories. Cambridge: Cambridge University Press. Available at: https://avehtari.github.io/ROS-Examples/.
• 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/.
• 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.
• 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/.
• 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.
• Sterman, J.D. (2000) Business Dynamics: Systems Thinking and Modeling for a Complex World. Boston: Irwin/McGraw-Hill. Available at: https://web.mit.edu/jsterman/www/BusDyn2.html.
• 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 ↑