⚡ Bolt: Optimize is_neighbor to use squared distance with early exit

.jules/bolt.md

@@ -5,3 +5,7 @@
 ## 2026-05-01 - Avoid High-Level Tensor Ops in Scalar Reductions
 **Learning:** High-level `Tensor` operations like `sub()` and `mul()` trigger intermediate heap allocations for shape and stride metadata. When computing scalar reductions (like MSE, distances, or loss functions), using these operations introduces severe memory overhead inside hot loops. Attempting to use `.min()` length truncation as a safeguard is an anti-pattern as it masks shape mismatch errors.
 **Action:** For scalar reductions, assert shape equality (`assert_eq!(a.shape, b.shape)`) and perform a single-pass iteration directly over the underlying borrowed data arrays (`a.data.borrow()`) to eliminate intermediate allocations and safely compute the result.
+
+## 2026-05-01 - Avoid sqrt in Hot Distance Thresholding Loops
+**Learning:** In operations that scan distances for thresholding (like `SparseAttentionGraph::add_point` bounding the neighborhood radius `epsilon`), calculating the true Euclidean distance with `libm::sqrt` is a significant bottleneck.
+**Action:** Replace `distance < epsilon` checks with an inline squared distance loop `sum(d^2) < epsilon^2`. Include an early exit condition `!(sum < eps_sq)` inside the loop to short-circuit the calculation, and safely handle edge cases like `!(epsilon > 0.0)` at the beginning.

crates/aether-core/src/manifold.rs

@@ -24,7 +24,6 @@
 // ═══════════════════════════════════════════════════════════════════════════════
 //
 
-
 #![allow(dead_code)]
 
 use libm::sqrt;
@@ -76,7 +75,20 @@ impl<const D: usize> ManifoldPoint<D> {
 
     /// Check if within epsilon-neighborhood (sparse attention criterion)
     pub fn is_neighbor(&self, other: &Self, epsilon: f64) -> bool {
-        self.distance(other) < epsilon
+        if !(epsilon > 0.0) {
+            return false;
+        }
+        let eps_sq = epsilon * epsilon;
+        let mut sum = 0.0;
+        for i in 0..D {
+            let d = self.coords[i] - other.coords[i];
+            sum += d * d;
+            // Early exit condition (also correctly handles NaNs by using inverted condition)
+            if !(sum < eps_sq) {
+                return false;
+            }
+        }
+        true
     }
 }