⚡ Bolt: Optimize is_neighbor to avoid costly square root calculation in spatial scans

.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-30 - Optimize Euclidean Distance in Hot Spatial Scans
+**Learning:** `libm::sqrt` is relatively slow, especially when computing exact distances repeatedly within hot inner loops, such as `SparseAttentionGraph::add_point` which performs O(N) spatial scans using `ManifoldPoint::is_neighbor`.
+**Action:** Replace `is_neighbor` calculations with inline, squared distance comparisons (`d^2 < r^2`). Explicitly reject non-positive or `NaN` thresholds (e.g., `!(epsilon > 0.0)`), and utilize early loop exits formatted as `!(sum < eps_sq)` to safely manage `NaN` coordinates without altering behavior, effectively avoiding the `sqrt` bottleneck.

crates/aether-core/src/manifold.rs

@@ -24,7 +24,6 @@
 // ═══════════════════════════════════════════════════════════════════════════════
 //
 
-
 #![allow(dead_code)]
 
 use libm::sqrt;
@@ -76,7 +75,21 @@ 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 if distance already exceeds epsilon^2.
+            // Using !(sum < eps_sq) to correctly handle NaN values.
+            if !(sum < eps_sq) {
+                return false;
+            }
+        }
+        true
     }
 }