29 Limits and continuity

What a function approaches, not what it equals

Your car’s speedometer reads 80 km/h at this exact instant. But speed is distance divided by time — and at a single instant, no time has passed, no distance covered. So what is the speedometer actually measuring?

The answer is a limit. It’s the value that the ratio distance/time approaches as the time interval shrinks toward zero — not the ratio at zero, which is 0/0 and meaningless, but the value that ratio gets closer and closer to.

You’ve already seen this pattern in another form. In the last chapter you watched sequences converge to numbers they never quite reached. A limit is that same idea applied to functions.

29.1 What this chapter helps you do

Symbols to keep handy

These are the bits of notation you'll see a lot. If a line of symbols feels like a fence, read it out loud once, then keep going.

_{x a} f(x): the limit of f(x) as x approaches a
_{x a^+} f(x): the limit from the right
_{x a^-} f(x): the limit from the left

Definitions to keep handy

These are the words we keep coming back to. If one feels slippery, come back here and steady it before you push on.

limit: The value a function’s outputs get closer to as the input gets close to a point (even if the function is undefined or different at that point).
continuity: A function is continuous at a point when its value matches the limit there: no jump, no hole, no mismatch.
epsilon-delta definition: A precise way to say: we can make the outputs as close as we want by taking the inputs close enough.

This chapter gives you a precise way to talk about what a function is doing near a point, especially when direct substitution stops being reliable. We start with the intuitive idea of approach, then move into standard techniques for evaluating limits. After that, we separate the idea of a limit from the idea of continuity, so “what happens near the point” does not get confused with “what happens at the point.” The final section shows how all of this is made fully precise with the \varepsilon-\delta definition.

Watch for this

Students often collapse two different questions into one:

What value does f(x) approach as x gets close to a?
What value, if any, does the function actually have at x = a?

Limits answer the first question. Continuity asks whether the two answers agree.

29.2 The idea before the notation

Three situations will make this concrete. Notice what they have in common.

The speedometer. A car’s position at time t is some function s(t). To estimate speed, you record position over a short interval: speed \approx (s(t + \Delta t) - s(t)) / \Delta t. The shorter the interval, the better the estimate. The true instantaneous speed is what this ratio approaches as \Delta t shrinks toward zero. The ratio itself is never evaluated at \Delta t = 0 — that would be 0/0 — but it heads steadily toward a definite value.

The temperature probe. A weather sensor is mounted on a boundary between two air masses — one at 18°C and one at 12°C. On the warm side, readings approach 18°C. On the cold side, readings approach 12°C. The sensor itself sits exactly at the boundary and might read either, neither, or something else entirely depending on how it was calibrated. The function has a well-defined approach from each side. Whether the value at the boundary matches either approach is a separate question.

Sequences converging to a number. In Vol 4 ch 4 you watched the sequence 1, \frac{1}{2}, \frac{1}{4}, \frac{1}{8}, \ldots converge to zero. The terms never equal zero, but they get arbitrarily close. Functions can do exactly the same thing: a function can get arbitrarily close to a value L as x approaches some point a, without ever equalling L at x = a.

All three situations share the same structure: a value is approached without necessarily being reached. That is the concept of a limit. This means limits let you describe behaviour exactly at the places where ordinary evaluation becomes unreliable.

29.3 What the notation is saying

How to read the main symbol

Symbol: \lim_{x \to a} f(x) = L
Reads as: “the limit of f(x) as x approaches a is L”
Means: when x is close to a (but not equal), the outputs f(x) are close to L
Use when: direct substitution is unreliable (holes, jumps, asymptotes, boundaries)
Common misread: \lim_{x \to a} f(x) is not automatically f(a)

The symbol

\lim_{x \to a} f(x) = L

is read: the limit of f(x) as x approaches a equals L.

Every piece matters:

x \to a means x gets closer and closer to a, from either side, but does not equal a.
f(x) is the output of the function at each nearby x.
L is the value that f(x) approaches.

The limit says nothing about f(a) itself. The function might be defined at a, undefined at a, or defined but with the wrong value. The limit only asks about the approach. This means “what happens near the point” and “what happens at the point” are different questions, and calculus keeps them separate on purpose.

29.3.1 One-sided limits

Sometimes the approach from the left and the approach from the right give different values. Two separate notations handle this.

One-sided limits

Symbol: \lim_{x \to a^-} f(x) / \lim_{x \to a^+} f(x)
Reads as: “limit from the left” / “limit from the right”
Means: you only allow x to approach a from one side of the number line
Use when: the function switches rule at a boundary, or has a jump
Common misread: a two-sided limit exists only if the left and right limits agree

\lim_{x \to a^-} f(x)

is the left-hand limit — the value f(x) approaches as x comes in from values less than a. Read it: the limit from the left.

\lim_{x \to a^+} f(x)

is the right-hand limit — the value f(x) approaches as x comes in from values greater than a. Read it: the limit from the right. This means one-sided limits are the tool for checking whether the two sides of a function agree at a boundary.

The two-sided limit exists if and only if both one-sided limits exist and are equal. If the left-hand limit is L_1 and the right-hand limit is L_2, then:

\lim_{x \to a} f(x) = L \iff \lim_{x \to a^-} f(x) = \lim_{x \to a^+} f(x) = L

If L_1 \neq L_2, the two-sided limit does not exist.

29.3.2 The limit versus the value — three cases

There is no rule that says \lim_{x \to a} f(x) must equal f(a). In fact, that equality is the definition of continuity, and it can fail in three genuinely distinct ways.

Case 1 — Continuous point. The function is defined at a, the limit exists, and they agree:

\lim_{x \to a} f(x) = f(a)

