Implicit Differentiation and Coupled Relationships

Last Updated June 14, 2026

Implicit differentiation is the calculus of coupled relationships. It applies when variables are bound together by an equation, constraint, equilibrium condition, conservation law, feasibility boundary, or feedback relation rather than arranged as a simple explicit function. In systems modeling, this matters because many important relationships cannot honestly be written as “output equals function of input” without hiding the structure of the system.

Implicit differentiation asks how variables co-adjust when a relationship must remain true. If \(F(x,y)=0\), then \(x\) and \(y\) are coupled. A change in \(x\) may require a compensating change in \(y\) to stay on the constraint curve. In higher dimensions, a system of equations may define an equilibrium surface, feasible manifold, calibration condition, conservation relation, or coupled state space. The derivative describes motion along that relationship, not independent movement through unconstrained space.

This article develops implicit differentiation as both a formal calculus technique and a structural tool for systems modeling. It explains constraint curves, total differentials, implicit function conditions, coupled variables, equilibrium sensitivity, feedback systems, Jacobian formulations, singular cases, boundary behavior, computational workflows, and responsible interpretation.

Many systems are defined by relationships that must hold: supply equals demand, inflow balances outflow, mass is conserved, budget constraints bind, calibration equations must match observations, equilibrium conditions define feasible states, and feedback relationships connect causes with their own consequences. Implicit differentiation gives a language for asking how one variable must change when another changes while the relationship remains valid.

Why Implicit Differentiation Matters

Implicit differentiation matters because many systems are not naturally organized as a single dependent variable explicitly solved in terms of a single independent variable. Instead, variables are jointly determined. A market price may be determined by supply and demand together. A biological steady state may be determined by growth and loss terms together. A physical state may be determined by conservation constraints. A calibrated model may be defined by a parameter value that makes a residual equation equal zero.

In these cases, asking for a derivative requires care. We are not simply asking how an output responds to an input. We are asking how variables must co-adjust to remain on a relationship. The derivative is a tangent to a constraint, not a free movement through the surrounding space.

Suppose a relationship is written as:

If \(x\) changes, \(y\) may need to change so that \(F(x,y)=0\) remains true. Implicit differentiation gives the local co-adjustment rate:

This formula is compact, but its modeling meaning is substantial. It says that the derivative depends on how strongly the constraint responds to \(x\) and how strongly it responds to \(y\). If \(F_y\) is small, the required adjustment in \(y\) may be large. If \(F_y=0\), local solvability may fail. If \(F_x\) and \(F_y\) change sign, the direction of co-adjustment may change.

Implicit differentiation is therefore central to constraint modeling, equilibrium analysis, coupled feedback systems, feasible-boundary reasoning, calibration, optimization, comparative statics, and sensitivity analysis under structural relationships.

Back to top ↑

Explicit and Implicit Models

An explicit model writes one variable directly as a function of another:

An implicit model writes a relationship that the variables must jointly satisfy:

Sometimes an implicit relationship can be solved explicitly. For example, \(x+y-10=0\) can be rewritten as \(y=10-x\). But many implicit relationships are difficult, inconvenient, multivalued, or impossible to solve globally. Even when a local explicit representation exists, the implicit form may be more meaningful because it preserves the constraint structure.

In systems modeling, implicit form is often more honest. Supply and demand jointly determine price. A constraint defines feasibility. A steady state satisfies net flow equal to zero. A calibrated parameter solves a residual equation. A policy threshold may define a boundary. These structures are not merely algebraic inconveniences; they are part of the model’s meaning.

Back to top ↑

Basic Implicit Differentiation

To differentiate an implicit relationship, treat \(y\) as a function of \(x\) locally, even if that function is not explicitly written. Starting with:

Differentiate both sides with respect to \(x\):

Solving for \(dy/dx\) gives:

For example, consider the circle:

Writing \(F(x,y)=x^2+y^2-1\), we get:

Thus:

