The Chain Rule and Composite Change in Interacting Systems

Last Updated June 14, 2026

The chain rule is the calculus of mediated change. It explains how change moves through composite structures: one quantity changes another, which changes another, which changes the final outcome. In systems modeling, this is rarely a minor technical detail. It is how models represent pathways, cascades, feedback loops, transformations, delayed effects, and multi-stage interactions.

This article develops the chain rule as both a formal differentiation rule and a structural tool for interpreting interacting systems. It examines composite functions, nested mechanisms, state transformations, pathway sensitivity, multivariable chain rules, Jacobian composition, feedback interpretation, automatic differentiation, and model-audit workflows. The goal is not merely to compute derivatives of \(f(g(x))\), but to understand what composite change means when systems are built from linked processes.

In an interacting system, change is often indirect. Emissions alter atmospheric concentration; concentration affects forcing; forcing changes temperature; temperature affects ecological stress; stress affects productivity. A policy changes behavior; behavior changes demand; demand changes infrastructure load; load changes risk. The chain rule gives a disciplined language for tracing these pathways without pretending that the final outcome responded directly to the original input.

Many model outputs are not direct functions of inputs. They are functions of functions: \(Y=F(G(H(x)))\). That nested form may describe physical transformation, institutional mediation, computational preprocessing, behavioral response, or mathematical reparameterization. The chain rule reveals how a local perturbation travels through the layers.

Why the Chain Rule Matters

The chain rule matters because systems rarely respond in a single step. A change in one variable often passes through intermediate variables before affecting the modeled outcome. Those intermediate variables are not decorative. They shape magnitude, direction, delay, amplification, damping, and interpretation.

Suppose a model represents final outcome \(Y\) as a function of intermediate state \(Z\), and \(Z\) as a function of input \(x\):

The chain rule says:

This is a structural statement. It says that the effect of \(x\) on \(Y\) is mediated by \(Z\). If \(x\) strongly changes \(Z\), but \(Y\) is insensitive to \(Z\), the total effect may be small. If \(x\) weakly changes \(Z\), but \(Y\) is extremely sensitive to \(Z\), the total effect may still be large. If either link has zero local derivative, the local pathway can vanish. If either link is unstable, the total pathway becomes unstable.

In systems modeling, the chain rule supports pathway sensitivity, multi-stage causal diagrams, climate response models, epidemiological transmission chains, infrastructure risk models, economic input-output pathways, and machine-learning optimization. It is the rule that turns “everything is connected” into a specific mathematical decomposition.

Back to top ↑

The Formal Chain Rule

For single-variable functions, if \(g\) is differentiable at \(x\) and \(f\) is differentiable at \(g(x)\), then the composite function \(f\circ g\) is differentiable at \(x\), and:

For a deeper composition:

The derivative is:

