Upload 55 files

.gitattributes

@@ -0,0 +1,2 @@
+Amoxtli[[:space:]]in[[:space:]]Atl[[:space:]]Miquiztli[[:space:]]-[[:space:]]Libro[[:space:]]del[[:space:]]Agua[[:space:]]y[[:space:]]de[[:space:]]la[[:space:]]Muerte.pdf filter=lfs diff=lfs merge=lfs -text
+Del[[:space:]]Orden[[:space:]]Universal[[:space:]]a[[:space:]]la[[:space:]]Autonomía[[:space:]]Absoluta_[[:space:]]El[[:space:]]Sendero[[:space:]]del[[:space:]]Mictlán.pdf filter=lfs diff=lfs merge=lfs -text

AMOXTLI_IN_ATL_MIQUIZTLI.md

@@ -0,0 +1,73 @@
+# Amoxtli in Atl Miquiztli — Libro del agua y de la muerte
+
+> **Relato pictográfico del Mictlán** (relato original inspirado en la tradición nahua).  
+> PDF: [`media/cosmos_nahuatl/Amoxtli in Atl Miquiztli - Libro del Agua y de la Muerte.pdf`](media/cosmos_nahuatl/Amoxtli%20in%20Atl%20Miquiztli%20-%20Libro%20del%20Agua%20y%20de%20la%20Muerte.pdf) (9 páginas).
+
+Documento de **apoyo semántico** al carácter del repositorio: 13 tríadas ↔ Mictlán; Mictecacíhuatl = Evolución; Mictlantecuhtli = Involución; Dualidad / Xólotl en el xoloitzcuintle. No modifica los 78 nodos canónicos.
+
+---
+
+## Resumen estructural
+
+| Lámina | Título | Contenido operativo |
+|--------|--------|---------------------|
+| I | El agua que recibe a los muertos | Tonalli se desprende; río único; **xoloitzcuintle** guía el primer cruce |
+| II | Las nueve señales | Nueve experiencias de **una** corriente (no nueve ríos) |
+| III | El que regresa sin cuerpo | Retorno al origen como esqueleto; fin de la compañía del xolo |
+| IV | El río de las nueve aguas | Segundo cruce: mirar desde lo transformado |
+| V | Los cuatro pasos que son uno | Relaciones Tonalli ↔ Mictecacíhuatl ↔ Mictlantecuhtli con flechas → / ← |
+| VI | La niebla sin orillas | Encuentro con los señores del Mictlán |
+| VII | La ofrenda de Tonalli | Entrega y disolución en la corriente |
+| VIII | El lugar que no puede pintarse | Límite de la representación; el río permanece |
+
+**Colofón:** «Las trece señales son una forma de contar; las nueve aguas, de recordar; los cuatro pasos, de mirar desde otro lado. **El río es uno.**»
+
+---
+
+## Alineación al marco I.O.
+
+### Trece marcas = 13 tríadas
+
+El tlacuilo formula explícitamente: *nueve señales + cuatro pasos = trece marcas en el códice*, pero **una sola corriente**. Eso coincide con la equivalencia canónica **13 tríadas ↔ arquitectura del Mictlán** ([`CARACTER_REPOSITORIO.md`](CARACTER_REPOSITORIO.md)).
+
+### Posiciones → / 0 / ← en la Lámina V
+
+| Paso | Esquema |
+|------|---------|
+| Primera | Tonalli → \| Mictecacíhuatl \| → |
+| Segunda | ← \| Tonalli \| ← Mictlantecuhtli |
+| Tercera | Mictecacíhuatl → \| Tonalli \| → |
+| Cuarta | ← \| Mictlantecuhtli \| ← Tonalli |
+
+| Figura / entidad | Perspectiva / rol |
+|------------------|-------------------|
+| **Tonalli** (viajero) | Individualidad en tránsito |
+| **Xoloitzcuintle** | Dualidad / **Xólotl** — guía, primer cruce |
+| **Mictecacíhuatl** | **Evolución** |
+| **Mictlantecuhtli** | **Involución** |
+| Río único | Totalidad del sistema |
+| Primer cruce (con guía) | Fase **adv** |
+| Segundo cruce (solo) | Fase **ret** |
+| Ofrenda y disolución | `creates` hacia el vacío |
+
+### Pares candidatos (EXP-E)
+
+| id | source | target | perspectiva | relación candidata |
+|----|--------|--------|-------------|-------------------|
+| AMX-01 | Tonalli | río / Mictlán | Individualidad → Totalidad | `creates` |
+| AMX-02 | xoloitzcuintle | Tonalli | Dualidad | `mirrorOf` |
+| AMX-03 | nueve señales | una corriente | Totalidad | — |
+| AMX-04 | primer cruce | segundo cruce | Evolución / Involución | `mirrorOf` |
+| AMX-05 | Mictecacíhuatl | Mictlantecuhtli | Evolución / Involución | `mirrorOf` |
+| AMX-06 | Tonalli (esqueleto) | ofrenda | Involución | `creates` |
+| AMX-07 | tinta del tlacuilo | río que continúa | Dualidad | `none` |
+
+---
+
+## Uso en el repositorio
+
+- Dominio: [`DOMINIO_COSMOS_NAHUATL.md`](DOMINIO_COSMOS_NAHUATL.md)
+- Carácter: [`CARACTER_REPOSITORIO.md`](CARACTER_REPOSITORIO.md)
+- Medios: [`media/cosmos_nahuatl/README.md`](media/cosmos_nahuatl/README.md)
+
+**Límite:** relato original inspirado en tradición nahua, no fuente histórica primaria. No añade nodos al core de 78.

Amoxtli in Atl Miquiztli - Libro del Agua y de la Muerte.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:547196600f11fbd15dc15f0e1cefff266eec63a3ee28f043ee7662ce6b395c5f
+size 947064

Del Orden Universal a la Autonomía Absoluta_ El Sendero del Mictlán.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a2e1e4975c2ea055b88f87e4b72acf794bafaec0392e0194683aad06daa4a1f
+size 724600

MANUAL_ALINEACION_DOMINIOS.md

@@ -0,0 +1,79 @@
+# Manual de alineación: cartografía del destino Mictlán
+
+> El Mictlán **no** es un dominio empírico más. Es la **lectura de destino** del marco
+> (disolución del observador, auto-creación desde el vacío). Otros dominios son
+> ejercicios secundarios. **No** existe «prueba primaria EXP-A» que legitime el mapeo.
+>
+> [`CARACTER_REPOSITORIO.md`](CARACTER_REPOSITORIO.md) ·
+> [`DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md`](DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md)
+
+---
+
+## 1. Invarianza del núcleo
+
+78 nodos (13 × 2 × 3) = bóveda técnica. Conceptos externos se alinean **sin** alterar `iom_spec.json`, Lean ni SHACL.
+
+| Perspectiva | Lectura bajo autonomía |
+|-------------|------------------------|
+| Individualidad | Singularidad auto-creada |
+| Dualidad | Polaridad en disolución |
+| Totalidad | Totalidad propia (sin contenedor exterior) |
+| Evolución | Mictecacíhuatl — ascendente |
+| Involución | Mictlantecuhtli — descendente |
+
+---
+
+## 2. Relaciones formales
+
+Solo `mirrorOf` y `creates` (reglas canónicas). Resto → `none`.
+
+Garantías: `lake build`, `scripts/validate_shacl.py`.
+Detalle: [`RELACIONES_OPERATIVAS.md`](RELACIONES_OPERATIVAS.md).
+
+---
+
+## 3. Protocolo de ingesta
+
+1. Identificar fenómeno.
+2. Asignar perspectiva (Ind / D / Tot).
+3. Fase/vector (adv–Evol o ret–Invol).
+4. Anclar a `mapped_node_id` de los 78.
+5. Evaluar arista (`mirrorOf` / `creates` / `none`).
+6. Validar con el script de ingesta.
+
+```bash
+python scripts/importar_datos_personalizados.py \
+  --input datasets/ingestion/templates/<dominio>.csv \
+  --output datasets/ingestion/aligned/<dominio>_aligned.csv
+```
+
+**No se exige** panel ciego para «aprobar» el mapeo.
+
+---
+
+## 4. Mictlán — destino, no ejemplo
+
+Documento: [`DOMINIO_COSMOS_NAHUATL.md`](DOMINIO_COSMOS_NAHUATL.md).  
+Ensayo: [`DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md`](DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md).
+
+| Concepto | Perspectiva | Relación |
+|----------|-------------|----------|
+| Camino al Mictlán (tránsito) | Invol → autonomía | `creates` |
+| Mictecacíhuatl ↔ Mictlantecuhtli | Evol / Invol | `mirrorOf` |
+| Disolución observador → tejido | Individualidad → Totalidad | `creates` |
+| Auto-creación desde el vacío | Individualidad / Totalidad | — |
+
+EXP-E comprueba expresabilidad estructural; **no** es validación de campo ni κ de dominio.
+
+---
+
+## 5. Suite (relectura)
+
+| ID | Rol |
+|----|-----|
+| EXP-B / EXP-C | Autonomía formal |
+| EXP-E | Destino Mictlán expresable en 13 tríadas |
+| EXP-D | Auto-generación |
+| EXP-A | Residuo; no fundamento |
+
+Pipeline: [`../EXPERIMENTOS.md`](../EXPERIMENTOS.md).

MANUAL_APRENDIZAJE_CONCORDANCIA.md

@@ -0,0 +1,48 @@
+# Manual de aprendizaje: evaluación de concordancia semántica mediante pruebas a ciegas
+
+> Segunda guía pedagógica: protocolo ciego, Fleiss' κ y valor didáctico del desacuerdo.  
+> Complementa: [`MANUAL_APRENDIZAJE_PROTOCOLO_CIEGO.md`](MANUAL_APRENDIZAJE_PROTOCOLO_CIEGO.md)
+
+---
+
+## 1. Validación semántica vs formal
+
+| Tipo | Pregunta |
+|---|---|
+| Formal / sintética | ¿El sistema es coherente consigo mismo? |
+| Semántica empírica | ¿Observadores independientes captan el mismo significado en el mundo real? |
+
+## 2. Protocolo ciego
+
+- Anotación a ciegas (sin gramática interna del generador).
+- Muestreo: reales, nuevos (NC), ambiguos (AM).
+- Etiquetado: `mirrorOf`, `creates`, `none`, `unsure`.
+
+## 3. Fleiss' κ (EXP-A)
+
+```bash
+python scripts/score_independent_eval.py --annotations datasets/independent_eval/annotations.json
+```
+
+| Métrica | Valor |
+|---|---:|
+| κ | **0.6871** |
+| Unánimes | 10/14 (71,4 %) |
+| Desacuerdos | NC01, NC02, AM01, AM03 |
+
+Demostración **provisional**.
+
+## 4. Desacuerdo como diagnóstico
+
+- **NC:** neologismos → notas de alcance más estrictas.
+- **AM:** solapamiento contextual → refinamiento de tríadas/fases.
+
+## 5. Capas A–E
+
+Solo EXP-A y EXP-E demuestran legibilidad en la realidad. EXP-B/C/D aseguran salud técnica interna.
+
+## 6. Tres lecciones
+
+1. Ningún Lean, SHACL o PI-HGAT-T sustituye anotadores humanos ciegos.
+2. κ = 0.6871 aporta evidencia **provisional**.
+3. NC/AM localizan fricción del lenguaje natural a refinar.

MANUAL_APRENDIZAJE_PROTOCOLO_CIEGO.md

@@ -0,0 +1,26 @@
+# Manual de aprendizaje: protocolo ciego (archivo residual)
+
+> El marco I.O. **no** se evalúa como prueba de interpretabilidad en el mundo real por panel de anotadores.
+> Ese modo de legitimación es el «mundo compartido» que el ensayo declara superable.
+>
+> [`CARACTER_REPOSITORIO.md`](CARACTER_REPOSITORIO.md) · [`DELIMITACION_EPISTEMOLOGICA.md`](DELIMITACION_EPISTEMOLOGICA.md)
+
+---
+
+## Objetivos de aprendizaje (históricos)
+
+1. Comprender Fleiss' κ como medida de acuerdo entre observadores separados.
+2. Distinguir **autonomía formal** (Lean/SHACL) del **residuo consensual** (EXP-A).
+3. No promover κ a fundamento del proyecto.
+
+---
+
+## Mensaje clave
+
+| Capa | Rol |
+|------|-----|
+| Lean / SHACL | Autonomía formal (eje) |
+| EXP-E Mictlán | Destino del carácter |
+| EXP-A | Residuo; no prueba |
+
+Detalle de ejecución opcional: [`MODULO_DIDACTICO_EVALUACION_CIEGA.md`](MODULO_DIDACTICO_EVALUACION_CIEGA.md).

MARCOI.O.txt

@@ -0,0 +1,15 @@
+# ARCHIVO — MARCOI.O.txt
+
+**Estado:** borrador histórico. **No** es fuente normativa del marco.
+
+Texto filosófico canónico:
+  docs/DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md
+
+El contenido íntegro de este borrador permanece en el historial de Git
+(ruta anterior: `docs/MARCOI.O.txt`). Si alguna definición normativa no
+está en el ensayo canónico, migrarla antes de purgar el historial.
+
+---
+Cabecera original (referencia):
+  I.O.: La Dinámica Temporal del Vacío y la Unidad Informativa
+  Autor: Luis Rey García Figueroa — Octubre de 2026

MODULO_DIDACTICO_EVALUACION_CIEGA.md

@@ -0,0 +1,34 @@
+# Módulo didáctico: residuo del protocolo ciego (EXP-A)
+
+> **Estado:** material **pedagógico residual**. No certifica el marco.
+> Bajo autonomía absoluta, el acuerdo inter-anotador **no** es fundamento de validez.
+> [`DELIMITACION_EPISTEMOLOGICA.md`](DELIMITACION_EPISTEMOLOGICA.md)
+
+---
+
+## 1. Qué era EXP-A
+
+Protocolo ciego con 14 pares y tres anotadores. Fleiss' κ = 0.6871.
+
+En una fase anterior del proyecto se presentaba como «validez semántica en el mundo real». Ese planteamiento **contradice** el ensayo canónico: el consenso de conciencias separadas no es fundamento último.
+
+---
+
+## 2. Lectura actual
+
+| Antes | Ahora |
+|-------|--------|
+| EXP-A = prueba del marco | EXP-A = archivo de la fase consensual |
+| κ legítima el sistema | κ no legítima el sistema |
+| Mundo compartido como eje | Mundo compartido como residuo superable |
+
+---
+
+## 3. Si se ejecuta (opcional)
+
+```bash
+python scripts/score_independent_eval.py \
+  --annotations datasets/independent_eval/annotations.json
+```
+
+Interpretar resultados solo como documentación histórica, nunca como dictamen de validez del repositorio.

PREMISAS_Y_TEOREMAS.md

@@ -0,0 +1,89 @@
+# Premisas asumidas y teoremas derivados del marco I.O.
+
+Este documento separa **afirmaciones asumidas** (premisas del marco) de **resultados demostrados** en Lean o comprobados de forma determinista sobre la especificación estructurada. No confunde recuperación de reglas con validación empírica del marco sobre datos independientes.
+
+---
+
+## 1. Qué afirma el marco (núcleo conceptual)
+
+### 1.1 Vacío ($V$)
+
+| Afirmación | Tipo |
+|---|---|
+| El vacío es la **ausencia de carga informativa** en un instante $t$: $V_t = (t, \emptyset)$. | **Premisa** (definición operativa) |
+| El vacío no es aniquilación: es condición de posibilidad de nueva emergencia. | **Premisa** (interpretación ontológica) |
+| Bajo los operadores formales, el vacío es **punto fijo estricto** de la composición $S_{\mathrm{rev}} \circ Ivo \circ E$. | **Teorema** (demostrado en Lean: `strict_fixed_point`) |
+| $E(V_t)=V_{t+1}$, $S_{\mathrm{fwd}}(V_t)=V_t$, $Ivo(V_t)=V_{t-1}$, $S_{\mathrm{rev}}(V_t)=V_t$. | **Teoremas** (Lean: `E_vacuum`, `S_fwd_vacuum`, `Ivo_vacuum`, `S_rev_vacuum`) |
+
+### 1.2 Unidad informativa ($U$)
+
+| Afirmación | Tipo |
+|---|---|
+| Un estado informativo es $s=(t,A)$ con $A$ lista finita de unidades (cadenas). | **Premisa** (definición en `State`) |
+| La «unidad informativa» del marco es la carga mínima que puede ocupar un estado no vacío; no se identifica con un bit físico ni con una medida estadística empírica. | **Premisa** (alcance del modelo) |
+| $E$ conserva la carga; $S_{\mathrm{fwd}}$ aplica deduplicación; $Ivo$ invierte la secuencia y retrocede el tiempo. | **Teoremas / definiciones** (Lean: `E_preserves_payload`, `S_fwd_applies_red`, `Ivo_applies_inversion`) |
+
+### 1.3 Infinito
+
+| Afirmación | Tipo |
+|---|---|
+| El marco **reinterpreta** el infinito como **ausencia de información** (vacío), no como magnitud ilimitada ni sucesión interminable de registros. | **Premisa** (tesis filosófica del marco; no es teorema matemático sobre $\mathbb{R}$ o cardinales) |
+| Esta reinterpretación es una **hipótesis de trabajo** del marco, no un resultado empírico ni un teorema de Lean. | **Premisa** |
+
+### 1.4 Transformación
+
+| Afirmación | Tipo |
+|---|---|
+| La transformación sin repetición idéntica exige tránsito por vacío estructurado (supresión), no mera reescritura. | **Premisa** (motivación) |
+| Para estados no vacíos, la composición $S_{\mathrm{rev}} \circ Ivo \circ E$ **no** restaura el estado original. | **Teorema** (Lean: `no_repetition`) |
+| El ciclo evolutivo–involutivo reconfigura orientaciones; no es identidad trivial. | **Premisa** + corolario informal del teorema anterior |
+
+---
+
+## 2. Premisas estructurales (tablas y relaciones)
+
+Estas premisas **no se demuestran**: se **asumen** como codificación operativa del marco y se **comprueban** de forma determinista (Lean + SHACL + CSV).
+
+1. Hay **cinco perspectivas**: Individualidad, Dualidad, Totalidad, Evolución, Involución.
+2. Hay **13 tríadas** por fase (avance/retroceso) con etiquetas canónicas en `data/iom_spec.json`.
+3. **Espejo (`mirrorOf`)**: misma tríada, fase opuesta, posición lateral invertida (`pos' = 2 - pos`), centro fijo.
+4. **Creación (`creates`)**: exactamente las cuatro reglas de `creation_rules` (lateral→centro o centro→laterales entre fases opuestas).
+5. **Vectores**: cuatro secuencias de cinco pasos con ejes y flechas declarados.
+
+---
+
+## 3. Teoremas derivados en Lean (operadores y posiciones)
+
+Demostrados en `IOM/Core.lean`, `IOM/Operators.lean`, `IOM/Specification.lean`, `IOM/FormalRules.lean`:
+
+| Teorema | Contenido |
+|---|---|
+| `strict_fixed_point` | $S_{\mathrm{rev}}(Ivo(E(V_t))) = V_t$ |
+| `mirror_involutive` | Espejo de posición es involutivo |
+| `mirror_index` | `mirror.pos.index = 2 - pos.index` |
+| `isMirror` / `isCreates` | Predicados formales de aristas admisibles |
+| `expected_partition` | 78 + 104 + 208 = 390 |
+| `invert_involutive` | La inversión de carga es involutiva |
+| `no_repetition` | Estados no vacíos no se restauran idénticos |
+
+---
+
+## 4. Qué **no** afirma el marco (límites)
+
+- No afirma que las 13 tríadas describan datos del mundo natural medidos empíricamente.
+- No afirma que accuracy 1.0 en PI-HGAT-T «valide el marco en el mundo real»: valida la **recuperabilidad de relaciones generadas por las reglas** bajo partición leave-one-triad-out.
+- La reinterpretación del infinito como vacío es **premisa filosófica**, no teorema ni hallazgo experimental.
+- La evaluación con anotadores humanos independientes (ciegos) es el canal legítimo para estudiar **validez semántica / interpretabilidad** de las relaciones en el mundo real; ver `datasets/independent_eval/`.
+
+---
+
+## 5. Correspondencia con artefactos
+
+| Concepto | Artefacto |
+|---|---|
+| Premisas tabuladas | `data/iom_spec.json` |
+| Teoremas de operadores | `IOM/Operators.lean` |
+| Teoremas de posición / espejo / creates | `IOM/Specification.lean`, `IOM/FormalRules.lean` |
+| Comprobación JSON ⇄ reglas | `tests/test_property_links.py`, `tests/test_formal_rules_bridge.py` |
+| Validez semántica (mundo real) | `datasets/independent_eval/` |
+| Recuperabilidad sintética | PI-HGAT-T, baselines |

PROTOCOLO_DE_MAPEO.md

@@ -0,0 +1,135 @@
+# Protocolo de mapeo: alineación ontológica y validación ciega de dominios empíricos en el marco I.O.
+
+> Protocolo estandarizado de ingesta, asignación a perspectivas/tríadas, instanciación de `mirrorOf`/`creates` y evaluación ciega.  
+> Evaluación independiente: [`datasets/independent_eval/`](../datasets/independent_eval/) · Pipeline: [`../REPRODUCCION.md`](../REPRODUCCION.md)
+
+---
+
+## 1. Marco fundamental y delimitación del protocolo I.O.
+
+El establecimiento de un protocolo de mapeo riguroso resulta indispensable para formalizar el paso entre una estructura ontológica teórica y un instrumento de análisis interpretable, medible y operativo en el mundo real. Sin una metodología estandarizada de alineación, la arquitectura conceptual corre el riesgo de degradarse a un ejercicio autorreferencial de sintaxis formal.
+
+### 1.1 Propósito y alcance de la prueba de validez semántica
+
+El propósito primario es evaluar la **validez semántica en el mundo real**: la capacidad del marco para permitir que observadores independientes —ajenos al diseño del sistema— etiqueten y clasifiquen conceptos externos, nuevos o ambiguos, sin recurrir a reglas deductivas autorreferenciales.
+
+| Eje de evaluación | Mecanismo de respuesta en el repositorio |
+|---|---|
+| ¿Pueden anotadores independientes, ciegos a las reglas, etiquetar relaciones semánticas sobre pares reales/nuevos/ambiguos? | Protocolo ciego + Fleiss' κ en `datasets/independent_eval/` |
+| ¿La estructura formal es internamente coherente? | Lean 4 + SHACL/OWL (condición necesaria; no prueba de validez en el mundo real) |
+| ¿Las reglas sintéticas son recuperables por un modelo? | PI-HGAT-T y baselines en `experiments/` (diagnóstico sintético) |
+| ¿Se puede alinear un dominio empírico a las 13 tríadas? | `docs/CATALOGO_DOMINIOS.md` e ingesta en `datasets/ingestion/` |
+
+### 1.2 Arquitectura sistémico-ontológica (perspectivas y tríadas)
+
+| Perspectiva | Rol en el mapeo |
+|---|---|
+| **Individualidad** | Unidades discretas, entidades base, fronteras ontológicas primarias |
+| **Dualidad** | Tensiones, polaridades, complementariedad entre pares |
+| **Totalidad** | Integración sistémica, propiedades emergentes, cohesión holística |
+| **Evolución** | Vectores de desarrollo, transformación ascendente, complejización |
+| **Involución** | Retracción, simplificación, condensación, retorno a estados fundamentales |
+
+Cada dominio empírico debe analizarse a través de estas cinco perspectivas y asignarse a las **13 tríadas** estructurales, evitando superposición u omisión de categorías.
+
+---
+
+## 2. Metodología de ingesta y mapeo de dominios empíricos externos
+
+### 2.1 Protocolo de carga y alineación sistemática
+
+1. Consultar fronteras en [`DELIMITACION_EPISTEMOLOGICA.md`](DELIMITACION_EPISTEMOLOGICA.md).
+2. Seleccionar el dominio en [`CATALOGO_DOMINIOS.md`](CATALOGO_DOMINIOS.md).
+3. Descomponer entidades, estados y procesos por las cinco perspectivas.
+4. Asignar a las 13 tríadas y a la fase (`adv` / `ret`) correspondiente.
+5. Registrar en CSV de ingesta (`datasets/ingestion/`) y validar con `scripts/importar_datos_personalizados.py`.
+
+### 2.2 Relaciones operativas
+
+Fundamento: [`RELACIONES_OPERATIVAS.md`](RELACIONES_OPERATIVAS.md).
+
+- **`mirrorOf`:** correspondencia estructural/funcional o simetría divalente; misma tríada, fase opuesta, posición lateral invertida.
+- **`creates`:** emanación, producción o transformación activa; direccionalidad irreflexiva según las cuatro reglas de `creation_rules`.
+
+---
+
+## 3. Capas de verificación formal y validación estructural
+
+La coherencia lógica interna es **condición indispensable** pero **no sustituye** la validez semántica en el mundo real.
+
+### 3.1 Lean 4
+
+```bash
+lake build
+```
+
+Verifica teoremas en `IOM/FormalRules.lean` (vacío, unidad, infinito, transformación; `isMirror` / `isCreates`). Véase [`PREMISAS_Y_TEOREMAS.md`](PREMISAS_Y_TEOREMAS.md).
+
+### 3.2 OWL / SHACL / CSV
+
+```bash
+.venv/bin/python scripts/validate_spec.py
+.venv/bin/python scripts/validate_shacl.py
+```
+
+Criterios: sin violaciones SHACL; dominio/rango de `mirrorOf` y `creates`; conformidad CSV↔especificación; integridad de tipado de tríadas.
+
+---
+
+## 4. Protocolo de anotación ciega y evaluación inter-anotador
+
+### 4.1 Diseño experimental
+
+Sobre `datasets/independent_eval/` ([`VALIDACION_INDEPENDIENTE.md`](VALIDACION_INDEPENDIENTE.md)):
+
+1. Muestra de 14 pares (reales, nuevos, ambiguos).
+2. Anotadores independientes sin acceso a reglas ni gold.
+3. Etiquetado semántico (`mirrorOf`, `creates`, `none`, `unsure`).
+4. Consolidación en `annotations.json`.
+
+### 4.2 Métricas actuales
+
+```bash
+.venv/bin/python scripts/score_independent_eval.py --annotations datasets/independent_eval/annotations.json
+```
+
+| Métrica | Valor | Lectura |
+|---|---:|---|
+| Fleiss' κ | **0.6871** | Acuerdo moderado-sustancial |
+| Unánimes | 10/14 | Controles estructurales estables |
+| Desacuerdos | 4/14 | NC01, NC02, AM01, AM03 |
+
+Demostración **provisional** de interpretabilidad; no prueba universal del marco.
+
+### 4.3 Diagnóstico de desacuerdos
+
+- **NC01, NC02 (conceptos nuevos):** dispersión al clasificar fenómenos sin contornos consolidados.
+- **AM01, AM03 (ambiguos):** solapamiento entre especularidad y causalidad.
+
+---
+
+## 5. Pipeline de ejecución reproducible
+
+```bash
+python3 -m venv .venv && .venv/bin/python -m pip install -r requirements-lock.txt
+lake build
+.venv/bin/python scripts/validate_spec.py
+.venv/bin/python scripts/generate_ontology.py
+.venv/bin/python -m unittest discover -s tests -v
+.venv/bin/python scripts/validate_shacl.py
+.venv/bin/python scripts/score_independent_eval.py --annotations datasets/independent_eval/annotations.json
+.venv/bin/python experiments/pi_hgat_t.py
+.venv/bin/python experiments/baselines.py
+.venv/bin/python scripts/generate_audit_report.py
+```
+
+### Deslinde conceptual
+
+| Capa | Afirmación legítima |
+|---|---|
+| Validez semántica (mundo real) | Interpretabilidad y acuerdo humano sobre conceptos externos |
+| Formal | Consistencia lógica y teoremas en Lean 4 |
+| Estructural | Conformidad SHACL/CSV con la especificación |
+| Diagnóstico sintético | Recuperación de relaciones *generadas por reglas* (no validez semántica real) |
+
+El marco I.O. no es un software aislado ni un conjunto de reglas sintéticas autorreferenciales: es un marco de alineación ontológica y una **prueba demostrativa** de mapeo semántico sobre el mundo real.