The undefined cases do not mean the circle disappears. They mean that \(y\) cannot be represented locally as a differentiable function of \(x\) at those points. A different local parameterization may still be possible.

Back to top ↑

Total Differentials and Constraint Motion

Implicit differentiation can also be understood through total differentials. If \(F(x,y)=0\), then along the constraint:

Solving for \(dy/dx\):

This differential view is especially useful for systems modeling because it emphasizes motion along a constraint. A feasible state may not be free to move in every direction. Instead, the system’s allowed local directions are those that keep a conservation law, budget relation, equilibrium condition, or feasibility boundary satisfied.

For a constraint \(F(x,y,z)=0\), the differential is:

This reveals the geometry of constrained systems. The gradient \(\nabla F\) is normal to the constraint surface. Tangent directions \(v\) must satisfy:

Implicit differentiation therefore connects algebra, geometry, and systems interpretation. It shows not only how to compute a derivative, but what movements are allowed by the model’s structure.

Back to top ↑

The Implicit Function Theorem

The implicit function theorem gives conditions under which an implicit relationship can be treated locally as an explicit function. In one common form, suppose \(F(x,y)\) is continuously differentiable near a point \((a,b)\), \(F(a,b)=0\), and:

Then near \((a,b)\), there is a differentiable function \(y=f(x)\) such that \(F(x,f(x))=0\), and:

This theorem is more than a technical detail. It tells the modeler when a local response rate is meaningful. If the relevant partial derivative is nonzero, then the coupled relationship can locally support a derivative. If that condition fails, local solvability may break down.

In systems modeling, this matters near turning points, bifurcations, thresholds, vertical tangents, singular equilibria, and regime transitions. A model may be differentiable in a formal sense while the implicit representation becomes locally ill-conditioned. The derivative may become very large, undefined, or dependent on a different parameterization.

The implicit function theorem is therefore a regularity test. It asks whether the relationship is locally well behaved enough to support the derivative claim being made.

Back to top ↑

Coupled Relationships in Systems Modeling

A coupled relationship is one in which variables are jointly determined. Neither variable can be interpreted in isolation without the relationship that binds them. This is common in complex systems.

Examples include:

• supply and demand jointly determining price and quantity;
• population and resource availability jointly shaping carrying capacity;
• inflow, outflow, and storage jointly determining stock equilibrium;
• behavior and policy response jointly shaping disease transmission;
• load and capacity jointly determining utilization risk;
• investment, depreciation, and output jointly shaping capital accumulation;
• model parameters and residual conditions jointly determining calibration results.

Implicit differentiation asks how the coupled variables move together. If the relationship is:

Then changes in \(p\) may require changes in \(x\) and \(y\). If \(y\) is locally a function of \(x\) and \(p\), implicit differentiation can describe these local sensitivities:

This makes implicit differentiation a natural language for comparative statics and constrained sensitivity analysis. It helps explain how equilibrium states respond to parameter shifts without pretending that the equilibrium equation has a simple closed-form solution.

Back to top ↑

Equilibrium Sensitivity

Many systems models define equilibrium implicitly. A state \(x^\ast\) may be an equilibrium when net change is zero:

Implicit differentiation gives the sensitivity of the equilibrium to the parameter. Differentiating with respect to \(p\):

If \(G_x\neq 0\), then:

This is a powerful tool for systems modeling. It can estimate how a steady-state population changes with carrying capacity, how a market equilibrium changes with tax policy, how a stock-flow equilibrium changes with inflow, how a calibrated parameter changes when a target observation changes, or how a constrained optimum shifts when a constraint parameter changes.

But equilibrium sensitivity can also become unstable. If \(G_x\) is small, the equilibrium may be highly sensitive. If \(G_x=0\), the local equilibrium may lose regularity. In dynamic systems, this can signal a bifurcation, tipping point, or loss of local stability.

Back to top ↑

Feedback and Co-Adjustment

