Create consensus/topo.py

consensus/topo.py

@@ -1,13 +1,8 @@
+# consensus/topo.py
 import numpy as np
 from numpy.linalg import eigh, norm
 
 class TopologicalConsciousness:
-    """
-    Practical shim inspired by the EFL/3^627 spec:
-    - calculate_coherence: modular-invariance/phase-coherence proxy via
-      principal eigenvector of the Gram (cosine) matrix.
-    - cardy_boundary_energy: boundary energy proxy from hidden-states.
-    """
     def __init__(self, n_anyons: int, central_charge: float = 627.0):
         self.n = n_anyons
         self.c = central_charge
@@ -18,33 +13,17 @@ class TopologicalConsciousness:
         return X / d
 
     def calculate_coherence(self, embeddings: list[np.ndarray]) -> float:
-        """
-        embeddings: list of [d]-vectors (one per model output).
-        Returns PC in [0,1] using principal-eigenvector mass concentration.
-        """
-        E = np.stack(embeddings, axis=0)          # (M, d)
+        E = np.stack(embeddings, axis=0)
         E = self._normalize_rows(E)
-        K = E @ E.T                                # cosine Gram
-        # symmetrize for safety
-        K = 0.5 * (K + K.T)
-        # principal eigenvector (largest eigenvalue)
+        K = 0.5 * ((E @ E.T) + (E @ E.T).T)  # cosine Gram, symmetrized
         vals, vecs = eigh(K)
-        w = np.abs(vecs[:, -1])
-        w = w / (w.sum() + 1e-12)
+        w = np.abs(vecs[:, -1]); w = w / (w.sum() + 1e-12)
         M = len(embeddings)
         pc = (w.max() - 1.0/M) / (1.0 - 1.0/M)
         return float(np.clip(pc, 0.0, 1.0))
 
     def cardy_boundary_energy(self, hidden: np.ndarray) -> float:
-        """
-        Proxy for boundary energy: encourages smoothness and low-norm at
-        the 'boundary'. Use total variation + L2. Scale by central charge.
-        hidden: [T, D] or [D]
-        """
         h = np.atleast_2d(hidden)
-        # temporal variation (if T>1)
         tv = np.abs(np.diff(h, axis=0)).mean() if h.shape[0] > 1 else 0.0
         l2 = norm(h) / np.sqrt(h.size)
-        # couple terms; scale by c like a 'boundary condition strength'
-        energy = (0.5 * l2 + 0.5 * tv) * np.log1p(self.c)
-        return float(energy)
+        return float((0.5*l2 + 0.5*tv) * np.log1p(self.c))