Example: f(x) = x^2 at a = 3. The limit is 9, the value is 9.

Case 2 — Removable discontinuity (value mismatch). The limit exists, f(a) is defined, but they are unequal. The function has a value at a — it is simply the wrong value relative to what the surrounding behaviour predicts.

Example: define g(x) = x + 2 for x \neq 2, but g(2) = 7. The limit as x \to 2 is 4. The function value at x = 2 is 7. There is a mismatch. The discontinuity can be removed by redefining g(2) = 4.

Case 3 — Hole (value absent). The limit exists, but f(a) is simply not defined. There is no value to mismatch — the function has a gap at x = a.

Example: h(x) = \dfrac{x^2 - 4}{x - 2}. At x = 2 the denominator is zero, so h(2) is undefined. But for every x \neq 2:

h(x) = \frac{(x-2)(x+2)}{x-2} = x + 2

The limit is 4. The function has a hole at (2, 4) — no value is there at all. Patching the hole by defining h(2) = 4 would make h continuous.

Cases 2 and 3 are genuinely different situations: in Case 2 you have a value but it conflicts with the limit; in Case 3 you simply have nothing. Both are called removable discontinuities because the fix — redefining or defining f(a) = L — is the same in both cases. This means continuity fails here for a local reason only: the surrounding behaviour already agrees on what the value should be.

Code

{
  const width = 560, height = 300;
  const margin = { top: 20, right: 20, bottom: 40, left: 45 };
  const innerW = width - margin.left - margin.right;
  const innerH = height - margin.top - margin.bottom;

  const xDom = [-1, 5];
  const yDom = [0, 6];

  const xScale = d3_limits.scaleLinear().domain(xDom).range([0, innerW]);
  const yScale = d3_limits.scaleLinear().domain(yDom).range([innerH, 0]);

  const svg = d3_limits.create("svg")
    .attr("width", width)
    .attr("height", height)
    .style("font-family", "inherit");

  const g = svg.append("g")
    .attr("transform", `translate(${margin.left},${margin.top})`);

  // Axes
  g.append("g")
    .attr("transform", `translate(0,${innerH})`)
    .call(d3_limits.axisBottom(xScale).ticks(6))
    .append("text")
    .attr("x", innerW / 2).attr("y", 35)
    .attr("fill", "#374151").attr("text-anchor", "middle")
    .style("font-size", "13px").text("x");

  g.append("g")
    .call(d3_limits.axisLeft(yScale).ticks(6))
    .append("text")
    .attr("transform", "rotate(-90)")
    .attr("x", -innerH / 2).attr("y", -35)
    .attr("fill", "#374151").attr("text-anchor", "middle")
    .style("font-size", "13px").text("f(x)");

  // Grid
  g.append("g")
    .selectAll("line.hgrid")
    .data(yScale.ticks(6))
    .join("line")
    .attr("x1", 0).attr("x2", innerW)
    .attr("y1", d => yScale(d)).attr("y2", d => yScale(d))
    .attr("stroke", "#f3f4f6").attr("stroke-width", 1);

  // Line generator
  const line = d3_limits.line()
    .x(d => xScale(d[0]))
    .y(d => yScale(d[1]));

  // Left segment: x in [-1, 2) — f(x) = x+2
  const leftPts = d3_limits.range(-1, 1.98, 0.01).map(x => [x, x + 2]);
  g.append("path")
    .datum(leftPts)
    .attr("d", line)
    .attr("fill", "none")
    .attr("stroke", "#2563eb")
    .attr("stroke-width", 2.5);

  // Right segment: x in (2, 5] — f(x) = x+2
  const rightPts = d3_limits.range(2.02, 5.01, 0.01).map(x => [x, x + 2]);
  g.append("path")
    .datum(rightPts)
    .attr("d", line)
    .attr("fill", "none")
    .attr("stroke", "#2563eb")
    .attr("stroke-width", 2.5);

  // Open circle at (2, 4)
  g.append("circle")
    .attr("cx", xScale(2)).attr("cy", yScale(4))
    .attr("r", 6)
    .attr("fill", "white")
    .attr("stroke", "#2563eb")
    .attr("stroke-width", 2.5);

  // Moving dot — hide when within 0.02 of x=2
  const x = xSlider;
  const fx = x + 2;
  const nearHole = Math.abs(x - 2) < 0.02;

  if (!nearHole) {
    g.append("circle")
      .attr("cx", xScale(x)).attr("cy", yScale(fx))
      .attr("r", 6)
      .attr("fill", "#dc2626");
  }

  // Static label
  g.append("text")
    .attr("x", xScale(3.6)).attr("y", yScale(5.5))
    .attr("fill", "#6b7280")
    .style("font-size", "12px")
    .text("The dot never lands at x = 2");

  // Dynamic readout
  const readX = x.toFixed(3);
  const readFx = nearHole ? "undefined" : fx.toFixed(3);

  g.append("text")
    .attr("x", xScale(-0.8)).attr("y", yScale(5.6))
    .attr("fill", "#374151")
    .style("font-size", "13px").style("font-weight", "500")
    .text(`x = ${readX}`);

  g.append("text")
    .attr("x", xScale(-0.8)).attr("y", yScale(5.1))
    .attr("fill", nearHole ? "#9ca3af" : "#374151")
    .style("font-size", "13px").style("font-weight", "500")
    .text(`f(x) ≈ ${readFx}`);

  return svg.node();
}

29.4 The method — evaluating limits

Four techniques cover the vast majority of problems you will encounter.

29.4.1 Technique 1: Direct substitution