Feedback systems often create implicit relationships because outputs affect inputs, responses affect drivers, and effects alter their own causes. In such systems, co-adjustment is not optional. It is part of the model structure.

Consider a response variable \(y\) that depends on \(x\), while \(x\) also depends on \(y\):

This can be written as an implicit relationship:

Implicit differentiation can then describe how the coupled state changes when \(p\) changes. Feedback strength appears in the denominator of the sensitivity expression. When feedback is strong, small parameter changes may produce large state changes. When feedback creates near-singular conditions, the derivative may become unstable.

This is why implicit differentiation is closely related to stability analysis. A feedback loop can make a system locally robust, locally fragile, or locally indeterminate. The derivative of the implicit relationship helps diagnose whether co-adjustment is well conditioned.

In policy modeling, this is especially important. An intervention may change behavior, and behavior may change the conditions that determine the intervention’s effectiveness. Implicit differentiation helps represent this mutual adjustment without collapsing the system into a one-way causal chain.

Back to top ↑

Systems of Equations and Jacobian Form

Many coupled systems involve more than two variables and more than one equation. Suppose \(F:\mathbb{R}^n\times\mathbb{R}^m\to\mathbb{R}^n\), and an implicit system is defined by:

Differentiating gives:

If the Jacobian \(F_x\) is invertible, then:

This matrix formulation is central to scientific computing and systems modeling. It appears in equilibrium sensitivity analysis, nonlinear solvers, constrained optimization, dynamic systems, calibration, inverse problems, structural models, and policy simulation.

The expression \(-F_x^{-1}F_p\) should not be read as a purely symbolic formula. In computation, one usually solves the linear system:

This is numerically important. If \(F_x\) is ill-conditioned, the sensitivity estimate may be unreliable. If \(F_x\) is singular, local solvability may fail. If the system is near a regime transition, small parameter shifts may produce large or discontinuous changes.

Back to top ↑

Singular Cases and Loss of Local Solvability

Implicit differentiation depends on regularity conditions. When those conditions fail, the derivative may become undefined, infinite, multivalued, or dependent on a different local parameterization.

In the simple equation \(F(x,y)=0\), the formula:

If \(F_y=0\), it may not be possible to solve locally for \(y\) as a function of \(x\). This does not always mean the relationship is meaningless. It may mean the curve has a vertical tangent, a cusp, a crossing, a fold, or a singular point. A different variable may need to be solved for, or the model may require a different parameterization.

In systems modeling, singular cases are often meaningful. They can correspond to tipping points, folds in equilibrium curves, capacity limits, feasibility boundary failures, non-identifiability, phase transitions, or sudden changes in comparative statics.

For a vector system \(F(x,p)=0\), singularity appears when \(F_x\) is not invertible. Near such points, sensitivity may become large, local approximations may fail, and equilibrium branches may merge or disappear. These are not merely numerical problems. They may signal structural change in the modeled system.

Responsible implicit differentiation therefore requires regularity checks. Analysts should report whether the denominator or Jacobian condition is satisfied, whether the system is close to singularity, and whether the local derivative is stable enough to interpret.

Back to top ↑

Mathematical Deepening

This section adds a more formal layer for mathematically advanced readers. Implicit differentiation can be understood as differentiating a constraint map and solving for tangent directions under regularity conditions. The central issue is not only how to compute \(dy/dx\), but when the local function whose derivative is being computed actually exists.

Back to top ↑

Back to top ↑

Computation and Reproducible Workflows

Computational workflows for implicit differentiation should record the constraint equation, the variables being solved for, the parameter being varied, the relevant partial derivatives, the regularity condition, the implicit derivative, and any singularity or conditioning warnings.

For scalar implicit relationships, the workflow should check whether the denominator \(F_y\) or \(G_x\) is near zero. For vector systems, it should compute or approximate the relevant Jacobian block and assess whether the corresponding linear system is well conditioned. In both cases, the derivative should be validated against numerical perturbation when possible.

