Modelo conceptual de Monte Carlo

01 · Punto de partida

El papel antes que el código

Muchas simulaciones fallan antes de correr: mezclan entradas con salidas, esconden supuestos o evalúan otra pregunta. El modelo conceptual es el plano en papel: qué es aleatorio, qué es decisión, qué fórmula une ambos y qué se reporta.

En Monte Carlo estático el plano es simple y siempre igual: entradas → modelo → salidas, más supuestos escritos.

• ¿Qué pregunta debe responder la simulación?
• ¿Qué entradas son aleatorias y con qué F?
• ¿Qué parámetros decide el usuario?
• ¿Qué salidas se promedian y qué decisión toman?

02 · Definición

Las cuatro cajas

03 · Cómo armarlo

Del enunciado al esquema en 4 pasos

1. 1
   Escribir la pregunta.

   «¿Qué Q maximiza la ganancia media?» y no «simular el negocio». Una pregunta = un modelo.

2. 2
   Listar entradas.

   Separar aleatorias (con F) de decisiones (valores a probar). Nada de «demanda más o menos 100».

3. 3
   Escribir g(x).

   Una fórmula por salida, con unidades. Si lleva tiempo o «si ayer…», no es estática.

4. 4
   Definir salidas y supuestos.

   Media, probabilidad, intervalo. Y por escrito: iid, N, semilla, límites.

Supuesto

Decisión explícita que sostiene el modelo: distribución elegida, independencia, rango válido. Se escribe, no se esconde.

Parámetro

Constante del modelo que podés variar para decidir: Q, precio, umbral. No se sortea, se prueba.

Frontera

Qué queda dentro y qué fuera: un periodo, un producto, un horizonte. Todo lo fuera entra como supuesto.

04 · Ejemplos

Tres planos en una línea cada uno

1. 1
   Diarios.

   Entradas: D en {80,100,120}; decisión Q. Modelo: 5·min(Q,D)−2·Q. Salida: media. Supuesto: demandas iid.

2. 2
   π.

   Entradas: (x,y) ~ U². Modelo: dentro = x²+y² ≤ 1. Salida: 4·dentro/N. Supuesto: uniforme real.

3. 3
   Garantía.

   Entrada: falla ~ Bernoulli(0,05). Modelo: costo = 200·falla. Salida: costo medio. Supuesto: p constante.

05 · Representación en Python

El plano se vuelve diccionario y función

El modelo conceptual cabe en un diccionario (qué es qué) y una función pura (cómo se calcula). La simulación solo itera.

modelo = {
    "pregunta": "¿Cuál es la utilidad media si el ingreso es 150?",
    "entradas": {"costo": "Normal(100, 15)"},
    "parametros": {"ingreso": 150},
    "modelo": "utilidad = ingreso - costo",
    "salidas": ["utilidad media", "P(costo > 120)"],
    "supuestos": ["costos iid", "N = 10000"],
}

def utilidad(costo, ingreso=150):
    return ingreso - costo

print(modelo["pregunta"])
print(utilidad(110))

import random

def simular_utilidad(N, ingreso=150, mu=100, sigma=15):
    tot, caros = 0, 0
    for _ in range(N):
        costo = random.gauss(mu, sigma)
        tot += ingreso - costo
        if costo > 120:
            caros += 1
    return tot / N, caros / N

print(simular_utilidad(10000))

06 · Exploración

Laboratorio: mover una entrada, mover la salida

Cambiamos el costo medio μ y miramos la utilidad 150 − costo. El histograma se desplaza entero: el modelo conceptual predice antes de correr.

Barras: distribución de la utilidad. La media debe caer sobre 150 − μ. Si subís μ, todo el histograma viaja a la izquierda.

Preguntas para explorar

1. Con μ = 100, ¿la media ronda 50? ¿Y con μ = 120?
2. ¿Por qué el ancho del histograma no cambia al mover μ?
3. ¿Qué parte del dibujo es entrada, cuál modelo y cuál salida?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: escribir el plano

Completá el diccionario para π por puntos y ejecutalo.

plano_pi = {
    "pregunta": "¿Cuánto vale pi por puntos?",
    "entradas": {"x": "U(0,1)", "y": "U(0,1)"},
    "modelo": "dentro = (x*x + y*y <= 1); pi = 4*dentro/N",
    "salidas": ["pi estimado"],
    "supuestos": ["puntos iid uniformes"],
}
print(plano_pi["modelo"])

Ejercicio 2: predecir sin correr

Si ingreso = 150 y costo ~ N(110, 10), ¿qué utilidad media esperás? Comprobalo.

import random

def media(N, ingreso=150, mu=110, sigma=10):
    return sum(ingreso - random.gauss(mu, sigma) for _ in range(N)) / N

print(media(10000))

Ejercicio 3: separar piezas

Dividí en generar(), modelo() y simular() el caso garantía: falla ~ Bernoulli(0,05), costo = 200·falla.

import random

def generar():
    return 1 if random.random() < 0.05 else 0

def modelo(falla):
    return 200 * falla

def simular(N):
    return sum(modelo(generar()) for _ in range(N)) / N

print(simular(20000))

09 · Síntesis

Ideas para recordar

En el próximo tema distinguiremos las variables de entrada: qué sortear, con qué F y con qué datos.