Puntos de equilibrio

01 · Punto de partida

El sistema quieto en movimiento

El tanque en N* = 15 sigue recibiendo 3 y soltando 3 por minuto: el nivel no se mueve porque los flujos se compensan. Ese es el equilibrio: tasa cero con flujos activos. Encontrarlo es resolver f(x*) = 0, sin integrar nada.

Todo destino del curso —techos, ambientes, capacidades, R(∞)— es un equilibrio de alguna f. Cazarlos primero ahorra simulaciones.

• ¿Dónde se anula cada tasa?
• ¿El equilibrio mueve flujos o es reposo total?
• ¿Cuántos hay y dónde están ordenados?
• ¿Cuál sobrevive si cambio un parámetro?

02 · Definición

¿Qué es un punto de equilibrio?

Cero de la regla, candidato a destino:

Arrancar justo en x* dibuja una horizontal perfecta: la prueba de que el álgebra y el integrador coinciden.

03 · Anatomía

Cazar, ordenar y contar equilibrios

La receta algebraica:

Igualar a cero

Plantear f(x) = 0 y despejar: lineal da uno, cuadrática da dos, SIR da una recta.

Ordenar en la fase

Ubicarlos en la recta: 0 < K·(1 − h/r) < K. El orden decide las flechas.

Colisión

Si dos se juntan y desaparecen, el sistema cambia de régimen (bifurcación). Con cosecha h = r colapsa.

En sistemas

Resolver el sistema f₁ = 0, f₂ = 0: cascada da (q/k₁, q/k₂); SIR da (S*, 0).

04 · Equilibrios del curso

El catálogo de destinos

Cada destino con nombre es un f = 0 resuelto:

1. 1
   Tanque.

   N* = q/k: compensa entrada y desagüe.

2. 2
   Ambiente.

   T* = T_amb (+ P/k con fuente).

3. 3
   Capacidad.

   P* = K (y 0): techo y vacío.

4. 4
   Cosecha.

   P* = K·(1 − h/r): el techo baja con la extracción.

5. 5
   SIR.

   I* = 0 con cualquier S*: línea de equilibrios.

05 · Representación en Python

Resolver f = 0 antes de simular

En Python, los equilibrios son una función que despeja la fórmula: sin bucles, sin dt. La simulación después verifica.

def equilibrios_cosecha(r=0.3, k=100.0, h=0.1):
    if h >= r:
        return [0.0]
    return [0.0, k * (1 - h / r)]


for h in [0.0, 0.1, 0.3, 0.4]:
    print(h, equilibrios_cosecha(h=h))

K·(1 − h/r): 100 → 66,7 → colapso en 0 cuando h ≥ r.

Verificar que reposa

En el equilibrio la tasa es cero con flujos activos:

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


p_star = 100 * (1 - 0.1 / 0.3)
print(round(p_star, 1), round(f(p_star), 6))

06 · Exploración

Laboratorio: la cosecha que baja el techo

Logístico con cosecha f(P) = r·P·(1 − P/K) − h·P, K = 100. Izquierda: órbitas desde P₀ = 10 y 90. Derecha: parábola f(P) con sus ceros marcados: 0 y K·(1 − h/r). Subí h y mirá cómo el segundo cero camina hacia 0 hasta colapsar.

La parábola se hunde con h: sus cruces con cero son los destinos. Cuando h ≥ r solo queda el 0: colapso.

Preguntas para explorar

1. Con h = 0, ¿dónde están los ceros? ¿Y con h = 0,3 = r?
2. Con h = 0,4 > r, ¿a dónde van las órbitas desde 10 y 90?
3. Si P₀ = 0 exacto, ¿la órbita se mueve? ¿Qué equilibrio es?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: techo con cosecha

Con r = 0,4, K = 200 y h = 0,1, ¿dónde queda el techo efectivo? ¿Y con h = 0,5?

def techo(r, k, h):
    return 0.0 if h >= r else k * (1 - h / r)


print(techo(0.4, 200, 0.1))
print(techo(0.4, 200, 0.5))

Ejercicio 2: verificar el cero

Con r = 0,3, K = 100 y h = 0,1, evaluá f en P* = 66,67. ¿Da cero con flujos activos?

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


p_star = 100 * (1 - 0.1 / 0.3)
print(round(p_star, 2), round(f(p_star), 6))

Ejercicio 3: colisión de equilibrios

Barré h de 0 a 0,6 con r = 0,3 y K = 100 y listá los equilibrios. ¿Dónde colapsa?

def equilibrios(h, r=0.3, k=100.0):
    return [0.0] if h >= r else [0.0, round(k * (1 - h / r), 1)]


for h in [0.0, 0.1, 0.2, 0.3, 0.4, 0.6]:
    print(h, equilibrios(h))

09 · Síntesis

Ideas para recordar

En el próximo tema probaremos si esos puntos atraen o repelen: la estabilidad.