Implicit derivatives are especially useful in scientific computing because they avoid repeatedly solving a nonlinear system for every small parameter change. Once an equilibrium is found, the local sensitivity can often be obtained by solving a linearized system. But this efficiency depends on the correctness and stability of the implicit sensitivity calculation.

Reproducible workflows make the assumptions visible. They turn implicit differentiation from a hidden algebraic step into an auditable part of the modeling process.

Back to top ↑

Python Workflow: Implicit Sensitivity Audit

The Python workflow below computes implicit sensitivity for a simple equilibrium condition and records regularity warnings.

from __future__ import annotations

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


@dataclass(frozen=True)
class ImplicitAudit:
    parameter: float
    equilibrium_state: float
    constraint_value: float
    partial_state: float
    partial_parameter: float
    implicit_sensitivity: float
    finite_difference_check: float
    absolute_error: float
    warning: str


def equilibrium_state(parameter: float) -> float:
    # Example equilibrium from G(x, p) = x^2 + p*x - 10 = 0.
    # Use positive branch for teaching purposes.
    return (-parameter + (parameter**2 + 40.0) ** 0.5) / 2.0


def constraint(x: float, p: float) -> float:
    return x**2 + p*x - 10.0


def partial_state(x: float, p: float) -> float:
    return 2.0 * x + p


def partial_parameter(x: float, p: float) -> float:
    return x


def implicit_sensitivity(x: float, p: float, threshold: float = 1e-8) -> float:
    gx = partial_state(x, p)
    if abs(gx) < threshold:
        raise ValueError("regularity failure: partial derivative with respect to state is near zero")
    return -partial_parameter(x, p) / gx


def finite_difference_sensitivity(p: float, h: float = 1e-5) -> float:
    return (equilibrium_state(p + h) - equilibrium_state(p - h)) / (2.0 * h)


def audit_parameter(p: float) -> ImplicitAudit:
    x = equilibrium_state(p)
    gx = partial_state(x, p)
    gp = partial_parameter(x, p)
    sens = implicit_sensitivity(x, p)
    fd = finite_difference_sensitivity(p)
    error = abs(sens - fd)

    warning = ""
    if abs(gx) < 1e-4:
        warning = "near singular state Jacobian; sensitivity may be unstable"
    elif error > 1e-5:
        warning = "finite-difference check differs from implicit derivative"

    return ImplicitAudit(
        parameter=p,
        equilibrium_state=x,
        constraint_value=constraint(x, p),
        partial_state=gx,
        partial_parameter=gp,
        implicit_sensitivity=sens,
        finite_difference_check=fd,
        absolute_error=error,
        warning=warning
    )


rows = [audit_parameter(p) for p in [-3.0, -1.0, 0.0, 1.0, 3.0]]

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

with (output_dir / "implicit_sensitivity_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 implicit sensitivity audit.")

This workflow records the equilibrium state, constraint residual, state partial derivative, parameter partial derivative, implicit sensitivity, finite-difference check, and warning. It treats implicit differentiation as an auditable sensitivity calculation.

Back to top ↑

R Workflow: Constraint-Based Co-Adjustment

The R workflow below computes the same implicit sensitivity for a scalar equilibrium equation.

# Implicit Differentiation and Coupled Relationships
# Base R workflow for constraint-based co-adjustment.

equilibrium_state <- function(parameter) {
  (-parameter + sqrt(parameter^2 + 40)) / 2
}

constraint <- function(x, p) {
  x^2 + p * x - 10
}

partial_state <- function(x, p) {
  2 * x + p
}

partial_parameter <- function(x, p) {
  x
}

implicit_sensitivity <- function(x, p) {
  gx <- partial_state(x, p)
  if (abs(gx) < 1e-8) {
    stop("regularity failure: partial derivative with respect to state is near zero")
  }
  -partial_parameter(x, p) / gx
}

