Update app.py

app.py

@@ -130,71 +130,6 @@ df_human["source"] = "Human"
 df_combined = pd.concat([df_dog, df_human], ignore_index=True)
 print(f"Loaded {len(df_dog)} dog rows and {len(df_human)} human rows")
 
-# ---------------------------------------------------------------
-# CMT Implementation with Mathematical Rigor
-# ---------------------------------------------------------------
-class ExpandedCMT:
-    def __init__(self):
-        # These constants are from the mathematical derivation
-        self.c1 = 0.587 + 1.223j  # From first principles
-        self.c2 = -0.994 + 0.0j   # From first principles
-        self.ZETA_POLE_REGULARIZATION = 1e6 - 1e6j
-        self.lens_library = {
-            "gamma": sp_special.gamma,
-            "zeta": self._regularized_zeta,
-            "airy": lambda z: sp_special.airy(z)[0],
-            "bessel": lambda z: sp_special.jv(0, z),
-        }
-
-    def _regularized_zeta(self, z: np.ndarray) -> np.ndarray:
-        """Handle the pole at z=1 mathematically."""
-        z_out = np.copy(z).astype(np.complex128)
-        pole_condition = np.isclose(np.real(z), 1.0) & np.isclose(np.imag(z), 0.0)
-        non_pole_points = ~pole_condition
-        z_out[non_pole_points] = sp_special.zeta(z[non_pole_points], 1)
-        z_out[pole_condition] = self.ZETA_POLE_REGULARIZATION
-        return z_out
-
-    def _robust_normalize(self, signal: np.ndarray) -> np.ndarray:
-        if signal.size == 0: 
-            return signal
-        Q1, Q3 = np.percentile(signal, [25, 75])
-        IQR = Q3 - Q1
-        if IQR < 1e-9:
-            median = np.median(signal)
-            mad = np.median(np.abs(signal - median))
-            return np.zeros_like(signal) if mad < 1e-9 else (signal - median) / (mad + 1e-9)
-        lower, upper = Q1 - 1.5 * IQR, Q3 + 1.5 * IQR
-        clipped = np.clip(signal, lower, upper)
-        s_min, s_max = np.min(clipped), np.max(clipped)
-        return np.zeros_like(signal) if s_max == s_min else 2.0 * (clipped - s_min) / (s_max - s_min) - 1.0
-
-    def _encode(self, signal: np.ndarray) -> np.ndarray:
-        N = len(signal)
-        if N == 0: 
-            return signal.astype(np.complex128)
-        i = np.arange(N)
-        theta = 2.0 * np.pi * i / N
-        # These frequency and amplitude values are from the mathematical derivation
-        f_k = np.array([271, 341, 491])
-        A_k = np.array([0.033, 0.050, 0.100])
-        phi = np.sum(A_k[:, None] * np.sin(2.0 * np.pi * f_k[:, None] * i / N), axis=0)
-        Theta = theta + phi
-        exp_iTheta = np.exp(1j * Theta)
-        g = signal * exp_iTheta
-        m = np.abs(signal) * exp_iTheta
-        return 0.5 * g + 0.5 * m
-
-    def _apply_lens(self, encoded_signal: np.ndarray, lens_type: str):
-        lens_fn = self.lens_library.get(lens_type)
-        if not lens_fn: 
-            raise ValueError(f"Lens '{lens_type}' not found.")
-        with np.errstate(all="ignore"):
-            w = lens_fn(encoded_signal)
-            phi_trajectory = self.c1 * np.angle(w) + self.c2 * np.abs(encoded_signal)
-        finite_mask = np.isfinite(phi_trajectory)
-        return (phi_trajectory[finite_mask], w[finite_mask], encoded_signal[finite_mask], 
-                len(encoded_signal), len(phi_trajectory[finite_mask]))
 
 # ---------------------------------------------------------------
 # Feature preparation and UMAP embedding