Research-Stack/4-Infrastructure/shim/test_validate_rrc_predictions.py

#!/usr/bin/env python3
"""Unit tests for pure functions in validate_rrc_predictions.py.

The module uses Python 3.12+ f-string syntax, so we extract testable functions
via targeted exec rather than a full module import.
"""

import math
import os
import re
import sys
import unittest
from collections import Counter
from pathlib import Path

# ---------------------------------------------------------------------------
# Extract testable functions from source without full module load
# ---------------------------------------------------------------------------

_SRC = Path(__file__).with_name("validate_rrc_predictions.py").read_text()

_NAMESPACE: dict = {}
# Execute only the pure-function portion (up to the classify function)
# by extracting individual function blocks.

exec(
    compile(
        """
import json, os, re, subprocess, sys, tempfile, math
from collections import Counter, defaultdict

"""
        + re.search(
            r"(def require_path.*?)(?=\nPIST_DECOMPOSE)",
            _SRC,
            re.DOTALL,
        ).group(1)
        + "\n"
        + re.search(
            r"(MATH_OPERATORS\s*=\s*\{.*?\})",
            _SRC,
            re.DOTALL,
        ).group(1)
        + "\n"
        + re.search(
            r"(MATH_VARIABLES\s*=\s*\{.*?\})",
            _SRC,
            re.DOTALL,
        ).group(1)
        + "\n"
        + re.search(
            r"(MATH_CONSTANTS\s*=\s*\{.*?\})",
            _SRC,
            re.DOTALL,
        ).group(1)
        + "\n"
        + re.search(
            r"(def parse_equation.*?)(?=\ndef build_proof_metrics)",
            _SRC,
            re.DOTALL,
        ).group(1)
        + "\n"
        + re.search(
            r"(def build_proof_metrics.*?)(?=\ndef build_receipt)",
            _SRC,
            re.DOTALL,
        ).group(1)
        + "\n"
        + re.search(
            r"(def build_receipt.*?)(?=\ndef classify)",
            _SRC,
            re.DOTALL,
        ).group(1),
        "<validate_rrc_extracted>",
        "exec",
    ),
    _NAMESPACE,
)

require_path = _NAMESPACE["require_path"]
parse_equation = _NAMESPACE["parse_equation"]
build_proof_metrics = _NAMESPACE["build_proof_metrics"]
build_receipt = _NAMESPACE["build_receipt"]
MATH_OPERATORS = _NAMESPACE["MATH_OPERATORS"]
MATH_VARIABLES = _NAMESPACE["MATH_VARIABLES"]
MATH_CONSTANTS = _NAMESPACE["MATH_CONSTANTS"]


# ---------------------------------------------------------------------------
# require_path
# ---------------------------------------------------------------------------

class TestRequirePath(unittest.TestCase):
    def test_single_key(self):
        self.assertEqual(require_path({"a": 1}, "a"), 1)

    def test_nested_keys(self):
        self.assertEqual(require_path({"a": {"b": {"c": 42}}}, "a", "b", "c"), 42)

    def test_missing_key_raises(self):
        with self.assertRaises((KeyError, TypeError)):
            require_path({"a": 1}, "a", "b")

    def test_missing_top_key_raises(self):
        with self.assertRaises(KeyError):
            require_path({}, "missing")


# ---------------------------------------------------------------------------
# parse_equation
# ---------------------------------------------------------------------------

class TestParseEquation(unittest.TestCase):
    def test_basic_equation(self):
        result = parse_equation("cognitive_load_field")
        self.assertEqual(result["equation_text"], "cognitive_load_field")
        # "cognitive", "load", "field" are all in MATH_OPERATORS
        self.assertIn("cognitive", result["operators"])

    def test_operator_extraction(self):
        result = parse_equation("adjusted-overflow-gate")
        self.assertIn("adjusted", result["operators"])
        self.assertIn("overflow", result["operators"])
        self.assertIn("gate", result["operators"])

    def test_constant_extraction(self):
        result = parse_equation("phi-delta-mapping")
        self.assertIn("phi", result["constants"])
        self.assertIn("delta", result["constants"])

    def test_normalized_equation_sorted(self):
        result = parse_equation("z-a-m")
        self.assertEqual(result["normalized_equation"], "a_m_z")

    def test_ast_metrics_present(self):
        result = parse_equation("heat-loss-equations")
        self.assertIn("node_count", result["ast_metrics"])
        self.assertIn("depth", result["ast_metrics"])
        self.assertIn("branching_factor", result["ast_metrics"])
        self.assertIn("symbol_entropy", result["ast_metrics"])

    def test_depth_clamped_at_16(self):
        long_eq = "-".join(["x"] * 20)
        result = parse_equation(long_eq)
        self.assertEqual(result["ast_metrics"]["depth"], 16)

    def test_single_part_zero_entropy(self):
        result = parse_equation("single")
        self.assertEqual(result["ast_metrics"]["symbol_entropy"], 0.0)

    def test_operator_counts(self):
        result = parse_equation("adjusted-adjusted-gate-loss")
        self.assertEqual(result["operator_counts"]["adjusted"], 2)
        self.assertEqual(result["operator_counts"]["gate"], 1)
        self.assertEqual(result["operator_counts"]["loss"], 1)
        self.assertEqual(result["operator_counts"]["overflow"], 0)