finite_difference_sensitivity <- function(p, h = 1e-5) {
  (equilibrium_state(p + h) - equilibrium_state(p - h)) / (2 * h)
}

audit_parameter <- function(p) {
  x <- equilibrium_state(p)
  gx <- partial_state(x, p)
  gp <- partial_parameter(x, p)
  sens <- implicit_sensitivity(x, p)
  fd <- finite_difference_sensitivity(p)
  error <- abs(sens - fd)

  warning <- ""
  if (abs(gx) < 1e-4) {
    warning <- "near singular state Jacobian; sensitivity may be unstable"
  } else if (error > 1e-5) {
    warning <- "finite-difference check differs from implicit derivative"
  }

  data.frame(
    parameter = p,
    equilibrium_state = x,
    constraint_value = constraint(x, p),
    partial_state = gx,
    partial_parameter = gp,
    implicit_sensitivity = sens,
    finite_difference_check = fd,
    absolute_error = error,
    warning = warning
  )
}

results <- do.call(rbind, lapply(c(-3, -1, 0, 1, 3), audit_parameter))

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

print(results)

This workflow is useful for teaching because it makes the implicit derivative visible as a balance between the parameter effect and the state effect.

Back to top ↑

Haskell Workflow: Typed Coupled Relationships

Haskell can represent the components of an implicit relationship as typed records, keeping the constraint, state, parameter, and sensitivity distinct.

module Main where

newtype Parameter = Parameter Double deriving (Show)
newtype State = State Double deriving (Show)
newtype PartialState = PartialState Double deriving (Show)
newtype PartialParameter = PartialParameter Double deriving (Show)
newtype Sensitivity = Sensitivity Double deriving (Show)

data ImplicitAudit = ImplicitAudit
  { parameter :: Parameter
  , equilibriumState :: State
  , constraintValue :: Double
  , statePartial :: PartialState
  , parameterPartial :: PartialParameter
  , implicitDerivative :: Sensitivity
  , warning :: String
  } deriving (Show)

equilibriumStateValue :: Parameter -> Double
equilibriumStateValue (Parameter p) =
  (-p + sqrt (p * p + 40.0)) / 2.0

constraint :: State -> Parameter -> Double
constraint (State x) (Parameter p) =
  x * x + p * x - 10.0

partialState :: State -> Parameter -> Double
partialState (State x) (Parameter p) =
  2.0 * x + p

partialParameter :: State -> Parameter -> Double
partialParameter (State x) _ =
  x

implicitSensitivity :: State -> Parameter -> Double
implicitSensitivity x p =
  let gx = partialState x p
      gp = partialParameter x p
  in -gp / gx

auditParameter :: Parameter -> ImplicitAudit
auditParameter p =
  let xValue = equilibriumStateValue p
      x = State xValue
      gx = partialState x p
      gp = partialParameter x p
      sens = implicitSensitivity x p
      warningText = if abs gx < 1.0e-8
        then "regularity failure"
        else ""
  in ImplicitAudit
      { parameter = p
      , equilibriumState = x
      , constraintValue = constraint x p
      , statePartial = PartialState gx
      , parameterPartial = PartialParameter gp
      , implicitDerivative = Sensitivity sens
      , warning = warningText
      }

main :: IO ()
main = do
  mapM_ (print . auditParameter . Parameter) [-3.0, -1.0, 0.0, 1.0, 3.0]

The typed representation helps preserve the distinction between a constraint value, a partial derivative, and an implicit sensitivity. These quantities are related, but they are not interchangeable.

Back to top ↑

SQL Workflow: Implicit Relationship Registry

SQL can document implicit differentiation assumptions and coupled-relationship warnings for audit-friendly model review.

CREATE TABLE implicit_relationship_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 implicit_relationship_registry VALUES
(
  'constraint_equation',
  'Constraint equation',
  'An implicit relationship is written as F(x,y)=0 or F(x,p)=0.',
  'Identifies the relationship that must remain satisfied.',
  'The derivative is meaningful only relative to the stated constraint.'
);

