Representation Choices and Model Assumptions: How Linear Algebra Defines What Systems Models Can See

Last Updated July 6, 2026

Representation choices and model assumptions explain how linear algebra models decide what counts as structure before any computation begins. A matrix is never a neutral container. Its rows, columns, entries, zeros, units, scale, aggregation, encoding, weighting, missing values, coordinate system, and transformations all express assumptions about what matters in the system being modeled.

This article begins Part IX of the Linear Algebra for Systems Modeling series by connecting representation choices, model assumptions, matrix construction, feature design, basis selection, coordinate systems, scaling, normalization, aggregation, discretization, categorical encoding, missingness, zero interpretation, adjacency structure, state definitions, measurement choices, simplification, abstraction, uncertainty, and responsible interpretation.

The central modeling question is not only “What matrix should we compute with?” It is “What assumptions have already entered the model through the way the system was represented as a matrix?”

Linear algebra often appears to begin once a matrix has been written down. But modeling begins earlier. It begins when a system is converted into rows, columns, coordinates, variables, features, states, weights, coefficients, constraints, distances, flows, or probabilities. That conversion is representation.

Representation determines what the model can see. It also determines what the model ignores. A transportation network represented as an adjacency matrix emphasizes connectivity. The same network represented as a weighted flow matrix emphasizes capacity and movement. The same system represented as a state-transition matrix emphasizes dynamics. None of these representations is simply “the system.” Each is a structured interpretation of the system for a particular purpose.

Why Representation Choices Matter

Representation choices matter because they define the model’s evidence before the model produces results. The same system can be represented through different matrices, and those matrices can produce different conclusions even when each computation is internally correct.

A model of infrastructure can represent physical connectivity, travel time, capacity, cost, failure probability, energy demand, or dependency. A model of an economy can represent transactions, technical coefficients, emissions, employment, imports, or financial exposure. A model of knowledge can represent documents, terms, embeddings, citations, topics, or semantic similarity. Each representation foregrounds some structure and background others.

Representation is the first layer of model judgment. Computation cannot remove that judgment; it can only operate within it.

Back to top ↑

Representation Before Computation

Before a solver, decomposition, simulation, or visualization is chosen, the system must be represented. This step defines what becomes data, what becomes structure, what becomes noise, what becomes a constraint, and what remains outside the model.

The representation step is often treated as preprocessing, but it is actually modeling. A row is a choice. A column is a choice. A unit is a choice. A normalization rule is a choice. A missing-value strategy is a choice. A boundary around the system is a choice.

A reproducible workflow should document these choices before presenting the result of any computation.

Back to top ↑

Matrices as Modeling Objects

A matrix is both a mathematical object and a modeling object. Mathematically, it has entries, rows, columns, rank, null space, column space, eigenvalues, singular values, norms, and decompositions. As a modeling object, it has provenance, units, measurement assumptions, boundary decisions, encoding rules, and interpretive limits.

When the representation rule changes, the mathematical object changes. A binary adjacency matrix, weighted adjacency matrix, normalized Laplacian, transition matrix, and distance matrix can describe the same network but support different questions.

The matrix should be read as a structured claim about the system, not only as data waiting for computation.

Back to top ↑

Rows, Columns, and System Boundaries

Rows and columns define what enters the model. They also define what is left out. A model of cities may use neighborhoods, census tracts, grid cells, households, firms, or road intersections as rows. Each choice changes the structure that linear algebra can analyze.

System boundaries decide what is inside the matrix. A boundary may be geographic, institutional, temporal, disciplinary, technological, or conceptual. Boundary choices affect rank, sparsity, connectivity, eigenstructure, centrality, estimated coefficients, and model interpretation.

Rows, columns, and boundaries should be documented as modeling assumptions, not treated as obvious facts.

Back to top ↑

Features, Variables, and State Definitions

Feature and variable choices determine the dimensions of comparison. In data matrices, columns often represent features. In state-space models, vectors represent system states. In input-output models, variables may represent sector outputs or demands. In optimization, variables represent decisions.

Changing the variable set can change the model’s apparent structure. Adding a feature can reveal dependence. Removing a feature can hide confounding. Combining variables can simplify the model but obscure variation. Splitting variables can reveal heterogeneity but increase complexity.

Feature design is not a merely technical step. It defines what the linear algebra model considers comparable, relevant, and measurable.

Back to top ↑

Coordinate Systems and Basis Choices

Linear algebra represents objects in coordinate systems. A vector’s components depend on a basis. A transformation’s matrix depends on input and output coordinates. A decomposition may reveal structure relative to a chosen basis. PCA, SVD, Fourier methods, wavelets, embeddings, and state-space models all depend on representation choices.