Each factor has a distinct role. \(H'(t)\) measures how the first state responds to time or input. \(G'(H(t))\) measures how the second transformation responds to that state. \(F'(G(H(t)))\) measures how the final output responds to the transformed intermediate state. The derivative is not merely a number; it is a pathway product.

This structure also explains why chain-rule claims must be local. The derivative is evaluated at the current operating point. A pathway that is sensitive in one regime may be insensitive in another. A transformation may saturate, change sign, become nondifferentiable, or leave the valid model domain.

Back to top ↑

Composite Change and Pathway Interpretation

Composite change occurs when a change in one quantity affects another through one or more intermediate transformations. The chain rule provides a compact expression for total local sensitivity, but the modeling interpretation requires more than the formula.

A composite pathway has three interpretive layers:

The chain rule says that the total local response is a product of pathway sensitivities. But it does not say that the pathway is empirically true, causally complete, globally stable, or policy-reliable. Those questions require model validation, data analysis, domain knowledge, uncertainty analysis, and governance review.

Composite change can also be amplifying or dampening. If each link has magnitude greater than one in appropriate units, small upstream changes may become large downstream changes. If each link has magnitude less than one, a shock may be dampened. If some links are negative, the pathway may reverse direction. If some links are near zero, the pathway may be locally blocked.

For responsible interpretation, analysts should report the total derivative and the component derivatives. A chain-rule derivative should be explained as a sequence of linked sensitivities rather than a black-box derivative value.

Back to top ↑

Nested Mechanisms in Systems Models

Nested mechanisms are common in systems modeling. A variable is transformed into an index; the index is transformed into a risk score; the risk score is transformed into a decision threshold; the decision threshold changes an intervention; the intervention changes system behavior. The chain rule helps trace how a perturbation moves through this nested structure.

Consider a sustainability model:

The derivative is:

This representation clarifies the model’s pathway. It also reveals points where uncertainty may enter. The emissions pathway, concentration model, forcing relationship, and temperature response each have assumptions. The total derivative inherits those assumptions.

A nested mechanism is therefore not automatically more realistic than a simple model. It is more structured. That structure must be documented. Each link should be interpretable, differentiable where needed, valid over the operating range, and appropriate for the modeling purpose.

Back to top ↑

Interacting Systems and Mediated Effects

Interacting systems often combine chain-rule and product-rule structure. A pathway may involve nested transformations, while each transformation depends on multiple factors. For example, disease transmission may depend on contact behavior, susceptibility, infectiousness, immunity, intervention response, mobility patterns, and reporting processes. A change in policy can influence behavior, behavior can influence contact rate, contact rate can influence transmission, and transmission can influence observed prevalence.

A simplified pathway might be:

The chain rule gives:

This formula is helpful precisely because it resists oversimplification. It does not say that policy directly changes outcomes. It says that a particular model represents policy effects through intermediate mechanisms. If behavior does not respond, the pathway may be weak. If contact responds strongly but outcome is saturated, the pathway may still be weak. If the intermediate relationship changes over time, the derivative may drift.

In interacting systems, the chain rule should be paired with structural judgment. Are the links sequential or simultaneous? Are there feedback loops? Are intermediate variables observed or inferred? Are units compatible? Are there lags? Are there thresholds or discontinuities? These questions determine whether a chain-rule interpretation is meaningful.

Back to top ↑

Feedback, Recursion, and Circular Dependence

Feedback systems complicate simple chain-rule interpretation because a downstream variable may influence an upstream variable. The pathway is no longer purely one-directional. Change may circulate through a loop.

A simplified feedback relation might be:

Substitution gives a composite system:

The derivative includes both direct and indirect pathways:

This is a crucial distinction. Feedback derivatives often combine partial derivatives and chain-rule terms. The direct pathway and feedback pathway can reinforce, cancel, or destabilize each other. A negative feedback may dampen change. A positive feedback may amplify change. A delayed feedback may produce oscillation or overshoot.

The chain rule helps identify mediated effects, but feedback systems require additional analysis: stability, eigenvalues, fixed points, delays, nonlinear response, and regime boundaries. Chain-rule decomposition is the beginning of feedback interpretation, not the end.

Back to top ↑

The Multivariable Chain Rule

Many systems models have multiple inputs and multiple intermediate states. In this setting, the chain rule is expressed using gradients and Jacobians.

If \(g:\mathbb{R}^n\to\mathbb{R}^m\) and \(f:\mathbb{R}^m\to\mathbb{R}\), then \(h=f\circ g\) maps \(\mathbb{R}^n\to\mathbb{R}\). The derivative of \(h\) with respect to input \(x\) is:

If both functions are vector-valued, \(g:\mathbb{R}^n\to\mathbb{R}^m\) and \(f:\mathbb{R}^m\to\mathbb{R}^k\), then:

This formula is central to multivariable systems modeling. A perturbation vector passes through a sequence of local linear maps. Each map changes direction, scale, and coupling. The final sensitivity depends on how these maps compose.

The multivariable chain rule is also the mathematical foundation for many computational methods: backpropagation, automatic differentiation, adjoint sensitivity, gradient-based calibration, and differentiable simulation. Yet the same interpretive warnings remain. The derivative of a computational graph describes the implemented model, not automatically the real system.

Back to top ↑

Jacobians and Local Linear Maps

The Jacobian gives the local linear approximation of a vector-valued function. If \(F:\mathbb{R}^n\to\mathbb{R}^m\), then:

For a composite system:

The Jacobian chain rule is:

This local-linear-map view is more powerful than treating the chain rule as a symbolic formula. It shows how perturbations move through model architecture. A direction in input space may be amplified, rotated, dampened, or collapsed. Some input directions may strongly affect output; others may lie near a null direction of the composite map.

For interacting systems, Jacobian composition helps analyze sensitivity pathways, stability near equilibria, parameter identifiability, feedback strength, and multi-output response. It also gives a natural bridge to eigenvalue analysis, singular values, conditioning, and numerical stability.

Back to top ↑

Automatic Differentiation and Computational Graphs

Automatic differentiation applies chain-rule logic to computer programs. A program is decomposed into elementary operations. Each operation has a local derivative. The derivative of the full computation is obtained by composing local derivatives across the computational graph.

For a simple computation:

The derivative is:

This is the basic logic behind many machine-learning gradients, optimization systems, differentiable simulations, and scientific-computing workflows. Reverse-mode automatic differentiation is especially useful when there are many inputs and one scalar objective, because it efficiently propagates sensitivities backward from the output.

But automatic differentiation also creates a modeling distinction. It differentiates the program that was written. If the program contains discontinuities, clipping, conditionals, approximations, missing physics, empirical regressions, or governance assumptions, the computed derivative reflects those implementation choices. The derivative of the code is not automatically the derivative of the world.

Responsible use requires documenting the computational graph, differentiability assumptions, nondifferentiable branches, smoothing choices, and whether the derivative is being used for explanation, prediction, optimization, or decision support.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. The chain rule is not merely a symbolic rule for nested functions. It is a theorem about composition of local approximations. In higher dimensions, it states that derivative maps compose as linear maps.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for chain-rule models should record each pathway link, each local derivative, the total composite derivative, domain conditions, differentiability warnings, and numerical checks. A single total derivative is rarely enough for interpretation.

Symbolic differentiation can produce formulas for simple composite functions. Automatic differentiation can compute derivatives for complex computational graphs. Finite differences can provide numerical checks. But each method has limitations. Symbolic formulas may exceed model domains. Automatic differentiation may silently differentiate implementation details. Finite differences may fail near thresholds, discontinuities, or poorly scaled variables.

A reproducible workflow should therefore include pathway records. For each composite derivative, it should document the input, intermediate variables, output, local derivative at each link, product of derivatives, numerical comparison, and warnings about invalid domains, nondifferentiable points, or unstable scales.

Back to top ↑

Python Workflow: Chain-Rule Pathway Audit

The Python workflow below computes a chain-rule pathway audit for a simplified climate response model.

from __future__ import annotations

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


@dataclass(frozen=True)
class ChainRuleAudit:
    t: float
    emissions: float
    concentration: float
    forcing: float
    temperature: float
    emissions_rate: float
    d_concentration_d_emissions: float
    d_forcing_d_concentration: float
    d_temperature_d_forcing: float
    total_derivative: float
    finite_difference_check: float
    absolute_error: float
    warning: str


def emissions(t: float) -> float:
    return 50.0 * math.exp(0.015 * t)


def emissions_rate(t: float) -> float:
    return 0.015 * emissions(t)


def concentration(e: float) -> float:
    return 0.5 * e


def d_concentration_d_emissions(_: float) -> float:
    return 0.5


def forcing(c: float) -> float:
    return math.log(1.0 + c)


def d_forcing_d_concentration(c: float) -> float:
    return 1.0 / (1.0 + c)


def temperature_response(f: float) -> float:
    return 1.2 * f


def d_temperature_d_forcing(_: float) -> float:
    return 1.2


def temperature_pathway(t: float) -> float:
    e = emissions(t)
    c = concentration(e)
    f = forcing(c)
    return temperature_response(f)


def finite_difference(t: float, h: float = 1e-4) -> float:
    return (temperature_pathway(t + h) - temperature_pathway(t - h)) / (2.0 * h)


def chain_rule_audit(t: float) -> ChainRuleAudit:
    e = emissions(t)
    c = concentration(e)
    f = forcing(c)
    temp = temperature_response(f)

    local_1 = emissions_rate(t)
    local_2 = d_concentration_d_emissions(e)
    local_3 = d_forcing_d_concentration(c)
    local_4 = d_temperature_d_forcing(f)

    total = local_4 * local_3 * local_2 * local_1
    fd = finite_difference(t)
    error = abs(total - fd)

    warning = ""
    if error > 1e-5:
        warning = "finite-difference check differs from chain-rule derivative"

    return ChainRuleAudit(
        t=t,
        emissions=e,
        concentration=c,
        forcing=f,
        temperature=temp,
        emissions_rate=local_1,
        d_concentration_d_emissions=local_2,
        d_forcing_d_concentration=local_3,
        d_temperature_d_forcing=local_4,
        total_derivative=total,
        finite_difference_check=fd,
        absolute_error=error,
        warning=warning
    )


rows = [chain_rule_audit(t) for t in [0, 5, 10, 20, 40]]

output_dir = Path("outputs/tables")
output_dir.mkdir(parents=True, exist_ok=True)

with (output_dir / "chain_rule_pathway_audit.csv").open("w", newline="", encoding="utf-8") as handle:
    writer = csv.DictWriter(handle, fieldnames=asdict(rows[0]).keys())
    writer.writeheader()
    for row in rows:
        writer.writerow(asdict(row))

print("Wrote chain-rule pathway audit.")

This workflow records each local derivative rather than hiding the composite derivative inside a single value. That makes the pathway auditable and easier to interpret.

Back to top ↑

R Workflow: Composite Sensitivity Decomposition

The R workflow below decomposes a composite pathway into local sensitivities and a total chain-rule derivative.

# The Chain Rule and Composite Change in Interacting Systems
# Base R workflow for chain-rule pathway decomposition.

emissions <- function(t) {
  50 * exp(0.015 * t)
}

emissions_rate <- function(t) {
  0.015 * emissions(t)
}

concentration <- function(e) {
  0.5 * e
}

d_concentration_d_emissions <- function(e) {
  0.5
}

forcing <- function(c) {
  log(1 + c)
}

d_forcing_d_concentration <- function(c) {
  1 / (1 + c)
}

temperature_response <- function(f) {
  1.2 * f
}

d_temperature_d_forcing <- function(f) {
  1.2
}

chain_rule_audit <- function(t) {
  e <- emissions(t)
  c <- concentration(e)
  f <- forcing(c)
  temp <- temperature_response(f)

  local_1 <- emissions_rate(t)
  local_2 <- d_concentration_d_emissions(e)
  local_3 <- d_forcing_d_concentration(c)
  local_4 <- d_temperature_d_forcing(f)

  total_derivative <- local_4 * local_3 * local_2 * local_1

  data.frame(
    t = t,
    emissions = e,
    concentration = c,
    forcing = f,
    temperature = temp,
    emissions_rate = local_1,
    d_concentration_d_emissions = local_2,
    d_forcing_d_concentration = local_3,
    d_temperature_d_forcing = local_4,
    total_derivative = total_derivative
  )
}

results <- do.call(rbind, lapply(c(0, 5, 10, 20, 40), chain_rule_audit))

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

print(results)

The workflow makes the pathway explicit: emissions rate, concentration sensitivity, forcing sensitivity, and temperature sensitivity combine into the total derivative.

Back to top ↑

Haskell Workflow: Typed Composite Pathways

Haskell can represent composite pathways with typed records, helping distinguish intermediate states, local sensitivities, and final derivatives.

module Main where

newtype Time = Time Double deriving (Show)
newtype Emissions = Emissions Double deriving (Show)
newtype Concentration = Concentration Double deriving (Show)
newtype Forcing = Forcing Double deriving (Show)
newtype Temperature = Temperature Double deriving (Show)
newtype Sensitivity = Sensitivity Double deriving (Show)

data ChainRuleAudit = ChainRuleAudit
  { time :: Time
  , emissionsValue :: Emissions
  , concentrationValue :: Concentration
  , forcingValue :: Forcing
  , temperatureValue :: Temperature
  , emissionsRateValue :: Sensitivity
  , concentrationSensitivity :: Sensitivity
  , forcingSensitivity :: Sensitivity
  , temperatureSensitivity :: Sensitivity
  , totalDerivative :: Sensitivity
  } deriving (Show)

emissions :: Time -> Double
emissions (Time t) =
  50.0 * exp (0.015 * t)

emissionsRate :: Time -> Double
emissionsRate t =
  0.015 * emissions t

concentration :: Emissions -> Double
concentration (Emissions e) =
  0.5 * e

dConcentrationDEmissions :: Emissions -> Double
dConcentrationDEmissions _ =
  0.5

forcing :: Concentration -> Double
forcing (Concentration c) =
  log (1.0 + c)

dForcingDConcentration :: Concentration -> Double
dForcingDConcentration (Concentration c) =
  1.0 / (1.0 + c)

temperatureResponse :: Forcing -> Double
temperatureResponse (Forcing f) =
  1.2 * f

dTemperatureDForcing :: Forcing -> Double
dTemperatureDForcing _ =
  1.2

chainRuleAudit :: Time -> ChainRuleAudit
chainRuleAudit t =
  let e = emissions t
      c = concentration (Emissions e)
      f = forcing (Concentration c)
      temp = temperatureResponse (Forcing f)
      s1 = emissionsRate t
      s2 = dConcentrationDEmissions (Emissions e)
      s3 = dForcingDConcentration (Concentration c)
      s4 = dTemperatureDForcing (Forcing f)
      total = s4 * s3 * s2 * s1
  in ChainRuleAudit
      { time = t
      , emissionsValue = Emissions e
      , concentrationValue = Concentration c
      , forcingValue = Forcing f
      , temperatureValue = Temperature temp
      , emissionsRateValue = Sensitivity s1
      , concentrationSensitivity = Sensitivity s2
      , forcingSensitivity = Sensitivity s3
      , temperatureSensitivity = Sensitivity s4
      , totalDerivative = Sensitivity total
      }

main :: IO ()
main = do
  mapM_ (print . chainRuleAudit . Time) [0.0, 5.0, 10.0, 20.0, 40.0]

The typed workflow helps prevent the pathway from collapsing into an anonymous derivative. Each intermediate state and local sensitivity remains visible.

Back to top ↑

SQL Workflow: Chain-Rule Assumption Registry

SQL can document chain-rule assumptions and pathway warnings in a model registry.

CREATE TABLE chain_rule_assumption_registry (
    assumption_key TEXT PRIMARY KEY,
    assumption_name TEXT NOT NULL,
    mathematical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_warning TEXT NOT NULL
);

INSERT INTO chain_rule_assumption_registry VALUES
(
  'domain_compatibility',
  'Domain compatibility',
  'The image of the inner function must lie in the domain of the outer function.',
  'Ensures that the composite pathway is meaningful.',
  'A formal composition can fail if intermediate values leave the valid domain.'
);

INSERT INTO chain_rule_assumption_registry VALUES
(
  'differentiable_links',
  'Differentiable links',
  'Every link in the pathway must be differentiable at the relevant point.',
  'Supports local sensitivity propagation through the pathway.',
  'Thresholds, clipping, discontinuities, and branches can break differentiability.'
);

INSERT INTO chain_rule_assumption_registry VALUES
(
  'pathway_interpretation',
  'Pathway interpretation',
  'The total derivative is a product or composition of local derivative maps.',
  'Allows analysts to identify amplification, damping, and sign reversal along the pathway.',
  'A pathway derivative is not automatically causal proof.'
);

INSERT INTO chain_rule_assumption_registry VALUES
(
  'local_validity',
  'Local validity',
  'A chain-rule derivative is evaluated at a specific operating point.',
  'Prevents local sensitivity from being overstated as a global relationship.',
  'Composite sensitivities can change across regimes, thresholds, and boundaries.'
);

INSERT INTO chain_rule_assumption_registry VALUES
(
  'implementation_warning',
  'Implementation warning',
  'Automatic differentiation applies chain-rule logic to implemented code.',
  'Supports reproducible computational derivatives.',
  'The derivative of code is not automatically the derivative of the real-world system.'
);

SELECT
    assumption_name,
    mathematical_role,
    systems_modeling_role,
    review_warning
FROM chain_rule_assumption_registry
ORDER BY assumption_key;

This registry makes the chain-rule pathway auditable. It records that domain compatibility, differentiable links, local validity, and implementation details are part of the derivative claim.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports chain-rule pathway audits, composite sensitivity decomposition, multistage transformation records, feedback-mediated derivative examples, Jacobian composition notes, automatic-differentiation warnings, typed composite pathway records, chain-rule assumption registries, reproducible notebooks, documentation, generated outputs, and advanced mathematical audit reports.

Back to top ↑

Interpretive Limits and Responsible Use

The chain rule can make composite pathways legible, but it can also create false confidence. A chain-rule derivative is only as reliable as the model structure and assumptions behind each link. If the pathway is misspecified, the derivative may be mathematically correct but substantively misleading.

Responsible use requires several checks. State the full pathway. Identify the input, intermediate variables, and output. Document each local derivative. Confirm domain compatibility. Check differentiability at every relevant link. Report units through the pathway. Identify thresholds, saturations, clipping, conditionals, and discontinuities. Distinguish implemented computational derivatives from real-system sensitivities. Avoid treating pathway decomposition as causal proof unless supported by empirical and theoretical evidence.

The chain rule is powerful because it shows how change is mediated. Its central modeling question is not only “What is the derivative of the composite?” but “Which pathway carries the change, where is it amplified or dampened, and which assumptions make that pathway meaningful?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• The Quotient Rule and Relative Change
• Rules of Differentiation and Model Structure
• Derivatives and Rates of Change
• Differentiability and Local Behavior
• Partial Derivatives and Multivariable Change
• Gradients, Jacobians, and Vector Fields
• Optimization and Critical Points in Systems Modeling
• Systems Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• Apostol, T.M. (1967) Calculus, Volume 1: One-Variable Calculus, with an Introduction to Linear Algebra. 2nd edn. New York: Wiley.
• Spivak, M. (2008) Calculus. 4th edn. Houston, TX: Publish or Perish.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill.
• Abbott, S. (2015) Understanding Analysis. 2nd edn. New York: Springer.
• Courant, R. and John, F. (1999) Introduction to Calculus and Analysis, Volume I. Berlin: Springer.
• Hubbard, J.H. and Hubbard, B.B. (2015) Vector Calculus, Linear Algebra, and Differential Forms: A Unified Approach. 5th edn. Ithaca, NY: Matrix Editions.
• Griewank, A. and Walther, A. (2008) Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2010) Single Variable Calculus. Cambridge, MA: MIT OpenCourseWare.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2020) Real Analysis. Cambridge, MA: MIT OpenCourseWare.
• OpenStax (2016a) Calculus Volume 1. Houston, TX: OpenStax, Rice University.

