Infinity, Infinitesimals, and the Historical Problem of Change

Last Updated June 14, 2026

Infinity, infinitesimals, and the historical problem of change sit near the origin of calculus. Long before calculus became a formal discipline, mathematicians and philosophers struggled with a basic question: how can continuous change be understood if motion, growth, accumulation, and curvature seem to involve infinitely many moments, infinitely small differences, or quantities that are never quite zero?

In systems modeling, this historical problem remains practical. A model of population growth, infrastructure stress, climate accumulation, disease transmission, resource depletion, or economic change often depends on local rates and cumulative effects. To describe those processes mathematically, the modeler must reason about change over very small intervals, long-run behavior over large scales, and transitions between discrete measurements and continuous processes.

This article explains how the concepts of infinity and infinitesimals shaped the development of calculus and why they still matter for systems modeling. It traces the problem of change from ancient paradoxes and geometric methods through early calculus, the later formalization of limits, and modern computational interpretation. The goal is not to treat history as decoration, but to show why calculus emerged as a language for modeling systems that change continuously.

Calculus became powerful because it created a way to reason about quantities that change continuously. But continuous change is conceptually difficult. A moving object passes through infinitely many positions. A curve can be approximated by smaller and smaller straight-line segments. A growing population changes by increments that may be measured discretely but modeled continuously. An accumulated stock results from flows that occur through time. The history of calculus is, in part, the history of making these ideas mathematically usable.

Why the Problem of Change Matters

The problem of change is simple to state and difficult to formalize: how can a quantity vary continuously, and how can that variation be measured? If a system changes over time, one can measure its state at two moments and compare them. But calculus asks a sharper question: what is the rate of change at a moment? That question requires reasoning about intervals that become smaller and smaller.

This issue appears whenever a model tries to move from average change to local change. Average speed over a trip is not the same as speed at an instant. Average population growth over a decade is not the same as the instantaneous growth rate in a continuous model. Average emissions over a year are not the same as a continuously varying emissions pathway. Average infrastructure stress over a season is not the same as stress at a critical moment.

Early mathematics could handle many discrete and geometric problems, but continuous change posed a deeper challenge. Motion, curvature, area, accumulation, and local rate all seemed to require some form of infinite subdivision or vanishingly small quantity. Calculus emerged by making these problems workable.

For systems modeling, the historical problem is not merely philosophical. A modeler still has to decide whether a system should be represented discretely or continuously, how small a time step should be, whether a rate is local or averaged, whether a numerical approximation is stable, and whether a model’s continuous mathematics corresponds to the system being studied.

The history of infinity and infinitesimals helps explain why those decisions matter.

Back to top ↑

Infinity and Motion

Ancient discussions of motion often exposed the difficulty of reasoning about infinity. Zeno’s paradoxes, for example, raised questions about how motion is possible if a moving object must pass through infinitely many intermediate positions. The point of these paradoxes is not that motion does not occur. The point is that motion becomes conceptually difficult when space and time are treated as infinitely divisible.

Systems modeling often faces a similar tension. A model may represent time in discrete steps, but the underlying process may appear continuous. A population changes one individual at a time, yet a differential equation may represent it as a continuous quantity. A river flow changes continuously, but measurements arrive at intervals. A disease spreads through discrete contacts, but aggregate transmission may be modeled as a smooth rate.

Infinity enters because continuous change seems to contain indefinitely many subdivisions. Between any two times, there are more times. Between any two positions, there are more positions. Between any two approximations, a finer approximation can be imagined. This does not make modeling impossible, but it forces the modeler to clarify how the continuous structure is being represented.

Calculus did not eliminate the conceptual problem of infinite divisibility. It gave mathematics tools for working with it. Limits, derivatives, integrals, series, and differential equations all provide disciplined ways to reason about infinite refinement without treating every subdivision as a separate physical event.

