File size: 5,518 Bytes
66f9450 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | #!/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()
|