Back to top ↑

References

• Abbott, S. (2015) Understanding Analysis. 2nd edn. New York: Springer.
• Apostol, T.M. (1967) Calculus, Volume 1: One-Variable Calculus, with an Introduction to Linear Algebra. 2nd edn. New York: Wiley.
• Courant, R. and John, F. (1999) Introduction to Calculus and Analysis, Volume I. Berlin: Springer.
• Griewank, A. and Walther, A. (2008) Evaluating Derivatives: Principles and Techniques of Algorithmic Differentiation. 2nd edn. Philadelphia, PA: Society for Industrial and Applied Mathematics.
• Hubbard, J.H. and Hubbard, B.B. (2015) Vector Calculus, Linear Algebra, and Differential Forms: A Unified Approach. 5th edn. Ithaca, NY: Matrix Editions.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2010) Single Variable Calculus. Cambridge, MA: MIT OpenCourseWare.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2020) Real Analysis. Cambridge, MA: MIT OpenCourseWare.
• Nocedal, J. and Wright, S.J. (2006) Numerical Optimization. 2nd edn. New York: Springer.
• OpenStax (2016a) Calculus Volume 1. Houston, TX: OpenStax, Rice University.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill.
• Spivak, M. (2008) Calculus. 4th edn. Houston, TX: Publish or Perish.

Back to top ↑