Use exact rational evidence gates independent of Decimal context

Author: Exohayvan

docs/capability-fixture.md

@@ -48,7 +48,8 @@ necessary to establish that two differently named actors are independent.
 
 Metrics must match policy exactly. Conservative uncertainty intervals must satisfy
 resource/value bounds, every regression budget and each required positive gain.
-Decimal comparison avoids binary floating-point subtraction at policy boundaries.
+Exact rational comparisons of decoded numeric values avoid binary floating-point
+subtraction and do not depend on ambient Decimal precision, rounding or traps.
 Missing/conflicting evidence or failed gates returns experimental with no proposed
 name or version increment. Passing evidence that does not classify the intended
 capability returns unclassified. Internal versions stop at 4096. No training-run

src/aethermesh_core/capability_fixture.py

@@ -6,7 +6,7 @@
 import json
 import re
 from dataclasses import dataclass
-from decimal import Decimal
+from fractions import Fraction
 from typing import Any, Literal
 
 from .artifact_codec import CheckCancel, _cancel, _integer
@@ -75,11 +75,11 @@ def _digest(value: Any) -> str:
     return str(value)
 
 
-def _number(value: Any) -> Decimal:
+def _number(value: Any) -> Fraction:
     if type(value) not in (int, float):
         raise ValueError("fixture metric must be a finite number")
-    result = Decimal(str(value))
-    if not result.is_finite() or abs(result) > 10**12:
+    result = Fraction(str(value))
+    if abs(result) > 10**12:
         raise ValueError("fixture metric magnitude bound")
     return result
 

tests/test_capability_fixture.py

@@ -1,6 +1,7 @@
 """Synthetic evidence must never become publication or live capability authority."""
 
 import copy
+import decimal
 import json
 import unittest
 from pathlib import Path
@@ -291,3 +292,62 @@ def cancel(stop=stop):
 
             with self.subTest(stop=stop), self.assertRaises(InterruptedError):
                 evaluate(fixture(), check_cancel=cancel)
+
+    def test_gate_decisions_ignore_ambient_decimal_context(self):
+        accepted = fixture()
+        for report in accepted["reports"].values():
+            report["metrics"]["accuracy"]["uncertainty"] = 0
+        accepted["reports"]["candidate"]["metrics"]["accuracy"]["value"] = 0.85
+        rejected = copy.deepcopy(accepted)
+        rejected["reports"]["candidate"]["metrics"]["accuracy"]["value"] = 0.849
+        rounded_up = fixture()
+        rounded_up["reports"]["candidate"]["metrics"]["accuracy"]["value"] = 0.84
+        cases = [accepted, rejected, rounded_up]
+        for uncertainty in (1e-30, 5e-324):
+            tiny = copy.deepcopy(accepted)
+            tiny["reports"]["candidate"]["metrics"]["accuracy"]["uncertainty"] = (
+                uncertainty
+            )
+            self.assertIn("insufficient_gain", evaluate(tiny).reasons)
+            cases.append(tiny)
+        classified = copy.deepcopy(cases[3])
+        classified["policy"]["metrics"][0]["gain"] = 0.04
+        classified["taxonomy"]["rules"][0]["minimum"] = 0.85
+        retax(classified)
+        self.assertEqual(evaluate(classified).status, "unclassified")
+        resource = copy.deepcopy(cases[3])
+        resource["policy"]["metrics"][0].update(gain=0.04, maximum=0.85)
+        self.assertIn("resource_or_uncertainty", evaluate(resource).reasons)
+        regression = copy.deepcopy(accepted)
+        regression["reports"]["candidate"]["metrics"]["memory"].update(
+            value=1024, uncertainty=1e-30
+        )
+        regression["policy"]["metrics"][1]["uncertainty"] = 1
+        self.assertIn("regression", evaluate(regression).reasons)
+        cases.extend((classified, resource, regression))
+        expected = tuple(evaluate(case) for case in cases)
+        self.assertEqual(expected[0].status, "eligible")
+        self.assertIn("insufficient_gain", expected[1].reasons)
+        self.assertIn("insufficient_gain", expected[2].reasons)
+        for precision in (1, 2, 28, 100, 350):
+            for rounding in (
+                decimal.ROUND_DOWN,
+                decimal.ROUND_UP,
+                decimal.ROUND_HALF_EVEN,
+                decimal.ROUND_FLOOR,
+                decimal.ROUND_CEILING,
+            ):
+                with (
+                    self.subTest(precision=precision, rounding=rounding),
+                    decimal.localcontext() as context,
+                ):
+                    context.prec = precision
+                    context.rounding = rounding
+                    context.Emax = 1
+                    context.Emin = -1
+                    for signal in context.traps:
+                        context.traps[signal] = True
+                    self.assertEqual(tuple(evaluate(case) for case in cases), expected)
+                    self.assertFalse(any(context.flags.values()))
+                    with self.assertRaises(ValueError):
+                        naming._number(10**12 + 1)