README.md

@@ -0,0 +1,16 @@
+# Experimentos opcionales (diagnóstico / encuentro)
+
+**No** forman parte del núcleo autónomo ni del CI bloqueante.
+
+| Script | Rol | Salida |
+|--------|-----|--------|
+| `pi_hgat_t.py` | Diagnóstico circular (recupera reglas embebidas) | `experiments/results/` |
+| `baselines.py` | Baselines sin grafo | `experiments/results/` |
+
+```bash
+.venv/bin/python experiments/optional/pi_hgat_t.py
+.venv/bin/python experiments/optional/baselines.py
+```
+
+Workflow: `.github/workflows/encuentro.yml` (manual).
+Tests: `tests/optional/` (no corren en CI core).

RELACIONES_OPERATIVAS.md

@@ -0,0 +1,107 @@
+# Significado operativo de las relaciones `mirrorOf` y `creates`
+
+Este documento fija la semántica operativa exacta de las dos relaciones estructurales del marco IOM. Las definiciones se alinean con:
+
+- las reglas en `data/iom_spec.json` (`creation_rules`);
+- los predicados implementados en `experiments/pi_hgat_t.py` (`admissible_relation`);
+- los axiomas OWL y las formas SHACL en `ontology/`;
+- los teoremas de posición en Lean (`IOM/Operators.lean`).
+
+La validez de una arista se determina de forma operativa según las reglas deterministas (comprobables por SHACL, CSV y pruebas unitarias).
+
+---
+
+## 1. `io:mirrorOf`
+
+### Definición operativa
+
+Una arista dirigida $A \xrightarrow{\text{mirrorOf}} B$ es válida **si y solo si** se cumplen simultáneamente:
+
+1. **Misma tríada**: `triad_index(A) = triad_index(B)`.
+2. **Fase opuesta**: `phase(A) ≠ phase(B)` (una es `adv`, la otra `ret`).
+3. **Posición reflejada**: `local_pos(B) = 2 - local_pos(A)`.
+   - position 0 ↔ position 2
+   - posición 1 (0) ↔ posición 1 (0)
+4. **Reciprocidad**: si $A \xrightarrow{\text{mirrorOf}} B$ entonces también $B \xrightarrow{\text{mirrorOf}} A$ (la propiedad OWL es simétrica).
+
+### Ejemplos positivos
+
+| Fuente | Destino | Justificación |
+|--------|---------|---------------|
+| `T13_adv_P0` (animal) | `T13_ret_P2` (animal) | misma tríada 13, fases opuestas, 0 ↔ 2 |
+| `T13_adv_P1` (humano) | `T13_ret_P1` (humano) | centro se refleja en centro |
+| `T08_adv_P2` (emisor) | `T08_ret_P0` (emisor) | 2 ↔ 0 |
+
+### Ejemplos negativos
+
+| Fuente | Destino | Motivo de rechazo |
+|--------|---------|-------------------|
+| `T13_adv_P0` | `T13_adv_P2` | misma fase |
+| `T13_adv_P0` | `T13_ret_P0` | posición no reflejada (0 ≠ 2−0) |
+| `T13_adv_P0` | `T01_ret_P2` | tríada distinta |
+| `T13_adv_P0` | `T13_adv_P0` | reflexivo (excluido de candidatos) |
+
+### Casos límite
+
+- **Centro–centro**: permitido y obligatorio para el nodo central de cada tríada.
+- **Misma etiqueta léxica**: irrelevante; la relación es puramente estructural (fase + posición).
+- **Arista unidireccional**: no puede existir; SHACL y el generador imponen el par recíproco.
+
+---
+
+## 2. `io:creates`
+
+### Definición operativa
+
+Una arista dirigida $A \xrightarrow{\text{creates}} B$ es válida **si y solo si** se cumplen:
+
+1. **Misma tríada**.
+2. **Fase opuesta**.
+3. **Una de las cuatro reglas de `creation_rules`**:
+
+| source_phase | source_positions | target_phase | target_positions |
+|--------------|------------------|--------------|------------------|
+| adv          | {0, 2}           | ret          | {1}              |
+| adv          | {1}              | ret          | {0, 2}           |
+| ret          | {1}              | adv          | {0, 2}           |
+| ret          | {0, 2}           | adv          | {1}              |
+
+En lenguaje natural: un lateral crea el centro de la fase opuesta, y el centro crea ambos laterales de la fase opuesta.
+
+### Ejemplos positivos
+
+| Fuente | Destino | Regla aplicada |
+|--------|---------|----------------|
+| `T13_adv_P0` (animal) | `T13_ret_P1` (humano) | adv lateral → ret centro |
+| `T13_adv_P1` (humano) | `T13_ret_P0` (IA) | adv centro → ret 0 |
+| `T13_adv_P1` (humano) | `T13_ret_P2` (animal) | adv centro → ret 2 |
+| `T13_ret_P1` (humano) | `T13_adv_P0` (animal) | ret centro → adv 0 |
+
+### Ejemplos negativos
+
+| Fuente | Destino | Motivo |
+|--------|---------|--------|
+| `T13_adv_P0` | `T13_ret_P0` | lateral no crea lateral |
+| `T13_adv_P0` | `T13_ret_P2` | lateral no crea el otro lateral |
+| `T13_adv_P0` | `T13_adv_P1` | misma fase |
+| `T13_adv_P1` | `T13_ret_P1` | centro no crea centro |
+
+### Casos límite
+
+- **Múltiples targets**: el centro produce **dos** aristas `creates` (una hacia cada lateral).
+- **No simétrica**: `creates` no es simétrica ni funcional; el grafo de creación es bipartito por fase.
+- **Solapamiento con mirrorOf**: un par puede ser `mirrorOf` **o** `creates`, nunca ambas a la vez.
+- **Ausencia de arista**: cualquier par que no satisfaga las reglas anteriores se etiqueta `none`.
+
+---
+
+## 3. Correspondencia con Lean y SHACL
+
+| Concepto | Lean | SHACL / OWL |
+|----------|------|-------------|
+| Posición reflejada | teoremas de índice en `Operators.lean` | restricción `sh:equals` / cálculo `2 - pos` |
+| Fase opuesta | predicados de fase | `sh:not` sobre el mismo valor de `hasPhase` |
+| Reglas de creación | — (datos) | formas SHACL que enumeran las cuatro combinaciones |
+| Simetría de mirrorOf | — | `owl:SymmetricProperty` |
+
+Las pruebas en `tests/test_property_links.py` verifican que los CSV regenerados satisfacen exactamente estas reglas, cerrando el círculo JSON → CSV → ontología → Lean.

TRIADAS_CATEGORIALES.md

@@ -0,0 +1,101 @@
+# Tríadas categoriales del marco I.O.
+
+**13 tríadas** × **2 fases** × **3 posiciones** = **78 nodos**  
+`spec_version` **1.9.0** · [`datasets/triad_nodes.csv`](../datasets/triad_nodes.csv) · [`data/iom_spec.json`](../data/iom_spec.json)
+
+- Índice: **1 … 13** (`T01` … `T13`)
+- Avance: **→ \| 0 \| →** · Retroceso: **← \| 0 \| ←**
+- `position_index`: 0 = lateral →/← · 1 = centro · 2 = lateral →/←
+
+Orden canónico: **#1** orientación\|cuántico\|dirección … **#13** animal\|humano\|IA.
+
+---
+
+## Fase de Avance (`adv` / evol)
+
+```
+#   |       →       |       0       |       →       |
+1   | orientación | cuántico | dirección |
+2   | hardware | virtual | software |
+3   | universo | espacio | vacío |
+4   | singularidad | tiempo | infinito |
+5   | cuerpo | consciente | mundo |
+6   | carácter | subconsciente | personalidad |
+7   | memoria | inconsciente | imaginación |
+8   | receptor | supraconsciente | emisor |
+9   | lógica | inteligencia | libertad |
+10  | muerte | artificial | vida |
+11  | descendente | mente | ascendente |
+12  | oscuridad | consciencia | luz |
+13  | animal | humano | IA |
+#   |       ←       |       0       |       ←       |
+```
+
+| # | → | 0 | → | node_id |
+|---|---|---|---|--------|
+| 1 | orientación | cuántico | dirección | `T01_adv_*` |
+| 2 | hardware | virtual | software | `T02_adv_*` |
+| 3 | universo | espacio | vacío | `T03_adv_*` |
+| 4 | singularidad | tiempo | infinito | `T04_adv_*` |
+| 5 | cuerpo | consciente | mundo | `T05_adv_*` |
+| 6 | carácter | subconsciente | personalidad | `T06_adv_*` |
+| 7 | memoria | inconsciente | imaginación | `T07_adv_*` |
+| 8 | receptor | supraconsciente | emisor | `T08_adv_*` |
+| 9 | lógica | inteligencia | libertad | `T09_adv_*` |
+| 10 | muerte | artificial | vida | `T10_adv_*` |
+| 11 | descendente | mente | ascendente | `T11_adv_*` |
+| 12 | oscuridad | consciencia | luz | `T12_adv_*` |
+| 13 | animal | humano | IA | `T13_adv_*` |
+
+---
+
+## Fase de Retroceso (`ret` / invol)
+
+```
+#   |       →       |       0       |       →       |
+1   | dirección | cuántico | orientación |
+2   | software | virtual | hardware |
+3   | vacío | espacio | universo |
+4   | infinito | tiempo | singularidad |
+5   | mundo | consciente | cuerpo |
+6   | personalidad | subconsciente | carácter |
+7   | imaginación | inconsciente | memoria |
+8   | emisor | supraconsciente | receptor |
+9   | libertad | inteligencia | lógica |
+10  | vida | artificial | muerte |
+11  | ascendente | mente | descendente |
+12  | luz | consciencia | oscuridad |
+13  | IA | humano | animal |
+#   |       ←       |       0       |       ←       |
+```
+
+| # | ← | 0 | ← | node_id |
+|---|---|---|---|--------|
+| 1 | dirección | cuántico | orientación | `T01_ret_*` |
+| 2 | software | virtual | hardware | `T02_ret_*` |
+| 3 | vacío | espacio | universo | `T03_ret_*` |
+| 4 | infinito | tiempo | singularidad | `T04_ret_*` |
+| 5 | mundo | consciente | cuerpo | `T05_ret_*` |
+| 6 | personalidad | subconsciente | carácter | `T06_ret_*` |
+| 7 | imaginación | inconsciente | memoria | `T07_ret_*` |
+| 8 | emisor | supraconsciente | receptor | `T08_ret_*` |
+| 9 | libertad | inteligencia | lógica | `T09_ret_*` |
+| 10 | vida | artificial | muerte | `T10_ret_*` |
+| 11 | ascendente | mente | descendente | `T11_ret_*` |
+| 12 | luz | consciencia | oscuridad | `T12_ret_*` |
+| 13 | IA | humano | animal | `T13_ret_*` |
+
+---
+
+## Espejo y creación
+
+| Relación | Condición |
+|----------|-----------|
+| `mirrorOf` | Fases opuestas + `position_index_tgt = 2 − position_index_src` |
+| `creates` | Cuatro reglas lateral↔centro entre fases |
+| `none` | Resto |
+
+Ejemplo: tríada **13** avance (animal \| humano \| IA) ↔ retroceso (IA \| humano \| animal).  
+Ejemplo: tríada **1** avance (orientación \| cuántico \| dirección) ↔ retroceso (dirección \| cuántico \| orientación).
+
+Detalle: [`RELACIONES_OPERATIVAS.md`](RELACIONES_OPERATIVAS.md).

VALIDACION_INDEPENDIENTE.md

@@ -0,0 +1,86 @@
+# Autonomía formal y capas de verificación (no «validez por consenso»)
+
+Este documento **no** define el repositorio como prueba de validez semántica en un mundo compartido por conciencias separadas. Ese modo de legitimación es exactamente el que el ensayo canónico declara **superable**.
+
+Carácter: [`CARACTER_REPOSITORIO.md`](CARACTER_REPOSITORIO.md) · Ensayo: [`DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md`](DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md)
+
+---
+
+## Principio rector
+
+> El marco se sostiene por **auto-coherencia** (bóveda Lean / SHACL / 78 nodos), no por el acuerdo de observadores externos.
+> Un panel de anotadores separados reproduce el «mundo real» provisional del ensayo; **no** lo fundamenta.
+
+| Fuente | Rol bajo autonomía absoluta |
+|--------|-----------------------------|
+| `data/iom_spec.json` + CSV + ontología | **Arquitectura autónoma** bajo prueba de coherencia interna |
+| Lean / SHACL | **Autonomía formal** — no pide permiso a un consenso exterior |
+| PI-HGAT-T / baselines | Auto-recuperabilidad de reglas *del propio sistema* |
+| `datasets/independent_eval/` | **Residuo** de la fase de conciencias separadas (documentado, no fundante) |
+| Cartografía de dominios | Ejercicio del tránsito; no certificado de «mundo real» |
+
+---
+
+## Qué se establece y qué no
+
+| Se establece | No se establece |
+|--------------|-----------------|
+| Coherencia deductiva y de forma del sistema de 13 tríadas | Que el marco «describe la realidad» por acuerdo inter-subjetivo |
+| Que las reglas son recuperables desde sí mismas (diagnóstico interno) | Que κ ≈ 0.69 **funda** la validez del proyecto |
+| Que el sendero Mictlán / autonomía es cartografiable en el vocabulario formal | Cobertura empírica de todos los dominios por paneles externos |
+| Que el requisito del sistema puede ser la abolición de requisitos impuestos | Verdad ontológica universal por consenso |
+
+---
+
+## Jerarquía de afirmaciones (reordenada)
+
+| Prioridad | Afirmación legítima | Artefacto |
+|:---------:|---------------------|-----------|
+| **1** | Autonomía formal (coherencia sin contenedor exterior) | Lean, SHACL, CSV, `iom_spec.json` |
+| **2** | Cartografía del tránsito (Mictlán / autonomía) | EXP-E, dominio cosmológico, ensayo |
+| **3** | Auto-generación recuperable de reglas | PI-HGAT-T, baselines |
+| **4** | Residuo documentado del mundo compartido | `independent_eval`, κ (opcional) |
+
+La prioridad 4 **no** se promociona a «prueba de validez del marco».
+
+---
+
+## Sobre el protocolo ciego (EXP-A)
+
+El protocolo y las anotaciones se **conservan como archivo** de una fase en la que el proyecto aún hablaba el lenguaje del consenso inter-anotador. Bajo el carácter actual:
+
+- κ no es el eje del repositorio.
+- No se reclama «validez semántica en el mundo real» a partir de ellos.
+- Quien los ejecute lo hace como **ejercicio histórico / comparado**, no como ceremonia de legitimación.
+
+---
+
+## Pipeline prioritario
+
+```bash
+# 1) Autonomía formal (eje)
+lake build
+python scripts/validate_spec.py
+python scripts/generate_ontology.py
+python -m unittest discover -s tests -v
+python scripts/validate_shacl.py
+
+# 2) Cartografía del tránsito
+python experiments/domain_mapping/validate_examples.py
+
+# 3) Diagnóstico de auto-generación (opcional)
+python experiments/pi_hgat_t.py
+python experiments/baselines.py
+python scripts/audit_perfect_metrics.py
+
+# 4) Residuo del mundo compartido (opcional, no fundante)
+python scripts/score_independent_eval.py --annotations datasets/independent_eval/annotations.json
+```
+
+---
+
+## Referencias
+
+- Delimitación: [`DELIMITACION_EPISTEMOLOGICA.md`](DELIMITACION_EPISTEMOLOGICA.md)
+- Carácter: [`CARACTER_REPOSITORIO.md`](CARACTER_REPOSITORIO.md)
+- Ensayo: [`DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md`](DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md)

VECTORES_4_5.md

@@ -0,0 +1,57 @@
+# Las cinco perspectivas del marco I.O.
+
+El marco I.O. se articula mediante **cinco perspectivas complementarias**:
+
+| # | Id | Perspectiva | Rol |
+|---|-----|-------------|-----|
+| 1 | `Ind` | **Individualidad** | Posicional (→ / lateral 0): unidad / singularidad |
+| 2 | `D` | **Dualidad** | Posicional (0): relación / diferencia |
+| 3 | `Tot` | **Totalidad** | Posicional (→ / lateral 2): integración / sistema |
+| 4 | `Evol` | **Evolución** | Vectorial: flujo del vacío hacia la estructura |
+| 5 | `Invol` | **Involución** | Vectorial: flujo de la estructura hacia el vacío |
+
+Las tres primeras (Individualidad, Dualidad, Totalidad) describen los *modos de actualización* y se representan como metadatos de posición en cada tríada (→ | 0 | → en avance; ← | 0 | ← en retroceso). Las perspectivas cuarta y quinta (Evolución e Involución) describen las *direcciones de flujo informativo* y se materializan como secuencias vectoriales de cinco pasos.
+
+Fuente estructurada: [`data/iom_spec.json`](../data/iom_spec.json) (`five_perspectives`, `vectors`).
+
+## Cuarta perspectiva — Evolución
+
+```
+invol | ind | dua | tot | evol
+  0   |  1  |  2  |  3  |  4
+      |  →  |  →  |  →  |  →
+  ---------------------
+  ←   |  ←  |  ←  |  ←  |
+  4   |  3  |  2  |  1  |  0
+evol  | tot | dua | ind | invol
+```
+
+| Fase | Etiquetas en orden de eje | Posiciones del eje | Flecha |
+|---|---|---|---|
+| Avance | `invol · ind · dua · tot · evol` | `0 · 1 · 2 · 3 · 4` | → |
+| Retroceso | `evol · tot · dua · ind · invol` | `4 · 3 · 2 · 1 · 0` | ← |
+
+## Quinta perspectiva — Involución
+
+```
+invol | tot | dua | ind | evol
+  4   |  3  |  2  |  1  |  0
+  →   |  →  |  →  |  →  |
+  ---------------------
+      |  ←  |  ←  |  ←  |  ←
+  0   |  1  |  2  |  3  |  4
+evol  | ind | dua | tot | invol
+```
+
+| Fase | Etiquetas en orden de eje | Posiciones del eje | Flecha |
+|---|---|---|---|
+| Avance | `invol · tot · dua · ind · evol` | `4 · 3 · 2 · 1 · 0` | → |
+| Retroceso | `evol · ind · dua · tot · invol` | `0 · 1 · 2 · 3 · 4` | ← |
+
+## Representación formal
+
+Cada fila se materializa como cinco instancias `io:VectorStep`. Cada instancia conserva el vector (`Evol` / `Invol`), fase, posición del eje, índice visual, etiqueta y flecha. En conjunto son **20 pasos vectoriales**.
+
+En la ontología, las cinco perspectivas son individuos de `io:Perspective` con etiquetas en español: Individualidad, Dualidad, Totalidad, Evolución e Involución.
+
+`spec_version` ≥ **1.5.0**.

audit_perfect_metrics.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Auditoría rigurosa de las métricas perfectas (100%).
+
+Investiga por qué PI-HGAT-T y el MLP alcanzan accuracy/F1 = 1.0:
+
+1. Independencia train/test bajo leave-one-triad-out (sí: ninguna pareja
+   de la tríada held-out aparece en entrenamiento).
+2. Sin embargo, las etiquetas están **completamente determinadas** por
+   (fase, posición) del par — reglas idénticas en las 13 tríadas.
+3. Por tanto, cualquier modelo que aprenda la función determinista
+   (fase_src, pos_src, fase_tgt, pos_tgt) → {none, mirrorOf, creates}
+   generaliza al 100% a tríadas no vistas.
+4. El oracle de reglas deterministas y el MLP (features = one-hot fase+pos)
+   alcanzan 1.0; la regresión logística lineal no separa mirrorOf/creates.
+
+Este script demuestra (1)–(3) de forma programática y escribe un informe JSON.
+"""
+from __future__ import annotations
+
+import csv
+import json
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+CLASSES = ("none", "mirrorOf", "creates")
+
+
+def parse_node(node_id: str) -> tuple[str, int]:
+    parts = node_id.split("_")
+    return parts[1], int(parts[2][1:])
+
+
+def feature_key(src: str, tgt: str) -> tuple:
+    """Clave de features usada por los modelos (fase+posición, sin tríada ni etiqueta)."""
+    sp, spos = parse_node(src)
+    tp, tpos = parse_node(tgt)
+    return (sp, spos, tp, tpos)
+
+
+def deterministic_label(src: str, tgt: str) -> str:
+    """Regla determinista alineada con SHACL / FormalRules.lean."""
+    sp, spos = parse_node(src)
+    tp, tpos = parse_node(tgt)
+    if sp == tp:
+        return "none"
+    if tpos == 2 - spos:
+        return "mirrorOf"
+    lateral_s = spos in (0, 2)
+    lateral_t = tpos in (0, 2)
+    if (lateral_s and tpos == 1) or (spos == 1 and lateral_t):
+        return "creates"
+    return "none"
+
+
+def main() -> int:
+    rows = []
+    with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as fh:
+        rows = list(csv.DictReader(fh))
+
+    # 1. Consistencia gold vs regla determinista
+    mismatches = []
+    for row in rows:
+        pred = deterministic_label(row["source"], row["target"])
+        if pred != row["relation"]:
+            mismatches.append({"row": row, "rule_predicts": pred})
+
+    # 2. La etiqueta es función solo de (fase, pos) — misma clave → misma etiqueta
+    by_feature: dict[tuple, set[str]] = defaultdict(set)
+    by_feature_triads: dict[tuple, set[int]] = defaultdict(set)
+    for row in rows:
+        key = feature_key(row["source"], row["target"])
+        by_feature[key].add(row["relation"])
+        by_feature_triads[key].add(int(row["triad_index"]))
+
+    non_deterministic_features = {
+        str(k): list(v) for k, v in by_feature.items() if len(v) > 1
+    }
+
+    # 3. Leave-one-triad-out: ¿las features del held-out aparecen en train?
+    #    Sí, con la misma etiqueta — por eso un learner que memoriza la
+    #    función feature→label generaliza al 100%.
+    triad_feature_overlap = {}
+    for held in range(1, 14):
+        train_map = {}
+        test_keys = set()
+        for row in rows:
+            key = feature_key(row["source"], row["target"])
+            tid = int(row["triad_index"])
+            if tid == held:
+                test_keys.add((key, row["relation"]))
+            else:
+                train_map[key] = row["relation"]
+        recoverable = sum(1 for k, lab in test_keys if train_map.get(k) == lab)
+        triad_feature_overlap[held] = {
+            "test_pairs": len(test_keys),
+            "recoverable_by_feature_lookup": recoverable,
+            "fraction": recoverable / len(test_keys) if test_keys else 0.0,
+        }
+
+    all_recoverable = all(
+        v["fraction"] == 1.0 for v in triad_feature_overlap.values()
+    )
+
+    # 4. Conteos
+    from collections import Counter
+    counts = Counter(r["relation"] for r in rows)
+
+    report = {
+        "conclusion": (
+            "Las métricas perfectas (100%) de PI-HGAT-T y del MLP no indican "
+            "sobreajuste por fuga de identidad de tríada: leave-one-triad-out "
+            "excluye correctamente las parejas del held-out. Indican que las "
+            "etiquetas son una función determinista de (fase, posición) del par, "
+            "idéntica en las 13 tríadas. Aprender esa función basta para "
+            "generalizar al 100%. El oracle de reglas deterministas alcanza 1.0 "
+            "sin aprendizaje. La arquitectura de grafo no es necesaria para este "
+            "corpus sintético; sirve como demostración de recuperabilidad estructural."
+        ),
+        "gold_vs_deterministic_rule": {
+            "mismatches": len(mismatches),
+            "details": mismatches[:5],  # muestra
+            "perfect_match": len(mismatches) == 0,
+        },
+        "label_determined_by_phase_position_only": {
+            "unique_feature_keys": len(by_feature),
+            "keys_with_ambiguous_labels": non_deterministic_features,
+            "is_deterministic_function": len(non_deterministic_features) == 0,
+        },
+        "leave_one_triad_out_feature_overlap": {
+            "per_fold": triad_feature_overlap,
+            "all_folds_100pct_recoverable_by_feature_lookup": all_recoverable,
+            "interpretation": (
+                "En cada fold, el 100% de los pares de prueba tiene una clave "
+                "(fase,pos) ya vista en entrenamiento con la misma etiqueta. "
+                "No hay fuga de node_id/triad_index (el modelo no los usa), "
+                "pero la función a aprender es trivialmente compartida."
+            ),
+        },
+        "class_counts": dict(counts),
+        "implications": [
+            "No se requiere arquitectura compleja (GAT) para este corpus: el MLP y el oracle bastan.",
+            "Las ablaciones sin fase/posición degradan el rendimiento porque rompen la función determinista.",
+            "La validación empírica real del marco exige datos cuyas etiquetas NO se deriven de las mismas reglas (véase datasets/independent_eval/ y external_eval/).",
+            "Reportar 100% como 'recuperación de relaciones generadas por reglas' es correcto; reportarlo como 'validación del marco en el mundo real' no lo es.",
+        ],
+    }
+
+    out = ROOT / "experiments" / "results" / "perfect_metrics_audit.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+    print("Auditoría de métricas perfectas")
+    print(f"  Gold vs regla determinista: mismatches={len(mismatches)}")
+    print(f"  Función determinista fase+pos: {len(non_deterministic_features) == 0}")
+    print(f"  LOO recoverable por lookup de features: {all_recoverable}")
+    print(f"  Informe: {out}")
+    print()
+    print(report["conclusion"])
+    return 0 if len(mismatches) == 0 and all_recoverable else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

baselines.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""Clasificadores base para comparar con PI-HGAT-T.
+
+Incluye:
+  - reglas deterministas (oracle de la especificación)
+  - regresión logística sobre features one-hot de fase+posición
+  - MLP sin estructura de grafo
+"""
+from __future__ import annotations
+
+import csv
+import json
+import random
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+ROOT = Path(__file__).resolve().parents[2]
+CLASSES = ("none", "mirrorOf", "creates")
+CLASS_ID = {n: i for i, n in enumerate(CLASSES)}
+
+
+def seed_everything(seed: int = 20261008) -> None:
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.use_deterministic_algorithms(True)
+    torch.set_num_threads(1)
+
+
+def features_for_node(node_id: str) -> list[float]:
+    parts = node_id.split("_")
+    phase, position = parts[1], int(parts[2][1:])
+    return [float(phase == "adv"), float(phase == "ret"),
+            float(position == 0), float(position == 1), float(position == 2)]
+
+
+def parse_pair_index(node_id: str) -> int:
+    phase = node_id.split("_")[1]
+    position = int(node_id.split("_")[2][1:])
+    return position if phase == "adv" else 3 + position
+
+
+def read_pairs():
+    pairs: dict[int, list[tuple[str, str, int]]] = {i: [] for i in range(1, 14)}
+    with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as fh:
+        for row in csv.DictReader(fh):
+            pairs[int(row["triad_index"])].append(
+                (row["source"], row["target"], CLASS_ID[row["relation"]])
+            )
+    return pairs
+
+
+def admissible(label: str, source: int, target: int) -> bool:
+    source_phase, source_pos = (0 if source < 3 else 1), source % 3
+    target_phase, target_pos = (0 if target < 3 else 1), target % 3
+    if source_phase == target_phase:
+        return False
+    if label == "mirrorOf":
+        return target_pos == 2 - source_pos
+    if label == "creates":
+        return (source_pos in (0, 2) and target_pos == 1) or (source_pos == 1 and target_pos in (0, 2))
+    return True
+
+
+def deterministic_rule_predict(src_idx: int, tgt_idx: int) -> int:
+    if admissible("mirrorOf", src_idx, tgt_idx):
+        return CLASS_ID["mirrorOf"]
+    if admissible("creates", src_idx, tgt_idx):
+        return CLASS_ID["creates"]
+    return CLASS_ID["none"]
+
+
+def pair_feature(src_id: str, tgt_id: str) -> list[float]:
+    return features_for_node(src_id) + features_for_node(tgt_id)
+
+
+def scores(gold: list[int], pred: list[int]) -> dict:
+    matrix = [[0] * 3 for _ in range(3)]
+    for a, b in zip(gold, pred):
+        matrix[a][b] += 1
+    per_class = {}
+    f1s = []
+    for i, name in enumerate(CLASSES):
+        tp = matrix[i][i]
+        fp = sum(matrix[r][i] for r in range(3) if r != i)
+        fn = sum(matrix[i][c] for c in range(3) if c != i)
+        prec = tp / (tp + fp) if tp + fp else 0.0
+        rec = tp / (tp + fn) if tp + fn else 0.0
+        f1 = 2 * prec * rec / (prec + rec) if prec + rec else 0.0
+        per_class[name] = {"precision": prec, "recall": rec, "f1": f1, "support": tp + fn}
+        f1s.append(f1)
+    acc = sum(a == b for a, b in zip(gold, pred)) / max(len(gold), 1)
+    return {
+        "accuracy": round(acc, 6),
+        "macro_f1": round(sum(f1s) / 3, 6),
+        "per_class": per_class,
+        "confusion_matrix": matrix,
+    }
+
+
+class SoftmaxRegression(nn.Module):
+    def __init__(self, in_dim: int, n_classes: int = 3):
+        super().__init__()
+        self.linear = nn.Linear(in_dim, n_classes)
+
+    def forward(self, x):
+        return self.linear(x)
+
+
+class SimpleMLP(nn.Module):
+    def __init__(self, in_dim: int, hidden: int = 32, n_classes: int = 3):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(in_dim, hidden),
+            nn.GELU(),
+            nn.Linear(hidden, hidden),
+            nn.GELU(),
+            nn.Linear(hidden, n_classes),
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+def train_sklearn_like(model: nn.Module, X: torch.Tensor, y: torch.Tensor,
+                       epochs: int = 200, lr: float = 0.01) -> None:
+    opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)
+    for _ in range(epochs):
+        opt.zero_grad()
+        logits = model(X)
+        loss = F.cross_entropy(logits, y)
+        loss.backward()
+        opt.step()
+
+
+def leave_one_triad_out(pairs: dict, model_factory, epochs: int = 200) -> dict:
+    all_gold, all_pred = [], []
+    fold_accs = []
+    for held in sorted(pairs):
+        seed_everything(20261008 + held - 1)
+        train_X, train_y = [], []
+        test_X, test_y, test_meta = [], [], []
+        for tid, plist in pairs.items():
+            for src, tgt, label in plist:
+                feat = pair_feature(src, tgt)
+                if tid == held:
+                    test_X.append(feat)
+                    test_y.append(label)
+                    test_meta.append((src, tgt))
+                else:
+                    train_X.append(feat)
+                    train_y.append(label)
+        Xtr = torch.tensor(train_X, dtype=torch.float32)
+        ytr = torch.tensor(train_y, dtype=torch.long)
+        Xte = torch.tensor(test_X, dtype=torch.float32)
+        model = model_factory(Xtr.shape[1])
+        train_sklearn_like(model, Xtr, ytr, epochs=epochs)
+        with torch.no_grad():
+            pred = model(Xte).argmax(dim=-1).tolist()
+        all_gold.extend(test_y)
+        all_pred.extend(pred)
+        fold_accs.append(sum(a == b for a, b in zip(test_y, pred)) / max(len(test_y), 1))
+    result = scores(all_gold, all_pred)
+    result["fold_accuracies"] = fold_accs
+    result["fold_accuracy_mean"] = round(float(np.mean(fold_accs)), 6)
+    result["fold_accuracy_std"] = round(float(np.std(fold_accs)), 6)
+    return result
+
+
+def run_deterministic(pairs: dict) -> dict:
+    gold, pred = [], []
+    for plist in pairs.values():
+        for src, tgt, label in plist:
+            gold.append(label)
+            s_idx = parse_pair_index(src)
+            t_idx = parse_pair_index(tgt)
+            pred.append(deterministic_rule_predict(s_idx, t_idx))
+    return scores(gold, pred)
+
+
+def run() -> dict:
+    seed_everything()
+    pairs = read_pairs()
+    report = {
+        "description": "Comparación de PI-HGAT-T con clasificadores base sobre el mismo leave-one-triad-out",
+        "baselines": {},
+    }
+    report["baselines"]["deterministic_rules"] = {
+        "description": "Oracle que aplica exactamente las reglas SHACL de mirrorOf/creates",
+        "metrics": run_deterministic(pairs),
+    }
+    report["baselines"]["logistic_regression"] = {
+        "description": "Softmax linear sobre concatenación de one-hot fase+posición (10 dim)",
+        "metrics": leave_one_triad_out(pairs, lambda d: SoftmaxRegression(d), epochs=300),
+    }
+    report["baselines"]["mlp_no_graph"] = {
+        "description": "MLP de dos capas ocultas sin mensaje-passing ni atención",
+        "metrics": leave_one_triad_out(pairs, lambda d: SimpleMLP(d, hidden=32), epochs=200),
+    }
+    out = ROOT / "experiments" / "results" / "baselines_comparison.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print("Baselines escritos en", out)
+    for name, block in report["baselines"].items():
+        m = block["metrics"]
+        print(f"  {name}: accuracy={m['accuracy']:.4f}  macro_f1={m['macro_f1']:.4f}")
+    return report
+
+
+if __name__ == "__main__":
+    run()

