feat: complete verifiable birth-time rectification flow

2026-07-21 22:16:18 +08:00
parent eb8ed8bee4
commit bfc6870614
117 changed files with 6215 additions and 1038 deletions
@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Audit whether event evidence actually distinguishes adjacent birth minutes."""
+from __future__ import annotations
+
+import hashlib
+import json
+from collections import defaultdict
+from collections.abc import Sequence
+from typing import Any
+
+from scripts.active_rectification_events import CandidateScoreRow
+
+
+def _evidence_features(item: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "event_id": item["event_id"],
+        "domain": item["domain"],
+        "points": float(item["points"]),
+        "rule_ids": sorted(item["rule_ids"]),
+    }
+
+
+def feature_fingerprint(row: CandidateScoreRow) -> str:
+    """Hash only computed evidence features, never the candidate time or truth label."""
+    payload = {
+        "evidence": sorted(
+            (
+                _evidence_features(item)
+                for item in row["evidence"]
+            ),
+            key=lambda item: (item["event_id"], item["domain"]),
+        ),
+        "missing_layers": sorted(row["missing_layers"]),
+    }
+    canonical = json.dumps(payload, ensure_ascii=True, sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
+
+
+def analyze_candidate_rows(
+    rows: Sequence[CandidateScoreRow],
+    *,
+    ranking_rows: Sequence[CandidateScoreRow] | None = None,
+) -> dict[str, Any]:
+    """Return feature-equivalence classes and real adjacent-minute transitions."""
+    candidates = list(rows)
+    if not candidates:
+        return {
+            "scope": "minute_candidate_discriminability",
+            "candidate_count": 0,
+            "unique_feature_fingerprint_count": 0,
+            "distinguishable_candidate_ratio": 0.0,
+            "equivalence_classes": [],
+            "adjacent_transitions": [],
+            "indistinguishable_adjacent_pair_count": 0,
+            "top_candidate_feature_unique": False,
+            "status": "blocked_no_candidates",
+        }
+
+    fingerprints = {row["time"]: feature_fingerprint(row) for row in candidates}
+    classes: dict[str, list[str]] = defaultdict(list)
+    for row in candidates:
+        classes[fingerprints[row["time"]]].append(row["time"])
+    equivalence_classes = [
+        {"feature_fingerprint": fingerprint, "candidate_times": times, "size": len(times)}
+        for fingerprint, times in sorted(classes.items(), key=lambda item: item[1][0])
+    ]
+
+    adjacent_transitions = []
+    indistinguishable = 0
+    for previous, current in zip(candidates, candidates[1:]):
+        previous_by_event = {
+            item["event_id"]: _evidence_features(item) for item in previous["evidence"]
+        }
+        current_by_event = {
+            item["event_id"]: _evidence_features(item) for item in current["evidence"]
+        }
+        changed_event_ids = sorted(
+            event_id
+            for event_id in set(previous_by_event) | set(current_by_event)
+            if previous_by_event.get(event_id) != current_by_event.get(event_id)
+        )
+        feature_changed = fingerprints[previous["time"]] != fingerprints[current["time"]]
+        indistinguishable += int(not feature_changed)
+        adjacent_transitions.append({
+            "between": [previous["time"], current["time"]],
+            "feature_changed": feature_changed,
+            "changed_event_ids": changed_event_ids,
+            "score_delta": round(float(current["score"]) - float(previous["score"]), 4),
+        })
+
+    ranked = list(ranking_rows) if ranking_rows is not None else candidates
+    top_score = max(float(row["score"]) for row in ranked)
+    top_times = [row["time"] for row in ranked if float(row["score"]) == top_score]
+    top_unique = len(top_times) == 1 and len(classes[fingerprints[top_times[0]]]) == 1
+    unique_count = len(classes)
+    status = (
+        "minute_feature_unique"
+        if top_unique
+        else "range_has_differences_but_top_not_unique"
+        if unique_count > 1
+        else "blocked_feature_equivalent_range"
+    )
+    return {
+        "scope": "minute_candidate_discriminability",
+        "candidate_count": len(candidates),
+        "unique_feature_fingerprint_count": unique_count,
+        "distinguishable_candidate_ratio": round(unique_count / len(candidates), 4),
+        "equivalence_classes": equivalence_classes,
+        "adjacent_transitions": adjacent_transitions,
+        "indistinguishable_adjacent_pair_count": indistinguishable,
+        "top_candidate_times": top_times,
+        "top_candidate_feature_unique": top_unique,
+        "status": status,
+        "boundary": "Feature uniqueness describes this scorer's computed evidence only; it is not proof that a birth minute is true.",
+    }