A coordinate system can clarify structure by aligning representation with meaningful directions. It can also distort interpretation if components are treated as natural when they are only artifacts of a chosen basis.

Changing coordinates can be mathematically valid while changing what is easy, difficult, or dangerous to interpret.

Back to top ↑

Units, Scale, and Comparability

Units and scale shape both computation and interpretation. A matrix containing dollars, percentages, counts, distances, emissions, probabilities, and binary indicators cannot be interpreted responsibly without unit documentation and scaling decisions.

Scaling can improve conditioning, comparability, and model performance. It can also change meaning. In a standardized feature matrix, one unit no longer means one dollar, one kilometer, or one ton. It means one standard deviation. That may be appropriate for some analyses and misleading for others.

Scale choices should match the modeling question and should be disclosed wherever outputs are interpreted.

Back to top ↑

Zero Meaning and Missingness

Zeros are especially important in matrix representation. A zero may mean no relationship, no measurement, no flow, no event, no cost, no probability, no value, not applicable, or missing data encoded as zero. These meanings are not interchangeable.

Missingness also carries structure. Data may be missing randomly, systematically, institutionally, politically, or because the system does not observe certain populations or relationships.

Zero and missing-value assumptions should be documented because they affect sparsity, rank, distance, similarity, decomposition, regression, clustering, optimization, and interpretation.

Back to top ↑

Aggregation, Discretization, and Resolution

Aggregation combines smaller units into larger units. Discretization turns continuous systems into finite states, cells, bins, intervals, or categories. Resolution determines the level of detail used in representation.

These choices affect the structure that linear algebra can reveal. A city modeled by neighborhoods is different from a city modeled by parcels, intersections, households, or grid cells. A climate field represented by coarse spatial cells can hide local extremes. A time series aggregated monthly can hide daily volatility.

Aggregation and discretization should be chosen for the question, not only for convenience or data availability.

Back to top ↑

Categorical Encoding and Feature Design

Linear algebra requires numerical representation, so categorical information often must be encoded. Categories can be represented through one-hot encoding, ordinal encoding, embeddings, group indicators, contrast coding, or learned representations. Each approach carries assumptions.

Feature design is often where social, institutional, and measurement assumptions enter a model most quietly.

Back to top ↑

Network Representation Choices

Networks can be represented through adjacency matrices, weighted adjacency matrices, incidence matrices, Laplacians, transition matrices, distance matrices, flow matrices, or multilayer tensors. Each representation emphasizes different structure.

Network representation should match the question: connectivity, flow, influence, vulnerability, diffusion, reliability, or control.

Back to top ↑

Dynamic System Representation

Dynamic systems require state definitions. A state vector represents what is known or modeled at a given time. A transition matrix represents how the state changes. These choices determine what kind of dynamics the model can express.

The state vector might include population, inventory, demand, infection status, network load, financial exposure, environmental variables, or machine learning features. A different state definition produces a different model.

Dynamic representation choices determine what changes the model can recognize and what changes it cannot see.

Back to top ↑

Assumption Registers

An assumption register is a structured record of the modeling choices that define the representation. It should list not only mathematical assumptions but also data, measurement, encoding, boundary, scaling, and interpretation assumptions.

Assumption registers make the modeling judgment visible. They also make it easier to test whether conclusions change when representation choices change.

Back to top ↑

Representation Sensitivity

Representation sensitivity asks how conclusions change under different reasonable representations of the same system. This is different from numerical sensitivity. Numerical sensitivity asks how outputs change under small perturbations to numbers. Representation sensitivity asks how outputs change when modeling choices change.

Representation-sensitive conclusions should be communicated with caution. Representation-stable conclusions may be more robust, but they still require interpretation and validation.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer. Representation choices connect matrix construction, coordinate systems, basis selection, variable encoding, scaling, normalization, aggregation, rank structure, sparsity, distance metrics, similarity measures, projections, transformations, decomposition interpretation, and model assumptions.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for representation choices and model assumptions should document matrix source, row meaning, column meaning, value meaning, zero meaning, missing-value treatment, units, scaling, feature encoding, aggregation, discretization, coordinate system, basis choice, boundary decisions, transformation rules, rank effects, sparsity effects, sensitivity comparisons, validation checks, and interpretation warnings.

The companion repository treats representation as an auditable layer of systems modeling. 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 assumption documentation, representation diagnostics, sensitivity comparison, and responsible interpretation.

