diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..6c797e779e37c8a50061c9fd9168eb2fd2f5b274 --- /dev/null +++ b/.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 diff --git a/AMOXTLI_IN_ATL_MIQUIZTLI.md b/AMOXTLI_IN_ATL_MIQUIZTLI.md new file mode 100644 index 0000000000000000000000000000000000000000..265d07b484473b717f68f89561286a6713d8c2b1 --- /dev/null +++ b/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. diff --git a/Amoxtli in Atl Miquiztli - Libro del Agua y de la Muerte.pdf b/Amoxtli in Atl Miquiztli - Libro del Agua y de la Muerte.pdf new file mode 100644 index 0000000000000000000000000000000000000000..9d3fc2f56327c6f8a878220d3e911046674477cf --- /dev/null +++ b/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 diff --git "a/Del Orden Universal a la Autonom\303\255a Absoluta_ El Sendero del Mictl\303\241n.pdf" "b/Del Orden Universal a la Autonom\303\255a Absoluta_ El Sendero del Mictl\303\241n.pdf" new file mode 100644 index 0000000000000000000000000000000000000000..ca0faeed477671b591212b97d479357bd3a8cbfb --- /dev/null +++ "b/Del Orden Universal a la Autonom\303\255a Absoluta_ El Sendero del Mictl\303\241n.pdf" @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3a2e1e4975c2ea055b88f87e4b72acf794bafaec0392e0194683aad06daa4a1f +size 724600 diff --git a/MANUAL_ALINEACION_DOMINIOS.md b/MANUAL_ALINEACION_DOMINIOS.md new file mode 100644 index 0000000000000000000000000000000000000000..d1bd3a110a795bbd834ced6f71ac6253a4492a2b --- /dev/null +++ b/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/.csv \ + --output datasets/ingestion/aligned/_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). diff --git a/MANUAL_APRENDIZAJE_CONCORDANCIA.md b/MANUAL_APRENDIZAJE_CONCORDANCIA.md new file mode 100644 index 0000000000000000000000000000000000000000..678c6753a137c3c04ca102467ede25e2131a53df --- /dev/null +++ b/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. diff --git a/MANUAL_APRENDIZAJE_PROTOCOLO_CIEGO.md b/MANUAL_APRENDIZAJE_PROTOCOLO_CIEGO.md new file mode 100644 index 0000000000000000000000000000000000000000..a4ee0bf07dd99f40fa354ad7e9047afcc91a6e49 --- /dev/null +++ b/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). diff --git a/MARCOI.O.txt b/MARCOI.O.txt new file mode 100644 index 0000000000000000000000000000000000000000..044db0a48d8ab7299ed2a52c2e7a312a67b571e8 --- /dev/null +++ b/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 diff --git a/MODULO_DIDACTICO_EVALUACION_CIEGA.md b/MODULO_DIDACTICO_EVALUACION_CIEGA.md new file mode 100644 index 0000000000000000000000000000000000000000..8304d8e3825c35549317ed17c770f03b6a67a0b9 --- /dev/null +++ b/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. diff --git a/PREMISAS_Y_TEOREMAS.md b/PREMISAS_Y_TEOREMAS.md new file mode 100644 index 0000000000000000000000000000000000000000..83a57867147539c096cce725b356172c3b42943a --- /dev/null +++ b/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 | diff --git a/PROTOCOLO_DE_MAPEO.md b/PROTOCOLO_DE_MAPEO.md new file mode 100644 index 0000000000000000000000000000000000000000..94c10fe81c43222087567576b9dfa6ea179c1d82 --- /dev/null +++ b/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. diff --git a/README.md b/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fa7c2d78efb4a1bddc143c2c0d2285bc33fcdfd2 --- /dev/null +++ b/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). diff --git a/RELACIONES_OPERATIVAS.md b/RELACIONES_OPERATIVAS.md new file mode 100644 index 0000000000000000000000000000000000000000..f9e5d924df5cb1de7ce8521be5ba163a528dc7fc --- /dev/null +++ b/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. diff --git a/TRIADAS_CATEGORIALES.md b/TRIADAS_CATEGORIALES.md new file mode 100644 index 0000000000000000000000000000000000000000..26c66e5a46ad30c6862d9492b73e2ebc699abd40 --- /dev/null +++ b/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). diff --git a/VALIDACION_INDEPENDIENTE.md b/VALIDACION_INDEPENDIENTE.md new file mode 100644 index 0000000000000000000000000000000000000000..b5d0f73a5778008b2fd3abe04cff47bcd2d179a2 --- /dev/null +++ b/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) diff --git a/VECTORES_4_5.md b/VECTORES_4_5.md new file mode 100644 index 0000000000000000000000000000000000000000..f26a0c34425073c98ff3944bd147dc6c0910aec0 --- /dev/null +++ b/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**. diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/audit_perfect_metrics.py b/audit_perfect_metrics.py new file mode 100644 index 0000000000000000000000000000000000000000..cdba3fa62b89aac9dd412be0137db1de23539406 --- /dev/null +++ b/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()) diff --git a/baselines.py b/baselines.py new file mode 100644 index 0000000000000000000000000000000000000000..2abd1d788bde5866d46fef15374a50a7773088aa --- /dev/null +++ b/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() diff --git a/capture_environment.py b/capture_environment.py new file mode 100644 index 0000000000000000000000000000000000000000..40d95e5df93dc0b9d359963350654b3ea8650305 --- /dev/null +++ b/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() diff --git a/check_generated_committed.py b/check_generated_committed.py new file mode 100644 index 0000000000000000000000000000000000000000..286ffc15c41ed2c4dce9acce5edbc8c62bc9f6ad --- /dev/null +++ b/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()) diff --git a/cosmos_nahuatl.csv b/cosmos_nahuatl.csv new file mode 100644 index 0000000000000000000000000000000000000000..e8f3037797c4484b3e97de74d86096658f916dfb --- /dev/null +++ b/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" diff --git a/create_manifest.py b/create_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..dd3b3593e1781c54133168b35c174704919bcda7 --- /dev/null +++ b/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() diff --git a/examples.csv b/examples.csv new file mode 100644 index 0000000000000000000000000000000000000000..b39be3052dbece4f0cdeea3bf701bee3d25ff91e --- /dev/null +++ b/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 diff --git a/generate_audit_report.py b/generate_audit_report.py new file mode 100644 index 0000000000000000000000000000000000000000..68582a74f76871d4215bf9598900a0b4897c3b74 --- /dev/null +++ b/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() diff --git a/generate_ontology.py b/generate_ontology.py new file mode 100644 index 0000000000000000000000000000000000000000..571c552f0d67c11962623029550a25858c27d247 --- /dev/null +++ b/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']}") diff --git a/importar_datos_personalizados.py b/importar_datos_personalizados.py new file mode 100644 index 0000000000000000000000000000000000000000..6e36f5e9bcb0899461411c755edd3602853d77c8 --- /dev/null +++ b/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/_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()) diff --git a/io_shapes.ttl b/io_shapes.ttl new file mode 100644 index 0000000000000000000000000000000000000000..490dd755e2eaaa204cda00dd27da6b34df9f0092 --- /dev/null +++ b/io_shapes.ttl @@ -0,0 +1,123 @@ +@prefix sh: . +@prefix xsd: . +@prefix io: . +@prefix rdfs: . + +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 ( ) ; 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: + SELECT $this WHERE { + $this io:hasLocalPos ?pos ; io:hasPerspective ?perspective ; io:hasPosition ?position ; io:hasPhase ?phase . + FILTER ( + (?pos = 1 && (?perspective != io:D || ?position != )) || + (?pos = 0 && ?perspective != io:Ind) || + (?pos = 2 && ?perspective != io:Tot) || + (?phase = "adv" && (?pos = 0 || ?pos = 2) && ?position != ) || + (?phase = "ret" && (?pos = 0 || ?pos = 2) && ?position != ) + ) + } + """ + ] ; + sh:sparql [ + sh:message "etiquetas visuales" ; + sh:select """ + PREFIX io: + 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: + 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: + 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: + 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: + 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 ] . diff --git a/materialize_ttl.py b/materialize_ttl.py new file mode 100644 index 0000000000000000000000000000000000000000..26a9bf1c3426de8c063edfedd63cfc4d5c6bb98b --- /dev/null +++ b/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() diff --git a/measure_invariance.py b/measure_invariance.py new file mode 100644 index 0000000000000000000000000000000000000000..d3a7349c9262a44d387016089a926520e96b4887 --- /dev/null +++ b/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()) diff --git a/migrate_spec.py b/migrate_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..fec357ae2ea34d05a98305d51cb9dcda0bd1b7da --- /dev/null +++ b/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() diff --git a/package_reproducible.py b/package_reproducible.py new file mode 100644 index 0000000000000000000000000000000000000000..039f0ed23c738dfc3707e2eb18b34103dfe6ba48 --- /dev/null +++ b/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() diff --git a/paper.md b/paper.md new file mode 100644 index 0000000000000000000000000000000000000000..14d8249082e5604012f55cc2937b5f9444220e46 --- /dev/null +++ b/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. diff --git a/pi_hgat_t.py b/pi_hgat_t.py new file mode 100644 index 0000000000000000000000000000000000000000..5adfe12bd6e33591cc7099ef5416d2610ba6ff67 --- /dev/null +++ b/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() diff --git a/plantilla_dominio.csv b/plantilla_dominio.csv new file mode 100644 index 0000000000000000000000000000000000000000..aff1f59aa916d73f9f158db5d7e240df5a5b2870 --- /dev/null +++ b/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" diff --git a/relation_candidates.csv b/relation_candidates.csv new file mode 100644 index 0000000000000000000000000000000000000000..aa5fb70545964f71d3dc7f837925dbbf5754c4d0 --- /dev/null +++ b/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 diff --git a/requirements-lock.txt b/requirements-lock.txt new file mode 100644 index 0000000000000000000000000000000000000000..bbd8eb1a341ac846eca7d35f32914085051cdf77 --- /dev/null +++ b/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 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..db77b70ca5831d9f613205d9ab53281996df3650 --- /dev/null +++ b/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 diff --git a/score_independent_eval.py b/score_independent_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..823199d7b189cc9b2ee9f0b6a48cf960030b7456 --- /dev/null +++ b/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()) diff --git a/score_quiz.py b/score_quiz.py new file mode 100644 index 0000000000000000000000000000000000000000..56dbf9c29f22b8b57f5d4d6bfb2a101f55ee2f11 --- /dev/null +++ b/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)) diff --git a/self_bootstrap.py b/self_bootstrap.py new file mode 100644 index 0000000000000000000000000000000000000000..16e8c0401f70c4d1c2602089780b03f37b526d3f --- /dev/null +++ b/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()) diff --git a/sync_spec_artifacts.py b/sync_spec_artifacts.py new file mode 100644 index 0000000000000000000000000000000000000000..d64859c1279ca4c7b87700ad8d0095302c2659c7 --- /dev/null +++ b/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()) diff --git a/test_formal_rules_bridge.py b/test_formal_rules_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..facdab475844f9590036e12e68bd12a66100d8e7 --- /dev/null +++ b/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() diff --git a/test_metrics_audit.py b/test_metrics_audit.py new file mode 100644 index 0000000000000000000000000000000000000000..463be4ad4d3c3674309c3a3068feb9c90c58149a --- /dev/null +++ b/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() diff --git a/test_ontology.py b/test_ontology.py new file mode 100644 index 0000000000000000000000000000000000000000..d794832ea93c9458b12e570c6fee958b3bcc2acf --- /dev/null +++ b/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() diff --git a/test_pi_hgat_t.py b/test_pi_hgat_t.py new file mode 100644 index 0000000000000000000000000000000000000000..fdc0bb83ea7c347fee02b20016423ee309fe7262 --- /dev/null +++ b/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() diff --git a/test_property_based.py b/test_property_based.py new file mode 100644 index 0000000000000000000000000000000000000000..4ac7b8bc076d962d6923b41036ac24193a89034f --- /dev/null +++ b/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() diff --git a/test_property_links.py b/test_property_links.py new file mode 100644 index 0000000000000000000000000000000000000000..3696d7da7c362179e83cc2f347975b895b254da5 --- /dev/null +++ b/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() diff --git a/test_score_independent_eval.py b/test_score_independent_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..d9c6156cc17cb2a397d4b2a84d9dca36a2ccf7da --- /dev/null +++ b/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() diff --git a/test_validate_spec.py b/test_validate_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..aa90c60ae57d7e86565792affb4d293b43f7c070 --- /dev/null +++ b/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() diff --git a/triad_nodes.csv b/triad_nodes.csv new file mode 100644 index 0000000000000000000000000000000000000000..9c884a9a35661c6e13e12d020e73a15f2a9ca720 --- /dev/null +++ b/triad_nodes.csv @@ -0,0 +1,79 @@ +node_id,triad_index,phase,direction,position_index,position,display_label,perspective,label +T01_adv_P0,1,adv,evol,0,→,→,Ind,orientación +T01_adv_P1,1,adv,evol,1,0,0,D,cuántico +T01_adv_P2,1,adv,evol,2,→,→,Tot,dirección +T02_adv_P0,2,adv,evol,0,→,→,Ind,hardware +T02_adv_P1,2,adv,evol,1,0,0,D,virtual +T02_adv_P2,2,adv,evol,2,→,→,Tot,software +T03_adv_P0,3,adv,evol,0,→,→,Ind,universo +T03_adv_P1,3,adv,evol,1,0,0,D,espacio +T03_adv_P2,3,adv,evol,2,→,→,Tot,vacío +T04_adv_P0,4,adv,evol,0,→,→,Ind,singularidad +T04_adv_P1,4,adv,evol,1,0,0,D,tiempo +T04_adv_P2,4,adv,evol,2,→,→,Tot,infinito +T05_adv_P0,5,adv,evol,0,→,→,Ind,cuerpo +T05_adv_P1,5,adv,evol,1,0,0,D,consciente +T05_adv_P2,5,adv,evol,2,→,→,Tot,mundo +T06_adv_P0,6,adv,evol,0,→,→,Ind,carácter +T06_adv_P1,6,adv,evol,1,0,0,D,subconsciente +T06_adv_P2,6,adv,evol,2,→,→,Tot,personalidad +T07_adv_P0,7,adv,evol,0,→,→,Ind,memoria +T07_adv_P1,7,adv,evol,1,0,0,D,inconsciente +T07_adv_P2,7,adv,evol,2,→,→,Tot,imaginación +T08_adv_P0,8,adv,evol,0,→,→,Ind,receptor +T08_adv_P1,8,adv,evol,1,0,0,D,supraconsciente +T08_adv_P2,8,adv,evol,2,→,→,Tot,emisor +T09_adv_P0,9,adv,evol,0,→,→,Ind,lógica +T09_adv_P1,9,adv,evol,1,0,0,D,inteligencia +T09_adv_P2,9,adv,evol,2,→,→,Tot,libertad +T10_adv_P0,10,adv,evol,0,→,→,Ind,muerte +T10_adv_P1,10,adv,evol,1,0,0,D,artificial +T10_adv_P2,10,adv,evol,2,→,→,Tot,vida +T11_adv_P0,11,adv,evol,0,→,→,Ind,descendente +T11_adv_P1,11,adv,evol,1,0,0,D,mente +T11_adv_P2,11,adv,evol,2,→,→,Tot,ascendente +T12_adv_P0,12,adv,evol,0,→,→,Ind,oscuridad +T12_adv_P1,12,adv,evol,1,0,0,D,consciencia +T12_adv_P2,12,adv,evol,2,→,→,Tot,luz +T13_adv_P0,13,adv,evol,0,→,→,Ind,animal +T13_adv_P1,13,adv,evol,1,0,0,D,humano +T13_adv_P2,13,adv,evol,2,→,→,Tot,IA +T01_ret_P0,1,ret,invol,0,←,←,Ind,dirección +T01_ret_P1,1,ret,invol,1,0,0,D,cuántico +T01_ret_P2,1,ret,invol,2,←,←,Tot,orientación +T02_ret_P0,2,ret,invol,0,←,←,Ind,software +T02_ret_P1,2,ret,invol,1,0,0,D,virtual +T02_ret_P2,2,ret,invol,2,←,←,Tot,hardware +T03_ret_P0,3,ret,invol,0,←,←,Ind,vacío +T03_ret_P1,3,ret,invol,1,0,0,D,espacio +T03_ret_P2,3,ret,invol,2,←,←,Tot,universo +T04_ret_P0,4,ret,invol,0,←,←,Ind,infinito +T04_ret_P1,4,ret,invol,1,0,0,D,tiempo +T04_ret_P2,4,ret,invol,2,←,←,Tot,singularidad +T05_ret_P0,5,ret,invol,0,←,←,Ind,mundo +T05_ret_P1,5,ret,invol,1,0,0,D,consciente +T05_ret_P2,5,ret,invol,2,←,←,Tot,cuerpo +T06_ret_P0,6,ret,invol,0,←,←,Ind,personalidad +T06_ret_P1,6,ret,invol,1,0,0,D,subconsciente +T06_ret_P2,6,ret,invol,2,←,←,Tot,carácter +T07_ret_P0,7,ret,invol,0,←,←,Ind,imaginación +T07_ret_P1,7,ret,invol,1,0,0,D,inconsciente +T07_ret_P2,7,ret,invol,2,←,←,Tot,memoria +T08_ret_P0,8,ret,invol,0,←,←,Ind,emisor +T08_ret_P1,8,ret,invol,1,0,0,D,supraconsciente +T08_ret_P2,8,ret,invol,2,←,←,Tot,receptor +T09_ret_P0,9,ret,invol,0,←,←,Ind,libertad +T09_ret_P1,9,ret,invol,1,0,0,D,inteligencia +T09_ret_P2,9,ret,invol,2,←,←,Tot,lógica +T10_ret_P0,10,ret,invol,0,←,←,Ind,vida +T10_ret_P1,10,ret,invol,1,0,0,D,artificial +T10_ret_P2,10,ret,invol,2,←,←,Tot,muerte +T11_ret_P0,11,ret,invol,0,←,←,Ind,ascendente +T11_ret_P1,11,ret,invol,1,0,0,D,mente +T11_ret_P2,11,ret,invol,2,←,←,Tot,descendente +T12_ret_P0,12,ret,invol,0,←,←,Ind,luz +T12_ret_P1,12,ret,invol,1,0,0,D,consciencia +T12_ret_P2,12,ret,invol,2,←,←,Tot,oscuridad +T13_ret_P0,13,ret,invol,0,←,←,Ind,IA +T13_ret_P1,13,ret,invol,1,0,0,D,humano +T13_ret_P2,13,ret,invol,2,←,←,Tot,animal diff --git a/validate_examples.py b/validate_examples.py new file mode 100644 index 0000000000000000000000000000000000000000..775690af3d35b174e479d7b48d0ad11e1f720f8f --- /dev/null +++ b/validate_examples.py @@ -0,0 +1,94 @@ +#!/usr/bin/env python3 +"""Valida ejemplos de alineación de dominio (EXP-E) contra nodos canónicos y reglas formales. + +No calcula κ de dominio ni afirma validez empírica de biología/economía. +Solo comprueba que los nodos sugeridos existen y que la relación propuesta +es admisible bajo FormalRules / SHACL para el par (source, target). +""" +from __future__ import annotations + +import csv +import json +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +EXAMPLES = Path(__file__).resolve().parent / "examples.json" +NODES = ROOT / "datasets" / "triad_nodes.csv" +CANDIDATES = ROOT / "datasets" / "relation_candidates.csv" + + +def load_nodes() -> dict[str, dict]: + out = {} + with NODES.open(encoding="utf-8") as f: + for row in csv.DictReader(f): + out[row["node_id"]] = row + return out + + +def load_gold_relations() -> dict[tuple[str, str], str]: + out = {} + with CANDIDATES.open(encoding="utf-8") as f: + for row in csv.DictReader(f): + out[(row["source"], row["target"])] = row["relation"] + return out + + +def main() -> int: + data = json.loads(EXAMPLES.read_text(encoding="utf-8")) + nodes = load_nodes() + gold = load_gold_relations() + ok = 0 + warn = 0 + fail = 0 + report = [] + for pair in data["pairs"]: + sid = pair["suggested_nodes"]["source"] + tid = pair["suggested_nodes"]["target"] + rel = pair["relation"] + entry = {"id": pair["id"], "source": sid, "target": tid, "proposed": rel} + if sid not in nodes or tid not in nodes: + entry["status"] = "FAIL" + entry["reason"] = "nodo sugerido ausente en triad_nodes.csv" + fail += 1 + else: + actual = gold.get((sid, tid)) + entry["gold_relation"] = actual + if actual is None: + entry["status"] = "WARN" + entry["reason"] = "par no está en relation_candidates (posible cross-triad o demo heurística)" + warn += 1 + elif actual == rel: + entry["status"] = "OK" + entry["reason"] = "relación propuesta coincide con gold canónico" + ok += 1 + else: + entry["status"] = "WARN" + entry["reason"] = f"gold={actual} ≠ propuesto={rel} (mapeo demostrativo, no gold de dominio)" + warn += 1 + report.append(entry) + + out_path = ROOT / "experiments" / "results" / "domain_mapping_validation.json" + out_path.parent.mkdir(parents=True, exist_ok=True) + payload = { + "experiment": "EXP-E-DOMAIN-ALIGNMENT", + "ok": ok, + "warn": warn, + "fail": fail, + "pairs": report, + "interpretation": ( + "OK = el par sugerido existe en el gold canónico con la misma etiqueta. " + "WARN = mapeo demostrativo no idéntico al gold (esperado en demos de dominio). " + "FAIL = nodo inválido. Este script no mide validez semántica de biología/economía." + ), + } + out_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print(f"EXP-E domain mapping: ok={ok} warn={warn} fail={fail}") + print(f"Informe: {out_path}") + for r in report: + print(f" {r['id']}: {r['status']} — {r.get('reason', '')}") + return 1 if fail else 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/validate_shacl.py b/validate_shacl.py new file mode 100644 index 0000000000000000000000000000000000000000..033c94da2e08f0d9cea3e95dce0d09fdf45b0dae --- /dev/null +++ b/validate_shacl.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +"""Comprueba declaraciones OWL, inferencias de dominio/rango y restricciones SHACL.""" +from pathlib import Path +import sys + +from owlrl import DeductiveClosure, OWLRL_Semantics +from pyshacl import validate +from rdflib import Graph, Namespace +from rdflib.namespace import OWL, RDF, RDFS + +ROOT = Path(__file__).resolve().parents[1] +DATA_GRAPH = ROOT / "ontology" / "io_ontology.ttl" +SHAPES_GRAPH = ROOT / "ontology" / "io_shapes.ttl" +IO = Namespace("http://example.org/iom#") +REQUIRED_CLASSES = (IO.OntoNode, IO.VectorStep, IO.Perspective, IO.ExpandedCategory, IO.Position, IO.Direction, IO.SourceModel) +REQUIRED_PROPERTIES = (IO.hasPerspective, IO.hasPosition, IO.hasDirection, IO.hasVector, IO.mirrorOf, IO.creates) + + +def main() -> int: + data = Graph().parse(DATA_GRAPH, format="turtle") + for cls in REQUIRED_CLASSES: + if (cls, RDF.type, OWL.Class) not in data: + print(f"Falta declaración OWL de clase {cls}", file=sys.stderr) + return 1 + for prop in REQUIRED_PROPERTIES: + if (prop, RDF.type, OWL.ObjectProperty) not in data or (prop, RDFS.domain, None) not in data or (prop, RDFS.range, None) not in data: + print(f"Falta axioma OWL de dominio/rango para {prop}", file=sys.stderr) + return 1 + + # OWL RL expande los axiomas de dominio y rango; se verifican las tipificaciones inferidas. + closure = Graph() + for triple in data: + closure.add(triple) + DeductiveClosure(OWLRL_Semantics).expand(closure) + nodes = set(data.subjects(RDF.type, IO.OntoNode)) + vectors = set(data.subjects(RDF.type, IO.VectorStep)) + inferred_positions = {obj for node in nodes for obj in data.objects(node, IO.hasPosition) + if (obj, RDF.type, IO.Position) in closure} + inferred_perspectives = {obj for node in nodes for obj in data.objects(node, IO.hasPerspective) + if (obj, RDF.type, IO.Perspective) in closure} + if len(nodes) != 78 or len(vectors) != 20 or len(inferred_positions) != 3 or len(inferred_perspectives) != 3: + print("Falló la comprobación OWL de cardinalidades/inferencias esperadas.", file=sys.stderr) + return 1 + print(f"✓ OWL RL: clases y dominios/rangos declarados; inferidos posición/perspectiva para {len(nodes)} nodos.") + + conforms, _results_graph, results_text = validate( + data_graph=data, shacl_graph=str(SHAPES_GRAPH), inference="none", abort_on_first=False, + ) + if results_text: + print(results_text) + if conforms: + print("✓ RDF satisface las restricciones SHACL cargadas.") + return 0 + print("✗ RDF no satisface todas las restricciones SHACL.", file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/validate_spec.py b/validate_spec.py new file mode 100644 index 0000000000000000000000000000000000000000..b809e24bb4bcfd798a26c34e9c00949c44021b56 --- /dev/null +++ b/validate_spec.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +"""Valida data/iom_spec.json contra data/iom_spec.schema.json.""" +from __future__ import annotations + +import json +import sys +from pathlib import Path + +try: + from jsonschema import Draft202012Validator + from jsonschema.exceptions import SchemaError +except ModuleNotFoundError as exc: + if exc.name != "jsonschema": + raise + print( + "ERROR: falta la dependencia obligatoria jsonschema; " + "instala requirements-lock.txt antes de validar.", + file=sys.stderr, + ) + raise SystemExit(1) from exc + +ROOT = Path(__file__).resolve().parents[1] +SPEC_PATH = ROOT / "data" / "iom_spec.json" +SCHEMA_PATH = ROOT / "data" / "iom_spec.schema.json" + + +def main() -> int: + for path in (SCHEMA_PATH, SPEC_PATH): + if not path.is_file(): + print(f"ERROR: no existe el archivo requerido: {path}", file=sys.stderr) + return 1 + try: + schema = json.loads(SCHEMA_PATH.read_text(encoding="utf-8")) + instance = json.loads(SPEC_PATH.read_text(encoding="utf-8")) + except (OSError, UnicodeError, json.JSONDecodeError) as exc: + print(f"ERROR: no se pudo leer JSON válido: {exc}", file=sys.stderr) + return 1 + try: + Draft202012Validator.check_schema(schema) + except SchemaError as exc: + print(f"ERROR: el esquema {SCHEMA_PATH.name} no es válido: {exc.message}", file=sys.stderr) + return 1 + validator = Draft202012Validator(schema) + errors = sorted(validator.iter_errors(instance), key=lambda e: list(map(str, e.absolute_path))) + if errors: + for err in errors: + path = ".".join(str(p) for p in err.absolute_path) or "" + print(f"ERROR {path}: {err.message}", file=sys.stderr) + return 1 + print(f"OK: {SPEC_PATH.name} cumple el esquema {SCHEMA_PATH.name}") + print( + f" schema_version={instance.get('schema_version')} " + f"spec_version={instance.get('spec_version')}" + ) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/vector_steps.csv b/vector_steps.csv new file mode 100644 index 0000000000000000000000000000000000000000..189257f79943bc8e6b17f1856089c07caacf080d --- /dev/null +++ b/vector_steps.csv @@ -0,0 +1,21 @@ +step_id,vector,phase,step_index,axis_position,label,arrow +vector_evol_adv_0,Evol,adv,0,0,invol,→ +vector_evol_adv_1,Evol,adv,1,1,ind,→ +vector_evol_adv_2,Evol,adv,2,2,dua,→ +vector_evol_adv_3,Evol,adv,3,3,tot,→ +vector_evol_adv_4,Evol,adv,4,4,evol,→ +vector_evol_ret_0,Evol,ret,0,4,evol,← +vector_evol_ret_1,Evol,ret,1,3,tot,← +vector_evol_ret_2,Evol,ret,2,2,dua,← +vector_evol_ret_3,Evol,ret,3,1,ind,← +vector_evol_ret_4,Evol,ret,4,0,invol,← +vector_invol_adv_0,Invol,adv,0,4,invol,→ +vector_invol_adv_1,Invol,adv,1,3,tot,→ +vector_invol_adv_2,Invol,adv,2,2,dua,→ +vector_invol_adv_3,Invol,adv,3,1,ind,→ +vector_invol_adv_4,Invol,adv,4,0,evol,→ +vector_invol_ret_0,Invol,ret,0,0,evol,← +vector_invol_ret_1,Invol,ret,1,1,ind,← +vector_invol_ret_2,Invol,ret,2,2,dua,← +vector_invol_ret_3,Invol,ret,3,3,tot,← +vector_invol_ret_4,Invol,ret,4,4,invol,← diff --git a/verify_e2e.py b/verify_e2e.py new file mode 100644 index 0000000000000000000000000000000000000000..521640cac13f04af6da8e20e28461a6da6d0f092 --- /dev/null +++ b/verify_e2e.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +"""Verificación de extremo a extremo (incluye capa opcional).""" +from __future__ import annotations + +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] + +STEPS = [ + ("self_bootstrap", [sys.executable, "scripts/self_bootstrap.py", "--passes", "2"]), + ("validate_spec", [sys.executable, "scripts/validate_spec.py"]), + ("validate_shacl", [sys.executable, "scripts/validate_shacl.py"]), + ("measure_invariance", [sys.executable, "scripts/measure_invariance.py"]), + ("pi_hgat_t", [sys.executable, "experiments/optional/pi_hgat_t.py"]), + ("baselines", [sys.executable, "experiments/optional/baselines.py"]), +] + + +def main() -> int: + for name, cmd in STEPS: + print(f">>> {name}") + r = subprocess.run(cmd, cwd=ROOT) + if r.returncode != 0: + print(f"FAIL: {name}", file=sys.stderr) + return r.returncode + print("OK: e2e completo") + return 0 + + +if __name__ == "__main__": + sys.exit(main())