In systems modeling, this distinction matters. Infinite mathematical refinement is not the same as infinite empirical measurement. A continuous model may be useful even when the system is measured discretely, but the relationship between model, measurement, and interpretation must be explicit.

Back to top ↑

Geometric Approaches to Infinite Division

Long before modern calculus, mathematicians developed geometric methods that approached calculus-like reasoning. The method of exhaustion, associated especially with Greek geometry and Archimedes, approximated areas and volumes by using inscribed and circumscribed shapes. By refining these approximations, one could reason about curved figures without already having the modern language of limits and integrals.

This historical strategy is important because it shows a recurring idea: a difficult continuous problem can be approached through a sequence of better approximations. The area under a curve can be approximated by rectangles. A curved boundary can be approximated by polygons. A volume can be approximated by slices. A trajectory can be approximated by small time steps.

Modern computational modeling still uses this pattern. Numerical integration approximates accumulated quantities. Finite difference methods approximate derivatives. Simulation divides time into steps. Spatial models divide regions into cells or meshes. Agent-based models approximate aggregate dynamics through many discrete interactions. The basic logic of refinement remains central.

However, approximation is not the same as proof or interpretation. A finer approximation may be better, but it may also be computationally expensive, numerically unstable, or misleading if the model structure is wrong. The historical movement from geometric exhaustion to calculus reminds systems modelers that approximation must be connected to assumptions, error, convergence, and purpose.

The problem is not only whether a calculation can be made. The problem is whether the approximation supports the intended interpretation of the system.

Back to top ↑

Infinitesimals and the Birth of Calculus

An infinitesimal is often described informally as an infinitely small quantity: smaller than any ordinary positive number but not simply zero. Early calculus used infinitesimal reasoning to describe changes that are vanishingly small. The notation of differentials, such as \(dx\) and \(dy\), emerged from this way of thinking.

Infinitesimals were powerful because they matched the intuition of local change. If \(x\) changes by a tiny amount \(dx\), then \(y\) changes by a corresponding tiny amount \(dy\). The ratio \(dy/dx\) expresses how one quantity changes relative to another at a local scale. This language became central to differential calculus.

But infinitesimals also created foundational concerns. What exactly is an infinitely small quantity? Is it zero or not zero? If it is not zero, why can it sometimes be ignored? If it is zero, how can one divide by it? These questions led to criticism and eventually to the formal limit-based foundations taught in most modern calculus courses.

For systems modeling, infinitesimal reasoning remains useful as intuition. A derivative can be interpreted as the limiting value of average rates over smaller and smaller intervals. A differential equation can describe how a state changes locally. A small perturbation can approximate sensitivity. A marginal effect can describe local response. The language of infinitesimals helps modelers think locally, even when the formal foundation uses limits.

The key is to keep intuition and formal interpretation aligned. Infinitesimal language can clarify rates and local change, but it should not hide assumptions about smoothness, continuity, scale, measurement, or numerical approximation.

Back to top ↑

Newton, Leibniz, and Two Languages of Change

Isaac Newton and Gottfried Wilhelm Leibniz developed calculus in different notational and conceptual styles. Newton’s language of fluxions emphasized quantities changing through time. Leibniz’s notation emphasized differentials and relationships between small changes. Both approaches helped make the mathematics of change systematic.

For systems modeling, the contrast is useful. Newton’s perspective feels close to dynamics: quantities flow, rates describe motion, and time plays a central role. This language connects naturally to physical systems, differential equations, and dynamic modeling. Leibniz’s notation feels close to relational structure: \(dy/dx\) expresses how one quantity changes with respect to another. This connects naturally to sensitivity, marginal analysis, multivariable systems, and model interpretation.

Modern calculus uses both inheritances. A systems modeler might write a time derivative to describe a changing state:

The same modeler might also examine how an output changes with respect to a parameter:

These notations are not just technical marks. They carry modeling meaning. They tell the analyst what is changing, with respect to what, and under what assumptions. The historical development of calculus shows that notation is part of model thinking.