For this article, the computational examples focus on comparing two representation choices for the same small system: raw units and standardized values. The workflow records how scaling changes norms, column magnitudes, comparability, and interpretation warnings.

Back to top ↑

Python Workflow: Representation Assumption Audit

The Python workflow below creates a compact representation audit. It compares raw and standardized representations, records matrix metadata, computes column norms, checks zero meaning, and exports an assumption register.

from __future__ import annotations

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


@dataclass(frozen=True)
class RepresentationAssumptionAudit:
    workflow_name: str
    matrix_shape: str
    row_meaning: str
    column_meaning: str
    value_meaning: str
    zero_meaning: str
    missing_value_rule: str
    raw_column_norm_1: float
    raw_column_norm_2: float
    standardized_column_norm_1: float
    standardized_column_norm_2: float
    representation_change_warning: str
    interpretation_warning: str


def column(values: list[list[float]], index: int) -> list[float]:
    return [row[index] for row in values]


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


def std(values: list[float]) -> float:
    m = mean(values)
    variance = sum((x - m) ** 2 for x in values) / len(values)
    return math.sqrt(variance)


def norm2(values: list[float]) -> float:
    return math.sqrt(sum(x * x for x in values))


def standardize_matrix(A: list[list[float]]) -> list[list[float]]:
    cols = list(zip(*A))
    means = [mean(list(col)) for col in cols]
    stds = [std(list(col)) or 1.0 for col in cols]

    return [
        [(row[j] - means[j]) / stds[j] for j in range(len(row))]
        for row in A
    ]


def build_audit() -> RepresentationAssumptionAudit:
    # Rows represent three infrastructure zones.
    # Columns represent annual demand and outage exposure in different units.
    A_raw = [
        [1200.0, 0.08],
        [1800.0, 0.15],
        [900.0, 0.04],
    ]

    A_standardized = standardize_matrix(A_raw)

    return RepresentationAssumptionAudit(
        workflow_name="representation_assumption_audit",
        matrix_shape="3x2",
        row_meaning="infrastructure_zones",
        column_meaning="annual_demand_and_outage_exposure",
        value_meaning="mixed_units_before_standardization",
        zero_meaning="zero_would_mean_measured_absence_not_missingness",
        missing_value_rule="missing_values_must_not_be_encoded_as_zero_without_flag",
        raw_column_norm_1=round(norm2(column(A_raw, 0)), 12),
        raw_column_norm_2=round(norm2(column(A_raw, 1)), 12),
        standardized_column_norm_1=round(norm2(column(A_standardized, 0)), 12),
        standardized_column_norm_2=round(norm2(column(A_standardized, 1)), 12),
        representation_change_warning=(
            "Standardization improves comparability but changes interpretation from original units to relative position."
        ),
        interpretation_warning=(
            "Representation choices define what the model can compare, reveal, and hide. "
            "Rows, columns, units, zeros, scaling, missingness, and boundaries should be documented before computation."
        ),
    )


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

    report = [
        "# Representation Assumption Audit",
        "",
        f"- Workflow: {audit.workflow_name}",
        f"- Matrix shape: {audit.matrix_shape}",
        f"- Row meaning: {audit.row_meaning}",
        f"- Column meaning: {audit.column_meaning}",
        f"- Value meaning: {audit.value_meaning}",
        f"- Zero meaning: {audit.zero_meaning}",
        f"- Representation warning: {audit.representation_change_warning}",
        "",
        audit.interpretation_warning,
    ]

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


if __name__ == "__main__":
    write_outputs(Path("outputs"))
    print("Representation assumption audit complete.")

This workflow keeps representation choices attached to the computation instead of treating them as invisible preprocessing decisions.

Back to top ↑

R Workflow: Representation Diagnostics

R can support the same representation audit by comparing raw and standardized matrices, recording column norms, and exporting an assumption record.

A_raw <- matrix(
  c(
    1200.0, 0.08,
    1800.0, 0.15,
    900.0, 0.04
  ),
  nrow = 3,
  byrow = TRUE
)

colnames(A_raw) <- c("annual_demand", "outage_exposure")
rownames(A_raw) <- c("zone_a", "zone_b", "zone_c")

A_standardized <- scale(A_raw)

norm2 <- function(x) sqrt(sum(x^2))