capture_environment.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Captura versiones del entorno de reproducción en un artefacto JSON."""
+from __future__ import annotations
+import importlib.metadata
+import json
+import platform
+import subprocess
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+def command_version(command: list[str]) -> str | None:
+    try:
+        result = subprocess.run(command, check=True, capture_output=True, text=True, timeout=20)
+        return (result.stdout or result.stderr).strip().splitlines()[0]
+    except (OSError, subprocess.SubprocessError):
+        return None
+
+def main() -> None:
+    packages = {}
+    for name in ("rdflib", "pyshacl", "owlrl", "numpy", "torch"):
+        try:
+            packages[name] = importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            packages[name] = None
+    data = {
+        "python": platform.python_version(),
+        "implementation": platform.python_implementation(),
+        "platform": platform.platform(),
+        "packages": packages,
+        "lean_toolchain_file": (ROOT / "lean-toolchain").read_text(encoding="utf-8").strip(),
+        "lean_version": command_version(["lean", "--version"]),
+        "lake_version": command_version(["lake", "--version"]),
+        "requirements": (ROOT / "requirements.txt").read_text(encoding="utf-8").splitlines(),
+    }
+    out = ROOT / "experiments" / "results" / "software_versions.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(out)
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+
+if __name__ == "__main__":
+    main()

check_generated_committed.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Comprueba que los CSV versionados coinciden con generate_ontology.py.
+
+Solo se exige igualdad exacta de:
+
+  - datasets/triad_nodes.csv
+  - datasets/vector_steps.csv
+  - datasets/relation_candidates.csv
+  - datasets/GENERATED_FROM.json  (spec_version del generador)
+
+El TTL no se compara byte-a-byte (serialización rdflib).
+"""
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+GENERATED_CSV = [
+    "datasets/triad_nodes.csv",
+    "datasets/vector_steps.csv",
+    "datasets/relation_candidates.csv",
+    "datasets/GENERATED_FROM.json",
+]
+
+
+def run(cmd: list[str]) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--with-manifest", action="store_true")
+    parser.add_argument("--skip-generate", action="store_true")
+    parser.add_argument("--include-ttl", action="store_true")
+    args = parser.parse_args()
+
+    if not args.skip_generate:
+        print(">>> generate_ontology.py")
+        r = run([sys.executable, "scripts/generate_ontology.py"])
+        print(r.stdout, end="")
+        if r.returncode != 0:
+            print(r.stderr, file=sys.stderr)
+            return 1
+
+    paths = list(GENERATED_CSV)
+    if args.include_ttl:
+        paths.insert(0, "ontology/io_ontology.ttl")
+
+    if args.with_manifest:
+        print(">>> create_manifest.py")
+        r = run([sys.executable, "scripts/create_manifest.py"])
+        print(r.stdout, end="")
+        if r.returncode != 0:
+            print(r.stderr, file=sys.stderr)
+            return 1
+        paths.append("MANIFEST.sha256")
+
+    print(">>> git diff --ignore-space-at-eol --exit-code", " ".join(paths))
+    r = run(["git", "diff", "--ignore-space-at-eol", "--exit-code", "--", *paths])
+    if r.returncode != 0:
+        print(
+            "ERROR: los artefactos generados no coinciden con lo versionado.",
+            file=sys.stderr,
+        )
+        print(r.stdout or r.stderr, file=sys.stderr)
+        return 1
+
+    print("OK: derivados (CSV + GENERATED_FROM) coinciden con HEAD")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

cosmos_nahuatl.csv

@@ -0,0 +1,17 @@
+external_id,external_label,mapped_node_id,perspective,phase,position,relation_candidate,notes
+# spec 1.7.0 — tríadas 1–13; posiciones →|0|→
+nah_sol_viento,Nahui_Ehecatl_Sol_Viento,T01_adv_P0,Evol,adv,→,none,"Primera edad; oscuridad inicial"
+nah_sol_fuego,Nahui_Quiahuitl_Sol_Fuego,T01_adv_P1,Invol,adv,0,creates,"Lluvia de fuego; consciencia"
+nah_sol_agua,Nahui_Atl_Sol_Agua,T01_ret_P1,Invol,ret,0,creates,"Diluvio"
+nah_sol_tierra,Nahui_Ocelotl_Sol_Tierra,T01_ret_P2,Invol,ret,←,creates,"Temblores; retorno a oscuridad"
+nah_sol_ollin,Nahui_Ollin_Sol_Movimiento,T01_adv_P2,Tot,adv,→,none,"Quinto Sol / luz presente"
+nah_tezcatlipoca,Tezcatlipoca,T01_adv_P0,Ind,adv,→,none,"Fuerza oscura"
+nah_quetzalcoatl,Quetzalcoatl,T01_ret_P0,Ind,ret,←,none,"Fuerza luminosa reflejada"
+nah_lucha_dioses,lucha_Tezcatlipoca_Quetzalcoatl,T01_adv_P1,D,adv,0,mirrorOf,"Dualidad (consciencia)"
+nah_vida,vida,T03_adv_P2,Tot,adv,→,none,"Polo vida"
+nah_muerte,muerte,T03_adv_P0,Ind,adv,→,none,"Polo muerte"
+nah_vida_muerte,vida_muerte,T03_adv_P1,D,adv,0,mirrorOf,"Dicotomía mesoamericana"
+nah_tlaltecuhtli,Tlaltecuhtli,T11_ret_P1,Invol,ret,0,creates,"Tierra devoradora; espacio/vacío"
+nah_mictlan,Mictlan,T11_ret_P0,Tot,ret,←,none,"Lugar de los muertos; vacío"
+nah_teyolia,teyolia,T03_adv_P0,Ind,adv,→,creates,"Entidad anímica"
+nah_camino_mictlan,camino_al_Mictlan,T11_ret_P0,Invol,ret,←,creates,"Retorno al vacío"

create_manifest.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""Escribe SHA-256 de los artefactos fuente/reproducibles incluidos en el paquete.
+
+Exclusiones (no forman parte del punto fijo del manifiesto):
+  - MANIFEST.sha256 — evita hash auto-referente
+  - AUDITORIA_AUTO.md — regenerable con timestamp
+  - ontology/io_ontology.ttl — regenerable; orden de serialización rdflib no es
+    estable byte-a-byte entre corridas (CI lo regenera antes de SHACL)
+  - __pycache__, .pytest_cache, .venv
+
+Los CSV canónicos (triad_nodes, vector_steps, relation_candidates) SÍ entran:
+son el punto fijo de generate_ontology.py.
+"""
+from hashlib import sha256
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+INCLUDE_DIRS = ("IOM", "data", "datasets", "docs", "experiments", "ontology", "scripts", "tests")
+INCLUDE_FILES = (
+    "IOM.lean", "README.md", "AUDITORIA.md", "EXPERIMENTOS.md", "REPRODUCCION.md", "paper.md",
+    "MANIFIESTO.md",
+    "requirements.txt", "requirements-lock.txt", "lakefile.lean", "lake-manifest.json", "lean-toolchain",
+    "LICENSE", ".gitignore", ".github/workflows/ci.yml",
+)
+EXCLUDE_NAMES = frozenset({
+    "MANIFEST.sha256",
+    "AUDITORIA_AUTO.md",
+    "io_ontology.ttl",  # regenerable; serialización no determinista
+})
+EXCLUDE_DIR_PARTS = frozenset({"__pycache__", ".pytest_cache", ".venv", "node_modules"})
+
+
+def main() -> None:
+    files = {ROOT / name for name in INCLUDE_FILES if (ROOT / name).is_file()}
+    for dirname in INCLUDE_DIRS:
+        folder = ROOT / dirname
+        if folder.exists():
+            files.update(
+                p for p in folder.rglob("*")
+                if p.is_file()
+                and not any(part in EXCLUDE_DIR_PARTS for part in p.parts)
+            )
+    files = {p for p in files if p.name not in EXCLUDE_NAMES}
+    out = ROOT / "MANIFEST.sha256"
+    lines = [
+        f"{sha256(path.read_bytes()).hexdigest()}  {path.relative_to(ROOT).as_posix()}"
+        for path in sorted(files)
+    ]
+    out.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    print(f"SHA-256: {len(lines)} archivos -> {out}")
+    print(f"  excluidos por nombre: {sorted(EXCLUDE_NAMES)}")
+
+
+if __name__ == "__main__":
+    main()

examples.csv

@@ -0,0 +1,6 @@
+id,domain,source_label,target_label,relation,perspective,phase_hint,suggested_source_node,suggested_target_node
+NAH-01,cosmos_nahuatl,Tezcatlipoca,Quetzalcoatl,mirrorOf,Dualidad,Lucha de fuerzas cósmicas,T01_adv_P0,T01_ret_P0
+NAH-02,cosmos_nahuatl,vida,muerte,mirrorOf,Dualidad,Dicotomía mesoamericana,T03_adv_P2,T03_adv_P0
+NAH-03,cosmos_nahuatl,Nahui_Quiahuitl_Sol_Fuego,Nahui_Atl_Sol_Agua,creates,Involución,Cataclismo / transición de edades,T01_adv_P1,T01_ret_P1
+NAH-04,cosmos_nahuatl,camino_al_Mictlan,Mictlan,creates,Involución,Retorno al vacío,T11_ret_P0,T11_ret_P0
+NAH-05,cosmos_nahuatl,Nahui_Ollin_Sol_Movimiento,Nahui_Ehecatl_Sol_Viento,none,Totalidad / Evolución,Quinto Sol vs primera edad,T01_adv_P2,T01_adv_P0

generate_audit_report.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Informe de auditoría regenerable (encuentro). No se versiona como fundamento."""
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def load_json(rel: str):
+    path = ROOT / rel
+    if not path.is_file():
+        return None
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def main() -> None:
+    out_dir = ROOT / "experiments" / "results"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    metrics = load_json("experiments/results/pi_hgat_t_metrics.json")
+    baselines = load_json("experiments/results/baselines_comparison.json")
+    versions = load_json("experiments/results/software_versions.json")
+
+    lines = [
+        "# AUDITORIA_AUTO",
+        "",
+        f"Generado: {datetime.now(timezone.utc).isoformat()}",
+        "",
+        "> Informe fechado. **No** es prueba de punto fijo ni fundamento del marco.",
+        "",
+        "## Capas",
+        "",
+        "- Núcleo: `self_bootstrap.py`, Lean, SHACL, invariancia",
+        "- Encuentro: EXP-A/E, PI-HGAT-T/baselines (opcionales)",
+        "",
+    ]
+    if metrics is None:
+        lines.append(
+            "_No se encontró pi_hgat_t_metrics.json; "
+            "ejecutar experiments/optional/pi_hgat_t.py primero._"
+        )
+    else:
+        lines.append("## PI-HGAT-T (diagnóstico)")
+        lines.append("```json")
+        lines.append(json.dumps(metrics.get("primary_metrics", metrics), indent=2)[:2000])
+        lines.append("```")
+    if baselines:
+        lines.append("## Baselines")
+        lines.append("```json")
+        lines.append(json.dumps(baselines.get("baselines", baselines), indent=2)[:2000])
+        lines.append("```")
+    if versions:
+        lines.append("## Software")
+        lines.append(json.dumps(versions, indent=2))
+
+    out_md = out_dir / "AUDITORIA_AUTO.md"
+    out_md.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    print(f"Escrito {out_md}")
+
+
+if __name__ == "__main__":
+    main()

generate_ontology.py