# ---------------------------------------------------------------------------
# build_proof_metrics
# ---------------------------------------------------------------------------

class TestBuildProofMetrics(unittest.TestCase):
    def test_cognitive_load_field(self):
        m = build_proof_metrics("CognitiveLoadField")
        self.assertEqual(m["tactic_count"], 3)
        self.assertEqual(m["dependency_count"], 2)

    def test_signal_shaped(self):
        m = build_proof_metrics("SignalShapedRouteCompiler")
        self.assertEqual(m["tactic_count"], 4)

    def test_projectable_geometry(self):
        m = build_proof_metrics("ProjectableGeometryTopology")
        self.assertEqual(m["tactic_count"], 5)

    def test_cad_force(self):
        m = build_proof_metrics("CadForceProbeReceipt")
        self.assertEqual(m["tactic_count"], 6)

    def test_logogram(self):
        m = build_proof_metrics("LogogramProjection")
        self.assertEqual(m["tactic_count"], 8)

    def test_unknown_shape_defaults(self):
        m = build_proof_metrics("SomeUnknownShape")
        self.assertEqual(m["tactic_count"], 2)
        self.assertEqual(m["dependency_count"], 1)


# ---------------------------------------------------------------------------
# build_receipt
# ---------------------------------------------------------------------------

class TestBuildReceipt(unittest.TestCase):
    def test_receipt_structure(self):
        eq = {"equation": "heat-loss", "shape": "CognitiveLoadField", "status": "verified"}
        r = build_receipt(eq)
        self.assertEqual(r["receipt_version"], "rrc-proof-receipt-v2")
        self.assertEqual(r["theorem_name"], "heat-loss")
        self.assertEqual(r["domain"], "analysis")
        self.assertEqual(r["status"], "verified")
        self.assertTrue(r["kernel_checked"])
        self.assertIn("proof_metrics", r)
        self.assertIn("metrics", r)

    def test_domain_mapping_topology(self):
        eq = {"equation": "x", "shape": "SignalShapedRouteCompiler", "status": "ok"}
        r = build_receipt(eq)
        self.assertEqual(r["domain"], "topology")

    def test_domain_mapping_geometry(self):
        eq = {"equation": "x", "shape": "ProjectableGeometryTopology", "status": "ok"}
        r = build_receipt(eq)
        self.assertEqual(r["domain"], "geometry")

    def test_domain_mapping_physics(self):
        eq = {"equation": "x", "shape": "CadForceProbeReceipt", "status": "ok"}
        r = build_receipt(eq)
        self.assertEqual(r["domain"], "physics")

    def test_domain_mapping_symbolic(self):
        eq = {"equation": "x", "shape": "LogogramProjection", "status": "ok"}
        r = build_receipt(eq)
        self.assertEqual(r["domain"], "symbolic")

    def test_domain_mapping_unknown(self):
        eq = {"equation": "x", "shape": "HoldForUnlawfulOrUnderspecifiedShape", "status": "ok"}
        r = build_receipt(eq)
        self.assertEqual(r["domain"], "unknown")

    def test_metrics_present(self):
        eq = {"equation": "phi-mapping", "shape": "CognitiveLoadField", "status": "ok"}
        r = build_receipt(eq)
        self.assertIn("statement_chars", r["metrics"])
        self.assertIn("proof_chars", r["metrics"])
        self.assertIn("tactic_count", r["metrics"])


# ---------------------------------------------------------------------------
# MATH sets
# ---------------------------------------------------------------------------

class TestMathSets(unittest.TestCase):
    def test_operators_non_empty(self):
        self.assertTrue(len(MATH_OPERATORS) > 0)

    def test_variables_non_empty(self):
        self.assertTrue(len(MATH_VARIABLES) > 0)

    def test_constants_contain_known(self):
        self.assertIn("pi", MATH_CONSTANTS)
        self.assertIn("e", MATH_CONSTANTS)
        self.assertIn("phi", MATH_CONSTANTS)


if __name__ == "__main__":
    unittest.main()