Sequences and Convergence

Why This Matters

A sequence is an ordered list of numbers generated by a rule: a(1), a(2), a(3), and so on. The fundamental question is whether the terms settle down to a single value as n grows large. If they do, the sequence converges; if they do not, it diverges. This idea is the foundation for everything that follows in Calculus II -- infinite series, power series, and Taylor approximations all depend on understanding when sequences converge.

Two important properties help determine convergence. A monotone sequence is one that is always increasing or always decreasing -- it never reverses direction. A bounded sequence has all its terms trapped between a lower and upper bound. The Monotone Convergence Theorem guarantees that every bounded monotone sequence converges. This is a powerful tool: if you can show a sequence is both monotone and bounded, convergence is guaranteed even if you cannot find the exact limit.

Sequences model discrete processes: iterative algorithms, population models, compound interest, and recursive computations all produce sequences. Knowing whether a sequence converges (and to what) tells you whether an algorithm stabilizes, a population reaches equilibrium, or an investment approaches a limiting value.

Define Terms

Visual Model

Code Example

// Sequences and Convergence

// Generate terms of a sequence
function sequenceTerms(rule, count) {
  const terms = [];
  for (let n = 1; n <= count; n++) {
    terms.push(rule(n));
  }
  return terms;
}

// Sequence 1: a(n) = 1/n  (converges to 0)
const seq1 = sequenceTerms(n => 1 / n, 10);
console.log("1/n:", seq1.map(x => x.toFixed(4)).join(", "));

// Sequence 2: a(n) = (1 + 1/n)^n  (converges to e)
const seq2 = sequenceTerms(n => Math.pow(1 + 1/n, n), 10);
console.log("(1+1/n)^n:", seq2.map(x => x.toFixed(4)).join(", "));
console.log("e =", Math.E.toFixed(6));

// Sequence 3: a(n) = (-1)^n  (diverges, oscillates)
const seq3 = sequenceTerms(n => Math.pow(-1, n), 10);
console.log("(-1)^n:", seq3.join(", "));

// Check monotonicity
function isMonotone(terms) {
  let increasing = true, decreasing = true;
  for (let i = 1; i < terms.length; i++) {
    if (terms[i] > terms[i-1]) decreasing = false;
    if (terms[i] < terms[i-1]) increasing = false;
  }
  if (increasing) return "increasing";
  if (decreasing) return "decreasing";
  return "neither";
}
console.log("1/n monotone:", isMonotone(seq1));
console.log("(1+1/n)^n monotone:", isMonotone(seq2));
console.log("(-1)^n monotone:", isMonotone(seq3));

// Check boundedness
function isBounded(terms) {
  const min = Math.min(...terms);
  const max = Math.max(...terms);
  return { bounded: true, min: min.toFixed(4), max: max.toFixed(4) };
}
console.log("1/n bounds:", JSON.stringify(isBounded(seq1)));

// Estimate limit from last terms
const longSeq = sequenceTerms(n => (1 + 1/n)**n, 10000);
console.log("Estimated limit of (1+1/n)^n:", longSeq[longSeq.length - 1].toFixed(6));

Interactive Experiment

Try these exercises:

• Compute the first 20 terms of a(n) = n/(n+1). What value does this approach? Is the sequence monotone? Bounded?
• Try a(n) = sin(n)/n. Is it monotone? Does it converge? To what?
• Compute terms of a(n) = (2n)! / (n! * 4^n). Does this converge or diverge?
• Test the sequence a(1) = 1, a(n+1) = (a(n) + 2/a(n)) / 2. This is a Newton method iteration. What does it converge to?
• Find a sequence that is bounded but not convergent. Hint: try something that oscillates.

Quick Quiz

Coding Challenge

Real-World Usage

Sequences and their convergence appear in many practical contexts:

• Iterative algorithms: Newton method, gradient descent, and fixed-point iteration all generate sequences. Convergence of the sequence means the algorithm finds a solution.
• Compound interest: The balance after n periods forms a sequence. The continuous compounding limit (1 + r/n)^n as n approaches infinity gives e^r.
• Population models: Discrete population models produce sequences. Convergence to a fixed point represents ecological equilibrium.
• Numerical methods: Successive approximations in numerical PDE solvers form sequences that must converge to the true solution.
• Machine learning: Training loss over epochs forms a sequence. Monitoring its convergence is how you know when to stop training.

Connections