| |
| """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.""" |
| |
| 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() |
|
|
