Limites: a ideia central

O limite fundamenta derivadas, integrais e séries. Sua definição formaliza a noção intuitiva de aproximação e a transforma em ferramenta matemática.

1 Velocidade instantânea

Um carro passa por um radar e ele registra: 67 km/h naquele instante. No entanto, velocidade é distância dividida por tempo. Em um único instante, a distância percorrida é zero e o tempo decorrido é zero. Como pode existir uma “velocidade no instante”, se \frac{0}{0} não faz sentido?

O fato é que não conseguimos medir a velocidade no exato instante, mas conseguimos medir a velocidade média em intervalos cada vez menores ao redor dele, e observar para onde esses valores convergem.

Suponha que um objeto em queda percorre s(t) = 5t^2 metros em t segundos (ou seja, a posição é igual a cinco vezes o tempo ao quadrado). Qual a velocidade no instante t = 1?

v_{\text{média}} \text{ em } [1,\; t] \;=\; \frac{\Delta s}{\Delta t} = \frac{s(t) - s(1)}{t - 1}

Intervalo	Formula	Velocidade média
[1,\; 2]	\dfrac{s(2) - s(1)}{2-1} = \dfrac{20 - 5}{1}	15,\!0 m/s
[1,\; 1{,}5]	\dfrac{s(1{,}5) - s(1)}{1,5-1} = \dfrac{11,25 - 5}{0,5}	12,\!5 m/s
[1,\; 1{,}1]	\dfrac{s(1{,}1) - s(1)}{1,1-1} = \dfrac{6,05 - 5}{0,1}	10,\!5 m/s
[1,\; 1{,}01]	\dfrac{s(1{,}01) - s(1)}{1,01-1} = \dfrac{5,1005 - 5}{0,01}	10,\!05 m/s
[1,\; 1{,}001]	\dfrac{s(1{,}001) - s(1)}{1,001-1} = \dfrac{5,010005 - 5}{0,001}	10,\!005 m/s

Os valores estão convergindo para 10 m/s. Nenhuma dessas médias é a velocidade instantânea, mas todas apontam para ela. Dizemos que a velocidade instantânea é o limite das velocidades médias.

Código

import numpy as np
import matplotlib.pyplot as plt

# Configurações de exibição do matplotlib (grade, transparência, tamanho da fonte)
plt.rcParams.update({"axes.grid": True, "grid.alpha": 0.3, "font.size": 11})

# função da posição: s(t) = 5t^2
s = lambda t: 5 * t**2

# Cria um conjunto de valores t igualmente espaçados para o eixo x do gráfico
t = np.linspace(0, 2.3, 200)

# Cria a figura e o eixo para o gráfico
fig, ax = plt.subplots(figsize=(7, 4.4))

# Plota o gráfico da função posição s(t)
ax.plot(t, s(t), lw=2.5, label="$s(t) = 5t^2$")

# Instante fixo onde queremos a velocidade instantânea
t0 = 1.0

# Para cada valor de t1, desenha a reta secante entre t0 e t1, com uma cor diferente
for t1, cor in [(2.0, "#d62728"), (1.5, "#ff7f0e"), (1.1, "#2ca02c")]:
    # Calcula a inclinação (velocidade média) da reta secante
    m = (s(t1) - s(t0)) / (t1 - t0)
    # Define intervalo para a reta secante (um pouco além dos pontos para destacar)
    tt = np.array([t0 - 0.15, t1 + 0.15])
    # Plota a reta secante tracejada
    ax.plot(tt, s(t0) + m * (tt - t0), "--", color=cor, alpha=0.85,
            label=f"secante $[1;\\ {t1}]$, média {m:.1f} m/s")
    # Destaca o ponto extremo da secante
    ax.plot([t1], [s(t1)], "o", color=cor)

# Plota a reta tangente em t0 com inclinação 10 (velocidade instantânea)
tt = np.array([0.2, 2.1])
ax.plot(tt, s(t0) + 10 * (tt - t0), color="black", lw=1.8,
        label="tangente, instantânea 10 m/s")
# Marca o ponto t0 na curva
ax.plot([t0], [s(t0)], "ko")