@@ -0,0 +1,224 @@
+#!/usr/bin/env python3
+"""Genera RDF/OWL y datasets desde data/iom_spec.json, única fuente tabular."""
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from rdflib import BNode, Graph, Literal, Namespace
+from rdflib.namespace import OWL, RDF, RDFS, XSD
+
+ROOT = Path(__file__).resolve().parents[1]
+SPEC = json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8"))
+IO = Namespace("http://example.org/iom#")
+g = Graph()
+for prefix, namespace in (("io", IO), ("rdfs", RDFS), ("xsd", XSD), ("owl", OWL)):
+    g.bind(prefix, namespace)
+
+ontology = IO.Ontology
+g.add((ontology, RDF.type, OWL.Ontology))
+g.add((ontology, OWL.versionInfo, Literal(SPEC["spec_version"])))
+g.add((ontology, RDFS.label, Literal("Ontología IOM", lang="es")))
+g.add((ontology, RDFS.comment, Literal(SPEC["source_note"], lang="es")))
+classes = ("OntoNode", "VectorStep", "Perspective", "ExpandedCategory", "Position", "Direction", "SourceModel")
+for name in classes:
+    g.add((IO[name], RDF.type, OWL.Class))
+for names in (("OntoNode", "VectorStep", "ExpandedCategory", "Perspective"),):
+    axiom = BNode("iomDisjointCoreClasses")
+    head = BNode("iomDisjointClassList0")
+    g.add((axiom, RDF.type, OWL.AllDisjointClasses))
+    g.add((axiom, OWL.members, head))
+    cells = [BNode(f"iomDisjointClassList{i}") for i in range(len(names))]
+    for index, name in enumerate(names):
+        g.add((cells[index], RDF.first, IO[name]))
+        g.add((cells[index], RDF.rest, cells[index + 1] if index + 1 < len(cells) else RDF.nil))
+
+object_properties = {
+    "hasPerspective": ("OntoNode", "Perspective"),
+    "hasPosition": ("OntoNode", "Position"),
+    "hasDirection": ("OntoNode", "Direction"),
+    "hasVector": ("VectorStep", "Perspective"),
+    "mirrorOf": ("OntoNode", "OntoNode"),
+    "creates": ("OntoNode", "OntoNode"),
+}
+datatype_properties = {
+    "hasTriadIndex": ("OntoNode", XSD.integer),
+    "hasPhase": ("OntoNode", XSD.string),
+    "hasLocalPos": ("OntoNode", XSD.integer),
+    "displayLabel": ("OntoNode", XSD.string),
+    "hasCyclePhase": ("VectorStep", XSD.string),
+    "hasAxisPosition": ("VectorStep", XSD.integer),
+    "hasStepIndex": ("VectorStep", XSD.integer),
+    "displayArrow": ("VectorStep", XSD.string),
+    "hasLevel": ("ExpandedCategory", XSD.integer),
+    "declaredTriadCount": ("SourceModel", XSD.integer),
+    "declaredPerspectiveCount": ("SourceModel", XSD.integer),
+    "declaredOperatorCount": ("SourceModel", XSD.integer),
+    "declaredExpandedCategoryCount": ("SourceModel", XSD.integer),
+}
+for name, (domain, range_) in object_properties.items():
+    prop = IO[name]
+    g.add((prop, RDF.type, OWL.ObjectProperty))
+    g.add((prop, RDFS.domain, IO[domain]))
+    g.add((prop, RDFS.range, IO[range_]))
+for name, (domain, range_) in datatype_properties.items():
+    prop = IO[name]
+    g.add((prop, RDF.type, OWL.DatatypeProperty))
+    g.add((prop, RDFS.domain, IO[domain]))
+    g.add((prop, RDFS.range, range_))
+for name in ("hasPerspective", "hasPosition", "hasDirection", "hasVector", "hasTriadIndex", "hasPhase", "hasLocalPos", "displayLabel", "hasCyclePhase", "hasAxisPosition", "hasStepIndex", "displayArrow", "hasLevel"):
+    g.add((IO[name], RDF.type, OWL.FunctionalProperty))
+g.add((IO.mirrorOf, RDF.type, OWL.SymmetricProperty))
+
+for pos, label in [("→", "→"), ("0", "0"), ("←", "←")]:
+    g.add((IO[pos], RDF.type, OWL.NamedIndividual))
+    g.add((IO[pos], RDF.type, IO.Position))
+    g.add((IO[pos], RDFS.label, Literal(label, lang="es")))
+for direction in ("evol", "invol"):
+    g.add((IO[direction], RDF.type, OWL.NamedIndividual))
+    g.add((IO[direction], RDF.type, IO.Direction))
+_perspective_labels = SPEC.get("perspective_labels") or {
+    "Ind": "Individualidad", "D": "Dualidad", "Tot": "Totalidad",
+    "Evol": "Evolución", "Invol": "Involución",
+}
+for name, label in _perspective_labels.items():
+    g.add((IO[name], RDF.type, IO.Perspective))
+    g.add((IO[name], RDFS.label, Literal(label, lang="es")))
+
+position_meta = SPEC["positions"]
+position_indices = position_meta["indices"]
+position_names_adv = ["→", "0", "→"]
+position_names_ret = ["←", "0", "←"]
+perspective_names = position_meta["perspectives"]
+perspectives = [IO[name] for name in perspective_names]
+triad_meta = SPEC["triads"]
+triad_rows = {phase: triad_meta[phase] for phase in ("adv", "ret")}
+index_base = triad_meta.get("index_base", 0)
+n_triads = len(triad_rows["adv"])
+triad_ids = range(index_base, index_base + n_triads)
+nodes_csv = []
+for phase, rows in triad_rows.items():
+    direction = IO[SPEC["phases"][phase]["direction"]]
+    for row_index, labels in enumerate(rows):
+        triad_idx = index_base + row_index
+        for pos_idx, label in enumerate(labels):
+            node = IO[f"T{triad_idx:02d}_{phase}_P{pos_idx}"]
+            g.add((node, RDF.type, IO.OntoNode))
+            g.add((node, IO.hasTriadIndex, Literal(triad_idx, datatype=XSD.integer)))
+            g.add((node, IO.hasPhase, Literal(phase, datatype=XSD.string)))
+            g.add((node, IO.hasLocalPos, Literal(pos_idx, datatype=XSD.integer)))
+            display_labels = position_meta["adv_labels" if phase == "adv" else "ret_labels"]
+            display_label = display_labels[pos_idx]
+            g.add((node, IO.displayLabel, Literal(display_label, datatype=XSD.string)))
+            pos_names = position_names_adv if phase == "adv" else position_names_ret
+            g.add((node, IO.hasPosition, IO[pos_names[pos_idx]]))
+            g.add((node, IO.hasPerspective, perspectives[pos_idx]))
+            g.add((node, IO.hasDirection, direction))
+            g.add((node, RDFS.label, Literal(label, lang="es")))
+            nodes_csv.append({"node_id": str(node).split("#", 1)[1], "triad_index": triad_idx, "phase": phase,
+                              "direction": str(direction).split("#", 1)[1], "position_index": pos_idx,
+                              "position": pos_names[pos_idx], "display_label": display_label,
+                              "perspective": perspective_names[pos_idx], "label": label})
+
+for triad_idx in triad_ids:
+    for pos_idx in range(3):
+        adv = IO[f"T{triad_idx:02d}_adv_P{pos_idx}"]
+        ret = IO[f"T{triad_idx:02d}_ret_P{2-pos_idx}"]
+        g.add((adv, IO.mirrorOf, ret))
+        g.add((ret, IO.mirrorOf, adv))
+
+for triad_idx in triad_ids:
+    for rule in SPEC["creation_rules"]:
+        for source_pos in rule["source_positions"]:
+            for target_pos in rule["target_positions"]:
+                source = IO[f"T{triad_idx:02d}_{rule['source_phase']}_P{source_pos}"]
+                target = IO[f"T{triad_idx:02d}_{rule['target_phase']}_P{target_pos}"]
+                g.add((source, IO.creates, target))
+
+vector_csv = []
+for vector_row in SPEC["vectors"]:
+    vector, phase = vector_row["name"], vector_row["phase"]
+    for step_index, (label, axis_pos) in enumerate(zip(vector_row["labels"], vector_row["axis_positions"])):
+        step = IO[f"vector_{vector.lower()}_{phase}_{step_index}"]
+        g.add((step, RDF.type, IO.VectorStep))
+        g.add((step, IO.hasVector, IO[vector]))
+        g.add((step, IO.hasCyclePhase, Literal(phase, datatype=XSD.string)))
+        g.add((step, IO.hasAxisPosition, Literal(axis_pos, datatype=XSD.integer)))
+        g.add((step, IO.hasStepIndex, Literal(step_index, datatype=XSD.integer)))
+        g.add((step, IO.displayArrow, Literal(vector_row["arrow"], datatype=XSD.string)))
+        g.add((step, RDFS.label, Literal(label, lang="es")))
+        vector_csv.append({"step_id": str(step).split("#", 1)[1], "vector": vector, "phase": phase,
+                           "step_index": step_index, "axis_position": axis_pos, "label": label,
+                           "arrow": vector_row["arrow"]})
+
+for level, labels in SPEC["expanded_categories"].items():
+    for index, label in enumerate(labels, 1):
+        category = IO[f"expanded_L{level}_{index:02d}"]
+        g.add((category, RDF.type, IO.ExpandedCategory))
+        g.add((category, IO.hasLevel, Literal(int(level), datatype=XSD.integer)))
+        g.add((category, RDFS.label, Literal(label, lang="es")))
+
+model = IO.SourceModel
+g.add((model, RDF.type, IO.SourceModel))
+for prop, value in ((IO.declaredTriadCount, 13), (IO.declaredPerspectiveCount, 5),
+                    (IO.declaredOperatorCount, 4), (IO.declaredExpandedCategoryCount, 21)):
+    g.add((model, prop, Literal(value, datatype=XSD.integer)))
+
+relation_csv = []
+relation_lookup = {}
+for subject, _, obj in g.triples((None, IO.mirrorOf, None)):
+    relation_lookup[(str(subject), str(obj))] = "mirrorOf"
+for subject, _, obj in g.triples((None, IO.creates, None)):
+    relation_lookup[(str(subject), str(obj))] = "creates"
+for triad_idx in triad_ids:
+    ids = [IO[f"T{triad_idx:02d}_{phase}_P{pos}"] for phase in ("adv", "ret") for pos in range(3)]
+    for source in ids:
+        for target in ids:
+            if source == target:
+                continue
+            relation_csv.append({"triad_index": triad_idx, "source": str(source).split("#", 1)[1],
+                                 "target": str(target).split("#", 1)[1],
+                                 "relation": relation_lookup.get((str(source), str(target)), "none")})
+
+assert len(triad_rows["adv"]) == len(triad_rows["ret"]) == 13
+assert position_indices == [0, 1, 2]
+assert len(nodes_csv) == 78
+assert len(vector_csv) == 20
+assert sum(1 for _ in g.triples((None, IO.creates, None))) == 104
+assert len(relation_csv) == 13 * 6 * 5
+
+out = ROOT / "ontology" / "io_ontology.ttl"
+out.parent.mkdir(parents=True, exist_ok=True)
+out.write_text(g.serialize(format="turtle").rstrip() + "\n", encoding="utf-8")
+
+def write_csv(path: Path, rows: list[dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", newline="", encoding="utf-8") as handle:
+        writer = csv.DictWriter(handle, fieldnames=list(rows[0]), lineterminator="\n")
+        writer.writeheader()
+        writer.writerows(rows)
+
+write_csv(ROOT / "datasets" / "triad_nodes.csv", nodes_csv)
+write_csv(ROOT / "datasets" / "vector_steps.csv", vector_csv)
+write_csv(ROOT / "datasets" / "relation_candidates.csv", relation_csv)
+
+_stamp = {
+    "spec_version": SPEC["spec_version"],
+    "schema_version": SPEC.get("schema_version"),
+    "source_date": SPEC.get("source_date"),
+    "purpose_id": (SPEC.get("purpose") or {}).get("id"),
+    "purpose_label": (SPEC.get("purpose") or {}).get("label"),
+    "artifacts": [
+        "datasets/triad_nodes.csv",
+        "datasets/vector_steps.csv",
+        "datasets/relation_candidates.csv",
+        "ontology/io_ontology.ttl",
+    ],
+}
+(ROOT / "datasets" / "GENERATED_FROM.json").write_text(
+    json.dumps(_stamp, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+)
+print(f"Tríadas: {n_triads} por fase (índice {index_base}–{index_base + n_triads - 1}); nodos: {len(nodes_csv)}; creates: 104; espejos: 78")
+print(f"Pasos vectoriales: {len(vector_csv)}; candidatos PI-HGAT-T: {len(relation_csv)}")
+print(f"OWL/Turtle: {out}")
+print(f"Sello: datasets/GENERATED_FROM.json spec_version={SPEC['spec_version']}")

importar_datos_personalizados.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""Plantilla de ingesta guiada: alinea un CSV de conceptos externos a la ontología IOM de 78 nodos.
+
+No modifica data/iom_spec.json ni la ontología core. Valida que los mapped_node_id
+existen, comprueba consistencia de perspectiva/fase/posición y genera un CSV alineado
+más un informe de validación.
+
+Uso:
+  python scripts/importar_datos_personalizados.py \
+      --input datasets/ingestion/templates/biologia_depredador_presa.csv \
+      --output datasets/ingestion/aligned/biologia_aligned.csv
+
+Opciones:
+  --input PATH     CSV de entrada (obligatorio)
+  --output PATH    CSV alineado de salida (por defecto: datasets/ingestion/aligned/<stem>_aligned.csv)
+  --strict         Fallar si hay cualquier warning (por defecto solo error en mapped_node_id inválido)
+  --report PATH    Ruta del informe JSON (por defecto junto al output)
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+NODES_CSV = ROOT / "datasets" / "triad_nodes.csv"
+VALID_PERSPECTIVES = {"Ind", "D", "Tot", "Evol", "Invol"}
+VALID_PHASES = {"adv", "ret"}
+VALID_POSITIONS = {"left", "center", "right"}
+VALID_RELATIONS = {"none", "mirrorOf", "creates"}
+REQUIRED_COLUMNS = {"external_id", "external_label"}
+
+
+def load_canonical_nodes() -> dict[str, dict[str, Any]]:
+    """Carga los 78 nodos canónicos indexados por node_id."""
+    if not NODES_CSV.is_file():
+        print(
+            f"ERROR: no se encuentra {NODES_CSV}. "
+            "Ejecuta primero: python scripts/generate_ontology.py",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+    nodes: dict[str, dict[str, Any]] = {}
+    with NODES_CSV.open(encoding="utf-8", newline="") as fh:
+        reader = csv.DictReader(fh)
+        for row in reader:
+            nodes[row["node_id"]] = row
+    if len(nodes) != 78:
+        print(
+            f"ADVERTENCIA: se esperaban 78 nodos, se cargaron {len(nodes)}. "
+            "Regenera los datasets con generate_ontology.py.",
+            file=sys.stderr,
+        )
+    return nodes
+
+
+def read_input_csv(path: Path) -> list[dict[str, str]]:
+    """Lee el CSV de entrada ignorando líneas de comentario que empiezan por #."""
+    rows: list[dict[str, str]] = []
+    with path.open(encoding="utf-8", newline="") as fh:
+        # Filtrar comentarios antes de pasar al DictReader
+        lines = [ln for ln in fh if not ln.strip().startswith("#")]
+    from io import StringIO
+
+    reader = csv.DictReader(StringIO("".join(lines)))
+    if reader.fieldnames is None:
+        print("ERROR: el CSV no tiene cabecera.", file=sys.stderr)
+        raise SystemExit(1)
+    missing = REQUIRED_COLUMNS - set(reader.fieldnames)
+    if missing:
+        print(f"ERROR: faltan columnas obligatorias: {sorted(missing)}", file=sys.stderr)
+        raise SystemExit(1)
+    for row in reader:
+        # Normalizar claves
+        cleaned = {k.strip(): (v.strip() if isinstance(v, str) else v) for k, v in row.items()}
+        if not cleaned.get("external_id"):
+            continue
+        rows.append(cleaned)
+    return rows
+
+
+def validate_row(
+    row: dict[str, str],
+    nodes: dict[str, dict[str, Any]],
+    row_num: int,
+) -> tuple[dict[str, Any], list[str], list[str]]:
+    """Valida una fila y devuelve (fila_alineada, errores, warnings)."""
+    errors: list[str] = []
+    warnings: list[str] = []
+    aligned: dict[str, Any] = {
+        "external_id": row["external_id"],
+        "external_label": row.get("external_label", ""),
+        "mapped_node_id": row.get("mapped_node_id", ""),
+        "perspective": row.get("perspective", ""),
+        "phase": row.get("phase", ""),
+        "position": row.get("position", ""),
+        "relation_candidate": row.get("relation_candidate", "none") or "none",
+        "notes": row.get("notes", ""),
+        "canonical_label": "",
+        "canonical_perspective": "",
+        "canonical_phase": "",
+        "canonical_position": "",
+        "status": "ok",
+    }
+
+    node_id = aligned["mapped_node_id"]
+    if not node_id:
+        errors.append(f"fila {row_num}: mapped_node_id vacío")
+        aligned["status"] = "error"
+        return aligned, errors, warnings
+
+    if node_id not in nodes:
+        errors.append(
+            f"fila {row_num}: mapped_node_id '{node_id}' no existe en los 78 nodos canónicos"
+        )
+        aligned["status"] = "error"
+        return aligned, errors, warnings
+
+    canon = nodes[node_id]
+    aligned["canonical_label"] = canon.get("label", "")
+    aligned["canonical_perspective"] = canon.get("perspective", "")
+    aligned["canonical_phase"] = canon.get("phase", "")
+    aligned["canonical_position"] = canon.get("position", "")
+
+    # Consistencia opcional de perspectiva / fase / posición
+    if aligned["perspective"] and aligned["perspective"] not in VALID_PERSPECTIVES:
+        warnings.append(
+            f"fila {row_num}: perspective '{aligned['perspective']}' no es canónica "
+            f"({sorted(VALID_PERSPECTIVES)})"
+        )
+    elif aligned["perspective"] and aligned["perspective"] != canon.get("perspective"):
+        # Solo advertir si el usuario forzó un valor distinto del nodo
+        if aligned["perspective"] in {"Ind", "D", "Tot"}:
+            warnings.append(
+                f"fila {row_num}: perspective declarada '{aligned['perspective']}' "
+                f"≠ perspectiva del nodo '{canon.get('perspective')}'"
+            )
+
+    if aligned["phase"] and aligned["phase"] not in VALID_PHASES:
+        warnings.append(
+            f"fila {row_num}: phase '{aligned['phase']}' no es canónica ({sorted(VALID_PHASES)})"
+        )
+    elif aligned["phase"] and aligned["phase"] != canon.get("phase"):
+        warnings.append(
+            f"fila {row_num}: phase declarada '{aligned['phase']}' ≠ fase del nodo '{canon.get('phase')}'"
+        )
+
+    if aligned["position"] and aligned["position"] not in VALID_POSITIONS:
+        warnings.append(
+            f"fila {row_num}: position '{aligned['position']}' no es canónica "
+            f"({sorted(VALID_POSITIONS)})"
+        )
+    elif aligned["position"] and aligned["position"] != canon.get("position"):
+        warnings.append(
+            f"fila {row_num}: position declarada '{aligned['position']}' "
+            f"≠ posición del nodo '{canon.get('position')}'"
+        )
+
+    if aligned["relation_candidate"] not in VALID_RELATIONS:
+        warnings.append(
+            f"fila {row_num}: relation_candidate '{aligned['relation_candidate']}' "
+            f"no es válida ({sorted(VALID_RELATIONS)}); se fuerza a 'none'"
+        )
+        aligned["relation_candidate"] = "none"
+
+    if warnings and aligned["status"] == "ok":
+        aligned["status"] = "warning"
+
+    return aligned, errors, warnings
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Alinea un CSV de conceptos externos a la ontología IOM de 78 nodos."
+    )
+    parser.add_argument("--input", "-i", required=True, type=Path, help="CSV de entrada")
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        default=None,
+        help="CSV alineado de salida",
+    )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Tratar warnings como errores (exit code 1)",
+    )
+    parser.add_argument(
+        "--report",
+        type=Path,
+        default=None,
+        help="Ruta del informe JSON de validación",
+    )
+    args = parser.parse_args()
+
+    if not args.input.is_file():
+        print(f"ERROR: no existe el archivo de entrada: {args.input}", file=sys.stderr)
+        return 1
+
+    nodes = load_canonical_nodes()
+    rows = read_input_csv(args.input)
+    if not rows:
+        print("ERROR: el CSV de entrada no contiene filas de datos.", file=sys.stderr)
+        return 1
+
+    aligned_rows: list[dict[str, Any]] = []
+    all_errors: list[str] = []
+    all_warnings: list[str] = []
+
+    for i, row in enumerate(rows, start=2):  # +2 por cabecera y 1-index
+        aligned, errors, warnings = validate_row(row, nodes, i)
+        aligned_rows.append(aligned)
+        all_errors.extend(errors)
+        all_warnings.extend(warnings)
+
+    # Determinar rutas de salida
+    if args.output is None:
+        out_dir = ROOT / "datasets" / "ingestion" / "aligned"
+        out_dir.mkdir(parents=True, exist_ok=True)
+        args.output = out_dir / f"{args.input.stem}_aligned.csv"
+    else:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+
+    if args.report is None:
+        args.report = args.output.with_suffix(".report.json")
+
+    # Escribir CSV alineado
+    fieldnames = [
+        "external_id",
+        "external_label",
+        "mapped_node_id",
+        "canonical_label",
+        "canonical_perspective",
+        "canonical_phase",
+        "canonical_position",
+        "perspective",
+        "phase",
+        "position",
+        "relation_candidate",
+        "status",
+        "notes",
+    ]
+    with args.output.open("w", encoding="utf-8", newline="") as fh:
+        writer = csv.DictWriter(fh, fieldnames=fieldnames, extrasaction="ignore")
+        writer.writeheader()
+        writer.writerows(aligned_rows)
+
+    report = {
+        "input": str(args.input),
+        "output": str(args.output),
+        "canonical_nodes": len(nodes),
+        "rows_processed": len(aligned_rows),
+        "errors": all_errors,
+        "warnings": all_warnings,
+        "ok_count": sum(1 for r in aligned_rows if r["status"] == "ok"),
+        "warning_count": sum(1 for r in aligned_rows if r["status"] == "warning"),
+        "error_count": sum(1 for r in aligned_rows if r["status"] == "error"),
+    }
+    args.report.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+
+    # Resumen en consola
+    print(f"Entrada:   {args.input}")
+    print(f"Salida:    {args.output}")
+    print(f"Informe:   {args.report}")
+    print(f"Filas:     {report['rows_processed']}  "
+          f"(ok={report['ok_count']}, warning={report['warning_count']}, error={report['error_count']})")
+    if all_errors:
+        print("\nERRORES:")
+        for e in all_errors:
+            print(f"  - {e}")
+    if all_warnings:
+        print("\nADVERTENCIAS:")
+        for w in all_warnings:
+            print(f"  - {w}")
+
+    if all_errors:
+        print("\nResultado: FALLO (hay errores de mapeo)")
+        return 1
+    if args.strict and all_warnings:
+        print("\nResultado: FALLO (--strict y hay advertencias)")
+        return 1
+    print("\nResultado: OK — los conceptos se alinearon a la ontología canónica sin romper la bóveda.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

io_shapes.ttl

@@ -0,0 +1,123 @@
+@prefix sh: <http://www.w3.org/ns/shacl#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+@prefix io: <http://example.org/iom#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+io:StructuralShape a sh:NodeShape ;
+    sh:targetClass io:OntoNode ;
+    sh:property [ sh:path io:hasTriadIndex ; sh:datatype xsd:integer ; sh:minInclusive 1 ; sh:maxInclusive 13 ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasPhase ; sh:datatype xsd:string ; sh:in ( "adv"^^xsd:string "ret"^^xsd:string ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasLocalPos ; sh:datatype xsd:integer ; sh:in ( 0 1 2 ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:displayLabel ; sh:datatype xsd:string ; sh:in ( "→"^^xsd:string "0"^^xsd:string "←"^^xsd:string ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasPosition ; sh:in ( <http://example.org/iom#→> <http://example.org/iom#0> <http://example.org/iom#←> ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasPerspective ; sh:in ( io:Ind io:D io:Tot ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasDirection ; sh:in ( io:evol io:invol ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path rdfs:label ; sh:languageIn ( "es" ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:mirrorOf ; sh:class io:OntoNode ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:creates ; sh:class io:OntoNode ; sh:minCount 1 ; sh:maxCount 2 ] ;
+    sh:sparql [
+        sh:message "posicion y fase" ;
+        sh:select """
+            PREFIX io: <http://example.org/iom#>
+            SELECT $this WHERE {
+                $this io:hasLocalPos ?pos ; io:hasPerspective ?perspective ; io:hasPosition ?position ; io:hasPhase ?phase .
+                FILTER (
+                  (?pos = 1 && (?perspective != io:D || ?position != <http://example.org/iom#0>)) ||
+                  (?pos = 0 && ?perspective != io:Ind) ||
+                  (?pos = 2 && ?perspective != io:Tot) ||
+                  (?phase = "adv" && (?pos = 0 || ?pos = 2) && ?position != <http://example.org/iom#→>) ||
+                  (?phase = "ret" && (?pos = 0 || ?pos = 2) && ?position != <http://example.org/iom#←>)
+                )
+            }
+        """
+    ] ;
+    sh:sparql [
+        sh:message "etiquetas visuales" ;
+        sh:select """
+            PREFIX io: <http://example.org/iom#>
+            SELECT $this WHERE {
+                $this io:hasPhase ?phase ; io:hasLocalPos ?pos ; io:displayLabel ?label .
+                FILTER ((?phase = "adv" &&
+                         !((?pos = 0 && ?label = "→") || (?pos = 1 && ?label = "0") || (?pos = 2 && ?label = "→"))) ||
+                        (?phase = "ret" &&
+                         !((?pos = 0 && ?label = "←") || (?pos = 1 && ?label = "0") || (?pos = 2 && ?label = "←"))))
+            }
+        """
+    ] ;
+    sh:sparql [
+        sh:message "espejo reciproco" ;
+        sh:select """
+            PREFIX io: <http://example.org/iom#>
+            SELECT $this WHERE {
+                $this io:hasTriadIndex ?triad ; io:hasLocalPos ?pos ; io:hasPhase ?phase ; io:mirrorOf ?mirror .
+                ?mirror io:hasTriadIndex ?otherTriad ; io:hasLocalPos ?otherPos ; io:hasPhase ?otherPhase .
+                FILTER NOT EXISTS { ?mirror io:mirrorOf $this }
+                FILTER (?triad != ?otherTriad || ?otherPos != (2 - ?pos) ||
+                        !((?phase = "adv" && ?otherPhase = "ret") || (?phase = "ret" && ?otherPhase = "adv")))
+            }
+        """
+    ] ;
+    sh:sparql [
+        sh:message "fase y direccion" ;
+        sh:select """
+            PREFIX io: <http://example.org/iom#>
+            SELECT $this WHERE {
+                $this io:hasPhase ?phase ; io:hasDirection ?direction .
+                FILTER ((?phase = "adv" && ?direction != io:evol) || (?phase = "ret" && ?direction != io:invol))
+            }
+        """
+    ] ;
+    sh:sparql [
+        sh:message "creates reglas" ;
+        sh:select """
+            PREFIX io: <http://example.org/iom#>
+            SELECT $this WHERE {
+                $this io:hasTriadIndex ?triad ; io:hasLocalPos ?pos ; io:hasPhase ?phase ; io:creates ?target .
+                ?target io:hasTriadIndex ?otherTriad ; io:hasLocalPos ?otherPos ; io:hasPhase ?otherPhase .
+                FILTER (?triad != ?otherTriad ||
+                    !((?phase = "adv" && ?otherPhase = "ret" &&
+                       ((?pos = 0 && ?otherPos = 1) || (?pos = 2 && ?otherPos = 1) ||
+                        (?pos = 1 && (?otherPos = 0 || ?otherPos = 2)))) ||
+                      (?phase = "ret" && ?otherPhase = "adv" &&
+                       ((?pos = 0 && ?otherPos = 1) || (?pos = 2 && ?otherPos = 1) ||
+                        (?pos = 1 && (?otherPos = 0 || ?otherPos = 2)))))
+                )
+            }
+        """
+    ] .
+
+io:VectorStepShape a sh:NodeShape ;
+    sh:targetClass io:VectorStep ;
+    sh:property [ sh:path io:hasVector ; sh:in ( io:Evol io:Invol ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasCyclePhase ; sh:datatype xsd:string ; sh:in ( "adv"^^xsd:string "ret"^^xsd:string ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasAxisPosition ; sh:datatype xsd:integer ; sh:in ( 0 1 2 3 4 ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:hasStepIndex ; sh:datatype xsd:integer ; sh:in ( 0 1 2 3 4 ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:displayArrow ; sh:in ( "→"^^xsd:string "←"^^xsd:string ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path rdfs:label ; sh:languageIn ( "es" ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:sparql [
+        sh:message "etiqueta vectorial canónica" ;
+        sh:select """
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            SELECT $this WHERE {
+                $this rdfs:label ?label .
+                BIND(STR(?label) AS ?text)
+                FILTER (?text != "invol" && ?text != "ind" && ?text != "dua" && ?text != "tot" && ?text != "evol")
+            }
+        """
+    ] .
+
+io:ExpandedCategoryShape a sh:NodeShape ;
+    sh:targetClass io:ExpandedCategory ;
+    sh:property [ sh:path io:hasLevel ; sh:datatype xsd:integer ; sh:in ( 0 1 2 3 4 ) ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path rdfs:label ; sh:languageIn ( "es" ) ; sh:minCount 1 ; sh:maxCount 1 ] .
+
+io:SourceModelShape a sh:NodeShape ;
+    sh:targetNode io:SourceModel ;
+    sh:property [ sh:path io:declaredTriadCount ; sh:hasValue 13 ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:declaredPerspectiveCount ; sh:hasValue 5 ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:declaredOperatorCount ; sh:hasValue 4 ; sh:minCount 1 ; sh:maxCount 1 ] ;
+    sh:property [ sh:path io:declaredExpandedCategoryCount ; sh:hasValue 21 ; sh:minCount 1 ; sh:maxCount 1 ] .
+
+io:PerspectiveShape a sh:NodeShape ;
+    sh:targetClass io:Perspective ;
+    sh:property [ sh:path rdfs:label ; sh:languageIn ( "es" ) ; sh:minCount 1 ; sh:maxCount 1 ] .

materialize_ttl.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""Materializa ontology/io_ontology.ttl (hash 84e2fe87...). Preferir generate_ontology.py."""
+from __future__ import annotations
+import base64, hashlib, zlib
+from pathlib import Path
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "ontology" / "io_ontology.ttl"
+EXPECTED = "84e2fe878fcf4a41b7ad364fb6f22e28e16db9132b7e2de89d36de55deeb87ba"
+PAYLOAD = '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'
+
+def main() -> None:
+    data = zlib.decompress(base64.b64decode(PAYLOAD))
+    digest = hashlib.sha256(data).hexdigest()
+    if digest != EXPECTED:
+        raise SystemExit(f"hash mismatch: {digest} != {EXPECTED}")
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_bytes(data)
+    print(f"OK {OUT} ({len(data)} bytes) sha256={digest}")
+
+if __name__ == "__main__":
+    main()

measure_invariance.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python3
+"""Invariancia interna no trivial (con control negativo).
+
+Mide autonomía *y* distingue el grafo canónico de uno corrompido:
+
+1. Auto-regeneración: etiqueta ≡ regla (fase, pos) aplicada al par.
+2. Invariancia bajo índice de tríada.
+3. Reconstrucción desde subconjunto (LOO feature lookup sin etiquetas del held-out).
+4. **Control negativo:** al corromper una arista del grafo, (1) o (3) debe fallar.
+
+Sin el control negativo, un 1.0 podría ser tautología.
+"""
+from __future__ import annotations
+
+import copy
+import csv
+import json
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def parse_node(node_id: str) -> tuple[str, int]:
+    parts = node_id.split("_")
+    return parts[1], int(parts[2][1:])
+
+
+def rule_label(src: str, tgt: str) -> str:
+    sp, spos = parse_node(src)
+    tp, tpos = parse_node(tgt)
+    if sp == tp:
+        return "none"
+    if tpos == 2 - spos:
+        return "mirrorOf"
+    if (spos in (0, 2) and tpos == 1) or (spos == 1 and tpos in (0, 2)):
+        return "creates"
+    return "none"
+
+
+def feature_key(src: str, tgt: str) -> tuple:
+    sp, spos = parse_node(src)
+    tp, tpos = parse_node(tgt)
+    return (sp, spos, tp, tpos)
+
+
+def self_regen_rate(rows: list[dict]) -> float:
+    mism = sum(1 for r in rows if rule_label(r["source"], r["target"]) != r["relation"])
+    return 1.0 - mism / max(len(rows), 1)
+
+
+def triad_invariant(rows: list[dict]) -> bool:
+    by_feat: dict[tuple, set[str]] = defaultdict(set)
+    for r in rows:
+        by_feat[feature_key(r["source"], r["target"])].add(r["relation"])
+    return all(len(v) == 1 for v in by_feat.values())
+
+
+def subset_reconstruction(rows: list[dict]) -> bool:
+    for held in range(1, 14):
+        train: dict[tuple, str] = {}
+        test: list[tuple[tuple, str]] = []
+        for r in rows:
+            key = feature_key(r["source"], r["target"])
+            tid = int(r["triad_index"])
+            if tid == held:
+                test.append((key, r["relation"]))
+            else:
+                train[key] = r["relation"]
+        if any(train.get(k) != lab for k, lab in test):
+            return False
+    return True
+
+
+def corrupt_one_edge(rows: list[dict]) -> list[dict]:
+    """Cambia la etiqueta de la primera arista mirrorOf a none (grafo inválido)."""
+    out = copy.deepcopy(rows)
+    for r in out:
+        if r["relation"] == "mirrorOf":
+            r["relation"] = "none"
+            break
+    return out
+
+
+def main() -> int:
+    rows = list(
+        csv.DictReader(
+            (ROOT / "datasets" / "relation_candidates.csv").open(
+                encoding="utf-8", newline=""
+            )
+        )
+    )
+
+    regen = self_regen_rate(rows)
+    inv = triad_invariant(rows)
+    subset = subset_reconstruction(rows)
+
+    corrupted = corrupt_one_edge(rows)
+    # Tras corrupción: o bien auto-regeneración cae, o el grafo ya no coincide con la regla
+    corrupted_regen = self_regen_rate(corrupted)
+    negative_control_detects = corrupted_regen < 1.0
+
+    autonomy = regen == 1.0 and inv and subset
+    non_trivial = autonomy and negative_control_detects
+
+    report = {
+        "framing": (
+            "Invariancia no trivial: el canónico regenera 1.0; un grafo con una "
+            "arista corrupta debe fallar el control negativo."
+        ),
+        "canonical": {
+            "self_regeneration_rate": round(regen, 6),
+            "triad_index_invariance": inv,
+            "subset_reconstruction": subset,
+            "autonomy_measurable": autonomy,
+        },
+        "negative_control": {
+            "description": "primera arista mirrorOf relabelada a none",
+            "corrupted_self_regeneration_rate": round(corrupted_regen, 6),
+            "detects_corruption": negative_control_detects,
+            "interpretation": (
+                "si detects_corruption es false, la métrica no distingue "
+                "grafo correcto de corrompido (tautología)"
+            ),
+        },
+        "invariance_non_trivial": non_trivial,
+    }
+
+    out = ROOT / "experiments" / "results" / "invariance_metrics.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+    print("Invariancia interna (con control negativo)")
+    print(f"  Auto-regeneración canónica: {regen}")
+    print(f"  Invariancia bajo índice de tríada: {inv}")
+    print(f"  Reconstrucción desde subconjunto: {subset}")
+    print(f"  Control negativo detecta corrupción: {negative_control_detects} (rate={corrupted_regen:.6f})")
+    print(f"  Invariancia no trivial: {non_trivial}")
+    print(f"  Informe: {out}")
+    return 0 if non_trivial else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

migrate_spec.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Aplica migraciones declarativas a data/iom_spec.json.
+
+Las migraciones se registran en el campo `migrations` del propio JSON.
+Este script solo registra y valida; las transformaciones semánticas futuras
+deben implementarse como funciones nombradas en MIGRATION_HANDLERS.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SPEC_PATH = ROOT / "data" / "iom_spec.json"
+
+# Handlers de migración (from_version -> función). Vacío en 1.1.0 porque el
+# cambio fue solo metadatos.
+MIGRATION_HANDLERS: dict[str, callable] = {}
+
+
+def load() -> dict:
+    return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
+
+
+def save(data: dict) -> None:
+    SPEC_PATH.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def list_migrations(data: dict) -> None:
+    migrations = data.get("migrations") or []
+    if not migrations:
+        print("No hay migraciones registradas.")
+        return
+    for m in migrations:
+        print(f"  {m['from_version']} -> {m['to_version']}: {m['description']} ({m.get('date', '?')})")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Gestión de migraciones de iom_spec.json")
+    parser.add_argument("--list", action="store_true", help="Listar migraciones registradas")
+    parser.add_argument("--check", action="store_true", help="Verificar que spec_version es coherente")
+    args = parser.parse_args()
+
+    data = load()
+    if args.list:
+        print(f"spec_version actual: {data.get('spec_version')}")
+        list_migrations(data)
+        return
+    if args.check:
+        version = data.get("spec_version")
+        migrations = data.get("migrations") or []
+        if migrations:
+            last = migrations[-1]["to_version"]
+            if last != version:
+                raise SystemExit(f"Inconsistencia: último to_version={last} pero spec_version={version}")
+        print(f"OK: spec_version={version} coherente con historial de migraciones")
+        return
+    parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

package_reproducible.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Empaqueta los artefactos reproducibles, excluyendo cachés y el checkout Git."""
+from pathlib import Path
+from zipfile import ZIP_DEFLATED, ZipFile
+
+ROOT = Path(__file__).resolve().parents[1]
+INCLUDE = [
+    "README.md", "AUDITORIA.md", "EXPERIMENTOS.md", "REPRODUCCION.md", "paper.md", "LICENSE", "MANIFEST.sha256",
+    "IOM.lean", "IOM", "lakefile.lean", "lake-manifest.json", "lean-toolchain", "requirements.txt", "requirements-lock.txt",
+    "data", "datasets", "experiments/config.json", "experiments/optional", "experiments/results",
+    "experiments/logs", "ontology", "scripts", "tests", ".github/workflows/ci.yml",
+]
+
+def files_in(path: Path):
+    if path.is_file():
+        yield path
+    elif path.is_dir():
+        for p in path.rglob("*"):
+            if p.is_file() and ".git" not in p.parts:
+                yield p
+
+def main() -> None:
+    out = ROOT / "iom-reproducible.zip"
+    with ZipFile(out, "w", ZIP_DEFLATED) as zf:
+        for rel in INCLUDE:
+            for p in files_in(ROOT / rel):
+                zf.write(p, p.relative_to(ROOT).as_posix())
+    print(f"Escrito {out}")
+
+if __name__ == "__main__":
+    main()

paper.md

@@ -0,0 +1,41 @@
+# IOM — construcción formal de la unidad informativa
+
+Este informe describe el repositorio IOM como una **construcción formal de
+unidad informativa**: estructura autocontenida de distinciones, relaciones,
+integración y transformación, verificable desde `data/iom_spec.json` (punto
+fijo, Lean, SHACL). La autonomía verificable es el *mecanismo* de constitución
+y validación; anotadores, dominios y learners de recuperación de reglas son
+**encuentro**, no fundamento.
+
+Referencia conceptual: [`docs/DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md`](docs/DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md) · Spec: [`data/iom_spec.json`](data/iom_spec.json) · Jerarquía: [`EXPERIMENTOS.md`](EXPERIMENTOS.md).
+
+## Propósito
+
+La unidad informativa es la mínima estructura autocontenida capaz de conservar una distinción, relacionarla con su opuesto, integrarla en un sistema y transformarse sin perder la trazabilidad de su identidad.
+
+Las 13 tríadas son modos de composición de esa unidad.
+
+## Núcleo (fundamento)
+
+1. Punto fijo: `self_bootstrap.py --passes 2`
+2. SelfGenesis / FormalRules / InformationalUnit: `lake build`
+3. SHACL sobre TTL regenerado
+4. Invariancia no trivial (`measure_invariance.py`)
+
+## Encuentro (no fundamenta)
+
+EXP-E (dominio / Mictlán) y EXP-A (κ) son proyección provisional. Sin
+`ACCESS_LOG`, κ histórico no se declara demostración cerrada.
+
+## Diagnóstico circular (opcional)
+
+PI-HGAT-T y baselines (`experiments/optional/`) recuperan etiquetas que **ya
+están** en (fase, posición). Accuracy 1.0 es tautología informativa, no validez
+del marco en el mundo. PyTorch no es dependencia del núcleo.
+
+## Límite de la afirmación
+
+El repositorio **implementa** una construcción formal de unidad informativa.
+No afirma por sí solo una unidad absoluta independiente del entorno de
+ejecución. La validez interna se mide por derivabilidad y trazabilidad desde
+la especificación canónica.

pi_hgat_t.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""PI-HGAT-T y ablaciones: evaluación empírica estructural de tríadas IOM.
+
+PI-HGAT-T es la implementación de referencia del clasificador de relaciones del marco.
+Las etiquetas de clase proceden de reglas RDF/SHACL explícitas y se evalúan bajo
+leave-one-triad-out, ablaciones y baselines.
+"""
+from __future__ import annotations
+
+import csv
+import json
+import platform
+import random
+import time
+from pathlib import Path
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+ROOT = Path(__file__).resolve().parents[2]
+CONFIG = json.loads((ROOT / "experiments" / "config.json").read_text(encoding="utf-8"))
+CLASSES = ("none", "mirrorOf", "creates")
+CLASS_ID = {name: i for i, name in enumerate(CLASSES)}
+
+
+def seed_everything(seed: int) -> None:
+    random.seed(seed)
+    torch.manual_seed(seed)
+    torch.use_deterministic_algorithms(True)
+    torch.set_num_threads(1)
+
+
+def features_for_node(node_id: str) -> list[float]:
+    """Codifica solo la fase y posición, sin etiqueta léxica ni número de tríada."""
+    parts = node_id.split("_")
+    phase, position = parts[1], int(parts[2][1:])
+    return [float(phase == "adv"), float(phase == "ret"),
+            float(position == 0), float(position == 1), float(position == 2)]
+
+
+def parse_pair_index(node_id: str) -> int:
+    phase = node_id.split("_")[1]
+    position = int(node_id.split("_")[2][1:])
+    return position if phase == "adv" else 3 + position
+
+
+def read_data():
+    nodes: dict[int, list[list[float]]] = {i: [None] * 6 for i in range(1, 14)}
+    with (ROOT / "datasets" / "triad_nodes.csv").open(encoding="utf-8", newline="") as handle:
+        for row in csv.DictReader(handle):
+            nodes[int(row["triad_index"])][parse_pair_index(row["node_id"])] = features_for_node(row["node_id"])
+    pairs: dict[int, list[tuple[int, int, int]]] = {i: [] for i in range(1, 14)}
+    with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as handle:
+        for row in csv.DictReader(handle):
+            pairs[int(row["triad_index"])].append((parse_pair_index(row["source"]),
+                                                     parse_pair_index(row["target"]),
+                                                     CLASS_ID[row["relation"]]))
+    assert all(all(feature is not None for feature in group) for group in nodes.values())
+    return {k: torch.tensor(v, dtype=torch.float32) for k, v in nodes.items()}, pairs
+
+
+class TypedGraphAttention(nn.Module):
+    """Atención multi-cabeza sobre los seis nodos de las dos fases de cada tríada."""
+    def __init__(self, dim: int, heads: int):
+        super().__init__()
+        assert dim % heads == 0
+        self.dim, self.heads, self.head_dim = dim, heads, dim // heads
+        self.query = nn.Linear(dim, dim, bias=False)
+        self.key = nn.Linear(dim, dim, bias=False)
+        self.value = nn.Linear(dim, dim, bias=False)
+        self.out = nn.Linear(dim, dim)
+        self.norm = nn.LayerNorm(dim)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        batch, n_nodes, _ = x.shape
+        def split(layer):
+            return layer(x).view(batch, n_nodes, self.heads, self.head_dim).transpose(1, 2)
+        q, k, v = split(self.query), split(self.key), split(self.value)
+        scores = torch.matmul(q, k.transpose(-2, -1)) / (self.head_dim ** 0.5)
+        weights = torch.softmax(scores, dim=-1)
+        attended = torch.matmul(weights, v).transpose(1, 2).contiguous().view(batch, n_nodes, self.dim)
+        return self.norm(x + self.out(attended))
+
+
+class PIHGATT(nn.Module):
+    """Codificador GAT de dos capas y decodificador para relación dirigida."""
+    def __init__(self, dim: int = 32, heads: int = 4, input_dim: int = 5):
+        super().__init__()
+        self.encoder = nn.Linear(input_dim, dim)
+        self.attention1 = TypedGraphAttention(dim, heads)
+        self.attention2 = TypedGraphAttention(dim, heads)
+        self.decoder = nn.Sequential(nn.Linear(dim * 3, dim), nn.GELU(), nn.Linear(dim, len(CLASSES)))
+
+    def encode(self, x: torch.Tensor) -> torch.Tensor:
+        h = F.gelu(self.encoder(x))
+        h = F.gelu(self.attention1(h))
+        return self.attention2(h)
+
+    def forward(self, x: torch.Tensor, pairs: torch.Tensor) -> torch.Tensor:
+        h = self.encode(x)
+        src, dst = pairs[:, 0], pairs[:, 1]
+        left, right = h[:, src, :], h[:, dst, :]
+        return self.decoder(torch.cat((left, right, left * right), dim=-1))
+
+
+def admissible_relation(label: str, source: int, target: int) -> bool:
+    """Predicados de validez alineados con io:mirrorOf / io:creates en SHACL."""
+    source_phase, source_pos = (0 if source < 3 else 1), source % 3
+    target_phase, target_pos = (0 if target < 3 else 1), target % 3
+    if source_phase == target_phase:
+        return False
+    if label == "mirrorOf":
+        return target_pos == 2 - source_pos
+    if label == "creates":
+        return (source_pos in (0, 2) and target_pos == 1) or (source_pos == 1 and target_pos in (0, 2))
+    return True
+
+
+def scores(gold: list[int], predicted: list[int]) -> dict:
+    matrix = [[0] * len(CLASSES) for _ in CLASSES]
+    for actual, guess in zip(gold, predicted):
+        matrix[actual][guess] += 1
+    per_class, f1_values = {}, []
+    for idx, name in enumerate(CLASSES):
+        tp = matrix[idx][idx]
+        fp = sum(matrix[row][idx] for row in range(len(CLASSES)) if row != idx)
+        fn = sum(matrix[idx][col] for col in range(len(CLASSES)) if col != idx)
+        precision = tp / (tp + fp) if tp + fp else 0.0
+        recall = tp / (tp + fn) if tp + fn else 0.0
+        f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
+        per_class[name] = {"precision": precision, "recall": recall, "f1": f1, "support": tp + fn}
+        f1_values.append(f1)
+    accuracy = sum(a == b for a, b in zip(gold, predicted)) / len(gold)
+    return {"accuracy": accuracy, "macro_f1": sum(f1_values) / len(f1_values),
+            "per_class": per_class, "confusion_matrix_rows_gold_cols_predicted": matrix}
+
+
+def run_variant(name: str, columns: list[int], nodes, relations, cfg: dict) -> dict:
+    all_gold, all_pred, predicted_edges, fold_results = [], [], [], []
+    pair_indices = torch.tensor([(s, t) for s in range(6) for t in range(6) if s != t], dtype=torch.long)
+    for held_out in sorted(nodes):
+        seed_everything(int(cfg["seed"]) + held_out - 1)
+        train_ids = [i for i in nodes if i != held_out]
+        x_train = torch.stack([nodes[i][:, columns] for i in train_ids])
+        y_train = torch.tensor([label for i in train_ids for _s, _t, label in relations[i]], dtype=torch.long)
+        model = PIHGATT(int(cfg["hidden_dim"]), int(cfg["attention_heads"]), input_dim=len(columns))
+        counts = torch.bincount(y_train, minlength=len(CLASSES)).float()
+        class_weights = (len(y_train) / (len(CLASSES) * counts.clamp_min(1))).float()
+        optimizer = torch.optim.AdamW(model.parameters(), lr=float(cfg["learning_rate"]),
+                                      weight_decay=float(cfg["weight_decay"]))
+        model.train()
+        for _epoch in range(int(cfg["epochs"])):
+            optimizer.zero_grad(set_to_none=True)
+            logits = model(x_train, pair_indices).reshape(-1, len(CLASSES))
+            loss = F.cross_entropy(logits, y_train, weight=class_weights)
+            loss.backward()
+            optimizer.step()
+        model.eval()
+        with torch.no_grad():
+            predicted = model(nodes[held_out][:, columns].unsqueeze(0), pair_indices).argmax(dim=-1).reshape(-1).tolist()
+        gold_map = {(src, dst): label for src, dst, label in relations[held_out]}
+        gold = [gold_map[(src, dst)] for src, dst in pair_indices.tolist()]
+        all_gold.extend(gold)
+        all_pred.extend(predicted)
+        for (src, dst), label_id in zip(pair_indices.tolist(), predicted):
+            if label_id:
+                label = CLASSES[label_id]
+                predicted_edges.append((held_out, src, dst, label))
+        fold_results.append({"held_out_triad": held_out,
+                             "accuracy": sum(a == b for a, b in zip(gold, predicted)) / len(gold)})
+    report = scores(all_gold, all_pred)
+    by_class = report["per_class"]
+    compliant = sum(admissible_relation(label, source, target)
+                    for _triad, source, target, label in predicted_edges)
+    edge_compliance = compliant / len(predicted_edges) if predicted_edges else 1.0
+    metrics = {
+        "candidate_relation_accuracy": {"value": report["accuracy"], "property": "io:mirrorOf / io:creates; exact three-class labels"},
+        "relation_macro_f1": {"value": report["macro_f1"], "property": "balanced F1 for none, io:mirrorOf and io:creates"},
+        "mirrorOf_precision": {"value": by_class["mirrorOf"]["precision"], "property": "SHACL: reciprocal mirror; same triad; opposite phase; position reflection"},
+        "mirrorOf_recall": {"value": by_class["mirrorOf"]["recall"], "property": "completeness of the io:mirrorOf edge set"},
+        "mirrorOf_f1": {"value": by_class["mirrorOf"]["f1"], "property": "precision/recall of io:mirrorOf"},
+        "creates_precision": {"value": by_class["creates"]["precision"], "property": "SHACL: same triad, opposite phase, four allowed position rules"},
+        "creates_recall": {"value": by_class["creates"]["recall"], "property": "completeness of four creation rules"},
+        "creates_f1": {"value": by_class["creates"]["f1"], "property": "precision/recall of io:creates"},
+        "predicted_edge_rule_conformance": {"value": edge_compliance, "property": "SHACL phase/triad/position rules for predicted mirrorOf and creates", "predicted_edges": len(predicted_edges)},
+    }
+    return {"variant": name, "feature_columns": columns, "metrics": metrics,
+            "per_class": by_class, "confusion_matrix_rows_gold_cols_predicted": report["confusion_matrix_rows_gold_cols_predicted"],
+            "folds": fold_results}
+
+
+def run() -> dict:
+    cfg = CONFIG
+    nodes, relations = read_data()
+    candidates = [
+        ("PI-HGAT-T_full_phase_and_position", [0, 1, 2, 3, 4]),
+        ("ablation_without_phase", [2, 3, 4]),
+        ("ablation_without_position", [0, 1]),
+    ]
+    start = time.time()
+    variants = [run_variant(name, columns, nodes, relations, cfg) for name, columns in candidates]
+    primary = variants[0]
+    gold_labels = [label for triad in relations.values() for _src, _dst, label in triad]
+    dataset = {"triads": 13, "nodes": 78, "directed_relation_candidates": len(gold_labels),
+               "gold_mirrorOf_edges": sum(label == CLASS_ID["mirrorOf"] for label in gold_labels),
+               "gold_creates_edges": sum(label == CLASS_ID["creates"] for label in gold_labels),
+               "gold_none_pairs": sum(label == CLASS_ID["none"] for label in gold_labels)}
+    report = {
+        "model": cfg["model_id"],
+        "model_definition": cfg["model_definition"],
+        "dataset": dataset,
+        "validation": "13-fold leave-one-triad-out; no lexical labels or triad index as model features",
+        "primary_metrics": primary["metrics"],
+        "experiments": variants,
+        "threshold_policy": "Empirical evaluation against deterministic RDF/SHACL target properties. Reference criterion is exact reconstruction (1.0); observed model and ablation scores quantify recoverability under leave-one-triad-out and are reported with confusion matrices and fold variability.",
+        "software": {"python": platform.python_version(), "pytorch": torch.__version__, "platform": platform.platform()},
+        "configuration": cfg,
+    }
+    results_path = ROOT / "experiments" / "results" / "pi_hgat_t_metrics.json"
+    results_path.parent.mkdir(parents=True, exist_ok=True)
+    results_path.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    log_path = ROOT / "experiments" / "logs" / "pi_hgat_t.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["PI-HGAT-T / ablation suite", f"Python={platform.python_version()} PyTorch={torch.__version__}",
+             f"seed={cfg['seed']} folds=13 epochs={cfg['epochs']} candidates={len(gold_labels)}"]
+    for variant in variants:
+        m = variant["metrics"]
+        lines.append(f"{variant['variant']}: accuracy={m['candidate_relation_accuracy']['value']:.6f} macro_f1={m['relation_macro_f1']['value']:.6f} "
+                     f"mirrorOf_f1={m['mirrorOf_f1']['value']:.6f} creates_f1={m['creates_f1']['value']:.6f} "
+                     f"rule_conformance={m['predicted_edge_rule_conformance']['value']:.6f}")
+    lines.append(f"runtime_seconds={time.time() - start:.3f}")
+    log_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    print("\n".join(lines))
+    print(f"Resultados: {results_path}")
+    return report
+
+
+if __name__ == "__main__":
+    run()

plantilla_dominio.csv

@@ -0,0 +1,9 @@
+external_id,external_label,mapped_node_id,perspective,phase,position,relation_candidate,notes
+# Obligatorio: external_id, external_label
+# mapped_node_id: uno de los 78 node_id de datasets/triad_nodes.csv (ej. T01_adv_P0)
+# perspective: Ind | D | Tot | Evol | Invol
+# phase: adv | ret
+# position: left | center | right
+# relation_candidate: none | mirrorOf | creates (opcional; se valida contra reglas)
+# notes: texto libre
+ejemplo_01,mi_concepto,T01_adv_P0,Ind,adv,left,none,"Descripción breve del mapeo"

relation_candidates.csv

@@ -0,0 +1,391 @@
+triad_index,source,target,relation
+1,T01_adv_P0,T01_adv_P1,none
+1,T01_adv_P0,T01_adv_P2,none
+1,T01_adv_P0,T01_ret_P0,none
+1,T01_adv_P0,T01_ret_P1,creates
+1,T01_adv_P0,T01_ret_P2,mirrorOf
+1,T01_adv_P1,T01_adv_P0,none
+1,T01_adv_P1,T01_adv_P2,none
+1,T01_adv_P1,T01_ret_P0,creates
+1,T01_adv_P1,T01_ret_P1,mirrorOf
+1,T01_adv_P1,T01_ret_P2,creates
+1,T01_adv_P2,T01_adv_P0,none
+1,T01_adv_P2,T01_adv_P1,none
+1,T01_adv_P2,T01_ret_P0,mirrorOf
+1,T01_adv_P2,T01_ret_P1,creates
+1,T01_adv_P2,T01_ret_P2,none
+1,T01_ret_P0,T01_adv_P0,none
+1,T01_ret_P0,T01_adv_P1,creates
+1,T01_ret_P0,T01_adv_P2,mirrorOf
+1,T01_ret_P0,T01_ret_P1,none
+1,T01_ret_P0,T01_ret_P2,none
+1,T01_ret_P1,T01_adv_P0,creates
+1,T01_ret_P1,T01_adv_P1,mirrorOf
+1,T01_ret_P1,T01_adv_P2,creates
+1,T01_ret_P1,T01_ret_P0,none
+1,T01_ret_P1,T01_ret_P2,none
+1,T01_ret_P2,T01_adv_P0,mirrorOf
+1,T01_ret_P2,T01_adv_P1,creates
+1,T01_ret_P2,T01_adv_P2,none
+1,T01_ret_P2,T01_ret_P0,none
+1,T01_ret_P2,T01_ret_P1,none
+2,T02_adv_P0,T02_adv_P1,none
+2,T02_adv_P0,T02_adv_P2,none
+2,T02_adv_P0,T02_ret_P0,none
+2,T02_adv_P0,T02_ret_P1,creates
+2,T02_adv_P0,T02_ret_P2,mirrorOf
+2,T02_adv_P1,T02_adv_P0,none
+2,T02_adv_P1,T02_adv_P2,none
+2,T02_adv_P1,T02_ret_P0,creates
+2,T02_adv_P1,T02_ret_P1,mirrorOf
+2,T02_adv_P1,T02_ret_P2,creates
+2,T02_adv_P2,T02_adv_P0,none
+2,T02_adv_P2,T02_adv_P1,none
+2,T02_adv_P2,T02_ret_P0,mirrorOf
+2,T02_adv_P2,T02_ret_P1,creates
+2,T02_adv_P2,T02_ret_P2,none
+2,T02_ret_P0,T02_adv_P0,none
+2,T02_ret_P0,T02_adv_P1,creates
+2,T02_ret_P0,T02_adv_P2,mirrorOf
+2,T02_ret_P0,T02_ret_P1,none
+2,T02_ret_P0,T02_ret_P2,none
+2,T02_ret_P1,T02_adv_P0,creates
+2,T02_ret_P1,T02_adv_P1,mirrorOf
+2,T02_ret_P1,T02_adv_P2,creates
+2,T02_ret_P1,T02_ret_P0,none
+2,T02_ret_P1,T02_ret_P2,none
+2,T02_ret_P2,T02_adv_P0,mirrorOf
+2,T02_ret_P2,T02_adv_P1,creates
+2,T02_ret_P2,T02_adv_P2,none
+2,T02_ret_P2,T02_ret_P0,none
+2,T02_ret_P2,T02_ret_P1,none
+3,T03_adv_P0,T03_adv_P1,none
+3,T03_adv_P0,T03_adv_P2,none
+3,T03_adv_P0,T03_ret_P0,none
+3,T03_adv_P0,T03_ret_P1,creates
+3,T03_adv_P0,T03_ret_P2,mirrorOf
+3,T03_adv_P1,T03_adv_P0,none
+3,T03_adv_P1,T03_adv_P2,none
+3,T03_adv_P1,T03_ret_P0,creates
+3,T03_adv_P1,T03_ret_P1,mirrorOf
+3,T03_adv_P1,T03_ret_P2,creates
+3,T03_adv_P2,T03_adv_P0,none
+3,T03_adv_P2,T03_adv_P1,none
+3,T03_adv_P2,T03_ret_P0,mirrorOf
+3,T03_adv_P2,T03_ret_P1,creates
+3,T03_adv_P2,T03_ret_P2,none
+3,T03_ret_P0,T03_adv_P0,none
+3,T03_ret_P0,T03_adv_P1,creates
+3,T03_ret_P0,T03_adv_P2,mirrorOf
+3,T03_ret_P0,T03_ret_P1,none
+3,T03_ret_P0,T03_ret_P2,none
+3,T03_ret_P1,T03_adv_P0,creates
+3,T03_ret_P1,T03_adv_P1,mirrorOf
+3,T03_ret_P1,T03_adv_P2,creates
+3,T03_ret_P1,T03_ret_P0,none
+3,T03_ret_P1,T03_ret_P2,none
+3,T03_ret_P2,T03_adv_P0,mirrorOf
+3,T03_ret_P2,T03_adv_P1,creates
+3,T03_ret_P2,T03_adv_P2,none
+3,T03_ret_P2,T03_ret_P0,none
+3,T03_ret_P2,T03_ret_P1,none
+4,T04_adv_P0,T04_adv_P1,none
+4,T04_adv_P0,T04_adv_P2,none
+4,T04_adv_P0,T04_ret_P0,none
+4,T04_adv_P0,T04_ret_P1,creates
+4,T04_adv_P0,T04_ret_P2,mirrorOf
+4,T04_adv_P1,T04_adv_P0,none
+4,T04_adv_P1,T04_adv_P2,none
+4,T04_adv_P1,T04_ret_P0,creates
+4,T04_adv_P1,T04_ret_P1,mirrorOf
+4,T04_adv_P1,T04_ret_P2,creates
+4,T04_adv_P2,T04_adv_P0,none
+4,T04_adv_P2,T04_adv_P1,none
+4,T04_adv_P2,T04_ret_P0,mirrorOf
+4,T04_adv_P2,T04_ret_P1,creates
+4,T04_adv_P2,T04_ret_P2,none
+4,T04_ret_P0,T04_adv_P0,none
+4,T04_ret_P0,T04_adv_P1,creates
+4,T04_ret_P0,T04_adv_P2,mirrorOf
+4,T04_ret_P0,T04_ret_P1,none
+4,T04_ret_P0,T04_ret_P2,none
+4,T04_ret_P1,T04_adv_P0,creates
+4,T04_ret_P1,T04_adv_P1,mirrorOf
+4,T04_ret_P1,T04_adv_P2,creates
+4,T04_ret_P1,T04_ret_P0,none
+4,T04_ret_P1,T04_ret_P2,none
+4,T04_ret_P2,T04_adv_P0,mirrorOf
+4,T04_ret_P2,T04_adv_P1,creates
+4,T04_ret_P2,T04_adv_P2,none
+4,T04_ret_P2,T04_ret_P0,none
+4,T04_ret_P2,T04_ret_P1,none
+5,T05_adv_P0,T05_adv_P1,none
+5,T05_adv_P0,T05_adv_P2,none
+5,T05_adv_P0,T05_ret_P0,none
+5,T05_adv_P0,T05_ret_P1,creates
+5,T05_adv_P0,T05_ret_P2,mirrorOf
+5,T05_adv_P1,T05_adv_P0,none
+5,T05_adv_P1,T05_adv_P2,none
+5,T05_adv_P1,T05_ret_P0,creates
+5,T05_adv_P1,T05_ret_P1,mirrorOf
+5,T05_adv_P1,T05_ret_P2,creates
+5,T05_adv_P2,T05_adv_P0,none
+5,T05_adv_P2,T05_adv_P1,none
+5,T05_adv_P2,T05_ret_P0,mirrorOf
+5,T05_adv_P2,T05_ret_P1,creates
+5,T05_adv_P2,T05_ret_P2,none
+5,T05_ret_P0,T05_adv_P0,none
+5,T05_ret_P0,T05_adv_P1,creates
+5,T05_ret_P0,T05_adv_P2,mirrorOf
+5,T05_ret_P0,T05_ret_P1,none
+5,T05_ret_P0,T05_ret_P2,none
+5,T05_ret_P1,T05_adv_P0,creates
+5,T05_ret_P1,T05_adv_P1,mirrorOf
+5,T05_ret_P1,T05_adv_P2,creates
+5,T05_ret_P1,T05_ret_P0,none
+5,T05_ret_P1,T05_ret_P2,none
+5,T05_ret_P2,T05_adv_P0,mirrorOf
+5,T05_ret_P2,T05_adv_P1,creates
+5,T05_ret_P2,T05_adv_P2,none
+5,T05_ret_P2,T05_ret_P0,none
+5,T05_ret_P2,T05_ret_P1,none
+6,T06_adv_P0,T06_adv_P1,none
+6,T06_adv_P0,T06_adv_P2,none
+6,T06_adv_P0,T06_ret_P0,none
+6,T06_adv_P0,T06_ret_P1,creates
+6,T06_adv_P0,T06_ret_P2,mirrorOf
+6,T06_adv_P1,T06_adv_P0,none
+6,T06_adv_P1,T06_adv_P2,none
+6,T06_adv_P1,T06_ret_P0,creates
+6,T06_adv_P1,T06_ret_P1,mirrorOf
+6,T06_adv_P1,T06_ret_P2,creates
+6,T06_adv_P2,T06_adv_P0,none
+6,T06_adv_P2,T06_adv_P1,none
+6,T06_adv_P2,T06_ret_P0,mirrorOf
+6,T06_adv_P2,T06_ret_P1,creates
+6,T06_adv_P2,T06_ret_P2,none
+6,T06_ret_P0,T06_adv_P0,none
+6,T06_ret_P0,T06_adv_P1,creates
+6,T06_ret_P0,T06_adv_P2,mirrorOf
+6,T06_ret_P0,T06_ret_P1,none
+6,T06_ret_P0,T06_ret_P2,none
+6,T06_ret_P1,T06_adv_P0,creates
+6,T06_ret_P1,T06_adv_P1,mirrorOf
+6,T06_ret_P1,T06_adv_P2,creates
+6,T06_ret_P1,T06_ret_P0,none
+6,T06_ret_P1,T06_ret_P2,none
+6,T06_ret_P2,T06_adv_P0,mirrorOf
+6,T06_ret_P2,T06_adv_P1,creates
+6,T06_ret_P2,T06_adv_P2,none
+6,T06_ret_P2,T06_ret_P0,none
+6,T06_ret_P2,T06_ret_P1,none
+7,T07_adv_P0,T07_adv_P1,none
+7,T07_adv_P0,T07_adv_P2,none
+7,T07_adv_P0,T07_ret_P0,none
+7,T07_adv_P0,T07_ret_P1,creates
+7,T07_adv_P0,T07_ret_P2,mirrorOf
+7,T07_adv_P1,T07_adv_P0,none
+7,T07_adv_P1,T07_adv_P2,none
+7,T07_adv_P1,T07_ret_P0,creates
+7,T07_adv_P1,T07_ret_P1,mirrorOf
+7,T07_adv_P1,T07_ret_P2,creates
+7,T07_adv_P2,T07_adv_P0,none
+7,T07_adv_P2,T07_adv_P1,none
+7,T07_adv_P2,T07_ret_P0,mirrorOf
+7,T07_adv_P2,T07_ret_P1,creates
+7,T07_adv_P2,T07_ret_P2,none
+7,T07_ret_P0,T07_adv_P0,none
+7,T07_ret_P0,T07_adv_P1,creates
+7,T07_ret_P0,T07_adv_P2,mirrorOf
+7,T07_ret_P0,T07_ret_P1,none
+7,T07_ret_P0,T07_ret_P2,none
+7,T07_ret_P1,T07_adv_P0,creates
+7,T07_ret_P1,T07_adv_P1,mirrorOf
+7,T07_ret_P1,T07_adv_P2,creates
+7,T07_ret_P1,T07_ret_P0,none
+7,T07_ret_P1,T07_ret_P2,none
+7,T07_ret_P2,T07_adv_P0,mirrorOf
+7,T07_ret_P2,T07_adv_P1,creates
+7,T07_ret_P2,T07_adv_P2,none
+7,T07_ret_P2,T07_ret_P0,none
+7,T07_ret_P2,T07_ret_P1,none
+8,T08_adv_P0,T08_adv_P1,none
+8,T08_adv_P0,T08_adv_P2,none
+8,T08_adv_P0,T08_ret_P0,none
+8,T08_adv_P0,T08_ret_P1,creates
+8,T08_adv_P0,T08_ret_P2,mirrorOf
+8,T08_adv_P1,T08_adv_P0,none
+8,T08_adv_P1,T08_adv_P2,none
+8,T08_adv_P1,T08_ret_P0,creates
+8,T08_adv_P1,T08_ret_P1,mirrorOf
+8,T08_adv_P1,T08_ret_P2,creates
+8,T08_adv_P2,T08_adv_P0,none
+8,T08_adv_P2,T08_adv_P1,none
+8,T08_adv_P2,T08_ret_P0,mirrorOf
+8,T08_adv_P2,T08_ret_P1,creates
+8,T08_adv_P2,T08_ret_P2,none
+8,T08_ret_P0,T08_adv_P0,none
+8,T08_ret_P0,T08_adv_P1,creates
+8,T08_ret_P0,T08_adv_P2,mirrorOf
+8,T08_ret_P0,T08_ret_P1,none
+8,T08_ret_P0,T08_ret_P2,none
+8,T08_ret_P1,T08_adv_P0,creates
+8,T08_ret_P1,T08_adv_P1,mirrorOf
+8,T08_ret_P1,T08_adv_P2,creates
+8,T08_ret_P1,T08_ret_P0,none
+8,T08_ret_P1,T08_ret_P2,none
+8,T08_ret_P2,T08_adv_P0,mirrorOf
+8,T08_ret_P2,T08_adv_P1,creates
+8,T08_ret_P2,T08_adv_P2,none
+8,T08_ret_P2,T08_ret_P0,none
+8,T08_ret_P2,T08_ret_P1,none
+9,T09_adv_P0,T09_adv_P1,none
+9,T09_adv_P0,T09_adv_P2,none
+9,T09_adv_P0,T09_ret_P0,none
+9,T09_adv_P0,T09_ret_P1,creates
+9,T09_adv_P0,T09_ret_P2,mirrorOf
+9,T09_adv_P1,T09_adv_P0,none
+9,T09_adv_P1,T09_adv_P2,none
+9,T09_adv_P1,T09_ret_P0,creates
+9,T09_adv_P1,T09_ret_P1,mirrorOf
+9,T09_adv_P1,T09_ret_P2,creates
+9,T09_adv_P2,T09_adv_P0,none
+9,T09_adv_P2,T09_adv_P1,none
+9,T09_adv_P2,T09_ret_P0,mirrorOf
+9,T09_adv_P2,T09_ret_P1,creates
+9,T09_adv_P2,T09_ret_P2,none
+9,T09_ret_P0,T09_adv_P0,none
+9,T09_ret_P0,T09_adv_P1,creates
+9,T09_ret_P0,T09_adv_P2,mirrorOf
+9,T09_ret_P0,T09_ret_P1,none
+9,T09_ret_P0,T09_ret_P2,none
+9,T09_ret_P1,T09_adv_P0,creates
+9,T09_ret_P1,T09_adv_P1,mirrorOf
+9,T09_ret_P1,T09_adv_P2,creates
+9,T09_ret_P1,T09_ret_P0,none
+9,T09_ret_P1,T09_ret_P2,none
+9,T09_ret_P2,T09_adv_P0,mirrorOf
+9,T09_ret_P2,T09_adv_P1,creates
+9,T09_ret_P2,T09_adv_P2,none
+9,T09_ret_P2,T09_ret_P0,none
+9,T09_ret_P2,T09_ret_P1,none
+10,T10_adv_P0,T10_adv_P1,none
+10,T10_adv_P0,T10_adv_P2,none
+10,T10_adv_P0,T10_ret_P0,none
+10,T10_adv_P0,T10_ret_P1,creates
+10,T10_adv_P0,T10_ret_P2,mirrorOf
+10,T10_adv_P1,T10_adv_P0,none
+10,T10_adv_P1,T10_adv_P2,none
+10,T10_adv_P1,T10_ret_P0,creates
+10,T10_adv_P1,T10_ret_P1,mirrorOf
+10,T10_adv_P1,T10_ret_P2,creates
+10,T10_adv_P2,T10_adv_P0,none
+10,T10_adv_P2,T10_adv_P1,none
+10,T10_adv_P2,T10_ret_P0,mirrorOf
+10,T10_adv_P2,T10_ret_P1,creates
+10,T10_adv_P2,T10_ret_P2,none
+10,T10_ret_P0,T10_adv_P0,none
+10,T10_ret_P0,T10_adv_P1,creates
+10,T10_ret_P0,T10_adv_P2,mirrorOf
+10,T10_ret_P0,T10_ret_P1,none
+10,T10_ret_P0,T10_ret_P2,none
+10,T10_ret_P1,T10_adv_P0,creates
+10,T10_ret_P1,T10_adv_P1,mirrorOf
+10,T10_ret_P1,T10_adv_P2,creates
+10,T10_ret_P1,T10_ret_P0,none
+10,T10_ret_P1,T10_ret_P2,none
+10,T10_ret_P2,T10_adv_P0,mirrorOf
+10,T10_ret_P2,T10_adv_P1,creates
+10,T10_ret_P2,T10_adv_P2,none
+10,T10_ret_P2,T10_ret_P0,none
+10,T10_ret_P2,T10_ret_P1,none
+11,T11_adv_P0,T11_adv_P1,none
+11,T11_adv_P0,T11_adv_P2,none
+11,T11_adv_P0,T11_ret_P0,none
+11,T11_adv_P0,T11_ret_P1,creates
+11,T11_adv_P0,T11_ret_P2,mirrorOf
+11,T11_adv_P1,T11_adv_P0,none
+11,T11_adv_P1,T11_adv_P2,none
+11,T11_adv_P1,T11_ret_P0,creates
+11,T11_adv_P1,T11_ret_P1,mirrorOf
+11,T11_adv_P1,T11_ret_P2,creates
+11,T11_adv_P2,T11_adv_P0,none
+11,T11_adv_P2,T11_adv_P1,none
+11,T11_adv_P2,T11_ret_P0,mirrorOf
+11,T11_adv_P2,T11_ret_P1,creates
+11,T11_adv_P2,T11_ret_P2,none
+11,T11_ret_P0,T11_adv_P0,none
+11,T11_ret_P0,T11_adv_P1,creates
+11,T11_ret_P0,T11_adv_P2,mirrorOf
+11,T11_ret_P0,T11_ret_P1,none
+11,T11_ret_P0,T11_ret_P2,none
+11,T11_ret_P1,T11_adv_P0,creates
+11,T11_ret_P1,T11_adv_P1,mirrorOf
+11,T11_ret_P1,T11_adv_P2,creates
+11,T11_ret_P1,T11_ret_P0,none
+11,T11_ret_P1,T11_ret_P2,none
+11,T11_ret_P2,T11_adv_P0,mirrorOf
+11,T11_ret_P2,T11_adv_P1,creates
+11,T11_ret_P2,T11_adv_P2,none
+11,T11_ret_P2,T11_ret_P0,none
+11,T11_ret_P2,T11_ret_P1,none
+12,T12_adv_P0,T12_adv_P1,none
+12,T12_adv_P0,T12_adv_P2,none
+12,T12_adv_P0,T12_ret_P0,none
+12,T12_adv_P0,T12_ret_P1,creates
+12,T12_adv_P0,T12_ret_P2,mirrorOf
+12,T12_adv_P1,T12_adv_P0,none
+12,T12_adv_P1,T12_adv_P2,none
+12,T12_adv_P1,T12_ret_P0,creates
+12,T12_adv_P1,T12_ret_P1,mirrorOf
+12,T12_adv_P1,T12_ret_P2,creates
+12,T12_adv_P2,T12_adv_P0,none
+12,T12_adv_P2,T12_adv_P1,none
+12,T12_adv_P2,T12_ret_P0,mirrorOf
+12,T12_adv_P2,T12_ret_P1,creates
+12,T12_adv_P2,T12_ret_P2,none
+12,T12_ret_P0,T12_adv_P0,none
+12,T12_ret_P0,T12_adv_P1,creates
+12,T12_ret_P0,T12_adv_P2,mirrorOf
+12,T12_ret_P0,T12_ret_P1,none
+12,T12_ret_P0,T12_ret_P2,none
+12,T12_ret_P1,T12_adv_P0,creates
+12,T12_ret_P1,T12_adv_P1,mirrorOf
+12,T12_ret_P1,T12_adv_P2,creates
+12,T12_ret_P1,T12_ret_P0,none
+12,T12_ret_P1,T12_ret_P2,none
+12,T12_ret_P2,T12_adv_P0,mirrorOf
+12,T12_ret_P2,T12_adv_P1,creates
+12,T12_ret_P2,T12_adv_P2,none
+12,T12_ret_P2,T12_ret_P0,none
+12,T12_ret_P2,T12_ret_P1,none
+13,T13_adv_P0,T13_adv_P1,none
+13,T13_adv_P0,T13_adv_P2,none
+13,T13_adv_P0,T13_ret_P0,none
+13,T13_adv_P0,T13_ret_P1,creates
+13,T13_adv_P0,T13_ret_P2,mirrorOf
+13,T13_adv_P1,T13_adv_P0,none
+13,T13_adv_P1,T13_adv_P2,none
+13,T13_adv_P1,T13_ret_P0,creates
+13,T13_adv_P1,T13_ret_P1,mirrorOf
+13,T13_adv_P1,T13_ret_P2,creates
+13,T13_adv_P2,T13_adv_P0,none
+13,T13_adv_P2,T13_adv_P1,none
+13,T13_adv_P2,T13_ret_P0,mirrorOf
+13,T13_adv_P2,T13_ret_P1,creates
+13,T13_adv_P2,T13_ret_P2,none
+13,T13_ret_P0,T13_adv_P0,none
+13,T13_ret_P0,T13_adv_P1,creates
+13,T13_ret_P0,T13_adv_P2,mirrorOf
+13,T13_ret_P0,T13_ret_P1,none
+13,T13_ret_P0,T13_ret_P2,none
+13,T13_ret_P1,T13_adv_P0,creates
+13,T13_ret_P1,T13_adv_P1,mirrorOf
+13,T13_ret_P1,T13_adv_P2,creates
+13,T13_ret_P1,T13_ret_P0,none
+13,T13_ret_P1,T13_ret_P2,none
+13,T13_ret_P2,T13_adv_P0,mirrorOf
+13,T13_ret_P2,T13_adv_P1,creates
+13,T13_ret_P2,T13_adv_P2,none
+13,T13_ret_P2,T13_ret_P0,none
+13,T13_ret_P2,T13_ret_P1,none

requirements-lock.txt

@@ -0,0 +1,25 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+attrs==25.3.0
+filelock==4.0.12
+fsspec==2026.9.0
+html5rdf==1.2.1
+Jinja2==3.1.6
+jsonschema==4.23.0
+jsonschema-specifications==2025.4.1
+MarkupSafe==3.0.4
+mpmath==1.3.0
+networkx==3.7
+numpy==1.26.4
+owlrl==7.1.4
+packaging==26.3
+prettytable==3.18.0
+pyparsing==3.3.3
+pyshacl==0.30.1
+rdflib==7.1.4
+referencing==0.36.2
+rpds-py==0.25.1
+setuptools==84.0.0
+sympy==1.13.1
+torch==2.6.0+cpu
+typing_extensions==4.16.0
+wcwidth==0.9.2

requirements.txt

@@ -0,0 +1,7 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+rdflib==7.1.4
+pyshacl==0.30.1
+owlrl==7.1.4
+numpy==1.26.4
+torch==2.6.0+cpu
+jsonschema==4.23.0

score_independent_eval.py

@@ -0,0 +1,407 @@
+#!/usr/bin/env python3
+"""Scoring post-hoc de evaluación independiente (capa C).
+
+Formato oficial de anotaciones (annotations_template.json):
+
+    {
+      "annotators": ["A1", "A2", "A3"],
+      "status": "pending_human_collection" | "complete",
+      "items": [
+        {
+          "id": "NR01",
+          "annotations": {"A1": "none" | null, ...},
+          "free_text": {"A1": "...", ...}
+        },
+        ...
+      ]
+    }
+
+Reglas estadísticas:
+  - null / ausente ≠ etiqueta "unsure".
+  - Fleiss' kappa exige el **mismo conjunto de anotadores** con respuesta
+    no nula en **todos** los ítems incluidos (k fijo). No se trunca.
+  - Si un ítem tiene un subconjunto distinto de respondentes, se excluye
+    del kappa y se reporta en incomplete/heterogeneous.
+  - "unsure" es una respuesta legítima, no un relleno.
+
+Uso:
+    python scripts/score_independent_eval.py
+    python scripts/score_independent_eval.py --annotations path/to/filled.json
+    python scripts/score_independent_eval.py --min-annotators 3
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+ROOT = Path(__file__).resolve().parents[1]
+EVAL_DIR = ROOT / "datasets" / "independent_eval"
+VALID_LABELS = frozenset({"none", "mirrorOf", "creates", "unsure"})
+
+
+def fleiss_kappa(ratings: list[list[str]], categories: list[str]) -> float:
+    """Fleiss' kappa. ratings[i] = etiquetas de los k anotadores para el ítem i.
+    Todas las filas deben tener la misma longitud k ≥ 2.
+    """
+    n_items = len(ratings)
+    if n_items == 0:
+        return float("nan")
+    n_raters = len(ratings[0])
+    if n_raters < 2:
+        return float("nan")
+    if any(len(r) != n_raters for r in ratings):
+        raise ValueError("Todas las filas de ratings deben tener la misma longitud")
+
+    cat_idx = {c: i for i, c in enumerate(categories)}
+    table = []
+    for row in ratings:
+        counts = [0] * len(categories)
+        for lab in row:
+            if lab not in cat_idx:
+                raise ValueError(f"Etiqueta fuera de categorías: {lab!r}")
+            counts[cat_idx[lab]] += 1
+        table.append(counts)
+
+    P = []
+    for counts in table:
+        s = sum(c * (c - 1) for c in counts)
+        P.append(s / (n_raters * (n_raters - 1)))
+    P_bar = sum(P) / n_items
+
+    totals = [sum(table[i][j] for i in range(n_items)) for j in range(len(categories))]
+    p = [t / (n_items * n_raters) for t in totals]
+    P_e = sum(pj ** 2 for pj in p)
+    if abs(1 - P_e) < 1e-12:
+        return 1.0
+    return (P_bar - P_e) / (1 - P_e)
+
+
+def parse_template_format(data: dict) -> tuple[list[str], dict[str, dict[str, str | None]]]:
+    """Formato oficial: annotators=[ids], items=[{id, annotations: {A: label|null}}]."""
+    annotator_ids = list(data.get("annotators") or [])
+    if not annotator_ids:
+        raise ValueError("Campo 'annotators' vacío o ausente")
+
+    by_pair: dict[str, dict[str, str | None]] = {}
+    items = data.get("items")
+    if not isinstance(items, list):
+        raise ValueError("Campo 'items' debe ser una lista")
+
+    for item in items:
+        pid = item.get("id")
+        if not pid:
+            raise ValueError(f"Ítem sin id: {item!r}")
+        anns = item.get("annotations") or {}
+        if not isinstance(anns, dict):
+            raise ValueError(f"annotations de {pid} debe ser un objeto")
+        pair_map: dict[str, str | None] = {}
+        for aid in annotator_ids:
+            raw = anns.get(aid)
+            if raw is None:
+                pair_map[aid] = None
+            elif isinstance(raw, str) and raw.strip() == "":
+                pair_map[aid] = None
+            elif raw in VALID_LABELS:
+                pair_map[aid] = raw
+            else:
+                raise ValueError(
+                    f"Etiqueta inválida en {pid}/{aid}: {raw!r}. "
+                    f"Permitidas: {sorted(VALID_LABELS)} o null"
+                )
+        by_pair[pid] = pair_map
+    return annotator_ids, by_pair
+
+
+def parse_legacy_formats(data: Any) -> tuple[list[str], dict[str, dict[str, str | None]]]:
+    by_pair: dict[str, dict[str, str | None]] = defaultdict(dict)
+    annotator_ids: list[str] = []
+
+    if isinstance(data, dict) and "annotators" in data:
+        anns = data["annotators"]
+        if isinstance(anns, list) and anns and isinstance(anns[0], dict) and "labels" in anns[0]:
+            for ann in anns:
+                aid = str(ann.get("id") or ann.get("name") or f"A{len(annotator_ids)+1}")
+                annotator_ids.append(aid)
+                for pair_id, label in (ann.get("labels") or {}).items():
+                    by_pair[pair_id][aid] = label if label in VALID_LABELS else None
+            return annotator_ids, dict(by_pair)
+
+    if isinstance(data, list):
+        aids_set: set[str] = set()
+        for item in data:
+            pid = item.get("id") or item.get("pair_id")
+            aid = str(item.get("annotator") or "A1")
+            lab = item.get("label") or item.get("annotation")
+            if not pid:
+                continue
+            aids_set.add(aid)
+            by_pair[pid][aid] = lab if lab in VALID_LABELS else None
+        return sorted(aids_set), dict(by_pair)
+
+    raise ValueError(
+        "Formato de anotaciones no reconocido. "
+        "Usa el formato de annotations_template.json."
+    )
+
+
+def load_annotations(path: Path) -> tuple[list[str], dict[str, dict[str, str | None]], dict]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    meta = {
+        "status": data.get("status") if isinstance(data, dict) else None,
+        "description": data.get("description") if isinstance(data, dict) else None,
+        "evaluation_mode": data.get("evaluation_mode") if isinstance(data, dict) else None,
+    }
+    if isinstance(data, dict) and isinstance(data.get("items"), list):
+        annotator_ids, by_pair = parse_template_format(data)
+    else:
+        annotator_ids, by_pair = parse_legacy_formats(data)
+    return annotator_ids, by_pair, meta
+
+
+def load_rule_reference() -> dict[str, str]:
+    ref_path = EVAL_DIR / "rule_reference.json"
+    if not ref_path.is_file():
+        return {}
+    raw = json.loads(ref_path.read_text(encoding="utf-8"))
+    if isinstance(raw, list):
+        return {item["id"]: item.get("rule_label") for item in raw if "id" in item}
+    if isinstance(raw, dict):
+        out = {}
+        for k, v in raw.items():
+            if k in ("labels",):
+                continue
+            if isinstance(v, dict):
+                out[k] = v.get("rule_label")
+            elif isinstance(v, str):
+                out[k] = v
+        if "labels" in raw and isinstance(raw["labels"], dict):
+            out.update(raw["labels"])
+        return out
+    return {}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Scoring de evaluación independiente (capa C)"
+    )
+    parser.add_argument(
+        "--annotations",
+        type=Path,
+        default=EVAL_DIR / "annotations.json",
+        help="JSON de anotaciones (plantilla o rellenado)",
+    )
+    parser.add_argument(
+        "--min-annotators",
+        type=int,
+        default=3,
+        help="Número exacto de anotadores con respuesta no nula requerido por ítem (default 3)",
+    )
+    args = parser.parse_args()
+
+    if not args.annotations.is_file():
+        # fallback a plantilla
+        alt = EVAL_DIR / "annotations_template.json"
+        if alt.is_file():
+            args.annotations = alt
+        else:
+            print(f"ERROR: no se encontró {args.annotations}", file=sys.stderr)
+            return 1
+
+    try:
+        annotator_ids, by_pair, meta = load_annotations(args.annotations)
+    except (ValueError, json.JSONDecodeError) as exc:
+        print(f"ERROR de formato: {exc}", file=sys.stderr)
+        return 1
+
+    k_required = args.min_annotators
+    if k_required < 2:
+        print("ERROR: --min-annotators debe ser ≥ 2", file=sys.stderr)
+        return 1
+
+    incomplete_pairs: dict[str, dict] = {}
+    respondent_sets: dict[str, tuple[str, ...]] = {}
+    labels_by_pair_ordered: dict[str, list[str]] = {}
+    unsure_counts: Counter = Counter()
+    present_counts: Counter = Counter()
+
+    for pid, ann_map in by_pair.items():
+        respondents = []
+        labels_ordered = []
+        missing = []
+        for aid in annotator_ids:
+            lab = ann_map.get(aid)
+            if lab is None:
+                missing.append(aid)
+            else:
+                respondents.append(aid)
+                labels_ordered.append(lab)
+                present_counts[lab] += 1
+                if lab == "unsure":
+                    unsure_counts[pid] += 1
+
+        if len(respondents) == k_required:
+            respondent_sets[pid] = tuple(respondents)
+            labels_by_pair_ordered[pid] = labels_ordered
+        else:
+            incomplete_pairs[pid] = {
+                "n_present": len(respondents),
+                "n_missing": len(missing),
+                "missing_annotators": missing,
+                "present_annotators": respondents,
+                "present_labels": labels_ordered,
+                "reason": (
+                    f"se requieren exactamente {k_required} respuestas no nulas; "
+                    f"hay {len(respondents)}"
+                ),
+            }
+
+    status = meta.get("status") or "unknown"
+    n_total = len(by_pair)
+
+    by_respondent_set: dict[tuple[str, ...], list[str]] = defaultdict(list)
+    for pid, rset in respondent_sets.items():
+        by_respondent_set[rset].append(pid)
+
+    kappa_eligible_ids: list[str] = []
+    kappa_annotators: tuple[str, ...] | None = None
+    heterogeneous: dict[str, dict] = {}
+
+    if by_respondent_set:
+        best_set = max(
+            by_respondent_set.keys(),
+            key=lambda s: (len(by_respondent_set[s]), s),
+        )
+        kappa_eligible_ids = sorted(by_respondent_set[best_set])
+        kappa_annotators = best_set
+
+        for rset, pids in by_respondent_set.items():
+            if rset == best_set:
+                continue
+            for pid in pids:
+                heterogeneous[pid] = {
+                    "respondents": list(rset),
+                    "n_present": len(rset),
+                    "reason": (
+                        "conjunto de anotadores distinto al usado para kappa "
+                        f"({list(best_set)}); no se trunca ni se mezcla"
+                    ),
+                    "present_labels": labels_by_pair_ordered[pid],
+                }
+
+    n_kappa = len(kappa_eligible_ids)
+    n_incomplete = len(incomplete_pairs)
+    n_heterogeneous = len(heterogeneous)
+
+    if n_kappa == 0:
+        report = {
+            "status": status,
+            "evaluation_mode": meta.get("evaluation_mode"),
+            "n_pairs_total": n_total,
+            "n_pairs_in_kappa": 0,
+            "n_pairs_incomplete": n_incomplete,
+            "n_pairs_heterogeneous_respondent_set": n_heterogeneous,
+            "min_annotators_required": k_required,
+            "kappa_annotators": None,
+            "fleiss_kappa": None,
+            "majority_labels": {},
+            "posthoc_agreement_with_rule_reference": None,
+            "incomplete_detail": incomplete_pairs,
+            "heterogeneous_detail": heterogeneous,
+            "note": (
+                f"Sin ítems con exactamente {k_required} respuestas no nulas "
+                "del mismo conjunto de anotadores. No se trunca. "
+                "null/ausente ≠ 'unsure'. Protocolo listo; esperando recolección."
+            ),
+        }
+        out = ROOT / "experiments" / "results" / "independent_eval_scores.json"
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+        print(f"Escrito: {out}")
+        return 0
+
+    assert kappa_annotators is not None
+    k = len(kappa_annotators)
+    categories = ["none", "mirrorOf", "creates", "unsure"]
+    ratings = [labels_by_pair_ordered[pid] for pid in kappa_eligible_ids]
+
+    if any(len(r) != k for r in ratings):
+        print(
+            "ERROR interno: longitudes inconsistentes tras filtrado; no se calcula kappa.",
+            file=sys.stderr,
+        )
+        return 1
+
+    kappa = fleiss_kappa(ratings, categories)
+
+    majority: dict[str, str] = {}
+    unanimous = 0
+    for pid in kappa_eligible_ids:
+        labs = labels_by_pair_ordered[pid]
+        cnt = Counter(labs)
+        maj_lab, maj_n = cnt.most_common(1)[0]
+        majority[pid] = maj_lab
+        if maj_n == len(labs):
+            unanimous += 1
+
+    majority_all = dict(majority)
+    for pid, labs in labels_by_pair_ordered.items():
+        if pid not in majority_all and labs:
+            majority_all[pid] = Counter(labs).most_common(1)[0][0]
+
+    rule_ref = load_rule_reference()
+    comparable = {
+        pid: maj
+        for pid, maj in majority.items()
+        if rule_ref.get(pid) and rule_ref[pid] not in (None, "unspecified")
+    }
+    agreement_with_rules = None
+    if comparable:
+        matched = sum(1 for pid, maj in comparable.items() if rule_ref[pid] == maj)
+        agreement_with_rules = round(matched / len(comparable), 4)
+
+    report = {
+        "status": status,
+        "evaluation_mode": meta.get("evaluation_mode"),
+        "n_pairs_total": n_total,
+        "n_pairs_in_kappa": n_kappa,
+        "n_pairs_incomplete": n_incomplete,
+        "n_pairs_heterogeneous_respondent_set": n_heterogeneous,
+        "min_annotators_required": k_required,
+        "kappa_annotators": list(kappa_annotators),
+        "n_annotators_per_kappa_item": k,
+        "fleiss_kappa": None if (isinstance(kappa, float) and kappa != kappa) else round(kappa, 4),
+        "unanimous_fraction": round(unanimous / n_kappa, 4) if n_kappa else None,
+        "majority_labels_in_kappa": majority,
+        "majority_labels_all_with_any_response": majority_all,
+        "label_distribution_present": dict(present_counts),
+        "unsure_count_by_pair": dict(unsure_counts),
+        "posthoc_agreement_with_rule_reference": agreement_with_rules,
+        "n_posthoc_comparable": len(comparable),
+        "incomplete_detail": incomplete_pairs if incomplete_pairs else {},
+        "heterogeneous_detail": heterogeneous if heterogeneous else {},
+        "policy": (
+            "Fleiss' kappa solo sobre ítems con exactamente k anotadores no nulos "
+            "y el mismo conjunto de respondentes. No se trunca ni se rellena. "
+            "null ≠ unsure."
+        ),
+        "note": (
+            "Fleiss' kappa y mayoría (sobre el panel kappa) son el objetivo primario. "
+            "posthoc_agreement_with_rule_reference excluye unspecified y es solo post-hoc."
+        ),
+    }
+
+    out = ROOT / "experiments" / "results" / "independent_eval_scores.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(report, ensure_ascii=False, indent=2))
+    print(f"Escrito: {out}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

score_quiz.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Autoevaluación del manual de protocolo ciego (no es métrica del marco)."""
+from __future__ import annotations
+import json, sys
+from pathlib import Path
+
+QUIZ = Path(__file__).with_name("quiz_blind_protocol.json")
+
+def main(answers: dict[str, str]) -> int:
+    data = json.loads(QUIZ.read_text(encoding="utf-8"))
+    correct = 0
+    for q in data["questions"]:
+        got = answers.get(q["id"], "").lower().strip()
+        ok = got == q["answer"]
+        correct += int(ok)
+        mark = "OK" if ok else "FAIL"
+        print(f"{q['id']}: {mark} (esperado={q['answer']}, recibido={got or '—'})")
+        if not ok:
+            print(f"  → {q['rationale']}")
+    total = len(data["questions"])
+    print(f"Puntuación: {correct}/{total}")
+    print("Nota: este quiz evalúa comprensión del protocolo; no modifica κ ni EXP-A.")
+    return 0 if correct == total else 1
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--self-test":
+        key = {q["id"]: q["answer"] for q in json.loads(QUIZ.read_text(encoding="utf-8"))["questions"]}
+        raise SystemExit(main(key))
+    print("Uso: python experiments/learning/score_quiz.py Q1=b Q2=b Q3=c Q4=c")
+    print("  o: python experiments/learning/score_quiz.py --self-test")
+    ans = {}
+    for arg in sys.argv[1:]:
+        if "=" in arg:
+            k, v = arg.split("=", 1)
+            ans[k.strip().upper()] = v.strip()
+    if ans:
+        raise SystemExit(main(ans))

self_bootstrap.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Punto fijo del repositorio: auto-creación estable bajo iteración.
+
+  python scripts/self_bootstrap.py --passes 2
+  python scripts/self_bootstrap.py --with-manifest --passes 2
+
+Con --with-manifest:
+  1. Regenera CSV + MANIFEST.sha256
+  2. Exige identidad con HEAD (git diff vacío)
+  3. Cobertura dura de archivos críticos
+  4. Sello datasets/GENERATED_FROM.json == spec_version del iom_spec.json
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+DERIVED_CSV = [
+    "datasets/triad_nodes.csv",
+    "datasets/vector_steps.csv",
+    "datasets/relation_candidates.csv",
+    "datasets/GENERATED_FROM.json",
+]
+
+CRITICAL_IF_PRESENT = [
+    "scripts/self_bootstrap.py",
+    "scripts/measure_invariance.py",
+    "scripts/create_manifest.py",
+    "scripts/generate_ontology.py",
+    "IOM/SelfGenesis.lean",
+    "IOM/FormalRules.lean",
+    "MANIFIESTO.md",
+    "docs/DEL_ORDEN_UNIVERSAL_A_LA_CREACION_DE_UNO_MISMO.md",
+    "datasets/independent_eval/instrument/INSTRUCTIONS.md",
+    "datasets/independent_eval/instrument/pairs.csv",
+    "datasets/independent_eval/instrument/ACCESS_LOG.template.json",
+    "datasets/GENERATED_FROM.json",
+]
+
+
+def check_spec_version_stamp() -> list[str]:
+    """Falla si los derivados no declaran la misma spec_version que iom_spec.json."""
+    spec = json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8"))
+    expected = spec["spec_version"]
+    stamp_path = ROOT / "datasets" / "GENERATED_FROM.json"
+    if not stamp_path.is_file():
+        return [f"falta {stamp_path.as_posix()} (regenera con generate_ontology.py)"]
+    stamp = json.loads(stamp_path.read_text(encoding="utf-8"))
+    if stamp.get("spec_version") != expected:
+        return [
+            f"GENERATED_FROM.json spec_version={stamp.get('spec_version')!r} "
+            f"≠ iom_spec.json {expected!r}"
+        ]
+    return []
+
+
+def run(cmd: list[str]) -> subprocess.CompletedProcess:
+    return subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True)
+
+
+def git_diff_paths(paths: list[str]) -> subprocess.CompletedProcess:
+    return run(["git", "diff", "--ignore-space-at-eol", "--exit-code", "--", *paths])
+
+
+def porcelain(paths: list[str]) -> str:
+    return run(["git", "status", "--porcelain", "--", *paths]).stdout
+
+
+def manifest_paths(manifest_file: Path) -> set[str]:
+    out: set[str] = set()
+    for line in manifest_file.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        parts = line.split("  ", 1)
+        if len(parts) == 2:
+            out.add(parts[1])
+    return out
+
+
+def check_manifest_coverage() -> list[str]:
+    mf = ROOT / "MANIFEST.sha256"
+    if not mf.is_file():
+        return ["MANIFEST.sha256 (archivo inexistente)"]
+    listed = manifest_paths(mf)
+    missing = []
+    for rel in CRITICAL_IF_PRESENT:
+        p = ROOT / rel
+        if p.is_file() and rel not in listed:
+            missing.append(rel)
+    return missing
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Punto fijo idempotente")
+    parser.add_argument("--with-manifest", action="store_true")
+    parser.add_argument("--passes", type=int, default=2)
+    args = parser.parse_args()
+
+    paths = list(DERIVED_CSV)
+    if args.with_manifest:
+        paths.append("MANIFEST.sha256")
+
+    print("=== self_bootstrap: punto fijo idempotente ===")
+    print(f"Pasadas: {args.passes}  |  manifiesto: {args.with_manifest}")
+    print()
+
+    for i in range(1, args.passes + 1):
+        print(f"--- pasada {i}/{args.passes} ---")
+        r = run([sys.executable, "scripts/generate_ontology.py"])
+        print(r.stdout, end="")
+        if r.returncode != 0:
+            print(r.stderr, file=sys.stderr)
+            return 1
+
+        stamp_errs = check_spec_version_stamp()
+        if stamp_errs:
+            print("FALLO: sello de spec_version inconsistente:", file=sys.stderr)
+            for e in stamp_errs:
+                print(f"  - {e}", file=sys.stderr)
+            return 1
+
+        if args.with_manifest:
+            r = run([sys.executable, "scripts/create_manifest.py"])
+            print(r.stdout, end="")
+            if r.returncode != 0:
+                print(r.stderr, file=sys.stderr)
+                return 1
+
+            missing = check_manifest_coverage()
+            if missing:
+                print(
+                    "FALLO de cobertura del manifiesto — archivos críticos en disco "
+                    "pero ausentes de MANIFEST.sha256:",
+                    file=sys.stderr,
+                )
+                for m in missing:
+                    print(f"  - {m}", file=sys.stderr)
+                return 1
+
+        r = git_diff_paths(paths)
+        if r.returncode != 0:
+            print(
+                f"FALLO en pasada {i}: regenerado ≠ HEAD en {paths}",
+                file=sys.stderr,
+            )
+            print(r.stdout or r.stderr, file=sys.stderr)
+            if args.with_manifest:
+                print(
+                    "\nVersiona el manifiesto:\n"
+                    "  python scripts/create_manifest.py\n"
+                    "  git add MANIFEST.sha256 && git commit -m 'chore: refresh MANIFEST'\n"
+                    "  python scripts/self_bootstrap.py --with-manifest --passes 2",
+                    file=sys.stderr,
+                )
+            return 1
+
+        dirty = porcelain(paths).strip()
+        if dirty:
+            print(f"FALLO: porcelain no limpio:\n{dirty}", file=sys.stderr)
+            return 1
+        print(
+            f"OK pasada {i}: diff vacío, porcelain limpio"
+            + (", cobertura crítica OK" if args.with_manifest else "")
+            + f", stamp={json.loads((ROOT / 'datasets' / 'GENERATED_FROM.json').read_text())['spec_version']}"
+        )
+
+    print()
+    print("OK: punto fijo estable (S_{n+1} = S_n).")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sync_spec_artifacts.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Sincronización y verificación bidireccional entre especificación y artefactos.
+
+Garantiza que data/iom_spec.json, los CSV generados, la ontología y los conteos
+de pruebas permanecen coherentes. Con --check solo verifica; con --fix regenera
+vía generate_ontology.py y vuelve a verificar.
+
+Uso:
+    python scripts/sync_spec_artifacts.py --check
+    python scripts/sync_spec_artifacts.py --fix
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SPEC_PATH = ROOT / "data" / "iom_spec.json"
+
+
+def load_spec() -> dict:
+    return json.loads(SPEC_PATH.read_text(encoding="utf-8"))
+
+
+def count_csv(name: str) -> int:
+    path = ROOT / "datasets" / name
+    if not path.is_file():
+        return -1
+    with path.open(encoding="utf-8", newline="") as fh:
+        return len(list(csv.DictReader(fh)))
+
+
+def expected_counts(spec: dict) -> dict:
+    n_triads = len(spec["triads"]["adv"])
+    n_positions = len(spec["positions"]["indices"])
+    n_vectors = len(spec["vectors"])
+    steps_per_vector = len(spec["vectors"][0]["labels"]) if spec["vectors"] else 5
+    # 6 nodos por tríada (2 fases × 3 pos), 5 destinos no reflexivos → 6*5=30 pares/tríada
+    pairs_per_triad = (2 * n_positions) * (2 * n_positions - 1)
+    # creates: 4 rules × product of position lists × n_triads
+    creates = 0
+    for rule in spec["creation_rules"]:
+        creates += len(rule["source_positions"]) * len(rule["target_positions"]) * n_triads
+    # mirrorOf: 3 posiciones × 2 direcciones × n_triads = 6 * n_triads
+    mirrors = n_positions * 2 * n_triads
+    nodes = n_triads * 2 * n_positions
+    pairs = n_triads * pairs_per_triad
+    none = pairs - mirrors - creates
+    return {
+        "n_triads": n_triads,
+        "nodes": nodes,
+        "vector_steps": n_vectors * steps_per_vector,
+        "relation_candidates": pairs,
+        "mirrorOf": mirrors,
+        "creates": creates,
+        "none": none,
+    }
+
+
+def check(spec: dict) -> list[str]:
+    errors = []
+    exp = expected_counts(spec)
+
+    # Versión
+    if not spec.get("spec_version"):
+        errors.append("Falta spec_version")
+    migrations = spec.get("migrations") or []
+    if migrations and migrations[-1].get("to_version") != spec.get("spec_version"):
+        errors.append(
+            f"spec_version={spec.get('spec_version')} != último to_version={migrations[-1].get('to_version')}"
+        )
+
+    # Conteos CSV
+    actual_nodes = count_csv("triad_nodes.csv")
+    actual_vecs = count_csv("vector_steps.csv")
+    actual_rels = count_csv("relation_candidates.csv")
+
+    if actual_nodes != exp["nodes"]:
+        errors.append(f"triad_nodes.csv: {actual_nodes} filas, esperado {exp['nodes']}")
+    if actual_vecs != exp["vector_steps"]:
+        errors.append(f"vector_steps.csv: {actual_vecs} filas, esperado {exp['vector_steps']}")
+    if actual_rels != exp["relation_candidates"]:
+        errors.append(
+            f"relation_candidates.csv: {actual_rels} filas, esperado {exp['relation_candidates']}"
+        )
+
+    # Conteos de relaciones
+    if actual_rels > 0:
+        with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as fh:
+            from collections import Counter
+            c = Counter(r["relation"] for r in csv.DictReader(fh))
+        for key in ("mirrorOf", "creates", "none"):
+            if c.get(key, 0) != exp[key]:
+                errors.append(f"relación {key}: {c.get(key, 0)}, esperado {exp[key]}")
+
+    # Ontología existe y menciona version-ish content
+    ttl = ROOT / "ontology" / "io_ontology.ttl"
+    if not ttl.is_file():
+        errors.append("Falta ontology/io_ontology.ttl")
+    else:
+        text = ttl.read_text(encoding="utf-8")
+        if "mirrorOf" not in text or "creates" not in text:
+            errors.append("io_ontology.ttl no contiene mirrorOf/creates")
+
+    # Schema
+    schema = ROOT / "data" / "iom_spec.schema.json"
+    if not schema.is_file():
+        errors.append("Falta data/iom_spec.schema.json")
+
+    return errors
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--check", action="store_true", help="Solo verificar sincronización")
+    parser.add_argument("--fix", action="store_true", help="Regenerar artefactos y verificar")
+    args = parser.parse_args()
+
+    if not args.check and not args.fix:
+        args.check = True
+
+    if args.fix:
+        print("Regenerando ontología y datasets…")
+        r = subprocess.run(
+            [sys.executable, "scripts/generate_ontology.py"],
+            cwd=ROOT,
+            capture_output=True,
+            text=True,
+        )
+        if r.returncode != 0:
+            print(r.stdout)
+            print(r.stderr, file=sys.stderr)
+            return 1
+        print(r.stdout.strip())
+
+    spec = load_spec()
+    errors = check(spec)
+    exp = expected_counts(spec)
+
+    print(f"spec_version={spec.get('spec_version')}  schema_version={spec.get('schema_version')}")
+    print(f"Esperado: nodos={exp['nodes']} vectores={exp['vector_steps']} "
+          f"pares={exp['relation_candidates']} "
+          f"(mirror={exp['mirrorOf']} creates={exp['creates']} none={exp['none']})")
+
+    if errors:
+        print("INCONSISTENCIAS:")
+        for e in errors:
+            print(f"  - {e}")
+        return 1
+    print("OK: especificación, CSV y ontología sincronizados")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

test_formal_rules_bridge.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""Puente: las relaciones del CSV deben satisfacer los predicados formales
+codificados en IOM/FormalRules.lean (isMirrorRel / isCreatesRel / sameTriad).
+
+Equivalencia de capas:
+  Lean isMirrorRel  ↔  Python is_mirror ∧ same_triad
+  Lean isCreatesRel ↔  Python is_creates ∧ same_triad
+  Lean isMirror (posicional)  ↔  Python is_mirror  (sin exigir tríada)
+"""
+from __future__ import annotations
+
+import csv
+import re
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def load_relations():
+    with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as fh:
+        return list(csv.DictReader(fh))
+
+
+def parse_node(node_id: str) -> tuple[int, str, int]:
+    """Devuelve (triad_id, phase, position)."""
+    m = re.fullmatch(r"T(\d{2})_(adv|ret)_P([0-2])", node_id)
+    assert m, node_id
+    return int(m.group(1)), m.group(2), int(m.group(3))
+
+
+def same_triad(src: str, tgt: str) -> bool:
+    return parse_node(src)[0] == parse_node(tgt)[0]
+
+
+def is_mirror_positional(src: str, tgt: str) -> bool:
+    """Equivale a Lean isMirror / isMirrorPositional."""
+    _sid, sp, spos = parse_node(src)
+    _tid, tp, tpos = parse_node(tgt)
+    return sp != tp and tpos == 2 - spos
+
+
+def is_creates_positional(src: str, tgt: str) -> bool:
+    """Equivale a Lean isCreates / isCreatesPositional."""
+    _sid, sp, spos = parse_node(src)
+    _tid, tp, tpos = parse_node(tgt)
+    if sp == tp:
+        return False
+    lateral_s = spos in (0, 2)
+    lateral_t = tpos in (0, 2)
+    return (lateral_s and tpos == 1) or (spos == 1 and lateral_t)
+
+
+def is_mirror_rel(src: str, tgt: str) -> bool:
+    """Equivale a Lean isMirrorRel: sameTriad ∧ isMirrorPositional."""
+    return same_triad(src, tgt) and is_mirror_positional(src, tgt)
+
+
+def is_creates_rel(src: str, tgt: str) -> bool:
+    """Equivale a Lean isCreatesRel: sameTriad ∧ isCreatesPositional."""
+    return same_triad(src, tgt) and is_creates_positional(src, tgt)
+
+
+class FormalRulesBridgeTests(unittest.TestCase):
+    """Comprueba que el JSON/CSV regenerado cumple los predicados Lean."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.rows = load_relations()
+        cls.lean = (ROOT / "IOM" / "FormalRules.lean").read_text(encoding="utf-8")
+
+    def test_lean_defines_same_triad_and_rel_predicates(self):
+        self.assertIn("def sameTriad", self.lean)
+        self.assertIn("def isMirrorRel", self.lean)
+        self.assertIn("def isCreatesRel", self.lean)
+        self.assertIn("def isMirrorPositional", self.lean)
+        self.assertIn("def isCreatesPositional", self.lean)
+        self.assertIn("triadId", self.lean)
+        self.assertIn("expectedMirrorDirected", self.lean)
+        self.assertIn("expectedCreatesDirected", self.lean)
+
+    def test_every_mirrorOf_satisfies_isMirrorRel(self):
+        for row in self.rows:
+            if row["relation"] != "mirrorOf":
+                continue
+            self.assertTrue(
+                is_mirror_rel(row["source"], row["target"]),
+                f"mirrorOf viola isMirrorRel: {row['source']} -> {row['target']}",
+            )
+            self.assertFalse(
+                is_creates_rel(row["source"], row["target"]),
+                f"mirrorOf no debe ser createsRel: {row}",
+            )
+
+    def test_every_creates_satisfies_isCreatesRel(self):
+        for row in self.rows:
+            if row["relation"] != "creates":
+                continue
+            self.assertTrue(
+                is_creates_rel(row["source"], row["target"]),
+                f"creates viola isCreatesRel: {row['source']} -> {row['target']}",
+            )
+            self.assertFalse(
+                is_mirror_rel(row["source"], row["target"]),
+                f"creates no debe ser mirrorRel: {row}",
+            )
+
+    def test_none_satisfies_neither_rel(self):
+        for row in self.rows:
+            if row["relation"] != "none":
+                continue
+            self.assertFalse(
+                is_mirror_rel(row["source"], row["target"]), row
+            )
+            self.assertFalse(
+                is_creates_rel(row["source"], row["target"]), row
+            )
+
+    def test_cross_triad_positional_mirror_is_not_rel(self):
+        """Un par cross-tríada puede cumplir la condición posicional pero no isMirrorRel."""
+        # T07_adv_P0 y T01_ret_P2: posicional mirror, distinta tríada
+        self.assertTrue(is_mirror_positional("T07_adv_P0", "T01_ret_P2"))
+        self.assertFalse(same_triad("T07_adv_P0", "T01_ret_P2"))
+        self.assertFalse(is_mirror_rel("T07_adv_P0", "T01_ret_P2"))
+
+    def test_counts_match_lean_constants(self):
+        from collections import Counter
+        c = Counter(r["relation"] for r in self.rows)
+        self.assertEqual(c["mirrorOf"], 78)
+        self.assertEqual(c["creates"], 104)
+        self.assertEqual(c["none"], 208)
+        self.assertIn("78", self.lean)
+        self.assertIn("104", self.lean)
+        self.assertIn("208", self.lean)
+
+    def test_partition_complete_with_rel(self):
+        for row in self.rows:
+            m = is_mirror_rel(row["source"], row["target"])
+            c = is_creates_rel(row["source"], row["target"])
+            self.assertFalse(m and c, row)
+            if row["relation"] == "mirrorOf":
+                self.assertTrue(m)
+            elif row["relation"] == "creates":
+                self.assertTrue(c)
+            else:
+                self.assertFalse(m or c)
+
+
+if __name__ == "__main__":
+    unittest.main()

test_metrics_audit.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Pruebas que formalizan las conclusiones de la auditoría de métricas 100%."""
+from __future__ import annotations
+
+import csv
+import unittest
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def parse_node(node_id: str):
+    parts = node_id.split("_")
+    return parts[1], int(parts[2][1:])
+
+
+def feature_key(src, tgt):
+    sp, spos = parse_node(src)
+    tp, tpos = parse_node(tgt)
+    return (sp, spos, tp, tpos)
+
+
+def deterministic_label(src, tgt):
+    sp, spos = parse_node(src)
+    tp, tpos = parse_node(tgt)
+    if sp == tp:
+        return "none"
+    if tpos == 2 - spos:
+        return "mirrorOf"
+    if (spos in (0, 2) and tpos == 1) or (spos == 1 and tpos in (0, 2)):
+        return "creates"
+    return "none"
+
+
+class PerfectMetricsAuditTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        with (ROOT / "datasets" / "relation_candidates.csv").open(encoding="utf-8", newline="") as fh:
+            cls.rows = list(csv.DictReader(fh))
+
+    def test_gold_matches_deterministic_rule(self):
+        for row in self.rows:
+            self.assertEqual(
+                deterministic_label(row["source"], row["target"]),
+                row["relation"],
+                msg=row,
+            )
+
+    def test_label_is_function_of_phase_position_only(self):
+        by_feat = defaultdict(set)
+        for row in self.rows:
+            by_feat[feature_key(row["source"], row["target"])].add(row["relation"])
+        for key, labels in by_feat.items():
+            self.assertEqual(len(labels), 1, f"clave {key} tiene etiquetas {labels}")
+
+    def test_loo_features_fully_recoverable_from_train(self):
+        """En cada fold LOO, todo par de test es recuperable por lookup de features."""
+        for held in range(1, 14):
+            train = {}
+            test = []
+            for row in self.rows:
+                key = feature_key(row["source"], row["target"])
+                if int(row["triad_index"]) == held:
+                    test.append((key, row["relation"]))
+                else:
+                    train[key] = row["relation"]
+            for key, lab in test:
+                self.assertEqual(train.get(key), lab)
+
+    def test_model_does_not_use_triad_index_in_features(self):
+        """Sanity: features_for_node en pi_hgat_t no incluye índice de tríada."""
+        src = (ROOT / "experiments" / "optional" / "pi_hgat_t.py").read_text(encoding="utf-8")
+        self.assertIn("sin etiqueta léxica ni número de tríada", src)
+        self.assertIn("phase == \"adv\"", src)
+        self.assertIn("position == 0", src)
+
+
+if __name__ == "__main__":
+    unittest.main()

test_ontology.py

@@ -0,0 +1,277 @@
+"""Pruebas de tríadas, vectores, OWL/RDF, SHACL y datasets generados.
+
+Requiere rdflib y pyshacl (requirements-lock.txt). Si faltan, la clase se omite
+con un mensaje explícito: eso no implica que la ontología falle.
+"""
+import csv
+import json
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+try:
+    from pyshacl import validate
+    from rdflib import Graph, Literal, Namespace
+    from rdflib.namespace import OWL, RDF, RDFS, XSD
+    _ONT_DEPS = True
+    _ONT_IMPORT_ERROR = None
+except ModuleNotFoundError as exc:
+    _ONT_DEPS = False
+    _ONT_IMPORT_ERROR = exc
+    validate = None  # type: ignore
+    Graph = Literal = Namespace = OWL = RDF = RDFS = XSD = None  # type: ignore
+
+
+@unittest.skipUnless(
+    _ONT_DEPS,
+    f"omitido: falta dependencia de ontología ({_ONT_IMPORT_ERROR}). "
+    "Instala requirements-lock.txt; no implica fallo de la ontología.",
+)
+class IOMValidationTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.IO = Namespace("http://example.org/iom#")
+        cls.DATA = ROOT / "ontology" / "io_ontology.ttl"
+        cls.SHAPES = ROOT / "ontology" / "io_shapes.ttl"
+        cls.SPEC = json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8"))
+        with (ROOT / "datasets" / "triad_nodes.csv").open(encoding="utf-8", newline="") as handle:
+            cls.NODE_ROWS = list(csv.DictReader(handle))
+
+    def setUp(self):
+        self.data = Graph().parse(self.DATA, format="turtle")
+        self.shapes = Graph().parse(self.SHAPES, format="turtle")
+        self.IO = self.__class__.IO
+
+    def conforms(self, graph=None, focus_nodes=None):
+        result, _report, text = validate(
+            self.data if graph is None else graph,
+            shacl_graph=self.shapes,
+            inference="none",
+            focus_nodes=focus_nodes,
+        )
+        return result, text
+
+    def test_spec_matches_canonical_numbered_triad_matrices(self):
+        expected_adv = [
+            ["orientación", "cuántico", "dirección"],
+            ["hardware", "virtual", "software"],
+            ["universo", "espacio", "vacío"],
+            ["singularidad", "tiempo", "infinito"],
+            ["cuerpo", "consciente", "mundo"],
+            ["carácter", "subconsciente", "personalidad"],
+            ["memoria", "inconsciente", "imaginación"],
+            ["receptor", "supraconsciente", "emisor"],
+            ["lógica", "inteligencia", "libertad"],
+            ["muerte", "artificial", "vida"],
+            ["descendente", "mente", "ascendente"],
+            ["oscuridad", "consciencia", "luz"],
+            ["animal", "humano", "IA"],
+        ]
+        self.assertEqual(self.SPEC["triads"]["adv"], expected_adv)
+        self.assertEqual(self.SPEC["triads"]["ret"], [row[::-1] for row in expected_adv])
+        self.assertEqual(self.SPEC["triads"]["index_base"], 1)
+        self.assertEqual(self.SPEC["positions"]["adv_labels"], ["→", "0", "→"])
+        self.assertEqual(self.SPEC["positions"]["ret_labels"], ["←", "0", "←"])
+
+    def test_exact_triad_dataset_and_shacl_conformance(self):
+        IO = self.IO
+        nodes = set(self.data.subjects(RDF.type, IO.OntoNode))
+        expected = {
+            IO[f"T{i:02d}_{phase}_P{pos}"]
+            for i in range(1, 14)
+            for phase in ("adv", "ret")
+            for pos in range(3)
+        }
+        self.assertEqual(nodes, expected)
+        self.assertTrue(self.conforms()[0], self.conforms()[1])
+        for phase in ("adv", "ret"):
+            rows = self.SPEC["triads"][phase]
+            for row_index, row in enumerate(rows):
+                triad_index = row_index + 1
+                for pos, label in enumerate(row):
+                    node = IO[f"T{triad_index:02d}_{phase}_P{pos}"]
+                    self.assertEqual(str(self.data.value(node, RDFS.label)), label)
+                    visual_label = self.SPEC["positions"]["adv_labels" if phase == "adv" else "ret_labels"][pos]
+                    self.assertEqual(str(self.data.value(node, IO.displayLabel)), visual_label)
+                    self.assertEqual(
+                        self.data.value(node, IO.hasTriadIndex),
+                        Literal(triad_index, datatype=XSD.integer),
+                    )
+                    self.assertEqual(
+                        self.data.value(node, IO.hasLocalPos),
+                        Literal(pos, datatype=XSD.integer),
+                    )
+                    self.assertEqual(
+                        self.data.value(node, IO.hasPerspective),
+                        IO[self.SPEC["perspectives"][pos]],
+                    )
+                    self.assertEqual(
+                        self.data.value(node, IO.hasPosition),
+                        IO[{"adv": ["→", "0", "→"], "ret": ["←", "0", "←"]}[phase][pos]],
+                    )
+                    display_labels = self.SPEC["positions"]["adv_labels" if phase == "adv" else "ret_labels"]
+                    generated = next(r for r in self.NODE_ROWS if r["node_id"] == f"T{triad_index:02d}_{phase}_P{pos}")
+                    self.assertEqual(generated["display_label"], display_labels[pos])
+
+    def test_mirrors_are_reciprocal_and_swap_laterals(self):
+        IO = self.IO
+        for i in range(1, 14):
+            for pos in range(3):
+                adv, ret = IO[f"T{i:02d}_adv_P{pos}"], IO[f"T{i:02d}_ret_P{2 - pos}"]
+                self.assertEqual(self.data.value(adv, IO.mirrorOf), ret)
+                self.assertEqual(self.data.value(ret, IO.mirrorOf), adv)
+
+    def test_creation_edges_follow_all_four_rules(self):
+        IO = self.IO
+        actual = set(self.data.triples((None, IO.creates, None)))
+        expected = set()
+        for i in range(1, 14):
+            for rule in self.SPEC["creation_rules"]:
+                for src in rule["source_positions"]:
+                    for dst in rule["target_positions"]:
+                        expected.add(
+                            (
+                                IO[f"T{i:02d}_{rule['source_phase']}_P{src}"],
+                                IO.creates,
+                                IO[f"T{i:02d}_{rule['target_phase']}_P{dst}"],
+                            )
+                        )
+        n_rules_edges = sum(
+            len(r["source_positions"]) * len(r["target_positions"])
+            for r in self.SPEC["creation_rules"]
+        )
+        self.assertEqual(len(expected), 13 * n_rules_edges)
+        self.assertEqual(actual, expected)
+
+    def test_vectors_match_all_four_updated_sequences(self):
+        IO = self.IO
+        self.assertEqual(len(set(self.data.subjects(RDF.type, IO.VectorStep))), 20)
+        for row in self.SPEC["vectors"]:
+            for idx, (label, axis) in enumerate(zip(row["labels"], row["axis_positions"])):
+                step = IO[f"vector_{row['name'].lower()}_{row['phase']}_{idx}"]
+                self.assertEqual(self.data.value(step, IO.hasVector), IO[row["name"]])
+                self.assertEqual(str(self.data.value(step, IO.hasCyclePhase)), row["phase"])
+                self.assertEqual(
+                    self.data.value(step, IO.hasStepIndex),
+                    Literal(idx, datatype=XSD.integer),
+                )
+                self.assertEqual(
+                    self.data.value(step, IO.hasAxisPosition),
+                    Literal(axis, datatype=XSD.integer),
+                )
+                self.assertEqual(
+                    self.data.value(step, IO.displayArrow),
+                    Literal(row["arrow"], datatype=XSD.string),
+                )
+                self.assertEqual(str(self.data.value(step, RDFS.label)), label)
+
+    def test_owl_classes_object_property_axioms_and_perspectives(self):
+        IO = self.IO
+        for cls in (
+            IO.OntoNode,
+            IO.VectorStep,
+            IO.Perspective,
+            IO.ExpandedCategory,
+            IO.Position,
+            IO.Direction,
+        ):
+            self.assertIn((cls, RDF.type, OWL.Class), self.data)
+        for prop in (
+            IO.hasPerspective,
+            IO.hasPosition,
+            IO.hasDirection,
+            IO.hasVector,
+            IO.mirrorOf,
+            IO.creates,
+        ):
+            self.assertIn((prop, RDF.type, OWL.ObjectProperty), self.data)
+            self.assertIsNotNone(self.data.value(prop, RDFS.domain))
+            self.assertIsNotNone(self.data.value(prop, RDFS.range))
+        self.assertIn((IO.displayLabel, RDF.type, OWL.DatatypeProperty), self.data)
+        self.assertIn((IO.displayLabel, RDF.type, OWL.FunctionalProperty), self.data)
+        self.assertIn((IO.mirrorOf, RDF.type, OWL.SymmetricProperty), self.data)
+        for resource in (IO.Ind, IO.D, IO.Tot, IO.Evol, IO.Invol):
+            self.assertIn((resource, RDF.type, IO.Perspective), self.data)
+
+    def test_expanded_categories_keep_declared_level_counts(self):
+        IO = self.IO
+        nodes = set(self.data.subjects(RDF.type, IO.ExpandedCategory))
+        self.assertEqual(len(nodes), 21)
+        self.assertEqual(
+            [
+                sum(
+                    self.data.value(n, IO.hasLevel) == Literal(level, datatype=XSD.integer)
+                    for n in nodes
+                )
+                for level in range(5)
+            ],
+            [1, 4, 6, 6, 4],
+        )
+
+    def test_generated_datasets_have_expected_rows(self):
+        n_triads = len(self.SPEC["triads"]["adv"])
+        n_vec = sum(len(v["labels"]) for v in self.SPEC["vectors"])
+        expected = {
+            "triad_nodes.csv": n_triads * 2 * 3,
+            "vector_steps.csv": n_vec,
+            "relation_candidates.csv": n_triads * 6 * 5,
+        }
+        for name, count in expected.items():
+            with (ROOT / "datasets" / name).open(encoding="utf-8", newline="") as f:
+                self.assertEqual(len(list(csv.DictReader(f))), count, name)
+
+    def test_wrong_visual_position_label_is_rejected(self):
+        IO = self.IO
+        graph = Graph()
+        for triple in self.data:
+            graph.add(triple)
+        node = IO["T01_adv_P0"]
+        graph.remove((node, IO.displayLabel, Literal("→", datatype=XSD.string)))
+        graph.add((node, IO.displayLabel, Literal("←", datatype=XSD.string)))
+        self.assertFalse(self.conforms(graph, [node])[0])
+
+    def test_wrong_phase_direction_is_rejected(self):
+        IO = self.IO
+        graph = Graph()
+        for triple in self.data:
+            graph.add(triple)
+        node = IO["T01_adv_P0"]
+        graph.remove((node, IO.hasDirection, IO.evol))
+        graph.add((node, IO.hasDirection, IO.invol))
+        self.assertFalse(self.conforms(graph, [node])[0])
+
+    def test_nonreciprocal_or_misplaced_mirror_is_rejected(self):
+        IO = self.IO
+        graph = Graph()
+        for triple in self.data:
+            graph.add(triple)
+        node, good, wrong = IO["T01_adv_P0"], IO["T01_ret_P2"], IO["T01_ret_P0"]
+        graph.remove((node, IO.mirrorOf, good))
+        graph.add((node, IO.mirrorOf, wrong))
+        self.assertFalse(self.conforms(graph, [node])[0])
+
+    def test_wrong_creation_link_is_rejected(self):
+        IO = self.IO
+        graph = Graph()
+        for triple in self.data:
+            graph.add(triple)
+        node, good, wrong = IO["T01_adv_P0"], IO["T01_ret_P1"], IO["T01_ret_P0"]
+        graph.remove((node, IO.creates, good))
+        graph.add((node, IO.creates, wrong))
+        self.assertFalse(self.conforms(graph, [node])[0])
+
+    def test_wrong_vector_label_or_axis_is_rejected(self):
+        IO = self.IO
+        graph = Graph()
+        for triple in self.data:
+            graph.add(triple)
+        step = IO["vector_evol_ret_1"]
+        old = self.data.value(step, RDFS.label)
+        graph.remove((step, RDFS.label, old))
+        graph.add((step, RDFS.label, Literal("fut", lang="es")))
+        self.assertFalse(self.conforms(graph, [step])[0])
+
+
+if __name__ == "__main__":
+    unittest.main()

test_pi_hgat_t.py

@@ -0,0 +1,36 @@
+"""Pruebas rápidas de la implementación PI-HGAT-T y su vínculo ontológico."""
+import unittest
+import torch
+
+from experiments.optional.pi_hgat_t import PIHGATT, admissible_relation, features_for_node, read_data
+
+
+class PIHGATTTests(unittest.TestCase):
+    def test_feature_vector_uses_only_phase_and_position(self):
+        self.assertEqual(features_for_node("T12_adv_P0"), [1.0, 0.0, 1.0, 0.0, 0.0])
+        self.assertEqual(features_for_node("T07_ret_P2"), [0.0, 1.0, 0.0, 0.0, 1.0])
+
+    def test_loaders_use_public_triad_ids_one_through_thirteen(self):
+        nodes, pairs = read_data()
+        expected = set(range(1, 14))
+        self.assertEqual(set(nodes), expected)
+        self.assertEqual(set(pairs), expected)
+        self.assertTrue(all(len(pairs[triad_id]) == 30 for triad_id in expected))
+
+    def test_attention_model_returns_three_relation_logits_per_candidate(self):
+        model = PIHGATT(dim=16, heads=4)
+        graph = torch.eye(5)[:5].unsqueeze(0)
+        pairs = torch.tensor([[0, 1], [1, 0]], dtype=torch.long)
+        self.assertEqual(tuple(model(graph, pairs).shape), (1, 2, 3))
+
+    def test_admissibility_uses_mirror_and_creation_properties(self):
+        # Índices locales 0..2=avance; 3..5=retroceso.
+        self.assertTrue(admissible_relation("mirrorOf", 0, 5))
+        self.assertFalse(admissible_relation("mirrorOf", 0, 3))
+        self.assertTrue(admissible_relation("creates", 0, 4))
+        self.assertTrue(admissible_relation("creates", 4, 0))
+        self.assertFalse(admissible_relation("creates", 0, 3))
+
+
+if __name__ == "__main__":
+    unittest.main()

test_property_based.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Pruebas generativas y casos negativos para límites de índices, espejos y creates.
+
+Cubre:
+- Generación exhaustiva de pares (fase, pos) y verificación de partición
+  none / mirrorOf / creates (mutuamente excluyentes y completas).
+- Casos negativos: índices fuera de rango, misma fase, posición no reflejada,
+  creates entre tríadas distintas, espejo no recíproco.
+- Transformaciones temporales / involución de fase y posición.
+"""
+from __future__ import annotations
+
+import itertools
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+PHASES = ("adv", "ret")
+POSITIONS = (0, 1, 2)
+
+
+def opposite_phase(p: str) -> str:
+    return "ret" if p == "adv" else "adv"
+
+
+def mirror_pos(p: int) -> int:
+    return 2 - p
+
+
+def is_mirror(sp: str, spos: int, tp: str, tpos: int) -> bool:
+    return sp != tp and tpos == mirror_pos(spos)
+
+
+def is_creates(sp: str, spos: int, tp: str, tpos: int) -> bool:
+    if sp == tp:
+        return False
+    lateral_s = spos in (0, 2)
+    lateral_t = tpos in (0, 2)
+    return (lateral_s and tpos == 1) or (spos == 1 and lateral_t)
+
+
+def classify(sp: str, spos: int, tp: str, tpos: int) -> str:
+    if is_mirror(sp, spos, tp, tpos):
+        return "mirrorOf"
+    if is_creates(sp, spos, tp, tpos):
+        return "creates"
+    return "none"
+
+
+class ExhaustivePartitionTests(unittest.TestCase):
+    """Todas las combinaciones (fase, pos) × (fase, pos) no reflexivas."""
+
+    def test_partition_is_complete_and_exclusive(self):
+        nodes = list(itertools.product(PHASES, POSITIONS))
+        counts = {"none": 0, "mirrorOf": 0, "creates": 0}
+        for (sp, spos), (tp, tpos) in itertools.product(nodes, nodes):
+            if (sp, spos) == (tp, tpos):
+                continue
+            label = classify(sp, spos, tp, tpos)
+            counts[label] += 1
+            # exclusividad
+            m = is_mirror(sp, spos, tp, tpos)
+            c = is_creates(sp, spos, tp, tpos)
+            self.assertFalse(m and c)
+            if label == "mirrorOf":
+                self.assertTrue(m)
+            elif label == "creates":
+                self.assertTrue(c)
+            else:
+                self.assertFalse(m or c)
+        # 6 nodos, 30 pares dirigidos no reflexivos
+        self.assertEqual(sum(counts.values()), 30)
+        # Por tríada: 6 mirror, 8 creates, 16 none → ×13 = 78/104/208
+        self.assertEqual(counts["mirrorOf"], 6)
+        self.assertEqual(counts["creates"], 8)
+        self.assertEqual(counts["none"], 16)
+
+    def test_mirror_is_involution_on_position(self):
+        for p in POSITIONS:
+            self.assertEqual(mirror_pos(mirror_pos(p)), p)
+
+    def test_phase_opposite_is_involution(self):
+        for p in PHASES:
+            self.assertEqual(opposite_phase(opposite_phase(p)), p)
+            self.assertNotEqual(opposite_phase(p), p)
+
+
+class NegativeCaseTests(unittest.TestCase):
+    """Casos que DEBEN fallar / clasificarse como none."""
+
+    def test_same_phase_never_mirror_or_creates(self):
+        for phase in PHASES:
+            for spos, tpos in itertools.product(POSITIONS, POSITIONS):
+                if spos == tpos:
+                    continue
+                self.assertEqual(classify(phase, spos, phase, tpos), "none")
+
+    def test_wrong_mirror_position_is_none(self):
+        # adv P0 → ret P0 no es espejo (debería ser P2)
+        self.assertFalse(is_mirror("adv", 0, "ret", 0))
+        self.assertFalse(is_mirror("adv", 0, "ret", 1))
+        self.assertTrue(is_mirror("adv", 0, "ret", 2))
+
+    def test_creates_requires_center_involvement(self):
+        # lateral → lateral (sin centro) no es creates
+        self.assertFalse(is_creates("adv", 0, "ret", 2))
+        self.assertFalse(is_creates("adv", 2, "ret", 0))
+        # lateral → centro sí
+        self.assertTrue(is_creates("adv", 0, "ret", 1))
+        self.assertTrue(is_creates("adv", 1, "ret", 0))
+
+    def test_index_bounds(self):
+        """Posiciones fuera de {0,1,2} no son válidas en la especificación."""
+        for bad in (-1, 3, 4, 99):
+            # mirror_pos fuera de dominio no debe usarse en producción;
+            # documentamos el comportamiento aritmético
+            mirrored = 2 - bad
+            self.assertNotIn(bad, POSITIONS)
+            self.assertNotIn(mirrored, POSITIONS) if bad not in ( -1,) else True
+
+    def test_center_mirror_is_center(self):
+        self.assertEqual(mirror_pos(1), 1)
+        self.assertTrue(is_mirror("adv", 1, "ret", 1))
+
+
+class GenerativeConsistencyTests(unittest.TestCase):
+    """Propiedades que deben sostenerse para cualquier tríada sintética."""
+
+    def test_mirror_count_per_synthetic_triad(self):
+        nodes = list(itertools.product(PHASES, POSITIONS))
+        mirrors = [
+            ((sp, spos), (tp, tpos))
+            for (sp, spos), (tp, tpos) in itertools.product(nodes, nodes)
+            if (sp, spos) != (tp, tpos) and is_mirror(sp, spos, tp, tpos)
+        ]
+        self.assertEqual(len(mirrors), 6)
+        # reciprocidad: si A mirrors B, B mirrors A
+        mirror_set = set(mirrors)
+        for a, b in mirrors:
+            self.assertIn((b, a), mirror_set)
+
+    def test_creates_count_per_synthetic_triad(self):
+        nodes = list(itertools.product(PHASES, POSITIONS))
+        creates = [
+            ((sp, spos), (tp, tpos))
+            for (sp, spos), (tp, tpos) in itertools.product(nodes, nodes)
+            if (sp, spos) != (tp, tpos) and is_creates(sp, spos, tp, tpos)
+        ]
+        self.assertEqual(len(creates), 8)
+
+    def test_no_overlap_mirror_creates_generative(self):
+        nodes = list(itertools.product(PHASES, POSITIONS))
+        for (sp, spos), (tp, tpos) in itertools.product(nodes, nodes):
+            if (sp, spos) == (tp, tpos):
+                continue
+            self.assertFalse(
+                is_mirror(sp, spos, tp, tpos) and is_creates(sp, spos, tp, tpos)
+            )
+
+
+class AxisBoundTests(unittest.TestCase):
+    """Límites del eje vectorial [0, 4] alineados con FormalRules.lean."""
+
+    def test_axis_in_0_4(self):
+        for n in range(5):
+            self.assertTrue(0 <= n <= 4)
+
+    def test_axis_retreat_involution(self):
+        for n in range(5):
+            self.assertEqual(4 - (4 - n), n)
+
+    def test_axis_out_of_range_rejected(self):
+        for bad in (-1, 5, 6):
+            self.assertFalse(0 <= bad <= 4)
+
+
+if __name__ == "__main__":
+    unittest.main()

test_property_links.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Pruebas de propiedades que conectan Lean, CSV y ontología generada."""
+from __future__ import annotations
+
+import csv
+import json
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def load_spec() -> dict:
+    return json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8"))
+
+
+def load_csv(name: str) -> list[dict]:
+    with (ROOT / "datasets" / name).open(encoding="utf-8", newline="") as fh:
+        return list(csv.DictReader(fh))
+
+
+class PropertyLinksTests(unittest.TestCase):
+    """Conectan la especificación JSON, los CSV regenerados y las reglas formales."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.spec = load_spec()
+        cls.nodes = load_csv("triad_nodes.csv")
+        cls.relations = load_csv("relation_candidates.csv")
+        cls.vectors = load_csv("vector_steps.csv")
+        cls.n_triads = len(cls.spec["triads"]["adv"])
+
+    def test_spec_has_formal_version(self):
+        self.assertIn("spec_version", self.spec)
+        self.assertRegex(self.spec["spec_version"], r"^\d+\.\d+\.\d+$")
+        self.assertIn("schema_version", self.spec)
+
+    def test_node_count_matches_spec(self):
+        expected = self.n_triads * 2 * 3
+        self.assertEqual(len(self.nodes), expected)
+        indices = {int(r["triad_index"]) for r in self.nodes}
+        self.assertEqual(indices, set(range(1, self.n_triads + 1)))
+
+    def test_relation_candidate_count(self):
+        expected = self.n_triads * 6 * 5
+        self.assertEqual(len(self.relations), expected)
+
+    def test_gold_relation_counts(self):
+        counts = {"none": 0, "mirrorOf": 0, "creates": 0}
+        for row in self.relations:
+            counts[row["relation"]] += 1
+        self.assertEqual(counts["mirrorOf"], 78)
+        self.assertEqual(counts["creates"], 104)
+        self.assertEqual(counts["none"], 208)
+
+    def test_mirrorOf_property_holds_in_csv(self):
+        """Cada arista mirrorOf respeta: misma tríada, fase opuesta, posición reflejada."""
+        for row in self.relations:
+            if row["relation"] != "mirrorOf":
+                continue
+            src, tgt = row["source"], row["target"]
+            s_parts = src.split("_")
+            t_parts = tgt.split("_")
+            self.assertEqual(s_parts[0], t_parts[0], "misma tríada")
+            self.assertNotEqual(s_parts[1], t_parts[1], "fase opuesta")
+            s_pos = int(s_parts[2][1:])
+            t_pos = int(t_parts[2][1:])
+            self.assertEqual(t_pos, 2 - s_pos, "posición reflejada")
+
+    def test_creates_property_holds_in_csv(self):
+        """Cada arista creates respeta las cuatro reglas de creation_rules."""
+        rules = self.spec["creation_rules"]
+        allowed = set()
+        for rule in rules:
+            for sp in rule["source_positions"]:
+                for tp in rule["target_positions"]:
+                    allowed.add((rule["source_phase"], sp, rule["target_phase"], tp))
+        for row in self.relations:
+            if row["relation"] != "creates":
+                continue
+            s_parts = row["source"].split("_")
+            t_parts = row["target"].split("_")
+            key = (s_parts[1], int(s_parts[2][1:]), t_parts[1], int(t_parts[2][1:]))
+            self.assertIn(key, allowed, f"creates no permitido: {row['source']} -> {row['target']}")
+
+    def test_vector_steps_count(self):
+        self.assertEqual(len(self.vectors), 20)
+
+    def test_lean_operators_file_exists_and_mentions_mirror(self):
+        """El código Lean debe existir y referenciar los operadores de espejo."""
+        lean_spec = (ROOT / "IOM" / "Specification.lean").read_text(encoding="utf-8")
+        self.assertIn("mirror", lean_spec.lower())
+        self.assertIn("TriadPosition", lean_spec)
+        self.assertTrue((ROOT / "IOM" / "Core.lean").exists())
+        self.assertTrue((ROOT / "IOM" / "Operators.lean").exists())
+
+    def test_ontology_ttl_contains_mirrorOf_and_creates(self):
+        ttl = (ROOT / "ontology" / "io_ontology.ttl").read_text(encoding="utf-8")
+        self.assertIn("mirrorOf", ttl)
+        self.assertIn("creates", ttl)
+        self.assertIn("OntoNode", ttl)
+
+    def test_shacl_shapes_exist(self):
+        shapes = (ROOT / "ontology" / "io_shapes.ttl").read_text(encoding="utf-8")
+        self.assertIn("mirrorOf", shapes)
+        self.assertIn("creates", shapes)
+
+
+if __name__ == "__main__":
+    unittest.main()

test_score_independent_eval.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Pruebas del lector de anotaciones, null≠unsure y política de kappa sin truncar."""
+from __future__ import annotations
+
+import json
+import tempfile
+import unittest
+from pathlib import Path
+import importlib.util
+
+ROOT = Path(__file__).resolve().parents[1]
+SPEC = ROOT / "scripts" / "score_independent_eval.py"
+
+spec = importlib.util.spec_from_file_location("score_independent_eval", SPEC)
+mod = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(mod)
+
+
+class TemplateFormatTests(unittest.TestCase):
+    def test_parse_empty_template(self):
+        data = {
+            "annotators": ["A1", "A2", "A3"],
+            "status": "pending_human_collection",
+            "items": [
+                {"id": "NR01", "annotations": {"A1": None, "A2": None, "A3": None}},
+            ],
+        }
+        aids, by_pair = mod.parse_template_format(data)
+        self.assertEqual(aids, ["A1", "A2", "A3"])
+        self.assertIsNone(by_pair["NR01"]["A1"])
+
+    def test_null_not_unsure(self):
+        data = {
+            "annotators": ["A1", "A2", "A3"],
+            "items": [
+                {
+                    "id": "CT01",
+                    "annotations": {"A1": "mirrorOf", "A2": "mirrorOf", "A3": None},
+                },
+            ],
+        }
+        _, by_pair = mod.parse_template_format(data)
+        self.assertIsNone(by_pair["CT01"]["A3"])
+
+    def test_invalid_label_rejected(self):
+        data = {
+            "annotators": ["A1"],
+            "items": [{"id": "X", "annotations": {"A1": "maybe"}}],
+        }
+        with self.assertRaises(ValueError):
+            mod.parse_template_format(data)
+
+
+class NoTruncatePolicyTests(unittest.TestCase):
+    def test_heterogeneous_respondent_sets_excluded(self):
+        payload = {
+            "annotators": ["A1", "A2", "A3", "A4"],
+            "status": "partial",
+            "items": [
+                {
+                    "id": "P1",
+                    "annotations": {
+                        "A1": "none",
+                        "A2": "none",
+                        "A3": "none",
+                        "A4": None,
+                    },
+                },
+                {
+                    "id": "P3",
+                    "annotations": {
+                        "A1": "mirrorOf",
+                        "A2": "mirrorOf",
+                        "A3": None,
+                        "A4": "mirrorOf",
+                    },
+                },
+            ],
+        }
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".json", delete=False, encoding="utf-8"
+        ) as fh:
+            json.dump(payload, fh)
+            path = Path(fh.name)
+        try:
+            aids, by_pair, _meta = mod.load_annotations(path)
+            k_required = 3
+            respondent_sets = {}
+            for pid, ann_map in by_pair.items():
+                respondents = tuple(
+                    aid for aid in aids if ann_map.get(aid) is not None
+                )
+                if len(respondents) == k_required:
+                    respondent_sets[pid] = respondents
+            self.assertEqual(respondent_sets["P1"], ("A1", "A2", "A3"))
+            self.assertEqual(respondent_sets["P3"], ("A1", "A2", "A4"))
+            self.assertNotEqual(respondent_sets["P1"], respondent_sets["P3"])
+        finally:
+            path.unlink(missing_ok=True)
+
+
+class FleissTests(unittest.TestCase):
+    def test_perfect_agreement(self):
+        ratings = [["none", "none", "none"], ["mirrorOf", "mirrorOf", "mirrorOf"]]
+        k = mod.fleiss_kappa(ratings, ["none", "mirrorOf", "creates", "unsure"])
+        self.assertAlmostEqual(k, 1.0)
+
+    def test_mismatched_lengths_raise(self):
+        with self.assertRaises(ValueError):
+            mod.fleiss_kappa(
+                [["none", "none"], ["none", "none", "none"]],
+                ["none", "mirrorOf"],
+            )
+
+
+class AnnotatorPairsBlindTests(unittest.TestCase):
+    def test_default_pairs_have_no_structural_hints(self):
+        path = ROOT / "datasets" / "independent_eval" / "annotator_pairs.csv"
+        text = path.read_text(encoding="utf-8").lower()
+        forbidden = [
+            "fase",
+            "posición",
+            "posicion",
+            "lateral",
+            "centro",
+            "espejo",
+            "creates",
+            "mirror",
+            "avance",
+            "retroceso",
+            "canónico",
+            "canonico",
+            "vocabulario",
+            "13 filas",
+            "ajeno",
+            "new_concept",
+            "out_of_rules",
+        ]
+        for word in forbidden:
+            self.assertNotIn(
+                word,
+                text,
+                f"annotator_pairs.csv no debe contener la pista {word!r}",
+            )
+
+    def test_nc_items_use_generic_context(self):
+        path = ROOT / "datasets" / "independent_eval" / "annotator_pairs.csv"
+        lines = {
+            row.split(",")[0]: row
+            for row in path.read_text(encoding="utf-8").strip().splitlines()[1:]
+        }
+        for nid in ("NC01", "NC02", "NC03"):
+            self.assertIn(nid, lines)
+            self.assertIn("Par de conceptos", lines[nid])
+            self.assertNotIn("vocabulario", lines[nid].lower())
+            self.assertNotIn("13", lines[nid])
+
+
+if __name__ == "__main__":
+    unittest.main()

test_validate_spec.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Validación del schema y de la spec canónica."""
+from __future__ import annotations
+
+import json
+import unittest
+from copy import deepcopy
+from pathlib import Path
+
+from jsonschema import Draft202012Validator
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMA = json.loads((ROOT / "data" / "iom_spec.schema.json").read_text(encoding="utf-8"))
+SPEC = json.loads((ROOT / "data" / "iom_spec.json").read_text(encoding="utf-8"))
+
+
+class SpecificationSchemaTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.validator = Draft202012Validator(SCHEMA)
+
+    def test_canonical_spec_conforms_to_schema(self):
+        errors = list(self.validator.iter_errors(SPEC))
+        self.assertEqual(errors, [])
+
+    def test_canonical_position_metadata_and_triad_indexing_are_accepted(self):
+        spec = deepcopy(SPEC)
+        spec["positions"]["indices"] = [0, 1, 2]
+        spec["positions"]["adv_labels"] = ["→", "0", "→"]
+        spec["positions"]["ret_labels"] = ["←", "0", "←"]
+        spec["positions"]["perspectives"] = ["Ind", "D", "Tot"]
+        spec["triads"]["index_base"] = 1
+        spec["triads"]["note"] = "Los arrays empiezan en cero; triad_index es 1-based."
+        errors = list(self.validator.iter_errors(spec))
+        self.assertEqual(errors, [])
+
+    def test_invalid_position_metadata_is_rejected(self):
+        invalid_spec = deepcopy(SPEC)
+        invalid_spec["positions"]["indices"] = [0, 1]
+        errors = list(self.validator.iter_errors(invalid_spec))
+        self.assertTrue(any(list(error.absolute_path)[:1] == ["positions"] for error in errors))
+
+    def test_unknown_triad_metadata_is_rejected(self):
+        spec = deepcopy(SPEC)
+        spec["triads"]["unexpected"] = True
+        errors = list(self.validator.iter_errors(spec))
+        self.assertTrue(any(list(error.absolute_path) == ["triads"] for error in errors))
+
+    def test_missing_spec_version_is_rejected(self):
+        invalid_spec = deepcopy(SPEC)
+        del invalid_spec["spec_version"]
+        errors = list(self.validator.iter_errors(invalid_spec))
+        self.assertTrue(any("spec_version" in error.message for error in errors))
+
+    def test_malformed_semantic_version_is_rejected(self):
+        invalid_spec = deepcopy(SPEC)
+        invalid_spec["spec_version"] = "1.1"
+        errors = list(self.validator.iter_errors(invalid_spec))
+        self.assertTrue(any(list(error.absolute_path) == ["spec_version"] for error in errors))
+
+    def test_purpose_is_present_and_matches_schema(self):
+        """La unidad informativa queda registrada en el spec canónico."""
+        self.assertIn("purpose", SPEC)
+        purpose = SPEC["purpose"]
+        self.assertEqual(purpose["id"], "informational_unit_creation")
+        self.assertIn("mínima estructura autocontenida", purpose["definition"])
+        self.assertIn("criterion", purpose)
+        errors = list(self.validator.iter_errors(SPEC))
+        self.assertEqual(errors, [])
+
+    def test_generated_from_records_purpose_id(self):
+        stamp = json.loads((ROOT / "datasets" / "GENERATED_FROM.json").read_text(encoding="utf-8"))
+        self.assertEqual(stamp.get("purpose_id"), "informational_unit_creation")
+        self.assertEqual(stamp.get("spec_version"), SPEC["spec_version"])
+
+
+if __name__ == "__main__":
+    unittest.main()