Back to top ↑

Limits and Formalization

Modern calculus is usually grounded in limits. Instead of relying on informal infinitesimals, the derivative is defined through the limiting behavior of difference quotients as an interval approaches zero. This formalization made calculus more rigorous and clarified when derivative-based reasoning is valid.

The limit concept also provides a bridge between approximation and exact reasoning. A modeler may compute average change over an interval, then ask what happens as the interval becomes smaller. If the values approach a stable number, that number can be interpreted as a local rate of change. If they do not, the function may be discontinuous, nonsmooth, noisy, or not well represented by a derivative at that point.

This matters in systems modeling because many systems have thresholds, delays, shocks, discontinuities, regime shifts, or measurement noise. A derivative may be meaningful in smooth regions but weak or misleading near a breakpoint. An integral may be meaningful over a stable interval but difficult to interpret across a discontinuity. A numerical approximation may appear precise while hiding instability near a boundary.

Limits formalize what infinitesimal reasoning tries to capture: the behavior of a quantity under refinement. For modeling, the question becomes practical: as the time step shrinks, as the spatial mesh refines, as the perturbation becomes smaller, or as the approximation improves, does the model behave consistently?

When the answer is yes, calculus provides a powerful language for continuous change. When the answer is no, the failure is also informative. It may reveal a structural break, invalid model assumption, poor numerical method, or mismatch between continuous representation and system behavior.

Back to top ↑

Why This Matters for Systems Modeling

Systems modeling often translates complex processes into rates, flows, stocks, accumulations, sensitivities, and trajectories. These concepts depend on the historical ideas discussed above. A rate is a local comparison. A flow accumulates over time. A trajectory passes through a continuum of states. A sensitivity asks how an output responds to a small change. A simulation approximates continuous behavior through finite steps.

Consider a stock-and-flow model. The stock changes because inflows and outflows occur over time. In continuous form, this may be represented as a differential equation. But the modeler still has to decide how to interpret local rates, how to approximate change over time steps, and how to prevent the simulation from producing impossible states.

Consider a climate model. Emissions accumulate, concentrations change, feedbacks unfold, and temperature response occurs through time. The model may require both cumulative quantities and local rates. It may include long time horizons and small numerical steps. Infinity is not a literal physical input, but limiting and approximation ideas structure the model.

Consider an infrastructure model. Stress, fatigue, load, and failure risk may evolve continuously, but data may be sparse. The modeler may approximate derivatives, estimate rates, and simulate future trajectories. The historical problem of change becomes an applied problem: how can limited measurements support a model of continuous deterioration or sudden failure?

In each case, calculus is not merely a set of formulas. It is a disciplined way to reason about continuous change, small differences, accumulated effects, and the relationship between approximation and interpretation.

Back to top ↑

Mathematical Lens

The average rate of change over an interval is:

The derivative is the limiting value of that ratio:

Accumulation can be represented as a limiting sum:

A continuous-time dynamic model represents local change through a rate rule:

A numerical approximation turns the continuous rate rule into finite steps:

These equations show the link between history and modeling practice. Infinitely small differences, limiting processes, and finite approximations all help translate changing systems into analyzable structures.

Back to top ↑

Back to top ↑

Examples Across Systems Modeling

Infinity and infinitesimals may sound abstract, but their modeling consequences appear whenever systems change through time, accumulate flows, or require approximation.

These examples show that historical calculus concepts remain embedded in applied modeling. Every local rate, numerical step, cumulative integral, or sensitivity estimate carries assumptions about how change is represented.

Back to top ↑

Computation and Reproducible Workflows

Computational workflows make the historical problem of change concrete. A computer does not manipulate an actual continuum. It works with finite numbers, finite steps, finite arrays, finite precision, and finite runtime. When a program approximates a derivative, integral, or differential equation, it is using discrete computation to represent continuous mathematics.

