Estabilidad

01 · Punto de partida

Empujar para probar

El tanque en N* = 15 recibe un baldazo (+5) o le sacan un balde (−5): en ambos casos vuelve a 15. La colonia en P = 0 recibe 2 bacterias y despega: no vuelve. El equilibrio estaba, pero uno atrae y el otro repele. La estabilidad es esa prueba: perturbar un poco y mirar si retorna.

Encontrar el fijo (Tema 25) era el paso 1; perturbarlo es el paso 2. Sin este test, «equilibrio» no dice el destino.

• ¿Si lo muevo ±ε, la flecha apunta de vuelta o hacia afuera?
• ¿La pendiente f'(x*) es negativa o positiva?
• ¿Qué tan rápido retorna (1/|f'|)?
• ¿El retorno vale para todo x₀ o solo cerca?

02 · Definición

¿Qué es la estabilidad?

El veredicto cerca del fijo:

Es la linealización: cerca del fijo, f se parece a su tangente y la perturbación decae o crece exponencial con esa pendiente.

03 · Anatomía

Pendiente, retorno y alcance

La estabilidad se lee en tres capas:

Pendiente f'(x*)

Signo = veredicto; magnitud = velocidad. En el tanque, −k: retorna en 1/k.

Local vs global

Local vale cerca; global vale desde todo x₀. El K logístico es global en P > 0.

Perturbación ε

El empujón de prueba: ±5, ±20. Si vuelve con ε grande, la cuenca es amplia.

Caso borde f' = 0

La tangente no decide: hay que mirar más (términos de orden mayor o simular).

04 · Estabilidad en el curso

El veredicto de cada destino

Cada equilibrio con su firma:

1. 1
   Tanque q/k.

   f' = −k: atractor global. Todo vuelve.

2. 2
   Logístico 0 / K.

   +r repele, −r atrae: la recta se parte en dos destinos.

3. 3
   Ambiente T_amb.

   f' = −k: la taza siempre vuelve al ambiente.

4. 4
   Cosecha K(1 − h/r).

   Estable mientras h < r; en h = r choca y muere.

5. 5
   Resorte (0, 0).

   Foco estable con c > 0: espirales que entran (2D).

05 · Representación en Python

Pendiente numérica y veredicto

En Python, f' se estima con cociente incremental y el veredicto es un if sobre el signo. Sin fórmulas a mano.

def f(p, r=0.5, k=100.0):
    return r * p * (1 - p / k)


def derivada(p, r=0.5, k=100.0, h=1e-5):
    return (f(p + h, r, k) - f(p - h, r, k)) / (2 * h)


def veredicto(p, r=0.5, k=100.0):
    d = derivada(p, r, k)
    return f"f'={d:+.2f} → {'atractor' if d < 0 else 'repulsor' if d > 0 else 'borde'}"


for p in [0, 100]:
    print(p, veredicto(p))

0: f' = +0,50 → repulsor · 100: f' = −0,50 → atractor. La tangente firma.

Tiempo de retorno

La magnitud da el reloj de la vuelta:

import math


def tiempo_retorno(p_star, r=0.5, k=100.0):
    d = abs(derivada(p_star, r, k))
    return round(math.log(2) / d, 2) if d > 0 else None


print(tiempo_retorno(100))

06 · Exploración

Laboratorio: empujar y mirar si vuelve

Logístico con tu r y tu K. Izquierda: órbitas perturbadas —K − 20 (teal), K + 20 (naranja) y semilla ε = 3 (gris)— que prueban los dos fijos. Derecha: f(P) con tangentes en 0 (crece) y K (decrece): las pendientes firman repulsor y atractor. Agrandá la perturbación y mirá si igual vuelven.

Las tangentes anticipan: en 0 sube (escapa), en K baja (retorna). Las órbitas obedecen con retornos en 1/|f'|.

Preguntas para explorar

1. Con ε = 40 (K ± 40), ¿las dos vuelven? ¿Alguna se demora más?
2. Duplicá r con el mismo K. ¿Las pendientes se empinan? ¿El retorno es más rápido?
3. Si r fuera −0,5, ¿qué fijo atraería? ¿Qué dirían las tangentes?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: veredicto del tanque

Con q = 3 y k = 0,2, calculá f'(N*) numéricamente y firmá el veredicto.

def f(n, q=3.0, k=0.2):
    return q - k * n


n_star = 3 / 0.2
d = (f(n_star + 1e-5) - f(n_star - 1e-5)) / 2e-5
print(round(d, 3), "→", "atractor" if d < 0 else "repulsor")

Ejercicio 2: el 0 que repele

Con r = 0,4 y K = 100, evaluá f'(0) y pronosticá qué hace una semilla de 2.

r = 0.4
print("f'(0) =", r, "→ repele: la semilla", "despega" if r > 0 else "muere")

Ejercicio 3: perturbar de verdad

Simulá K ± 20 con r = 0,5, K = 100 hasta T = 20. ¿Vuelven ambas? ¿A qué distancia quedan?

import math


def final(p0, r=0.5, k=100.0, t=20.0):
    return k / (1 + (k - p0) / p0 * math.exp(-r * t))


a, b = final(80), final(120)
print(round(a, 2), round(b, 2), "Δ", round(abs(a - b), 2))

09 · Síntesis

Ideas para recordar

En el próximo tema miraremos lejos: el comportamiento a largo plazo del sistema.