If f is a polynomial, a rational function with a non-zero denominator at a, a trigonometric function, or any other function that is continuous at a — we’ll define exactly what this means shortly, but the idea is that the function has no break at that point — then:

\lim_{x \to a} f(x) = f(a)

Just substitute. This always works when no algebraic obstruction exists. This means direct substitution works whenever the function behaves normally at the point you are approaching.

When to use it: Try this first. If the substitution gives a real number, you’re done.

Worked example: Find \lim_{x \to 3} (x^2 + 2x - 1).

Substitute x = 3 directly:

\lim_{x \to 3} (x^2 + 2x - 1) = 3^2 + 2(3) - 1 = 9 + 6 - 1 = 14

The limit is 14. The function is a polynomial — continuous everywhere — so direct substitution is valid at every real number. This means polynomials are the simplest case: nearby behaviour and actual value already match.

When it fails: If substitution gives \frac{0}{0}, \frac{\infty}{\infty}, or another indeterminate form, you need one of the other techniques.

29.4.2 Technique 2: Factor and cancel

The \frac{0}{0} form is a signal: both numerator and denominator share a common factor that vanishes at x = a. Factor both, cancel the common factor, and then substitute.

When to use it: When direct substitution gives \frac{0}{0} and the expression is a ratio of polynomials.

Worked example: Find \lim_{x \to 2} \dfrac{x^2 - 4}{x - 2}.

Step 1. Attempt direct substitution: \dfrac{2^2 - 4}{2 - 2} = \dfrac{0}{0}. Indeterminate — proceed to step 2.

Step 2. Factor the numerator:

\frac{x^2 - 4}{x - 2} = \frac{(x-2)(x+2)}{x-2}

Step 3. Cancel the common factor (x - 2). This is valid because we are evaluating a limit as x \to 2, meaning x \neq 2, so (x-2) \neq 0:

\frac{(x-2)(x+2)}{x-2} = x + 2 \quad (x \neq 2)

Step 4. Now substitute:

\lim_{x \to 2} \frac{x^2 - 4}{x - 2} = \lim_{x \to 2}(x + 2) = 2 + 2 = 4

The cancellation is legal only because we never set x = 2 — the limit asks what happens as x approaches 2, not at x = 2. This means factoring does not change the nearby behaviour of the function; it reveals the simpler rule hidden behind the removable discontinuity.

29.4.3 Technique 3: Rationalise

When a square root appears and direct substitution gives \frac{0}{0}, the standard move is to multiply numerator and denominator by the conjugate of the expression containing the square root. The conjugate of (\sqrt{u} - v) is (\sqrt{u} + v). Multiplying removes the radical from one factor using the difference-of-squares identity.

When to use it: When the \frac{0}{0} form arises from a square root.

Worked example: Find \lim_{x \to 0} \dfrac{\sqrt{x+4} - 2}{x}.

Step 1. Direct substitution: \dfrac{\sqrt{0+4} - 2}{0} = \dfrac{2 - 2}{0} = \dfrac{0}{0}. Indeterminate — proceed.

Step 2. Multiply numerator and denominator by the conjugate (\sqrt{x+4} + 2):

\frac{\sqrt{x+4} - 2}{x} \cdot \frac{\sqrt{x+4} + 2}{\sqrt{x+4} + 2}

Step 3. Expand the numerator using (a-b)(a+b) = a^2 - b^2:

\frac{(\sqrt{x+4})^2 - 2^2}{x(\sqrt{x+4} + 2)} = \frac{(x+4) - 4}{x(\sqrt{x+4} + 2)} = \frac{x}{x(\sqrt{x+4} + 2)}

Step 4. Cancel the common factor x (valid since x \to 0 means x \neq 0):

\frac{x}{x(\sqrt{x+4} + 2)} = \frac{1}{\sqrt{x+4} + 2}

Step 5. Now substitute x = 0:

\lim_{x \to 0} \frac{\sqrt{x+4} - 2}{x} = \frac{1}{\sqrt{0+4} + 2} = \frac{1}{2 + 2} = \frac{1}{4}

The limit is \frac{1}{4}. This means rationalising removes the square-root expression that is causing the indeterminate form.

29.4.4 Technique 4: One-sided limits from graphs

When you have a graph (or can sketch one), you can read limits directly. Look at the curve’s approach as x moves toward the target from each side. Do not look at the dot at the target point — look at where the curve is heading.

When to use it: Piecewise functions, graphs given without formulas, or any function with a potential jump.

Worked example: Let

f(x) = \begin{cases} x + 1 & x < 3 \\ 5 & x = 3 \\ 2x - 4 & x > 3 \end{cases}

Find \lim_{x \to 3^-} f(x), \lim_{x \to 3^+} f(x), and \lim_{x \to 3} f(x).

Left-hand limit. For x < 3, the rule is f(x) = x + 1. As x \to 3^-:

\lim_{x \to 3^-} f(x) = 3 + 1 = 4

Right-hand limit. For x > 3, the rule is f(x) = 2x - 4. As x \to 3^+:

\lim_{x \to 3^+} f(x) = 2(3) - 4 = 2

Two-sided limit. The left and right limits are 4 \neq 2, so:

\lim_{x \to 3} f(x) \text{ does not exist}

Note that f(3) = 5 is defined — but the two-sided limit still fails to exist because the one-sided limits disagree. The value at the point is irrelevant to whether the limit exists. This means a function can have a value at a point and still fail to have a two-sided limit there.

29.5 Continuity

With limits in hand, the definition of continuity is short.

Definition. A function f is continuous at a if all three conditions hold:

f(a) is defined.
\lim_{x \to a} f(x) exists.
\lim_{x \to a} f(x) = f(a).

If any condition fails, f is discontinuous at a.