audit_record <- data.frame(
  workflow_name = "representation_assumption_audit",
  matrix_shape = paste(dim(A_raw), collapse = "x"),
  row_meaning = "infrastructure_zones",
  column_meaning = "annual_demand_and_outage_exposure",
  value_meaning = "mixed_units_before_standardization",
  zero_meaning = "zero_would_mean_measured_absence_not_missingness",
  missing_value_rule = "missing_values_must_not_be_encoded_as_zero_without_flag",
  raw_column_norm_1 = norm2(A_raw[, 1]),
  raw_column_norm_2 = norm2(A_raw[, 2]),
  standardized_column_norm_1 = norm2(A_standardized[, 1]),
  standardized_column_norm_2 = norm2(A_standardized[, 2]),
  representation_change_warning = paste(
    "Standardization improves comparability but changes interpretation",
    "from original units to relative position."
  ),
  interpretation_warning = paste(
    "Representation choices define what the model can compare, reveal, and hide.",
    "Rows, columns, units, zeros, scaling, missingness, and boundaries should",
    "be documented before computation."
  )
)

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

print(audit_record)

This R workflow makes the difference between raw-unit representation and standardized representation visible and documented.

Back to top ↑

Haskell Workflow: Typed Assumption Records

Haskell can represent modeling assumptions as typed records, keeping matrix meaning, zero meaning, missing-value rules, scale choices, and interpretation warnings attached to the workflow.

module Main where

data RepresentationAssumptionAudit = RepresentationAssumptionAudit
  { workflowName :: String
  , matrixShape :: String
  , rowMeaning :: String
  , columnMeaning :: String
  , valueMeaning :: String
  , zeroMeaning :: String
  , missingValueRule :: String
  , rawColumnNorm1 :: Double
  , rawColumnNorm2 :: Double
  , standardizedColumnNorm1 :: Double
  , standardizedColumnNorm2 :: Double
  , representationChangeWarning :: String
  , interpretationWarning :: String
  } deriving (Show)

buildAudit :: RepresentationAssumptionAudit
buildAudit =
  RepresentationAssumptionAudit
    "representation_assumption_audit"
    "3x2"
    "infrastructure_zones"
    "annual_demand_and_outage_exposure"
    "mixed_units_before_standardization"
    "zero_would_mean_measured_absence_not_missingness"
    "missing_values_must_not_be_encoded_as_zero_without_flag"
    2345.21
    0.1749
    1.4142
    1.4142
    "Standardization improves comparability but changes interpretation from original units to relative position."
    "Representation choices define what the model can compare, reveal, and hide. Rows, columns, units, zeros, scaling, missingness, and boundaries should be documented before computation."

main :: IO ()
main =
  print buildAudit

The typed record makes assumptions part of the workflow output rather than an informal comment.

Back to top ↑

SQL Workflow: Representation Governance Registry

SQL can document representation assumptions when matrices support reports, dashboards, repositories, audits, or institutional decision workflows.

CREATE TABLE representation_governance_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    modeling_role TEXT NOT NULL,
    representation_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO representation_governance_registry VALUES
(
  'system_boundary',
  'System boundary',
  'Defines what is inside or outside the model.',
  'Determines which rows, columns, relationships, states, or entities can appear in the matrix.',
  'Excluded structure cannot be recovered by later computation unless the representation changes.'
);

INSERT INTO representation_governance_registry VALUES
(
  'row_column_meaning',
  'Row and column meaning',
  'Defines what rows and columns stand for.',
  'Gives matrix dimensions substantive interpretation.',
  'Rows and columns should not be treated as self-explanatory.'
);

INSERT INTO representation_governance_registry VALUES
(
  'value_meaning',
  'Value meaning',
  'Defines what matrix entries measure.',
  'Connects numeric entries to relationships, flows, probabilities, distances, or coefficients.',
  'The same number can mean different things under different representation rules.'
);

INSERT INTO representation_governance_registry VALUES
(
  'zero_meaning',
  'Zero meaning',
  'Defines whether zero means absence, measurement, missingness, thresholding, or non-applicability.',
  'Shapes sparsity, distance, rank, and interpretation.',
  'Encoding missingness as zero can create false structure.'
);

INSERT INTO representation_governance_registry VALUES
(
  'scale_choice',
  'Scale choice',
  'Defines raw units, standardization, normalization, log transformation, or other scaling rules.',
  'Affects comparability, conditioning, geometry, and interpretation.',
  'Scaling changes what distances, coefficients, and components mean.'
);

INSERT INTO representation_governance_registry VALUES
(
  'aggregation_resolution',
  'Aggregation and resolution',
  'Defines the level at which entities, time, space, or categories are represented.',
  'Controls detail, sparsity, noise, and interpretability.',
  'Aggregation can hide local variation and distributional structure.'
);

