Estados transitorios

01 · Punto de partida

Visitar muchas veces y perderse igual

Un estado puede visitarse 10 veces y aun así perderse: si en cada visita hay chance de fugar, alguna vez la fuga ocurre. Ese es el transitorio: hotel de paso, no hogar.

A largo plazo los transitorios se vacían: la cadena termina en alguna clase cerrada (Tema 29).

• ¿La chance de volver es 1 o menor?
• ¿Cuántas visitas totales habrá: finitas o infinitas?
• ¿A dónde fuga cuando se va?
• ¿Cuánto tarda en absorberse?

02 · Definición

¿Qué es transitorio?

Tres marcas lo delatan:

En el mapa B (0–1 → 2): f₀₀ < 1 y f₁₁ < 1, pero f₂₂ = 1. El 2 absorbe lo que los otros pierden.

03 · Anatomía

Fuga, visitas y vaciado

Cuatro ideas para operar con transitorios:

Fuga

Camino hacia afuera de la clase sin vuelta. Basta una fuga con chance > 0 para ser transitorio.

Clase abierta

Todos sus estados son transitorios. Se hereda como la recurrencia.

Vaciado

P(Xₙ en transitorios) → 0. A largo plazo solo quedan cerradas.

Tiempo de absorción

Pasos hasta salir de lo transitorio. Finito en promedio si la fuga es segura. (Tema 37)

04 · Ejemplos

Transitorios de la vida real

Todo «mientras tanto» antes de un destino final:

1. 1
   Trámite → resuelto.

   Estados intermedios transitorios; resuelto absorbe.

2. 2
   Prueba → compra/fuga.

   El trial se abandona hacia cliente o perdido.

3. 3
   Cola antes del cierre.

   Niveles altos transitorios si el local cierra (absorbe en 0).

4. 4
   Enfermo → sano/crónico.

   Agudo transitorio hacia destinos cerrados.

5. 5
   Juego → banca rota.

   Capitales intermedios transitorios con ruina absorbente.

05 · Representación en Python

Contar visitas hasta absorber

En Python, lo transitorio se mide con visitas totales y tiempo hasta absorción: simular desde i hasta salir de lo transitorio o agotar el horizonte.

import random

P = [[0.5, 0.5, 0.0],
     [0.3, 0.4, 0.3],
     [0.0, 0.0, 1.0]]

def hasta_absorber(x0=0, horizonte=200, semilla=7):
    # Devuelve pasos hasta el 2 (None si no absorbe).
    random.seed(semilla)
    x = x0
    for n in range(1, horizonte + 1):
        u, ac = random.random(), 0.0
        for j, p in enumerate(P[x]):
            ac += p
            if u < ac:
                x = j
                break
        if x == 2:
            return n
    return None

print([hasta_absorber(semilla=s) for s in range(8)])

Casi todas absorben en pocos pasos (2, 5, 9…): lo transitorio dura poco aunque se visite.

Fracción aún transitoria

Con muchas réplicas: ¿cuántas siguen fuera del 2 en N?

import random

P = [[0.5, 0.5, 0.0],
     [0.3, 0.4, 0.3],
     [0.0, 0.0, 1.0]]

def absorbida(x0, N):
    x = x0
    for _ in range(N):
        u, ac = random.random(), 0.0
        for j, p in enumerate(P[x]):
            ac += p
            if u < ac:
                x = j
                break
    return x == 2

random.seed(11)
for N in [5, 20, 100]:
    print(N, sum(absorbida(0, N) for _ in range(2000)) / 2000)

06 · Exploración

Laboratorio: lo transitorio se vacía

Mapa B desde 0, 200 réplicas. La curva naranja es la fracción aún en {0,1} (transitoria); la verde, la ya absorbida en 2. Movete el horizonte N: lo naranja decae a 0 y lo verde sube a 1.

Cada réplica aporta su absorción; las curvas acumulan. Que lo naranja tienda a 0 es la firma de transitoriedad.

Preguntas para explorar

1. En N = 5, ¿qué fracción sigue transitoria? ¿Y en N = 40?
2. ¿El tiempo medio de absorción ronda cuánto? (Pista: pocos pasos.)
3. Generá nuevas réplicas: ¿el vaciado es estable o depende de la suerte?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: leer la fuga

Con esta fila desde 0 ([0,5 – 0,5 – 0]), ¿hay fuga directa al 2? ¿Y en dos pasos vía 1?

print("directa:", 0.0 > 0)
print("vía 1: 0.5 * 0.3 =", 0.5 * 0.3)

Ejercicio 2: vaciado a largo plazo

Sin ejecutar primero: con 200 réplicas en N = 100, ¿qué fracción transitoria esperás? Comprobalo.

import random

P = [[0.5, 0.5, 0.0],
     [0.3, 0.4, 0.3],
     [0.0, 0.0, 1.0]]

def final(x0=0, N=100):
    x = x0
    for _ in range(N):
        u, ac = random.random(), 0.0
        for j, p in enumerate(P[x]):
            ac += p
            if u < ac:
                x = j
                break
    return x

random.seed(5)
print(sum(1 for _ in range(200) if final() in (0, 1)) / 200)

Ejercicio 3: visitas finitas

Contá visitas a {0,1} antes de absorber en una réplica larga. ¿El total es finito?

import random

P = [[0.5, 0.5, 0.0],
     [0.3, 0.4, 0.3],
     [0.0, 0.0, 1.0]]
random.seed(2)
x, visitas = 0, 0
while x != 2:
    visitas += (x in (0, 1))
    u, ac = random.random(), 0.0
    for j, p in enumerate(P[x]):
        ac += p
        if u < ac:
            x = j
            break
print("visitas:", visitas)

09 · Síntesis

Ideas para recordar

En el próximo tema veremos el caso extremo: estados absorbentes.