This means continuity is a three-part agreement: the value exists, the limit exists, and both are the same.

Informally: a function is continuous at a point if you can draw through that point without lifting your pen. The limit and the value agree.

29.5.1 The three types of discontinuity

Removable discontinuity. Condition 1 or 3 fails, but condition 2 holds. The limit exists, but either the function is not defined there, or the function is defined but gives a different value. The graph has a single isolated hole. The discontinuity can be removed by redefining f(a) = L.

Example: g(x) = \dfrac{x^2 - 4}{x - 2} is not defined at x = 2, but \lim_{x \to 2} g(x) = 4. Removable.

Jump discontinuity. The left-hand and right-hand limits both exist, but they are not equal. The function “jumps” from one value to another. No amount of redefining a single point can fix this — the gap is structural.

Example: The piecewise function from Technique 4 above. At x = 3, the left limit is 4 and the right limit is 2.

Infinite discontinuity. One or both one-sided limits are \pm\infty. The graph has a vertical asymptote at x = a.

Example: h(x) = \dfrac{1}{x} at x = 0. As x \to 0^+, h(x) \to +\infty. As x \to 0^-, h(x) \to -\infty. This means the type of discontinuity tells you why continuity failed, not just that it failed.

Code

{
  const panelW = 170, panelH = 180;
  const m = { top: 28, right: 12, bottom: 28, left: 30 };
  const iW = panelW - m.left - m.right;
  const iH = panelH - m.top - m.bottom;
  const totalW = 3 * panelW + 2 * 16;

  const panels = [
    { id: "Removable", title: "Removable (hole)" },
    { id: "Jump",      title: "Jump" },
    { id: "Infinite",  title: "Infinite" }
  ];

  const conditions = {
    Removable: [
      { label: "Condition 1 — f(a) defined", pass: false, note: "f(2) is undefined (0/0)" },
      { label: "Condition 2 — limit exists",  pass: true,  note: "lim = 4 ✓" },
      { label: "Condition 3 — limit = f(a)",  pass: false, note: "f(a) missing, so cannot agree" }
    ],
    Jump: [
      { label: "Condition 1 — f(a) defined", pass: true,  note: "f(3) is defined ✓" },
      { label: "Condition 2 — limit exists",  pass: false, note: "left ≠ right, limit DNE" },
      { label: "Condition 3 — limit = f(a)",  pass: false, note: "limit doesn't exist, fails" }
    ],
    Infinite: [
      { label: "Condition 1 — f(a) defined", pass: false, note: "f(0) = 1/0, undefined" },
      { label: "Condition 2 — limit exists",  pass: false, note: "limits are ±∞" },
      { label: "Condition 3 — limit = f(a)",  pass: false, note: "neither condition holds" }
    ]
  };

  const container = document.createElement("div");
  container.style.cssText = "font-family:inherit;";

  // Panels row
  const svgRow = document.createElement("div");
  svgRow.style.cssText = "display:flex; gap:16px; flex-wrap:wrap;";

  panels.forEach(p => {
    const isSelected = p.id === selectedPanel;
    const wrap = document.createElement("div");
    wrap.style.cssText = `border:2px solid ${isSelected ? "#2563eb" : "#e5e7eb"}; border-radius:8px; background:${isSelected ? "#eff6ff" : "#fafafa"}; cursor:pointer; transition:border-color 0.15s;`;

    const svg = d3_cont.create("svg")
      .attr("width", panelW)
      .attr("height", panelH);

    const g = svg.append("g").attr("transform", `translate(${m.left},${m.top})`);

    // Title
    svg.append("text")
      .attr("x", panelW / 2).attr("y", 16)
      .attr("text-anchor", "middle")
      .attr("fill", isSelected ? "#1d4ed8" : "#374151")
      .style("font-size", "11px").style("font-weight", "600")
      .text(p.title);

    if (p.id === "Removable") {
      const xS = d3_cont.scaleLinear().domain([0, 4]).range([0, iW]);
      const yS = d3_cont.scaleLinear().domain([0, 6]).range([iH, 0]);
      g.append("g").attr("transform", `translate(0,${iH})`).call(d3_cont.axisBottom(xS).ticks(4).tickSize(3));
      g.append("g").call(d3_cont.axisLeft(yS).ticks(4).tickSize(3));
      const pts = d3_cont.range(0, 1.97, 0.05).concat(d3_cont.range(2.03, 4.01, 0.05));
      const leftPts = d3_cont.range(0, 1.97, 0.05).map(x => [x, x + 2]);
      const rightPts = d3_cont.range(2.03, 4.01, 0.05).map(x => [x, x + 2]);
      const line = d3_cont.line().x(d => xS(d[0])).y(d => yS(d[1]));
      g.append("path").datum(leftPts).attr("d", line).attr("fill","none").attr("stroke","#2563eb").attr("stroke-width",2);
      g.append("path").datum(rightPts).attr("d", line).attr("fill","none").attr("stroke","#2563eb").attr("stroke-width",2);
      g.append("circle").attr("cx", xS(2)).attr("cy", yS(4)).attr("r", 5).attr("fill","white").attr("stroke","#2563eb").attr("stroke-width",2);
    }

    if (p.id === "Jump") {
      const xS = d3_cont.scaleLinear().domain([0, 5]).range([0, iW]);
      const yS = d3_cont.scaleLinear().domain([0, 7]).range([iH, 0]);
      g.append("g").attr("transform", `translate(0,${iH})`).call(d3_cont.axisBottom(xS).ticks(5).tickSize(3));
      g.append("g").call(d3_cont.axisLeft(yS).ticks(5).tickSize(3));
      const line = d3_cont.line().x(d => xS(d[0])).y(d => yS(d[1]));
      // y=x for x<3
      g.append("path").datum([[0,0],[2.97,2.97]]).attr("d", line).attr("fill","none").attr("stroke","#2563eb").attr("stroke-width",2);
      // y=2x-4 for x>3
      g.append("path").datum([[3.03,2.06],[5,6]]).attr("d", line).attr("fill","none").attr("stroke","#2563eb").attr("stroke-width",2);
      // open circles at gap ends
      g.append("circle").attr("cx", xS(3)).attr("cy", yS(3)).attr("r", 4).attr("fill","white").attr("stroke","#2563eb").attr("stroke-width",2);
      g.append("circle").attr("cx", xS(3)).attr("cy", yS(2)).attr("r", 4).attr("fill","white").attr("stroke","#2563eb").attr("stroke-width",2);
    }

    if (p.id === "Infinite") {
      const xS = d3_cont.scaleLinear().domain([-2, 2]).range([0, iW]);
      const yS = d3_cont.scaleLinear().domain([-4, 4]).range([iH, 0]);
      g.append("g").attr("transform", `translate(0,${iH/2})`).call(d3_cont.axisBottom(xS).ticks(4).tickSize(3));
      g.append("g").call(d3_cont.axisLeft(yS).ticks(4).tickSize(3));
      // 1/x left branch
      const leftB = d3_cont.range(-2, -0.28, 0.05).map(x => [x, 1/x]);
      const rightB = d3_cont.range(0.28, 2.01, 0.05).map(x => [x, 1/x]);
      const line = d3_cont.line().x(d => xS(d[0])).y(d => yS(d[1])).defined(d => Math.abs(d[1]) <= 4);
      g.append("path").datum(leftB).attr("d", line).attr("fill","none").attr("stroke","#2563eb").attr("stroke-width",2);
      g.append("path").datum(rightB).attr("d", line).attr("fill","none").attr("stroke","#2563eb").attr("stroke-width",2);
      // vertical dashed asymptote
      g.append("line")
        .attr("x1", xS(0)).attr("x2", xS(0))
        .attr("y1", 0).attr("y2", iH)
        .attr("stroke", "#dc2626").attr("stroke-width", 1.5)
        .attr("stroke-dasharray", "4,3");
    }

    wrap.appendChild(svg.node());
    svgRow.appendChild(wrap);
  });

  container.appendChild(svgRow);

  // Condition analysis
  const info = document.createElement("div");
  info.style.cssText = "margin-top:1rem; border:1px solid #e5e7eb; border-radius:8px; padding:0.75rem 1rem; background:#fff;";

  const title = document.createElement("div");
  title.style.cssText = "font-weight:600; font-size:0.95em; color:#374151; margin-bottom:0.5rem;";
  title.textContent = `${selectedPanel} discontinuity — condition analysis`;
  info.appendChild(title);

  conditions[selectedPanel].forEach(c => {
    const row = document.createElement("div");
    row.style.cssText = "display:flex; align-items:baseline; gap:0.5rem; padding:0.2rem 0; font-size:0.9em;";
    const icon = document.createElement("span");
    icon.textContent = c.pass ? "✓" : "✗";
    icon.style.cssText = `font-weight:700; color:${c.pass ? "#059669" : "#dc2626"}; min-width:1.2em;`;
    const text = document.createElement("span");
    text.style.color = "#374151";
    text.textContent = c.label + " — " + c.note;
    row.appendChild(icon);
    row.appendChild(text);
    info.appendChild(row);
  });

  container.appendChild(info);
  return container;
}