This creates a modeling responsibility. Analysts should document the step size, approximation method, parameter values, output checks, and error behavior. A very small interval may improve an approximation, but it can also amplify roundoff error. A large step may run quickly, but it may miss important dynamics. A simulation may appear smooth while hiding numerical instability.

Python can demonstrate finite-difference approximations and convergence. R can compare approximation error across step sizes. Haskell can make finite approximation steps explicit through typed records. SQL can preserve a registry of historical and modeling concepts used in the workflow. Julia, C, C++, Fortran, Rust, and Go can extend the same ideas into numerical and compiled settings.

For systems modeling, the point is not simply to compute more finely. The point is to understand how approximation, refinement, and interpretation are connected.

Back to top ↑

Python Workflow: Difference Quotients and Small Intervals

The Python workflow below compares finite-difference estimates of a derivative for smaller and smaller interval sizes. It shows how local rate reasoning depends on refinement, convergence, and numerical interpretation.

from __future__ import annotations

from dataclasses import dataclass
import math
import pandas as pd


@dataclass(frozen=True)
class DifferenceQuotientRun:
    function_name: str
    x: float
    h: float
    estimate: float
    exact_value: float
    absolute_error: float


def system_response(x: float) -> float:
    """
    Synthetic system-response function.

    This example uses a smooth function so the derivative exists.
    In real systems modeling, smoothness should be justified.
    """
    return math.exp(0.2 * x)


def exact_derivative(x: float) -> float:
    return 0.2 * math.exp(0.2 * x)


def difference_quotient(x: float, h: float) -> float:
    return (system_response(x + h) - system_response(x)) / h


x0 = 5.0
h_values = [1.0, 0.5, 0.1, 0.05, 0.01, 0.005, 0.001]

rows = []

for h in h_values:
    estimate = difference_quotient(x0, h)
    exact = exact_derivative(x0)

    rows.append(DifferenceQuotientRun(
        function_name="exp(0.2x)",
        x=x0,
        h=h,
        estimate=estimate,
        exact_value=exact,
        absolute_error=abs(estimate - exact)
    ).__dict__)

results = pd.DataFrame(rows)

print(results)

results.to_csv("outputs/difference_quotient_convergence.csv", index=False)

This workflow shows why the derivative is not merely a formula. It is the limiting idea behind local change. The modeler observes how average change behaves as the interval becomes small and asks whether the estimates stabilize.

Back to top ↑

R Workflow: Approximation and Convergence

The R workflow below compares approximation error across step sizes. It uses base R so the relationship between step size, derivative estimate, and error remains visible.

# Infinity, Infinitesimals, and the Historical Problem of Change
# Base R difference-quotient convergence workflow.

system_response <- function(x) {
  exp(0.2 * x)
}

exact_derivative <- function(x) {
  0.2 * exp(0.2 * x)
}

difference_quotient <- function(x, h) {
  (system_response(x + h) - system_response(x)) / h
}

x0 <- 5.0
h_values <- c(1.0, 0.5, 0.1, 0.05, 0.01, 0.005, 0.001)

estimate <- difference_quotient(x0, h_values)
exact <- exact_derivative(x0)

results <- data.frame(
  x = x0,
  h = h_values,
  estimate = estimate,
  exact_value = exact,
  absolute_error = abs(estimate - exact)
)

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

print(results)

This workflow connects the historical idea of vanishing intervals to reproducible modeling practice. Each step size is recorded, each estimate is inspectable, and error is part of the output rather than hidden.

Back to top ↑

Haskell Workflow: Typed Approximation Steps

Haskell can preserve distinctions among a location, step size, derivative estimate, and exact comparison. This is useful because approximation workflows often fail when different quantities are treated as interchangeable numbers.

module Main where

newtype Location = Location Double deriving (Show)
newtype StepSize = StepSize Double deriving (Show)
newtype Estimate = Estimate Double deriving (Show)
newtype ExactValue = ExactValue Double deriving (Show)
newtype AbsoluteError = AbsoluteError Double deriving (Show)