INSERT INTO representation_governance_registry VALUES
(
  'encoding_rule',
  'Encoding rule',
  'Defines how categorical, qualitative, temporal, spatial, or relational information becomes numeric.',
  'Makes information usable in linear algebra.',
  'Encoding can impose false ordering, distance, or similarity.'
);

INSERT INTO representation_governance_registry VALUES
(
  'interpretation_boundary',
  'Interpretation boundary',
  'Defines what conclusions the representation can and cannot support.',
  'Prevents computational results from being overclaimed.',
  'A correct computation can still exceed the evidence allowed by the representation.'
);

SELECT
    assumption_name,
    modeling_role,
    representation_role,
    review_warning
FROM representation_governance_registry
ORDER BY assumption_key;

This registry keeps representation choices tied to system boundaries, row and column meaning, value meaning, zero meaning, scaling, aggregation, encoding, and interpretation boundaries.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports representation assumption audits, matrix construction records, scale comparisons, zero-meaning checks, feature documentation, governance tables, generated artifacts, advanced mathematical audit reports, and reusable calculator scripts.

Back to top ↑

Interpretive Limits and Responsible Use

Representation choices are powerful because they make systems computable. They allow analysts to turn messy realities into matrices, vectors, networks, state spaces, features, coefficients, constraints, and transformations. Without representation, linear algebra cannot be applied to systems modeling.

Their limits are equally important. A representation is not the system itself. It is a structured simplification of the system. It can clarify, but it can also erase. It can reveal patterns, but it can also impose categories. It can make comparison possible, but it can also create false comparability. It can make computation precise, but it cannot make hidden assumptions disappear.

Responsible use requires documenting representation choices before interpreting results. Rows, columns, values, zeros, missingness, units, scale, features, categories, boundaries, aggregation, coordinate systems, transformations, and assumptions should be explicit. Linear algebra becomes more trustworthy when the model’s representational limits are visible, testable, and communicated alongside the computation.

Back to top ↑

Related Articles

• What Is Linear Algebra for Systems Modeling?
• Reproducible Linear Algebra Workflows with Notebooks and Documentation
• Scaling, Normalization, and Comparative Structure
• When Linear Models Clarify and When They Distort
• Interpretation, Approximation, and Responsible Mathematical Modeling
• Matrix Operations Across Modeling Languages
• Visualization of Vectors, Transformations, and State Spaces
• Numerical Stability and Conditioning
• Decomposition Workflows for Systems Analysis
• Scientific Computing Workflows for Linear Algebra
• Rank, Nullity, and Structural Dependence
• Overdetermined Systems and Least Squares Thinking
• Network Adjacency Matrices
• State Transition Models and System Dynamics
• Machine Learning and Linear Algebra
• Linear Algebra for Systems Modeling
• Mathematical Modeling
• Systems Modeling

Back to top ↑

Further Reading

• Barocas, S., Hardt, M. and Narayanan, A. (2019) Fairness and Machine Learning: Limitations and Opportunities. Available at: https://fairmlbook.org/.
• 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.
• Gitelman, L. (ed.) (2013) “Raw Data” Is an Oxymoron. Cambridge, MA: MIT Press. Available at: https://mitpress.mit.edu/9780262518284/raw-data-is-an-oxymoron/.
• 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/.
• 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/.
• Winner, L. (1980) ‘Do artifacts have politics?’, Daedalus, 109(1), pp. 121–136. Available at: https://www.jstor.org/stable/20024652.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press. Available at: https://press.uchicago.edu/ucp/books/book/chicago/S/bo8286579.html.
• Wolfram, S. (2002) A New Kind of Science. Champaign, IL: Wolfram Media. Available at: https://www.wolframscience.com/nks/.

Back to top ↑

References

• Barocas, S., Hardt, M. and Narayanan, A. (2019) Fairness and Machine Learning: Limitations and Opportunities. Available at: https://fairmlbook.org/.
• 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.
• Gitelman, L. (ed.) (2013) “Raw Data” Is an Oxymoron. Cambridge, MA: MIT Press. Available at: https://mitpress.mit.edu/9780262518284/raw-data-is-an-oxymoron/.
• 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/.
• 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/.
• Winner, L. (1980) ‘Do artifacts have politics?’, Daedalus, 109(1), pp. 121–136. Available at: https://www.jstor.org/stable/20024652.
• Winsberg, E. (2010) Science in the Age of Computer Simulation. Chicago: University of Chicago Press. Available at: https://press.uchicago.edu/ucp/books/book/chicago/S/bo8286579.html.
• Wolfram, S. (2002) A New Kind of Science. Champaign, IL: Wolfram Media. Available at: https://www.wolframscience.com/nks/.

Back to top ↑