29.6 The epsilon-delta definition

The techniques above let you compute limits. The epsilon-delta definition lets you prove they are correct. These are different activities, and most students — even in university calculus — use the techniques far more often than the proof machinery. But understanding the definition is what separates a practitioner from a mathematician.

Return to the speedometer. Suppose you want to estimate speed to within \varepsilon = 0.01 km/h. You need to take a time interval short enough — call it \delta seconds — that the average speed over that interval lands within 0.01 km/h of the true instantaneous speed. Different tolerance \varepsilon, different required \delta. The claim “the limit is L” means: for every tolerance you name, I can find a window small enough to guarantee that accuracy.

Epsilon-delta definition of a limit.

\lim_{x \to a} f(x) = L

means: for every \varepsilon > 0, there exists \delta > 0 such that

0 < |x - a| < \delta \implies |f(x) - L| < \varepsilon

In plain language: however small a target band you set around L (the \varepsilon-band), I can find a window around a (the \delta-window) such that every x inside the window — but not equal to a itself — sends f(x) inside the target band. This means no matter how tightly you specify the output window around L, the inputs can be restricted tightly enough around a to force the function into that window.

One worked example. Prove that \lim_{x \to 2} 3x = 6.

We need to show that for any \varepsilon > 0 we can produce a \delta > 0 satisfying the definition.

We want |f(x) - L| < \varepsilon, i.e., |3x - 6| < \varepsilon.

Factor: |3x - 6| = 3|x - 2|.

So the condition |3x - 6| < \varepsilon becomes 3|x - 2| < \varepsilon, i.e., |x - 2| < \varepsilon/3.

This tells us to choose \delta = \varepsilon/3.

Verification. Suppose 0 < |x - 2| < \delta = \varepsilon/3. Then:

|3x - 6| = 3|x - 2| < 3 \cdot \frac{\varepsilon}{3} = \varepsilon

The condition is satisfied for every \varepsilon > 0. The limit is 6. \square This means the whole epsilon-delta proof is a controlled translation from an allowed output error back to a sufficient input error.

Why this works — the logical structure.

