The Precise Definition of a Limit

In first courses you usually meet the informal definition first: "$f(x)$ gets arbitrarily close to $L$ as $x$ gets close to $a$." A good picture, but a poor definition — what does "close" mean, and how close is close enough? If two students disagree about whether a limit exists, what concrete statement settles it?

Historically the inventors of calculus used infinitesimals — quantities "infinitely small but not zero" — which Bishop Berkeley mocked in 1734 as "ghosts of departed quantities." The repair came in stages: Bolzano and Cauchy recast limits in terms of quantities that become smaller than any prescribed bound, and in the 1860s Weierstrass replaced the vague word "arbitrarily" with an explicit quantifier structure: for every tolerance there exists a distance.

The statement $\lim_{x\to a}f(x)=L$ is true exactly when the Defender has a winning strategy: a rule that produces a valid δ for every tolerance ε the Challenger can name.

• The Defender sees ε before choosing δ, so δ may depend on ε (and on $a$ and the function) — hence $\delta(\varepsilon)$. But δ must never depend on $x$: the Challenger picks $x$ last.
• The Challenger's answer must work for every $x$ in the window, not just the points the Defender happened to test. Winning against a sample is not winning the game.

A programmer's translation

The quantifier structure for-all ε, there-exists δ, for-all x is exactly the structure of nested loops:

def limit_claim_holds(f, a, L, eps):
    delta = defender_chooses_delta(eps)   # chosen after seeing eps
    for x in every_real_except(a):        # adversarial; chosen last
        if 0 < abs(x - a) < delta:
            if not abs(f(x) - L) < eps:
                return False               # Challenger wins this round
    return True                            # Defender survives the eps

# "lim f(x) = L" iff this returns True for EVERY eps > 0.

The claim is a property that must survive an adversarial search over all inputs, for every tolerance — like property-based testing or a worst-case bound, except the adversarial search is over all reals in the window.

The sibling definitions

In the ε–N rows, $N$ plays the role of δ (a far threshold). In the M–δ rows, the Challenger attacks with a huge height $M$ instead of a small tolerance. Two-sided $\iff$ both one-sided limits exist and agree.

Three structural theorems

The negation: proving a limit fails

Four short programs turn the definition into something you can watch and stress-test. The proof certifies what the numbers merely suggest.

10.1 · Watching the box for f(x)=x²

import numpy as np
f = lambda x: x**2
a, L, eps, delta = 2.0, 4.0, 0.5, 0.1   # the (eps,delta) pair proved by hand
xs = np.linspace(a-delta, a+delta, 200_001)
xs = xs[np.abs(xs-a) > 1e-12]           # puncture: drop x = a
err = np.abs(f(xs) - L)
print("worst error:", err.max())
print("defender wins:", err.max() < eps)

The worst point sits at a window edge — you can't find it by sampling random points, which is exactly why sampling isn't a proof.

10.2 · Finding the largest δ numerically

from scipy.optimize import brentq
def largest_delta(f, a, L, eps, reach=1.0):
    x_left  = brentq(lambda x: f(x)-(L-eps), a-reach, a)
    x_right = brentq(lambda x: f(x)-(L+eps), a, a+reach)
    return min(a-x_left, x_right-a)
for eps in (1.0, 0.5, 0.1, 0.01, 1e-4):
    print(eps, largest_delta(lambda x: x**2, 2.0, 4.0, eps))

As ε shrinks, the optimal radius converges to $\varepsilon/|f'(2)|=\varepsilon/4$ — the window size dictated by the local slope. The gap between the crude bound ε/5 and the optimal ε/4 is typical proof engineering.

10.3 · Fuzzing the Defender's strategy

rng = np.random.default_rng(0); m, b, a = 2.0, 1.0, 3.0   # f=2x+1, L=7
L = m*a + b
for r in range(1, 6):
    eps   = 10.0 ** rng.uniform(-6, 0)   # challenger: random tolerance
    delta = eps / abs(m)                 # defender: strategy delta=eps/2
    x     = a + delta * rng.uniform(-1, 1)
    err   = abs((m*x + b) - L)
    print(r, eps, delta, err, "wins:", err < eps)

Every round prints wins: True. No finite number of rounds proves the universal statement — the hand proof does that — but the fuzzer finds an embarrassing counterexample fast if the strategy is wrong.

10.4 · Symbolic verification with SymPy

import sympy as sp
x = sp.symbols("x", real=True)
expr = (x**2 - 16)/(x - 4)              # undefined at x=4
print(sp.simplify(expr))                # x + 4  (for x != 4)
print(sp.limit(expr, x, 4))             # 8
print(sp.limit(sp.sin(x)/x, x, 0))      # 1

Level 1 — Conceptual

Level 2 — Standard calculations

Level 3 — Challenging

Exam Checklist — tick each before moving on

Further resources

Built from "The Precise Definition of a Limit: An ε–δ Deep Dive" (Calculus Deep Dives) · Game-first study guide