INSERT INTO implicit_relationship_registry VALUES
(
  'regularity_condition',
  'Regularity condition',
  'Local solvability requires a nonzero partial derivative or invertible Jacobian block.',
  'Supports interpretation of one variable as locally adjusting to another.',
  'If the condition fails, the derivative may be undefined, unstable, or branch-dependent.'
);

INSERT INTO implicit_relationship_registry VALUES
(
  'coadjustment_rate',
  'Co-adjustment rate',
  'For F(x,y)=0, dy/dx=-F_x/F_y when F_y is nonzero.',
  'Shows how variables must move together to preserve the relationship.',
  'Co-adjustment is not the same as independent causal response.'
);

INSERT INTO implicit_relationship_registry VALUES
(
  'equilibrium_sensitivity',
  'Equilibrium sensitivity',
  'For G(x,p)=0, dx/dp=-G_p/G_x when G_x is nonzero.',
  'Shows how an equilibrium shifts when a parameter changes.',
  'Sensitivity can become unstable near singular or bifurcation points.'
);

INSERT INTO implicit_relationship_registry VALUES
(
  'jacobian_conditioning',
  'Jacobian conditioning',
  'Vector systems require solving F_x S=-F_p.',
  'Supports multivariable coupled-system sensitivity analysis.',
  'Ill-conditioned Jacobians can make numerical sensitivity unreliable.'
);

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

This registry makes the derivative claim auditable by documenting the constraint, the regularity condition, the co-adjustment interpretation, and the numerical conditioning warning.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports implicit sensitivity audits, constraint-based co-adjustment examples, equilibrium sensitivity calculations, finite-difference comparisons, regularity-condition checks, singularity warnings, typed coupled-relationship records, implicit relationship registries, reproducible notebooks, documentation, generated outputs, and advanced mathematical audit reports.

Back to top ↑

Interpretive Limits and Responsible Use

Implicit differentiation can make coupled systems legible, but it can also produce misleading confidence if regularity conditions and model structure are not examined. A formula such as \(-F_x/F_y\) is meaningful only when the implicit relationship is valid, the relevant partial derivative is nonzero, the local branch is identified, and the derivative is interpreted as local co-adjustment under the constraint.

Responsible use requires several checks. State the constraint equation. Identify which variable is being treated as locally dependent. Check the regularity condition. Report whether the derivative is branch-specific. Examine denominator or Jacobian conditioning. Compare analytic sensitivity with numerical perturbation where possible. Distinguish co-adjustment from causal response. Avoid extending local implicit derivatives across singularities, thresholds, bifurcations, or structural breaks.

The key modeling question is not only “What is the implicit derivative?” It is “What relationship is being held fixed, which variables are allowed to co-adjust, and do the regularity conditions make that local sensitivity trustworthy?”

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• The Chain Rule and Composite Change in Interacting Systems
• 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

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.
• Krantz, S.G. and Parks, H.R. (2013) The Implicit Function Theorem: History, Theory, and Applications. New York: Birkhäuser.
• Strogatz, S.H. (2015) Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry, and Engineering. 2nd edn. Boulder, CO: Westview Press.
• 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.
• Hubbard, J.H. and Hubbard, B.B. (2015) Vector Calculus, Linear Algebra, and Differential Forms: A Unified Approach. 5th edn. Ithaca, NY: Matrix Editions.
• Krantz, S.G. and Parks, H.R. (2013) The Implicit Function Theorem: History, Theory, and Applications. New York: Birkhäuser.
• 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.
• Rudin, W. (1976) Principles of Mathematical Analysis. 3rd edn. New York: McGraw-Hill.
• Spivak, M. (2008) Calculus. 4th edn. Houston, TX: Publish or Perish.
• Strogatz, S.H. (2015) Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry, and Engineering. 2nd edn. Boulder, CO: Westview Press.

Back to top ↑