Standard Limit (Sine)

Deep Breakdown

What it tells me (Situation Awareness): This is one of the most important limits in calculus. It says that for very small $x$ (in radians), $\sin x \approx x$ — the sine function behaves like the identity function near zero. This is the small-angle approximation. Directly: it is a $0/0$ indeterminate form that resolves to 1. It is the foundational limit used to prove $d/dx[\sin x] = \cos x$ (set $x = a$, $h \to 0$, and the proof reduces to this limit). In DS/DA: the sinc function $\text{sinc}(x) = \sin(\pi x)/(\pi x)$ appears in signal processing, interpolation, and Fourier analysis — its value at $x = 0$ is exactly this limit; small-angle approximations in robotics and sensor models; the sinusoidal activation/feature map approximations in certain kernel methods; Fourier transform limit analysis.

Flowchart

Real-world use

Where it is used

Proof of $d/dx[\sin x] = \cos x$: $\lim_{h\to 0}[\sin(x+h)-\sin x]/h = \lim_{h\to 0}[\sin(x)\cos(h) + \cos(x)\sin(h) - \sin(x)]/h = \sin(x)\lim_{h\to 0}[(\cos h - 1)/h] + \cos(x)\lim_{h\to 0}[\sin h/h] = 0 + \cos(x) \cdot 1 = \cos x$; sinc function in signal processing and interpolation; small-angle approximations in navigation, robotics, and physics simulations; periodogram analysis where $\sin(\omega h)/(\omega h) \to 1$ as $h \to 0$; random Fourier features and kernel approximations.

Problem it solves

$\sin(0)/0 = 0/0$ is undefined. Yet intuitively, "how fast does $\sin x$ grow compared to $x$ near zero?" has an answer: they grow at the same rate (both have slope 1 at 0). This limit makes that precise. Without it, the derivative of $\sin$ cannot be derived from first principles.

How it solves the problem

The standard proof uses the squeeze theorem with geometric areas: for $0 < x < \pi/2$, $\sin x \le x \le \tan x$, so $\cos x \le \sin x / x \le 1$. As $x \to 0$, $\cos x \to 1$, so $\sin x / x$ is squeezed to 1. Alternatively: Taylor expansion $\sin x = x - x^3/6 + \ldots$ gives $\sin x / x = 1 - x^2/6 + \ldots \to 1$.

Example in a business

A DS implements a sinc-based interpolation filter for upsampling time series data. The filter's frequency response is $H(f) = T \cdot \text{sinc}(fT)$ where $\text{sinc}(u) = \sin(\pi u)/(\pi u)$. At $f = 0$ (DC component): $\lim_{u\to 0}\sin(\pi u)/(\pi u) = 1$ — the filter passes DC unchanged. This is a direct application of $\lim_{x\to 0}\sin x/x = 1$ with the substitution $x = \pi u$.

The formula, piece by piece

• $\sin x$: sine function, defined in radians for this limit
• $x$: the argument (in radians — critical: this limit fails if $x$ is in degrees)
• $\sin x / x$: ratio of sine to its argument — the "sinc" function (unnormalized)
• $\to 1$: the ratio approaches 1 as $x \to 0$; both numerator and denominator go to 0, but at the same rate
• Extension: $\lim_{x\to 0}\sin(ax)/(ax) = 1$ for any constant $a \ne 0$; so $\lim_{x\to 0}\sin(ax)/x = a$
• Related: $\lim_{x\to 0}[1-\cos x]/x = 0$ and $\lim_{x\to 0}[1-\cos x]/x^2 = 1/2$ (used in the derivative of cosine)
• Small-angle approximation: $\sin x \approx x$, $\cos x \approx 1 - x^2/2$, $\tan x \approx x$ for $|x| \ll 1$

The formula in words

"For very small angles (in radians), $\sin x$ and $x$ are essentially equal. The ratio $\sin x / x$ approaches 1 as the angle shrinks to zero." Tiny trace: $x = 0.1$: $\sin(0.1)/0.1 = 0.09983/0.1 = 0.9983$. $x = 0.01$: $\sin(0.01)/0.01 = 0.009999833/0.01 = 0.9999833$. $x \to 0$: ratio $\to 1$. $\checkmark$

Critical Concepts

