From 2b90253791a05f266059a12045ae4869282fe318 Mon Sep 17 00:00:00 2001
From: "google-labs-jules[bot]"
 <161369871+google-labs-jules[bot]@users.noreply.github.com>
Date: Sun, 14 Jun 2026 09:38:44 +0000
Subject: [PATCH] Optimize ManifoldPoint::is_neighbor with squared distance
 early exit

Co-authored-by: teerthsharma <78080953+teerthsharma@users.noreply.github.com>
---
 .jules/bolt.md                     |  4 ++++
 crates/aether-core/src/manifold.rs | 16 ++++++++++++++--
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/.jules/bolt.md b/.jules/bolt.md
index 2ac6922..548220c 100644
--- a/.jules/bolt.md
+++ b/.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.
diff --git a/crates/aether-core/src/manifold.rs b/crates/aether-core/src/manifold.rs
index 1bcc201..a955f3a 100644
--- a/crates/aether-core/src/manifold.rs
+++ b/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
     }
 }