data ApproximationRun = ApproximationRun
  { location :: Location
  , stepSize :: StepSize
  , estimate :: Estimate
  , exactValue :: ExactValue
  , absoluteError :: AbsoluteError
  } deriving (Show)

systemResponse :: Location -> Double
systemResponse (Location x) =
  exp (0.2 * x)

exactDerivative :: Location -> ExactValue
exactDerivative (Location x) =
  ExactValue (0.2 * exp (0.2 * x))

differenceQuotient :: Location -> StepSize -> Estimate
differenceQuotient loc@(Location x) (StepSize h) =
  Estimate ((systemResponse (Location (x + h)) - systemResponse loc) / h)

runApproximation :: Location -> StepSize -> ApproximationRun
runApproximation loc step =
  let est@(Estimate e) = differenceQuotient loc step
      exact@(ExactValue v) = exactDerivative loc
  in ApproximationRun
      { location = loc
      , stepSize = step
      , estimate = est
      , exactValue = exact
      , absoluteError = AbsoluteError (abs (e - v))
      }

main :: IO ()
main = do
  let locationValue = Location 5.0
  let steps = map StepSize [1.0, 0.5, 0.1, 0.05, 0.01, 0.005, 0.001]
  mapM_ (print . runApproximation locationValue) steps

This example is intentionally small. Its modeling value is structural: it separates the concepts that a numerical workflow must keep distinct. A step size is not a location. An estimate is not an exact value. Error is not an afterthought; it is part of the approximation record.

Back to top ↑

SQL Workflow: Concept Registry for Historical Modeling Terms

SQL can support article workflows by preserving concept registries, modeling terms, and historical notes. This helps connect computational examples to the conceptual vocabulary used in the article.

CREATE TABLE calculus_concept_registry (
    concept_key TEXT PRIMARY KEY,
    concept_name TEXT NOT NULL,
    historical_role TEXT NOT NULL,
    systems_modeling_role TEXT NOT NULL,
    review_note TEXT NOT NULL
);

INSERT INTO calculus_concept_registry VALUES
(
  'infinity',
  'Infinity',
  'Raised foundational questions about infinite division, motion, and accumulation.',
  'Appears in limiting processes, long-run behavior, refinement, and asymptotic reasoning.',
  'Do not confuse mathematical infinity with empirical measurement capacity.'
);

INSERT INTO calculus_concept_registry VALUES
(
  'infinitesimal',
  'Infinitesimal',
  'Supported early reasoning about vanishingly small changes and differentials.',
  'Supports intuition for local change, marginal response, and sensitivity.',
  'Use formal limit interpretation or validated infinitesimal framework when precision matters.'
);

INSERT INTO calculus_concept_registry VALUES
(
  'limit',
  'Limit',
  'Provided a rigorous foundation for derivatives, integrals, and convergence.',
  'Connects approximation, refinement, local rates, and numerical stability.',
  'Check whether refined approximations stabilize and remain meaningful.'
);

INSERT INTO calculus_concept_registry VALUES
(
  'difference_quotient',
  'Difference Quotient',
  'Connects average change over finite intervals to local derivative reasoning.',
  'Used in finite differences, rate estimation, and numerical derivatives.',
  'Step size affects accuracy, noise sensitivity, and interpretation.'
);

SELECT
    concept_name,
    historical_role,
    systems_modeling_role,
    review_note
FROM calculus_concept_registry
ORDER BY concept_key;

This registry makes the historical vocabulary part of the reproducible workflow. Concepts such as infinity, infinitesimal, limit, and difference quotient are not only discussed in prose; they can be documented as modeling concepts with review notes.

Back to top ↑

GitHub Repository

