Superposición de procesos

01 · Punto de partida

Dos filas, una sola puerta

Dos sucursales generan llamadas con tasas λ₁ y λ₂; un servidor recibe de tres APIs. Cada flujo es Poisson por su cuenta, pero lo que llega al centro es la suma: todos los eventos juntos ordenados por hora.

Esa suma es la superposición: juntar procesos independientes en uno solo. Con Poisson, la suma sigue siendo Poisson.

• ¿Qué tasa tiene el flujo total: λ₁ + λ₂?
• ¿De qué flujo vino cada evento: con qué chance es del A?
• ¿La suma conserva independencia y Poisson?
• ¿Y si los flujos no son independientes?

02 · Definición

¿Qué es superponer?

Superponer es mezclar listas de instantes ordenándolas:

Vale para N flujos y para intensidades: λ(t) = Σλᵢ(t). La independencia es el requisito: sin ella, la suma no es Poisson.

03 · Anatomía

Total, reparto y requisito

Cuatro ideas para usarla bien:

Total Poisson

La suma de independientes Poisson es Poisson con la suma. Se simula como un solo λ total.

Reparto binomial

Dado que hubo n eventos, cuántos son del A ~ Binomial(n, λ₁/λ). Así se «desmezcla».

Etiqueta al azar

Cada evento del total se marca A con p = λ₁/λ. Simular el total y etiquetar equivale a simular por separado.

Independencia exigida

Si los flujos se coordinan (mismo cliente llama a ambos), la suma no es Poisson.

04 · Ejemplos

Sumas que un programador junta

Todo «total de varias fuentes» es una superposición candidata:

1. 1
   Call center multisede.

   Norte λ₁ + Sur λ₂ = total con λ₁+λ₂ para dimensionar el centro.

2. 2
   Servidor multi-API.

   Tres clientes Poisson se suman en el request total.

3. 3
   Fallas por componente.

   Cada pieza Poisson; la máquina suma sus fallas.

4. 4
   Ventas online + local.

   Dos canales independientes: el total es la caja conjunta.

5. 5
   No suma: mismo origen.

   Reintentos del mismo pedido en dos colas: dependientes, no Poisson.

05 · Representación en Python

Mezclar es ordenar dos listas

En Python, superponer es juntar y ordenar instantes. La vía rápida (total + etiquetas) evita mezclar: se genera un Poisson y se marca cada evento.

import random, math

def generar(T, lam, semilla):
    random.seed(semilla)
    t, ev = 0.0, []
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            return ev
        ev.append(round(t, 2))

a = generar(10, 1.0, 7)
b = generar(10, 2.0, 21)
total = sorted(a + b)
print("A:", len(a), "| B:", len(b), "| total:", len(total))
print(total[:6])

El total mezcla ambos: ~10 del A y ~20 del B en T = 10. Ordenar es superponer.

La vía rápida: total + etiquetas

Un solo generador con λ₁+λ₂ y marcas con p = λ₁/λ: mismo resultado, mitad de sorteos de tiempos:

import random, math

random.seed(5)
lam1, lam2, T = 1.0, 2.0, 10.0
lam = lam1 + lam2
t, total, de_a = 0.0, 0, 0
while True:
    t += -math.log(1 - random.random()) / lam
    if t > T:
        break
    total += 1
    if random.random() < lam1 / lam:
        de_a += 1
print(total, de_a, round(de_a / total, 2))

06 · Exploración

Laboratorio: dos flujos, un total

Flujo A (turquesa, λ₁) y B (naranja, λ₂) hasta T = 10; abajo el total mezclado con el color de su origen. Movete λ₁ y λ₂: el total se empina con la suma y el reparto sigue a λ₁/λ.

Las dos filas superiores son los flujos; la inferior, la mezcla ordenada. El total tiene la tasa suma y cada tick conserva su color-origen.

Preguntas para explorar

1. Con λ₁ = 1 y λ₂ = 2, ¿qué % del total es del A? ¿Cerca de 1/3?
2. Igualá λ₁ = λ₂ = 2. ¿El total es Poisson(2) o Poisson(4)? ¿El reparto?
3. Apagá B (mínimo 0,5): ¿el total se parece a qué flujo?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: tasa total y reparto

Con λ₁ = 1,5 y λ₂ = 4,5 hasta T = 8, calculá el total esperado y el % del flujo 1.

lam1, lam2, T = 1.5, 4.5, 8
print("total:", (lam1 + lam2) * T)
print("% A:", round(100 * lam1 / (lam1 + lam2), 1))

Ejercicio 2: desmezclar con binomial

Sin ejecutar primero: si el total tuvo n = 30 con p = 1/3 del A, ¿cuántos del A esperás? Comprobalo simulando marcas.

import random

random.seed(9)
n, p = 30, 1 / 3
marcas = [1 if random.random() < p else 0 for _ in range(n)]
print(sum(marcas), "| esperado:", n * p)

Ejercicio 3: tres flujos

Sumá λ = 1, 2 y 3 hasta T = 10 por las dos vías (separado vs total + etiquetas) y compará.

import random, math

def generar(T, lam, semilla):
    random.seed(semilla)
    t, ev = 0.0, []
    while True:
        t += -math.log(1 - random.random()) / lam
        if t > T:
            return ev
        ev.append(round(t, 2))

a = generar(10, 1, 1) + generar(10, 2, 2) + generar(10, 3, 3)
print("separado:", len(a), "| esperado:", 60)

09 · Síntesis

Ideas para recordar

En el próximo tema haremos lo inverso: refinamiento de procesos (dividir un flujo).