Procesos de conteo

01 · Punto de partida

Contar es el proceso más simple con memoria

Llamadas que llegan, clientes que entran, piezas que fallan, clicks en una web: en todos los casos la pregunta es ¿cuántos van hasta t? La respuesta es N(t), el número acumulado de eventos.

Un proceso de conteo es un continuo en el tiempo (Tema 6) con estados 0, 1, 2… y una regla estricta: nunca baja y sube de a 1. Esa rigidez lo hace ideal como primer modelo de arribos.

• ¿Cuántos eventos ocurrieron hasta t: N(t)?
• ¿Cuántos cayeron entre s y t: el incremento N(t) − N(s)?
• ¿En qué instantes saltó: T₁, T₂…?
• ¿A qué velocidad llegan en promedio: la tasa?

02 · Definición

¿Qué es un proceso de conteo?

Cuatro condiciones lo definen sin excepción:

El incremento es lo útil: ¿cuántos llegaron esta hora, este minuto? Los modelos se distinguen por cómo se comportan esos incrementos (independientes, estacionarios, con tasa variable).

03 · Anatomía

Escalera, incrementos y tasa

Tres lecturas de la misma escalera:

Trayectoria escalera

Tramos planos + saltos +1 en Tₖ. Entre eventos, N(t) no se mueve.

Incrementos

N(t) − N(s) ≥ 0 y entero. Disjuntos que no se solapan se analizan por separado.

Tasa media

Eventos por unidad de tiempo: N(T)/T ≈ λ. La pendiente de la escalera a largo plazo.

Historial de arribos

La lista T₁, T₂… equivale a la escalera: con los instantes se reconstruye N(t).

04 · Ejemplos

Conteos que un programador registra

Si hay log con timestamps, hay un proceso de conteo escondido:

1. 1
   Llamadas por hora.

   N(t) = llamadas hasta t. Incremento horario para dimensionar agentes.

2. 2
   Pedidos a un servidor.

   Cada request suma 1. El log es la lista Tₖ.

3. 3
   Fallas de piezas.

   N(t) = fallas acumuladas. Nunca baja: lo roto contado queda.

4. 4
   Ventas del día.

   Cada ticket suma 1 (las devoluciones van a otro proceso).

5. 5
   Clicks en un botón.

   Eventos puntuales en tiempo real: base de Poisson y thinning.

05 · Representación en Python

De instantes a escalera y a incrementos

En Python, un conteo son dos vistas de lo mismo: la lista de instantes Tₖ y la función N(t) que cuenta cuántos Tₖ ≤ t. Los incrementos son restas de N.

arribos = [0.4, 1.1, 1.1, 2.7, 4.2]  # T1..T5 (dos juntos a propósito)

def N(t):
    return sum(1 for Tk in arribos if Tk <= t)

for t in [0, 1, 1.1, 3, 5]:
    print(t, N(t))

Notá el instante duplicado 1,1: N salta de a 1 por evento aunque dos caigan juntos. ¿Cumple «de a 1 por salto»?

Incrementos entre intervalos

Con N(t) los incrementos son restas. Así se pasa del acumulado al ritmo por hora:

arribos = [0.4, 1.1, 2.7, 4.2, 4.9, 7.3]

def N(t):
    return sum(1 for Tk in arribos if Tk <= t)

for s, t in [(0, 5), (5, 8)]:
    print(s, t, N(t) - N(s))

06 · Exploración

Laboratorio: la escalera N(t) y su pendiente λ

Generamos arribos con tasa λ (esperas exponenciales de media 1/λ). Cada escalera es un N(t); la recta blanca punteada es la teoría λ·t y la sólida la media simulada. Subí λ y la escalera se empina.

Las escaleras nunca bajan y suben de a 1. La pendiente media de todas estima λ; cada escalera sola es ruidosa.

Preguntas para explorar

1. Con λ = 1 y T = 10, ¿la media simulada da exactamente 10? ¿Por qué no?
2. Triplicá λ a 3. ¿La escalera se empina al triple? ¿Qué le pasa al % sin eventos?
3. Si una trayectoria baja en algún tramo, ¿sigue siendo un conteo?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: verificar un conteo

Ejecutá este chequeo sobre una lista de instantes. ¿Cumple N(0) = 0 y saltos de a 1?

arribos = [0.5, 1.8, 1.8, 3.2]

def N(t):
    return sum(1 for Tk in arribos if Tk <= t)

print("N(0) =", N(0))
print("N(2) =", N(2), "| N(4) =", N(4))
print("incremento (0,4]:", N(4) - N(0))

Ejercicio 2: tasa empírica

Sin ejecutar primero: con 12 eventos en T = 4, ¿qué tasa empírica da? Comprobalo.

N_T, T = 12, 4
print("tasa empírica:", N_T / T)

Ejercicio 3: generar un conteo con exponenciales

Generá arribos con tasa λ = 2 hasta T = 5 y contá N(5). Repetilo con otra semilla.

import random, math

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

a = generar_conteo(5, semilla=7)
print(len(a), a)

09 · Síntesis

Ideas para recordar

En el próximo tema llegará el proceso de Poisson: el conteo con incrementos independientes y tasa λ constante.