• Radians are mandatory: $\lim_{x\to 0}\sin(x^\circ)/x$ (degrees) is NOT 1 — it equals $\pi/180 \approx 0.01745$. The reason: $\sin(x^\circ) = \sin(x\pi/180)$, so the limit is $\pi/180 \cdot \lim_{u\to 0}\sin(u)/u = \pi/180$. All calculus with trig functions assumes radians.
• Foundation of trig derivatives: the entire table of trig derivatives ($d/dx[\sin x] = \cos x$, $d/dx[\cos x] = -\sin x$, etc.) ultimately depends on this limit. Without $\lim_{x\to 0}\sin x/x = 1$, none of them can be derived from first principles.
• Sinc function in signal processing: the sinc function $\text{sinc}(x) = \sin(\pi x)/(\pi x)$ (normalized) or $\sin(x)/x$ (unnormalized) is the ideal low-pass filter's impulse response. Its value at $x=0$ is defined as 1 by this limit. Sinc interpolation, the Whittaker-Shannon reconstruction formula, and discrete Fourier transform windowing all use sinc.
• Taylor series view: $\sin x = x - x^3/3! + x^5/5! - \ldots$, so $\sin x / x = 1 - x^2/6 + x^4/120 - \ldots$. Each term beyond 1 vanishes as $x \to 0$. The Taylor series also gives the rate of error in the small-angle approximation: $\sin x - x \approx -x^3/6$, so the relative error is $|x^2/6|$. At $x = 0.1$ rad: error $\approx 0.1^2/6 = 0.00167$ (0.17%), small enough for most sensor models.
• L'Hôpital confirmation: applying L'Hôpital to $0/0$: $\lim_{x\to 0}\sin x / x = \lim_{x\to 0}\cos x / 1 = \cos 0 = 1$.

This confirms the limit via derivatives — though technically L'Hôpital relies on the derivative of sine, creating a circular argument. The geometric/squeeze proof is rigorous.

Step-by-step calculation (tiny example)

Evaluate $\lim_{x\to 0}\sin(3x)/(5x)$.

Step 1: Rewrite to isolate the standard limit form. $\sin(3x)/(5x) = (3/5) \cdot \sin(3x)/(3x)$.

Step 2: Let $u = 3x$; as $x \to 0$, $u \to 0$. $= (3/5) \cdot \sin(u)/u$.

Step 3: Apply the standard limit. $= (3/5) \cdot 1 = 3/5 = 0.6$. Verify: $x = 0.001$: $\sin(0.003)/0.005 = 0.002999996/0.005 = 0.59999...\approx 0.6$. $\checkmark$

Code examples

Beginner example (Python)

import numpy as np


def sinc_unnormalized(x: np.ndarray) -> np.ndarray:
    """sin(x)/x, defined to be 1 at x=0 (by the standard limit)."""
    return np.where(np.abs(x) < 1e-10, 1.0, np.sin(x) / x)


# Demonstrate the limit numerically
print("Standard Limit: lim_{x->0} sin(x)/x = 1")
print(f"\n{'x (rad)':>12} {'sin(x)/x':>12} {'Error from 1':>14} {'sin(x) approx':>16}")
x_vals = [1.0, 0.5, 0.1, 0.05, 0.01, 0.001, 0.0001]
for x in x_vals:
    ratio = np.sin(x) / x
    error = abs(ratio - 1.0)
    taylor_err = x**2 / 6   # leading error term from Taylor: 1 - x^2/6
    print(f"{x:>12.4f} {ratio:>12.8f} {error:>14.2e} {taylor_err:>16.2e}")

# Derived limits: lim sin(ax) / x = a
print(f"\n--- Derived: lim_{{x->0}} sin(ax)/x = a ---")
print(f"{'a':>6} {'Numerical':>12} {'Analytic (=a)':>14}")
for a in [2, 3, 0.5, np.pi]:
    numerical = np.sin(a * 1e-8) / 1e-8
    print(f"{a:>6.4f} {numerical:>12.6f} {a:>14.6f}")

# Sinc function: signal processing zero-padding interpolation
print(f"\n--- Sinc function (unnormalized): sin(x)/x ---")
x_domain = np.linspace(-3 * np.pi, 3 * np.pi, 1000)
sinc_vals = sinc_unnormalized(x_domain)
print(f" sinc(0) = {sinc_unnormalized(np.array([0.0]))[0]:.6f} (defined by limit = 1)")
print(f" sinc(pi) = {sinc_unnormalized(np.array([np.pi]))[0]:.6f} (sin(pi)/pi = 0)")
print(f" sinc(2*pi) = {sinc_unnormalized(np.array([2*np.pi]))[0]:.6f}")
print(f" First zero crossing at x = pi = {np.pi:.4f}")

Beginner example (R)

# Standard limit: lim_{x->0} sin(x)/x = 1
sinc_unnormalized <- function(x) {
  ifelse(abs(x) < 1e-10, 1.0, sin(x) / x)
}
cat("Standard Limit: lim_{x->0} sin(x)/x = 1\n\n")
cat(sprintf("%-12s %-12s %-14s\n", "x (rad)", "sin(x)/x", "Error from 1"))
x_vals <- c(1.0, 0.5, 0.1, 0.01, 0.001, 0.0001)
for (x in x_vals) {
  ratio <- sin(x) / x
  error <- abs(ratio - 1.0)
  cat(sprintf("%-12.4f %-12.8f %-14.2e\n", x, ratio, error))
}