# Define os rótulos dos eixos e limites do eixo y
ax.set(xlabel="tempo $t$ (s)", ylabel="posição $s$ (m)", ylim=(-2, 27))

# Exibe a legenda no canto superior esquerdo
ax.legend(fontsize=9, loc="upper left")

# Mostra o gráfico
plt.show()

Gráfico da parábola s(t) = 5t² com três retas secantes partindo de t=1 e a reta tangente em t=1. — Cada velocidade média é a inclinação de uma reta secante. Encolhendo o intervalo, as secantes se aproximam da reta tangente, cuja inclinação é a velocidade instantânea.

“O que acontece com f(x) quando x se aproxima de a?”, sem nunca precisar chegar em a. Essa pergunta é o limite. A velocidade instantânea, a reta tangente, a área sob uma curva são todas respostas a versões dela.

2 O conceito de limite

Definição básica informal de limite

Escrevemos \lim_{x \to a} f(x) = L quando os valores de f(x) ficam tão próximos de L quanto quisermos, bastando tomar x suficientemente próximo de a, por qualquer um dos dois lados, sem que x seja igual a a.

Ou seja: “quando x chega perto de a, f(x) chega perto de L.”

A definição rigorosa será apresentada mais a frente quando falarmos de continuidade.

Um exemplo clássico de limite é a função:

f(x) = \frac{x^2 - 1}{x - 1}.

A substituição de x = 1 produz \frac{0}{0}, portanto f(1) não existe. O limite descreve o comportamento perto de 1, e não em 1:

x \to 1^-	f(x)	x \to 1^+	f(x)
0{,}9	1{,}9	1{,}1	2{,}1
0{,}99	1{,}99	1{,}01	2{,}01
0{,}999	1{,}999	1{,}001	2{,}001

Pelos dois lados, f(x) \to 2. Portanto:

\lim_{x \to 1} \frac{x^2 - 1}{x - 1} = 2

Neste caso, o limite de f(x) quando x tende a 1 é 2.

Código

import numpy as np
import matplotlib.pyplot as plt

# Cria um array de 100 valores de x igualmente espaçados de -0.5 a 2.5
x = np.linspace(-0.5, 2.5, 100)

# Cria a figura e o eixo do gráfico, define tamanho
fig, ax = plt.subplots(figsize=(6.5, 4))

# Plota a reta y = x + 1 (que representa f(x)), com espessura maior e rótulo latex
ax.plot(x, x + 1, lw=2.5, label=r"$f(x) = \frac{x^2-1}{x-1}$")

# Destaca o buraco em (1,2): círculo aberto em x = 1
ax.plot([1], [2], "o", mfc="white", mec="C0", mew=2, ms=9, zorder=5)

# Adiciona seta apontando para o ponto (0.9, 1.9), simulando aproximação pela esquerda
ax.annotate(
    "", 
    xy=(0.9, 1.9), 
    xytext=(0.45, 1.45),
    arrowprops=dict(arrowstyle="->", color="#d62728", lw=2)
)

# Adiciona seta apontando para o ponto (1.1, 2.1), simulando aproximação pela direita
ax.annotate(
    "", 
    xy=(1.1, 2.1), 
    xytext=(1.55, 2.55),
    arrowprops=dict(arrowstyle="->", color="#d62728", lw=2)
)

# Define os rótulos dos eixos e os valores dos ticks
ax.set(xlabel="$x$", ylabel="$y$", xticks=[0, 1, 2], yticks=[1, 2, 3])

# Adiciona legenda ao gráfico
ax.legend()

# Exibe o gráfico
plt.show()

Reta y = x + 1 com círculo aberto no ponto (1, 2) e setas indicando aproximação pelos dois lados. — O gráfico de f é a reta y = x + 1 com um buraco em x = 1. O limite enxerga para onde a função aponta, o buraco não importa.

Porquê o valor de f(a) não importa?

O limite em x = a depende só do comportamento perto de a. A função pode nem estar definida em a (como acima), ou ter um valor “errado” lá, o limite nem toma conhecimento. Limite é sobre os valores proximos, nunca sobre o ponto.

2.1 Limites laterais

Às vezes a função se comporta de um jeito à esquerda de a e de outro à direita. Por isso definimos:

\displaystyle\lim_{x \to a^-} f(x), limite pela esquerda (x se aproxima de a com x < a);
\displaystyle\lim_{x \to a^+} f(x), limite pela direita (x se aproxima de a com x > a).

O exemplo clássico é f(x) = \dfrac{|x|}{x}, que vale 1 para x > 0 e -1 para x < 0:

Código

import numpy as np
import matplotlib.pyplot as plt

# Cria a figura e o eixo, definindo o tamanho do gráfico
fig, ax = plt.subplots(figsize=(6.5, 3.6))

# Plota o trecho da função onde x < 0 (y = -1)
ax.plot([-2, 0], [-1, -1], lw=2.5, color="C0")

# Plota o trecho da função onde x > 0 (y = 1)
ax.plot([0, 2], [1, 1], lw=2.5, color="C0")

# Destaca os pontos em x = 0 (círculos abertos em y = -1 e y = 1, indicando que a função não está definida nesses pontos)
ax.plot([0, 0], [-1, 1], "o", mfc="white", mec="C0", mew=2, ms=9)

# Adiciona seta para ilustrar aproximação pela esquerda (x -> 0-)
ax.annotate(
    r"$x \to 0^-$",
    xy=(-0.15, -1),
    xytext=(-1.4, -0.55),
    arrowprops=dict(arrowstyle="->", color="#d62728", lw=2),
    fontsize=12
)

# Adiciona seta para ilustrar aproximação pela direita (x -> 0+)
ax.annotate(
    r"$x \to 0^+$",
    xy=(0.15, 1),
    xytext=(0.75, 0.45),
    arrowprops=dict(arrowstyle="->", color="#d62728", lw=2),
    fontsize=12
)

# Define os rótulos dos eixos, limites do eixo y e valores dos ticks
ax.set(xlabel="$x$", ylabel="$y$", ylim=(-1.8, 1.8), yticks=[-1, 0, 1])

# Exibe o gráfico
plt.show()

f(x) = |x|/x: pela esquerda a função aponta para −1, pela direita para +1. Os lados discordam, o limite em 0 não existe.

Teorema: o limite existe quando os lados convergem para o mesmo valor

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

Ou seja: o limite bilateral existe se, e somente se, os dois limites laterais existem e são iguais. Esse é o primeiro teste prático.

2.2 Quando o limite não existe

Três situações clássicas:

Os lados não convergem para o mesmo valor, como em \dfrac{|x|}{x} exemplificado acima.
A função oscila infinitas vezes, como \operatorname{sen}(\dfrac{1}{x}) perto de 0: por menor que seja a janela, ela continua alternando entre -1 e 1 infinitamente.
A função explode, como \dfrac{1}{x^2} perto de 0: os valores vão ao infinito. Nesse caso escrevemos \lim_{x \to 0} \dfrac{1}{x^2} = +\infty para descrever o comportamento, mas o limite não existe como número.

Código

import numpy as np
import matplotlib.pyplot as plt

# Cria uma figura com 2 subgráficos lado a lado e define o tamanho da figura
fig, axs = plt.subplots(1, 2, figsize=(9, 3.4))

# Para cada subgráfico e limite de janela correspondente
for ax, lim in [(axs[0], 0.5), (axs[1], 0.05)]:
    # Gera array de valores x, igualmente espaçados, no intervalo (-lim, lim), excluindo o zero
    x = np.linspace(-lim, lim, 8000)
    x = x[x != 0]
    # Plota a função sen(1/x) para esses valores de x, com linha fina
    ax.plot(x, np.sin(1 / x), lw=0.7)
    # Define o título do gráfico (indicando a janela), o rótulo do eixo x e os limites do eixo y
    ax.set(title=f"janela $\\pm{lim}$", xlabel="$x$", ylim=(-1.3, 1.3))

# Adiciona o rótulo do eixo y apenas ao primeiro gráfico
axs[0].set_ylabel(r"$\sin\left(\frac{1}{x}\right)$")

# Ajusta o layout para evitar sobreposição dos elementos visuais
plt.tight_layout()

# Exibe os gráficos
plt.show()

sen(1/x) perto da origem: quanto mais proximo de zero, maior a oscilação. Não há valor único para onde a função aponta.