The companion repository for this article is designed as a reproducible mathematical-modeling workspace. It supports article-level folders for calculus-based systems modeling, including historical concept registries, difference-quotient workflows, approximation records, convergence checks, typed model records, structured concept data, reproducible notebooks, documentation, generated outputs, and governance-oriented review artifacts.

Back to top ↑

Interpretive Limits and Responsible Use

Infinity and infinitesimals are powerful ideas, but they can be misused. A continuous model may imply a level of smoothness that the system does not have. An infinitesimal intuition may obscure measurement limits. A derivative may be interpreted locally even when the underlying data are noisy, discrete, or discontinuous. A numerical approximation may look accurate because it produces many digits, while the model itself rests on weak assumptions.

Historical awareness helps prevent overconfidence. Calculus was not born as a set of automatic procedures. It emerged from difficult questions about motion, accumulation, approximation, and infinite refinement. Those questions do not disappear in applied modeling. They reappear as questions about time step, scale, smoothness, convergence, extrapolation, discretization, and interpretation.

Responsible systems modeling should therefore treat continuous mathematics as a representation, not as a guarantee. Analysts should ask whether local rates are meaningful, whether accumulations are defined over valid intervals, whether approximation error is documented, whether numerical methods are stable, and whether the model’s continuous structure fits the system’s behavior.

The point is not to avoid calculus. The point is to use it with historical and mathematical discipline.

Back to top ↑

Related Articles

• Calculus for Systems Modeling
• What Is Calculus for Systems Modeling?
• Functions, Variables, and Mathematical Representation
• Domains, Ranges, and the Structure of Functional Models
• Limits and the Formal Basis of Calculus
• Continuity, Discontinuity, and Structural Breaks
• Mathematical Modeling
• Systems Modeling
• Scientific Computing for Systems Modeling

Back to top ↑

Further Reading

• OpenStax (2016a) Calculus Volume 1. Houston, TX: OpenStax, Rice University.
• OpenStax (2016b) Calculus Volume 2. Houston, TX: OpenStax, Rice University.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2010a) Single Variable Calculus. Cambridge, MA: MIT OpenCourseWare.
• Massachusetts Institute of Technology (MIT) OpenCourseWare (2010b) Multivariable Calculus. Cambridge, MA: MIT OpenCourseWare.
• Baron, M.E. (1969) The Origins of the Infinitesimal Calculus. Oxford: Pergamon Press.
• Boyer, C.B. (1959) The History of the Calculus and Its Conceptual Development. New York: Dover Publications.
• Katz, V.J. (2009) A History of Mathematics: An Introduction. 3rd edn. Boston, MA: Addison-Wesley.
• Robinson, A. (1996) Non-standard Analysis. Revised edn. Princeton, NJ: Princeton University Press.

Back to top ↑

References

• Archimedes (1897) The Works of Archimedes. Edited by T.L. Heath. Cambridge: Cambridge University Press.
• Aristotle (1930) Physics. Translated by P.H. Wicksteed and F.M. Cornford. Cambridge, MA: Harvard University Press.
• Baron, M.E. (1969) The Origins of the Infinitesimal Calculus. Oxford: Pergamon Press.
• Berkeley, G. (1734) The Analyst; or, A Discourse Addressed to an Infidel Mathematician. London: J. Tonson.
• Boyer, C.B. (1959) The History of the Calculus and Its Conceptual Development. New York: Dover Publications.
• Cauchy, A.-L. (1821) Cours d’analyse de l’École Royale Polytechnique. Paris: Debure frères.
• Leibniz, G.W. (1684) ‘Nova Methodus pro Maximis et Minimis’, Acta Eruditorum.
• Newton, I. (1736) The Method of Fluxions and Infinite Series. London: Henry Woodfall.
• OpenStax (2016a) Calculus Volume 1. Houston, TX: OpenStax, Rice University.
• Robinson, A. (1996) Non-standard Analysis. Revised edn. Princeton, NJ: Princeton University Press.
• 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 ↑