File size: 2,903 Bytes
8ccac0b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
"""Estado estratégico recursivo del modelo determinístico (Experimento A — TA-003).

Formaliza la idea de CADENA DE MARKOV: el estado en la jugada N se obtiene
aplicando una función de transición al estado anterior y a la jugada actual,

    estado_N = actualizar(estado_{N-1}, jugada_N)

donde el estado resume toda la historia relevante (es un *estadístico
suficiente*: contiene la serie y los features derivados de ella). Como la
transición es determinística y sin azar, el mismo historial produce SIEMPRE el
mismo estado → replicabilidad por construcción (RN-004).

Categoría académica: autómata de estado finito / proceso markoviano determinístico.
"""
from __future__ import annotations
from dataclasses import dataclass, replace

from . import features


@dataclass(frozen=True)
class EstadoEstrategico:
    """Estadístico suficiente de la partida hasta la jugada actual (un jugador).

    `frozen=True` lo vuelve inmutable: cada transición devuelve un estado nuevo,
    nunca muta el anterior. Esto refuerza la pureza y la replicabilidad.
    """
    n_jugadas: int = 0
    serie_cp: tuple = ()            # diferencia_cp del jugador, en orden cronológico
    errores: int = 0
    imprecisiones: int = 0
    # Features derivados (se recalculan en cada transición).
    media_propia: float = 0.0
    pendiente: float = 0.0
    racha: int = 0
    cambio: float = 0.0
    fase: str = "apertura"
    ultima_clasificacion: str = ""


def actualizar(estado: EstadoEstrategico, dif_cp: int,
               clasificacion: str, numero: int) -> EstadoEstrategico:
    """Función de transición de la cadena de Markov: estado_{N-1} → estado_N."""
    serie = estado.serie_cp + (dif_cp,)
    serie_lista = list(serie)
    media_propia = features.media(serie_lista)
    return replace(
        estado,
        n_jugadas=estado.n_jugadas + 1,
        serie_cp=serie,
        errores=estado.errores + (1 if clasificacion == "Error" else 0),
        imprecisiones=estado.imprecisiones + (1 if clasificacion == "Imprecisión" else 0),
        media_propia=media_propia,
        pendiente=features.pendiente(serie_lista[-features.VENTANA:]),
        racha=features.racha_bajo_media(serie_lista, media_propia),
        cambio=features.cambio_regimen(serie_lista),
        fase=features.fase(numero),
        ultima_clasificacion=clasificacion,
    )


def construir(jugadas: list[tuple]) -> EstadoEstrategico:
    """Reduce (fold) la función de transición sobre la secuencia de jugadas.

    `jugadas`: lista de tuplas (diferencia_cp, clasificacion, numero) en orden
    cronológico, correspondientes a un mismo jugador. Aplicar `actualizar`
    repetidamente ES la cadena de Markov desplegada sobre la partida.
    """
    estado = EstadoEstrategico()
    for dif_cp, clasificacion, numero in jugadas:
        estado = actualizar(estado, dif_cp, clasificacion, numero)
    return estado