# Derived limit: lim sin(ax)/x = a
cat("\nDerived: lim_{x->0} sin(ax)/x = a\n")
cat(sprintf("%-6s %-12s %-12s\n", "a", "Numerical", "Analytic"))
for (a in c(2, 3, 0.5, pi)) {
  h <- 1e-8
  numerical <- sin(a * h) / h
  cat(sprintf("%-6.4f %-12.6f %-12.6f\n", a, numerical, a))
}

Professional example (Python)

import numpy as np
from scipy.signal import resample_poly
from sklearn.metrics import mean_squared_error
np.random.seed(42)

# -- Standard limit sin(x)/x = 1: sinc interpolation for time series upsampling --
# Use case: A DS upsamples a sensor time series (e.g., IoT device sampled at 10 Hz)
# to a higher rate (50 Hz) for downstream feature engineering. The ideal
# reconstruction filter is sinc, whose DC value (gain at 0 Hz) = 1 by the standard limit.
# We compare sinc interpolation (ideal) against linear interpolation.
ORIG_RATE = 10   # Hz
TARGET_RATE = 50   # Hz
UP_FACTOR = TARGET_RATE // ORIG_RATE
DURATION = 2.0   # seconds
FREQ_SIGNAL = 3.0   # Hz (well below Nyquist of 5 Hz)

# Generate ground truth at target rate
t_high = np.linspace(0, DURATION, int(TARGET_RATE * DURATION), endpoint=False)
signal_truth = np.sin(2 * np.pi * FREQ_SIGNAL * t_high) + 0.3 * np.sin(2 * np.pi * 2.0 * t_high)

# Downsampled signal at original rate
t_low = t_high[::UP_FACTOR]
signal_low = signal_truth[::UP_FACTOR]


# --- Sinc interpolation ---
def sinc_interp(x_low: np.ndarray, t_low: np.ndarray, t_high: np.ndarray) -> np.ndarray:
    """Whittaker-Shannon sinc interpolation.

    x_reconstruct[t] = sum_k x[k] * sinc((t - t_k) / T)
    where sinc(u) = sin(pi*u)/(pi*u) -- value at u=0 is 1 by the standard limit.
    """
    T = t_low[1] - t_low[0]   # original sampling interval
    output = np.zeros_like(t_high)
    for k, (x_k, t_k) in enumerate(zip(x_low, t_low)):
        u = (t_high - t_k) / T
        # sinc(u) = sin(pi*u)/(pi*u), defined = 1 at u=0 (standard limit)
        sinc_vals = np.where(np.abs(u) < 1e-10, 1.0, np.sin(np.pi * u) / (np.pi * u))
        output += x_k * sinc_vals
    return output


# --- Linear interpolation ---
signal_linear = np.interp(t_high, t_low, signal_low)

# --- Sinc interpolation ---
signal_sinc = sinc_interp(signal_low, t_low, t_high)

# Compare quality
mse_linear = mean_squared_error(signal_truth, signal_linear)
mse_sinc = mean_squared_error(signal_truth, signal_sinc)
print("Standard Limit sin(x)/x=1: Sinc Interpolation for Time Series Upsampling")
print(f"\nOriginal rate: {ORIG_RATE} Hz, Target rate: {TARGET_RATE} Hz, Signal: {FREQ_SIGNAL} Hz")
print(f"\nSinc kernel center (u=0): sinc(0) = lim_{{x->0}} sin(pi*x)/(pi*x) = 1")
print(f" This ensures the reconstructed signal matches the original samples exactly.")
print(f"\nInterpolation quality (lower MSE = better):")
print(f" Linear interpolation MSE: {mse_linear:.6f}")
print(f" Sinc interpolation MSE: {mse_sinc:.8f}")
print(f" Improvement factor: {mse_linear / max(mse_sinc, 1e-12):.1f}x")
print(f"\nSinc at sample points (should be exactly 1 or 0):")
for k in range(min(5, len(t_low))):
    # At each original sample time: sinc(0) = 1 for matching sample, sinc(n) = 0 for others
    u_vals = (t_low[k] - t_low) / (t_low[1] - t_low[0])
    sinc_at_samples = np.where(np.abs(u_vals) < 1e-10, 1.0, np.sin(np.pi * u_vals) / (np.pi * u_vals))
    print(f" k={k}: sinc at own sample = {sinc_at_samples[k]:.6f} (expect 1.0)")

Source: 1300 p. 216

#calculus#differential-calculus#limits-of-functions