Verificación

01 · Punto de partida

¿El código obedece al modelo?

En el Tema 34 leímos tablas y gráficos como si el programa fuera fiel. Pero todo análisis pende de una pregunta previa: ¿el simulador implementa de verdad las reglas que escribimos en el modelo? Un signo cambiado, un tope olvidado o una agenda desordenada producen resultados nítidos, estables… y falsos.

Verificar es auditar el programa contra el modelo, con casos de respuesta conocida. No pregunta si el modelo es bueno (eso es validación, Tema 36): pregunta si el código lo ejecuta sin traicionarlo.

• ¿Cada regla del modelo tiene su caso testigo?
• ¿Los invariantes se cumplen en cada paso?
• ¿Dos motores distintos empatan ante lo mismo?
• ¿Un cambio mínimo rompe algún testigo?

02 · Vocabulario mínimo

Testigo, invariante y traza

03 · Tres técnicas

Cómo se verifica un simulador

1. 1
   Casos testigo.

   Entradas chicas con salida a mano. Rápidos, exactos, automáticos con assert.

2. 2
   Invariantes.

   Afirmaciones que el programa chequea en cada paso: rangos, conservación, orden de la agenda.

3. 3
   Doble vía.

   Dos implementaciones (paso fijo vs eventos, o Python vs planilla) deben empatar ante lo mismo.

Verificación

Comprobar que el programa implementa fielmente el modelo.

Testigo

Caso de respuesta conocida que custodia una regla.

Invariante

Propiedad que debe valer en todo paso de toda corrida.

Regresión

Batería de testigos que se corre ante cada cambio.

04 · Protocolo

La auditoría en cinco pasos

Cada pieza nace con su testigo, cada corrida chequea invariantes, cada bug se persigue en la traza, cada motor se empata con su doble vía y todo queda en una regresión que corre ante cada cambio.

05 · En Python

Testigos con assert

El testigo más barato es un assert con historia conocida. Si alguien rompe la transición, grita al instante:

def simular(n0, entradas, salida, tope=40):
    n = n0
    h = []
    for e in entradas:
        n = min(max(n + e - salida, 0), tope)
        h.append(n)
    return h


assert simular(10, [3, 3, 3, 3], 2) == [11, 12, 13, 14]
assert simular(39, [5], 0) == [40]  # el tope recorta
assert simular(1, [0], 5) == [0]    # el piso sostiene
print("testigos OK")

Invariantes dentro del motor

El invariante vive en el código y vigila cada paso, no solo los casos de prueba:

def simular_vigilada(n0, entradas, salida, tope=40):
    n = n0
    h = []
    for e in entradas:
        n = min(max(n + e - salida, 0), tope)
        assert 0 <= n <= tope, f"invariante roto: {n}"
        h.append(n)
    return h


print(simular_vigilada(10, [3, 3, 3], 2))

06 · Exploración

Laboratorio: cazar el bug del tope

Este simulador trae un bug inyectable: con el interruptor en sin tope, el nivel crece sin cota y viola el invariante. Activá el bug, subí las entradas y mirá cómo los testigos lo delatan.

Curva del nivel en 12 pasos. Línea punteada: tope 40. Sin tope, la curva lo atraviesa y los testigos fallan.

Preguntas para explorar

1. Sacá el tope con entrada 5. ¿Cuántos testigos fallan y cuál es el primero en gritar?
2. Bajá la entrada a 1 sin tope. ¿El bug se esconde? ¿Qué enseña eso sobre testigos «cómodos»?
3. ¿Por qué la semilla no cambia este resultado? ¿Cuándo sí importaría?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: escribir el testigo del tope

Completá el assert que custodia el recorte en 40.

def simular(n0, entradas, salida, tope=40):
    n = n0
    h = []
    for e in entradas:
        n = min(max(n + e - salida, 0), tope)
        h.append(n)
    return h


assert simular(39, [5], 0) == [40]
print("tope OK")

Ejercicio 2: vigilar el invariante

Agregá el chequeo que rompe la corrida en cuanto el nivel sale de rango.

def simular_vigilada(n0, entradas, salida, tope=40):
    n = n0
    for e in entradas:
        n = min(max(n + e - salida, 0), tope)
        assert 0 <= n <= tope
    return n


print(simular_vigilada(10, [3, 3, 3], 2))

Ejercicio 3: doble vía con dos motores

Empatá el motor paso a paso con su versión «de una línea» ante el mismo escenario.

def motor_a(n0, entradas, salida):
    n = n0
    return [n := max(n + e - salida, 0) for e in entradas]

def motor_b(n0, entradas, salida):
    h, n = [], n0
    for e in entradas:
        n = max(n + e - salida, 0)
        h.append(n)
    return h


assert motor_a(10, [3, 3, 3], 2) == motor_b(10, [3, 3, 3], 2)
print("doble vía OK")

09 · Síntesis

Ideas para recordar

En el próximo tema cruzaremos el puente hacia la realidad: la validación.