The phrase “for every \varepsilon > 0” covers every possible tolerance, however tiny. The phrase “there exists \delta > 0” says you can always respond to any challenge.

Together they convert the informal idea of “approaches without reaching” — which involves an infinite process — into a finite, checkable algebraic statement. You never have to evaluate an infinite process; you just have to exhibit the \delta as a function of \varepsilon and verify the implication.

This is the logical structure of most rigorous analysis. The techniques in the previous section are shortcuts valid because the functions involved are “nice enough” that the \varepsilon-\delta machinery can be applied once and the results packaged into rules.

29.7 Worked examples

29.7.1 Example 1 — Direct substitution (polynomial)

Problem. Find \lim_{x \to 3} (x^2 + 2x - 1).

Context. In structural engineering, polynomial functions describe deflection curves along a beam. Evaluating a deflection at a specific point is direct substitution.

Solution.

The function f(x) = x^2 + 2x - 1 is a polynomial. Polynomials are continuous everywhere. Direct substitution is valid at x = 3:

\lim_{x \to 3}(x^2 + 2x - 1) = 3^2 + 2(3) - 1 = 9 + 6 - 1 = \boxed{14}

Technique used: Direct substitution. Applied whenever the function is continuous at the target point — no denominator that vanishes, no radical causing trouble.

29.7.2 Example 2 — Factoring (removable discontinuity)

Problem. Find \lim_{x \to 2} \dfrac{x^2 - 4}{x - 2}.

Context. In software engineering, a function representing computational cost might be undefined at a specific input size but still have a meaningful limiting value. Analysing the limit is the correct tool.

Solution.

Step 1. Direct substitution gives \frac{0}{0} — indeterminate.

Step 2. Factor:

\frac{x^2 - 4}{x - 2} = \frac{(x - 2)(x + 2)}{x - 2}

Step 3. Cancel (x-2), valid since x \neq 2 in a limit:

= x + 2 \quad (x \neq 2)

Step 4. Substitute:

\lim_{x \to 2} \frac{x^2 - 4}{x - 2} = \lim_{x \to 2}(x + 2) = 2 + 2 = \boxed{4}

The function has a hole at (2, 4) — a removable discontinuity. The limit exists and equals 4 even though the function is undefined at x = 2.

29.7.3 Example 3 — Rationalisation (resolving an indeterminate form)

Problem. Find \lim_{x \to 0} \dfrac{\sqrt{x+4} - 2}{x}.

Context. In chemistry, reaction rate expressions often involve differences of concentrations under a square root. Finding the limiting rate at a reference condition uses exactly this technique.

Solution.

Step 1. Direct substitution: \frac{\sqrt{4} - 2}{0} = \frac{0}{0}. Indeterminate.

Step 2. Multiply by the conjugate \frac{\sqrt{x+4} + 2}{\sqrt{x+4} + 2}:

\frac{\sqrt{x+4} - 2}{x} \cdot \frac{\sqrt{x+4} + 2}{\sqrt{x+4} + 2} = \frac{(x+4) - 4}{x(\sqrt{x+4} + 2)} = \frac{x}{x(\sqrt{x+4} + 2)}

Step 3. Cancel x (x \neq 0 in the limit):

= \frac{1}{\sqrt{x+4} + 2}

Step 4. Substitute x = 0:

\lim_{x \to 0} \frac{\sqrt{x+4} - 2}{x} = \frac{1}{\sqrt{4} + 2} = \frac{1}{4} = \boxed{0.25}

29.7.4 Example 4 — One-sided limits (regime change)

Problem. A continuous-time financial model uses the interest rate function

r(t) = \begin{cases} 0.04 & t < 5 \\ 0.04 & t = 5 \\ 0.065 & t > 5 \end{cases}

where t is years from the start of a contract. Does \lim_{t \to 5} r(t) exist?

Context. In finance, many contracts include rate resets at specified times. Whether the limit exists at the reset point determines whether the model is mathematically continuous or whether a jump discontinuity must be handled separately.

Solution.

Left-hand limit: As t \to 5^-, the rule gives r(t) = 0.04:

\lim_{t \to 5^-} r(t) = 0.04

Right-hand limit: As t \to 5^+, the rule gives r(t) = 0.065:

\lim_{t \to 5^+} r(t) = 0.065

Two-sided limit: The one-sided limits are unequal (0.04 \neq 0.065), so:

\lim_{t \to 5} r(t) \text{ does not exist}

This is a jump discontinuity. Note that r(5) = 0.04 is defined — the value exists at the point — but the two-sided limit does not. The model has a structural break at t = 5 that must be accounted for, not patched over.

29.8 Where this goes

This chapter took the informal idea of “getting closer and closer” and turned it into a precise language for analysing functions. The next chapter uses that language to define the derivative itself.

Toward differential calculus (Chapter 2). The derivative of f at a point a is defined as:

f'(a) = \lim_{h \to 0} \frac{f(a+h) - f(a)}{h}

This is precisely a limit of the \frac{0}{0} form — the same kind you evaluated in Examples 2 and 3 above. The technique of factoring, cancelling, and substituting that you practised here is exactly the algebra you will apply to evaluate derivatives in the next chapter. Limits are not preliminary material to get past — they are the mechanism the derivative is made of.

Back to sequences and series (Vol 4 Ch 4). The convergence you studied there was the same idea in a different setting. When you showed that \sum_{k=0}^{\infty} \left(\frac{1}{2}\right)^k = 2, you were evaluating a limit of partial sums: \lim_{n \to \infty} S_n = 2. The same idea — for any tolerance, there’s a point beyond which the partial sums stay within that tolerance — reappears in the formal definition of series convergence. The concepts are one family, not two separate topics.

