Datasets:

Simple7up
/

IOM

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

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

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

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

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

MANUAL_ALINEACION_DOMINIOS.md DELETED Viewed

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

MANUAL_APRENDIZAJE_CONCORDANCIA.md DELETED Viewed

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

MANUAL_APRENDIZAJE_PROTOCOLO_CIEGO.md DELETED Viewed

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

MARCOI.O.txt DELETED Viewed

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

MODULO_DIDACTICO_EVALUACION_CIEGA.md DELETED Viewed

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

PREMISAS_Y_TEOREMAS.md DELETED Viewed

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

PROTOCOLO_DE_MAPEO.md DELETED Viewed

@@ -1,135 +0,0 @@
-# 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.

RELACIONES_OPERATIVAS.md DELETED Viewed

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

TRIADAS_CATEGORIALES.md DELETED Viewed

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

VALIDACION_INDEPENDIENTE.md DELETED Viewed

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

VECTORES_4_5.md DELETED Viewed

@@ -1,57 +0,0 @@
-# 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**.

__init__.py DELETED Viewed

File without changes

audit_perfect_metrics.py DELETED Viewed

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

baselines.py DELETED Viewed

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

capture_environment.py DELETED Viewed

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

check_generated_committed.py DELETED Viewed

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

cosmos_nahuatl.csv DELETED Viewed

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

create_manifest.py DELETED Viewed

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

examples.csv DELETED Viewed

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

generate_audit_report.py DELETED Viewed

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

generate_ontology.py DELETED Viewed

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

importar_datos_personalizados.py DELETED Viewed

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

io_shapes.ttl DELETED Viewed

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

materialize_ttl.py DELETED Viewed

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

measure_invariance.py DELETED Viewed

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

migrate_spec.py DELETED Viewed

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

package_reproducible.py DELETED Viewed

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

paper.md DELETED Viewed

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

pi_hgat_t.py DELETED Viewed

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

plantilla_dominio.csv DELETED Viewed

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

relation_candidates.csv DELETED Viewed

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

requirements-lock.txt DELETED Viewed

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

requirements.txt DELETED Viewed

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

score_independent_eval.py DELETED Viewed

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

score_quiz.py DELETED Viewed

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

self_bootstrap.py DELETED Viewed

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

sync_spec_artifacts.py DELETED Viewed

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

test_formal_rules_bridge.py DELETED Viewed

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

test_metrics_audit.py DELETED Viewed

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

test_ontology.py DELETED Viewed

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

test_pi_hgat_t.py DELETED Viewed

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

test_property_based.py DELETED Viewed

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

test_property_links.py DELETED Viewed

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

test_score_independent_eval.py DELETED Viewed

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

test_validate_spec.py DELETED Viewed

@@ -1,78 +0,0 @@
-#!/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()

triad_nodes.csv DELETED Viewed

@@ -1,79 +0,0 @@
-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

validate_examples.py DELETED Viewed

@@ -1,94 +0,0 @@
-#!/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())