Where limits appear in practice

Speedometers and velocity. Instantaneous velocity is \lim_{\Delta t \to 0} \frac{\Delta s}{\Delta t} — the starting point for all of mechanics.
Continuously compounded interest. \lim_{n \to \infty}\left(1 + \frac{r}{n}\right)^n = e^r. Every continuous-time financial model uses this limit.
Numerical root-finding. The bisection method generates a sequence of intervals that converge to a root. Convergence is a limit: each iteration halves the error, and the sequence of midpoints limits to the root.
Signal processing. A low-pass filter’s attenuation as frequency \to \infty is a limit question. Whether the filter “works” depends on whether that limit is zero.

29.9 What you can do now

You should now be able to tell when a question is about nearby behaviour and when it is about the function’s actual value. You can test whether a limit exists, choose an appropriate technique for evaluating it, and use the three continuity conditions without mixing them together. If the \varepsilon-\delta definition still feels more formal than intuitive, that is normal: its job is to make your existing picture of “getting arbitrarily close” exact.

29.10 Exercises

Code

function makeStepperHTML(exerciseNum, steps) {
  let current = 0;
  const totalSteps = steps.length;
  const container = document.createElement("div");
  container.style.cssText = "border:1px solid #e5e7eb; border-radius:8px; padding:1rem 1.25rem; margin:0.75rem 0; font-family:inherit;";
  const stepsDiv = document.createElement("div");
  stepsDiv.style.marginBottom = "0.75rem";

  function renderSteps() {
    stepsDiv.innerHTML = "";
    for (let i = 0; i < current; i++) {
      const s = steps[i];
      const row = document.createElement("div");
      row.style.cssText = "display:grid; grid-template-columns:200px 1fr; gap:0.35rem 1rem; align-items:baseline; padding:0.35rem 0; border-top:1px solid #f3f4f6;";
      const opCell = document.createElement("span");
      opCell.style.cssText = "font-size:0.85em; color:#6b7280; font-style:italic;";
      opCell.textContent = s.op;
      const eqCell = document.createElement("span");
      eqCell.innerHTML = katex.renderToString(s.eq, { throwOnError: false, displayMode: false });
      row.appendChild(opCell);
      row.appendChild(eqCell);
      if (s.note) {
        const noteRow = document.createElement("div");
        noteRow.style.cssText = "grid-column:2; font-size:0.82em; color:#6b7280; padding-bottom:0.2rem;";
        noteRow.textContent = s.note;
        row.appendChild(noteRow);
      }
      stepsDiv.appendChild(row);
    }
    if (current === totalSteps) {
      const done = document.createElement("div");
      done.style.cssText = "margin-top:0.5rem; font-size:0.9em; color:#059669; font-weight:500;";
      done.textContent = "✓ Solution complete";
      stepsDiv.appendChild(done);
    }
  }

  const controls = document.createElement("div");
  controls.style.cssText = "display:flex; gap:0.5rem; align-items:center;";
  const nextBtn = document.createElement("button");
  nextBtn.textContent = "Next step →";
  nextBtn.style.cssText = "padding:0.42rem 0.95rem; border:1px solid #2563eb; border-radius:5px; background:#2563eb; color:#ffffff; cursor:pointer; font-size:0.9em; font-weight:600; box-shadow:0 1px 2px rgba(37,99,235,0.18);";
  const resetBtn = document.createElement("button");
  resetBtn.textContent = "Reset";
  resetBtn.style.cssText = "padding:0.42rem 0.8rem; border:1px solid #cbd5e1; border-radius:5px; background:#f8fafc; cursor:pointer; font-size:0.9em; color:#475569; font-weight:500;";
  const counter = document.createElement("span");
  counter.style.cssText = "font-size:0.82em; color:#9ca3af; margin-left:0.25rem;";

  function updateButtons() {
    nextBtn.disabled = current === totalSteps;
    nextBtn.style.opacity = current === totalSteps ? "0.4" : "1";
    counter.textContent = current === 0 ? "Click to reveal steps" : `Step ${current} of ${totalSteps}`;
  }

  nextBtn.onclick = () => { if (current < totalSteps) { current++; renderSteps(); updateButtons(); } };
  resetBtn.onclick = () => { current = 0; renderSteps(); updateButtons(); };
  controls.appendChild(nextBtn);
  controls.appendChild(resetBtn);
  controls.appendChild(counter);
  container.appendChild(stepsDiv);
  container.appendChild(controls);
  renderSteps();
  updateButtons();
  return container;
}

Exercise 1. A structural engineer models the deflection of a beam using d(x) = 2x^3 - 3x^2 + x + 1, where x is position in metres.

Find \lim_{x \to 2} d(x).

Code

makeStepperHTML(1, [
  { op: "Identify the function type",  eq: "\\text{d(x) = 2x^3 - 3x^2 + x + 1 is a polynomial}" },
  { op: "Apply direct substitution",   eq: "\\text{Polynomials are continuous everywhere, so } \\lim_{x \\to 2} d(x) = d(2)" },
  { op: "Evaluate",                    eq: "d(2) = 2(2)^3 - 3(2)^2 + 2 + 1 = 16 - 12 + 2 + 1 = 7" },
  { op: "State the answer",            eq: "\\lim_{x \\to 2} d(x) = 7 \\text{ metres}" }
])

Exercise 2. A computing platform charges users based on data processed. The cost function has the form

C(x) = \frac{x^2 - 9}{x - 3}

where x is gigabytes processed. The pricing model is undefined at x = 3 GB due to a contract edge case. Find \lim_{x \to 3} C(x).

Code

makeStepperHTML(2, [
  { op: "Attempt direct substitution", eq: "C(3) = \\frac{9 - 9}{3 - 3} = \\frac{0}{0}", note: "Indeterminate — factor instead." },
  { op: "Factor the numerator",        eq: "x^2 - 9 = (x-3)(x+3), \\text{ so } C(x) = \\frac{(x-3)(x+3)}{x-3}" },
  { op: "Cancel the common factor",    eq: "C(x) = x + 3 \\quad (x \\neq 3)" },
  { op: "Substitute",                  eq: "\\lim_{x \\to 3} C(x) = 3 + 3 = 6" },
  { op: "Interpret",                   eq: "\\text{Cost approaches \\$6 per GB as usage approaches 3 GB threshold}" }
])

Exercise 3. In biochemistry, a reaction rate expression takes the form

R(c) = \frac{\sqrt{c + 9} - 3}{c}

where c is the change in concentration from a reference value. Find \lim_{c \to 0} R(c).

Code

makeStepperHTML(3, [
  { op: "Attempt direct substitution", eq: "R(0) = \\frac{\\sqrt{9} - 3}{0} = \\frac{0}{0}", note: "Indeterminate — rationalise." },
  { op: "Multiply by the conjugate",   eq: "\\frac{\\sqrt{c+9} - 3}{c} \\cdot \\frac{\\sqrt{c+9} + 3}{\\sqrt{c+9} + 3} = \\frac{(c+9) - 9}{c(\\sqrt{c+9} + 3)} = \\frac{c}{c(\\sqrt{c+9}+3)}" },
  { op: "Cancel c",                    eq: "\\frac{1}{\\sqrt{c+9}+3}", note: "Valid since c ≠ 0 in the limit." },
  { op: "Substitute c = 0",            eq: "\\frac{1}{\\sqrt{9}+3} = \\frac{1}{3+3} = \\frac{1}{6}" },
  { op: "Conclude",                    eq: "\\lim_{c \\to 0} R(c) = \\dfrac{1}{6}" }
])

Exercise 4. A piecewise model for a climate variable switches regime at time t = 10 years:

T(t) = \begin{cases} 2t + 1 & t < 10 \\ 30 & t = 10 \\ 3t - 8 & t > 10 \end{cases}

Find \lim_{t \to 10^-} T(t).
Find \lim_{t \to 10^+} T(t).
Does \lim_{t \to 10} T(t) exist? Explain.
Is T continuous at t = 10?

Code

makeStepperHTML(4, [
  { op: "Left-hand limit",   eq: "\\text{For } t < 10,\\; T(t) = 2t+1.\\; \\lim_{t \\to 10^-} T(t) = 2(10)+1 = 21" },
  { op: "Right-hand limit",  eq: "\\text{For } t > 10,\\; T(t) = 3t-8.\\; \\lim_{t \\to 10^+} T(t) = 3(10)-8 = 22" },
  { op: "Two-sided limit",   eq: "21 \\neq 22 \\implies \\lim_{t \\to 10} T(t) \\text{ does not exist}" },
  { op: "Check continuity",  eq: "T(10) = 30 \\text{ (defined ✓), but two-sided limit DNE ✗}", note: "Condition 2 fails — T is not continuous at t = 10." },
  { op: "Classify",          eq: "\\text{Jump discontinuity: both one-sided limits exist but are unequal}" }
])

Exercise 5. Use the three conditions to determine whether

f(x) = \begin{cases} x^2 - 1 & x \neq 2 \\ 3 & x = 2 \end{cases}

is continuous at x = 2.

Code

makeStepperHTML(5, [
  { op: "Condition 1: f(2) defined?",           eq: "f(2) = 3 \\text{ — defined ✓}" },
  { op: "Condition 2: limit exists?",            eq: "\\lim_{x \\to 2}(x^2 - 1) = 4 - 1 = 3 \\text{ — exists ✓}", note: "The limit uses the polynomial branch; the override at x=2 does not affect the approach." },
  { op: "Condition 3: limit = f(2)?",            eq: "\\lim = 3 = f(2) = 3 \\text{ — agree ✓}" },
  { op: "Conclude",                              eq: "\\text{All three conditions hold: } f \\text{ is continuous at } x = 2" },
  { op: "Note",                                  eq: "\\text{The piecewise value at } x=2 \\text{ happens to match the limit perfectly}", note: "No discontinuity despite the piecewise definition." }
])

Exercise 6 (epsilon-delta). Use the \varepsilon-\delta definition to prove that \lim_{x \to 1} (5x - 2) = 3.

Code

makeStepperHTML(6, [
  { op: "Write down what to show",     eq: "\\forall\\, \\varepsilon > 0,\\; \\exists\\, \\delta > 0 :\\; 0 < |x-1| < \\delta \\implies |(5x-2)-3| < \\varepsilon" },
  { op: "Simplify the target",         eq: "|(5x-2)-3| = |5x-5| = 5|x-1|" },
  { op: "Work backwards to find δ",    eq: "5|x-1| < \\varepsilon \\implies |x-1| < \\varepsilon/5 \\implies \\text{choose } \\delta = \\varepsilon/5" },
  { op: "Write the proof",             eq: "0 < |x-1| < \\delta = \\varepsilon/5 \\implies |(5x-2)-3| = 5|x-1| < 5 \\cdot \\tfrac{\\varepsilon}{5} = \\varepsilon \\quad \\square" },
  { op: "Reflect",                     eq: "\\text{Key move: simplify } |f(x)-L| \\text{ until it contains } |x-a|, \\text{ then read off } \\delta", note: "The same pattern applies to every linear limit proof." }
])