Window Graph-Based RFANNS Index

• The paper presents a novel window graph-based RFANNS index that embeds attribute locality into graph connectivity to maintain navigability under range filters.
• It constructs a hierarchy of window graphs with layer-specific half-window sizes and uses a weighted balanced tree for efficient candidate selection and incremental updates.
• Empirical results show improved indexing and query performance, outperforming competitors with significant speedups and reduced storage requirements on diverse datasets.

A window graph-based RFANNS index is a graph indexing architecture for range-filtering approximate nearest neighbor search in which graph connectivity is constrained, organized, or selected according to attribute-local “windows” or range predicates, so that nearest-neighbor traversal remains effective under filtering. In the most explicit form, introduced by WoW, the index is a hierarchy of directed window graphs over vector–attribute pairs, where each layer uses a different half window size in attribute order and supports arbitrary range filters together with fully incremental insertion (Wang et al., 26 Aug 2025). Closely related work interprets numeric filter ranges as interval windows whose induced subgraphs should remain navigable, either by assembling query-range-dedicated graphs from pre-materialized elemental graphs, as in iRangeGraph, or by constructing a single range-aware global graph whose interval-induced subgraph remains structurally valid, as in RNSG (Xu et al., 2024, Zou et al., 13 Mar 2026). A broader generalization appears in Garfield, where disjoint attribute-space cells function as multi-attribute windows and are connected by sparse inter-cell links for sequential GPU traversal (Li et al., 22 Apr 2026).

1. Problem formulation and window semantics

Window graph-based RFANNS indexes address hybrid datasets in which each object combines a vector with one or more attributes, and queries require nearest neighbors subject to attribute constraints. In the single-attribute setting emphasized by WoW, the hybrid dataset is written as $\mathcal{D} = \{\mathcal{V}, \mathcal{A}\}$, each object is a vector–attribute pair $v_a$, and an RFANNS query is $(q,R)$ with query vector $q$ and range predicate $R=[x,y]$. A pair $(v,a)$ is in-range iff $x\le a\le y$. WoW defines recall as $Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$, with normalization by $n'$ when fewer than $k$ objects satisfy the filter, where $v_a$0 is the number of in-range objects. It also defines the in-range fraction as $v_a$1 and selectivity as $v_a$2 (Wang et al., 26 Aug 2025).

The defining semantic idea is that attribute locality should be embedded into graph topology rather than deferred to post-filtering. In WoW, a window is an ordered attribute neighborhood centered at an attribute value. In iRangeGraph and RNSG, the corresponding abstraction is a numeric interval or contiguous window over a totally ordered scalar attribute. RNSG makes this interpretation explicit at the level of induced subgraphs: for a query interval $v_a$3, the effective search structure is the induced subgraph $v_a$4 over nodes whose attributes fall inside the interval, with $v_a$5 and $v_a$6 (Zou et al., 13 Mar 2026).

This window semantics differentiates the model from conventional graph ANNS. A global ANN graph optimized only for vector proximity can degrade under filtering because range predicates eliminate nodes and edges without preserving navigability. The supplied literature repeatedly frames this as the central difficulty of RFANNS: post-filtering wastes work on out-of-range nodes, whereas in-filtering on an ordinary graph can damage reachability in the filtered subgraph. Window graph-based designs instead make attribute restriction a first-class graph-design constraint (Xu et al., 2024, Zou et al., 13 Mar 2026).

2. Core index structures

WoW defines a window graph as a directed graph $v_a$7, where $v_a$8 is the vertex set, $v_a$9 is the edge set, and $(q,R)$0 is the half window size. Each vertex $(q,R)$1 denotes a vector–attribute pair whose attribute value is $(q,R)$2. Edges satisfy two conditions. First, an RNG property: $(q,R)$3 then

$(q,R)$4

Second, a window property: $(q,R)$5 Thus edges are both vector-proximate and local in attribute order (Wang et al., 26 Aug 2025).

A single window graph is not intended to serve all range filters. WoW therefore builds hierarchical window graphs

$(q,R)$6

with window boosting base $(q,R)$7 and layer-specific half-window size

$(q,R)$8

while

$(q,R)$9

All vertices appear in all layers; the hierarchy is over window size rather than sampled node subsets. This is a substantive distinction from HNSW-style multilayer routing, which WoW states serves vector neighborhood approaching, whereas its own hierarchy “serves the attribute instead of the vector” (Wang et al., 26 Aug 2025).

WoW couples the graph hierarchy with a weighted balanced tree (WBT) over attribute values. The WBT stores ordered attribute values and rooted subtree sizes, and is used for locating layer-specific windows $q$0, counting how many values lie in a query range, selecting in-window vertices efficiently, and maintaining order-statistics under insertion in logarithmic time. The paper emphasizes that an ordered array could also support windows, but insertion would degrade to linear time; WBT reduces this to logarithmic time (Wang et al., 26 Aug 2025).

Related work instantiates the same design space with different structural units. iRangeGraph materializes approximate RNG-based elemental graphs over segment-tree intervals and assembles a query-range-dedicated graph online from those pieces, reducing storage from $q$1 for all-range dedicated graphs to $q$2, or $q$3 when there are $q$4 distinct attribute values (Xu et al., 2024). RNSG, by contrast, seeks a single global range-aware graph whose interval-induced subgraph remains equivalent to a valid range-aware graph for the in-window objects, eliminating the need to store many window-specific graphs (Zou et al., 13 Mar 2026). Garfield generalizes the idea to multi-attribute filtering by partitioning selected attributes into quantile-balanced cells, building a local CAGRA graph per cell, and treating those cells as disjoint attribute-space windows connected by sparse inter-cell edges (Li et al., 22 Apr 2026).

3. Incremental construction and update mechanisms

A distinctive property of WoW is that it is fully incremental from an empty index. Given a new pair $q$5, insertion proceeds top-down across layers. If the current top-layer window cannot cover all attribute values after insertion,

$q$6

WoW clones the old top graph into a new top+1 layer and increments $q$7. Then, for each layer from $q$8 down to $q$9, it computes the layer window $R=[x,y]$0, obtains candidate neighbors inside that window, prunes them with $R=[x,y]$1, adjusts affected existing neighbors, and finally inserts $R=[x,y]$2 into the WBT and connects all selected edges (Wang et al., 26 Aug 2025).

The core optimization is window-to-window candidate reuse. For layer $R=[x,y]$3, WoW filters the previous-layer candidates by the smaller current window,

$R=[x,y]$4

with $R=[x,y]$5. If $R=[x,y]$6, it skips beam search and sets $R=[x,y]$7; otherwise it augments $R=[x,y]$8 using

$R=[x,y]$9

The new node then chooses

$(v,a)$0

reserving only $(v,a)$1 outgoing neighbors for the inserted node so that the remaining $(v,a)$2 slots remain available for future insertions. Existing neighbors may hold up to $(v,a)$3 outgoing neighbors (Wang et al., 26 Aug 2025).

When an existing neighbor $(v,a)$4 is already full, WoW performs local recomputation inside the current window: $(v,a)$5 followed by

$(v,a)$6

The paper explicitly states that out-of-window neighbors are not immediately removed unless pruning is triggered, because they may still fall inside future query ranges and later insertions may shift windows so that such edges become valid again (Wang et al., 26 Aug 2025).

The claimed worst-case insertion complexity is

$(v,a)$7

This incorporates amortized top-layer maintenance, $(v,a)$8 window lookup in WBT, beam candidate acquisition across layers, and pruning plus neighborhood adjustment costs (Wang et al., 26 Aug 2025).

The broader dynamic-graph literature suggests how such a design can be maintained under heavier update regimes. FreshDiskANN is evaluated under multiple cycles of deleting and inserting $(v,a)$9M points into an $x\le a\le y$0M-point SIFT index over $x\le a\le y$1-hour runs while maintaining target recall, and its phase labels “Delete / Insert / Patch / Merge” suggest a maintenance pipeline in which update visibility is decoupled from later graph repair (Singh et al., 2021). Greator targets the small-batch SSD-resident regime and adds a redundant topology-only file, logical deletion via $x\le a\le y$2 and $x\le a\le y$3, a localized update strategy, and degree-aware similarity-based deletion repair with default threshold $x\le a\le y$4 and relaxed patch capacity $x\le a\le y$5 when $x\le a\le y$6 (Yu et al., 1 Mar 2025). This suggests that a production window graph with insertions and expirations can combine window-local insertion logic with block-localized deletion repair and logical removal, although the supplied WoW data does not claim native deletion as a core contribution (Wang et al., 26 Aug 2025, Yu et al., 1 Mar 2025).

4. Query processing and selectivity-aware traversal

WoW answers queries in two stages: selecting a landing layer by range selectivity, then performing multi-layer beam search. For query $x\le a\le y$7, the WBT computes

$x\le a\le y$8

WoW then sets

$x\le a\le y$9

so that

$Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$0

and chooses the landing layer

$Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$1

The entry point is the vertex with attribute value closest to the median of $Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$2. Search then runs as

$Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$3

and returns the top-$Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$4 nearest vectors to $Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$5 from $Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$6 (Wang et al., 26 Aug 2025).

The search procedure maintains a candidate min-heap $Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$7 and a current best-result max-heap $Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$8. At each step it pops the nearest candidate, terminates early if

$Recall=\frac{|\mathcal{S}\cap \mathcal{G}|}{k}$9

otherwise inspects unvisited neighbors from high layer to low layer. It checks attribute membership before admitting a neighbor and limits distance evaluations at a hop to roughly $n'$0 via a per-hop counter. A flag next can skip lower-layer expansion when current-layer neighbors are already in-range and adequate. WoW states overall query time complexity as

$n'$1

with $n'$2 WBT-based range-cardinality computation and $n'$3 candidate acquisition on the selected hierarchy (Wang et al., 26 Aug 2025).

iRangeGraph takes a different query-time route: it constructs the outgoing edges of a visited object online for the exact query window. For object $n'$4 and query range $n'$5, it traverses the segment-tree path containing $n'$6, merges in-range neighbors from elemental graphs, and stops when the current segment is fully contained in the query range. With layer skipping, the amortized time complexity of this per-object online construction is

$n'$7

instead of $n'$8 without skipping (Xu et al., 2024).

RNSG avoids explicit window-graph materialization. It searches the global graph while traversing and accepting only in-range nodes, relying on the hereditary property that the effective filtered graph remains a valid range-aware search graph. It supplements this with an entry-node generation method based on the global centroid and a precomputed structure of size $n'$9; under the stated independence assumption between embedding and attribute distributions, the expected number of distinct entry nodes required for all ranges with fixed right endpoint is $k$0 (Zou et al., 13 Mar 2026).

Garfield’s multi-attribute variant illustrates a different but related traversal strategy. It identifies all query-relevant cells

$k$1

orders them by a cluster-based cardinality estimator, and then uses a sequential “search–jump–search” procedure in which sparse inter-cell edges serve as entry-point generators rather than as a fully navigable merged graph. If too many cells are selected, that is, $k$2, it switches to global ANNS followed by post-filtering (Li et al., 22 Apr 2026).

5. Theoretical properties and relations to adjacent graph models

The most explicit structural theory for window-constrained graph search appears in RNSG through the range-aware relative neighborhood graph (RRNG). RRNG modifies ordinary relative-neighborhood pruning so that an edge $k$3 with $k$4 exists iff there is no witness $k$5 satisfying

$k$6

The betweenness condition forces edge pruning to respect attribute order, so a witness used to remove an edge must remain available in every interval containing the endpoints (Zou et al., 13 Mar 2026).

RNSG proves two central properties of RRNG. The first is monotonic searchability: for any distinct nodes $k$7 and $k$8, there exists a path

$k$9

such that

$v_a$00

The second is structural heredity: for any interval $v_a$01, the induced subgraph $v_a$02 is equivalent to an RRNG constructed directly on the in-range objects. This is the strongest supplied formal statement of the window-graph idea, because it says that a single global graph implicitly contains valid graphs for all interval windows (Zou et al., 13 Mar 2026).

WoW does not present the same hereditary theorem, but its hierarchy can be read as a constructive response to the same mismatch between fixed global graphs and arbitrary range filters. Rather than proving that one global graph is valid for every interval, it stores multiple layers whose window sizes grow geometrically and then chooses the layer whose window size is closest to the query’s filtered cardinality (Wang et al., 26 Aug 2025). iRangeGraph responds differently still: instead of one hereditary graph or a persistent hierarchy over all window sizes, it assembles a query-range-dedicated graph from elemental graphs over segment-tree intervals (Xu et al., 2024).

The literature also shows that “window graph” is not limited to single-attribute contiguous intervals. Garfield’s GMG index can be interpreted as a cell-based or grid-window multi-graph, where each cell is a disjoint hyper-rectangular region in selected attribute dimensions, each local graph is a CAGRA index, and sparse inter-cell edges support traversal across multiple relevant cells with total storage

$v_a$03

This design avoids hierarchical overlapping partitions and instead relies on cell-by-cell traversal with candidate reuse (Li et al., 22 Apr 2026).

For graph construction itself, Relative NN-Descent offers a related but orthogonal idea: local relative-neighbor pruning and connectivity-preserving rewiring inside a restricted candidate pool. It does not define window graphs explicitly, but its localized candidate selection and search-time top-$v_a$04 expansion cap show how graph sparsification can be performed within bounded local neighborhoods, which is compatible with window-local graph construction (Ono et al., 2023).

6. Empirical characteristics, strengths, and limitations

WoW reports indexing time of 152 s on Sift, 391 s on Gist, 623 s on ArXiv, 1,557 s on Wikidata4M, and 3,360 s on Deep10M, with index sizes of 713 MB on Sift/Gist, 1,664 MB on ArXiv, 3,112 MB on Wikidata4M, and 8,430 MB on Deep10M. The paper summarizes that its indexing time is on par with the most building-efficient index, 4.9× faster than the most query-efficient competitor, and uses 0.4–0.5× smaller size than DIGRA. For querying, it reports that WoW is 4× faster than the best incremental baseline, HSIG, matches or exceeds the best static index, and is 1.5× faster than the best statically-built index on high-selectivity workloads (Wang et al., 26 Aug 2025).

iRangeGraph frames a different tradeoff. It replaces the infeasible $v_a$05 collection of dedicated range graphs, which would require $v_a$06 space, with elemental graphs occupying $v_a$07 space. Empirically, it reports superior and stable query performance across different query workloads, typically about 2× to 5× higher QPS at 0.9 recall than the strongest baseline on most datasets, and within less than 2× QPS of Oracle-HNSW at 0.9 recall on most datasets (Xu et al., 2024).

RNSG emphasizes compactness and single-index universality. On SIFT1M at 0.95 recall, it reports 5645 QPS versus 2805 QPS for iRangeGraph and 1401 QPS for UNIFY. On SIFT1M at 1% selectivity, it reports recall@10 of 1.0 and 2122 QPS, versus recall@10 0.99 and 614 QPS for iRangeGraph. Build time on SIFT1M is 78.12 s versus 467.15 s for iRangeGraph and 1168 s for UNIFY, while on WIT its index size is 0.38 GB versus 1.5 GB for iRangeGraph and 8.9 GB for UNIFY (Zou et al., 13 Mar 2026).

Garfield shows the benefits of the multi-attribute cell-window interpretation. It reports total storage

$v_a$08

a 4.4× smaller index and 119.8× higher throughput than state-of-the-art RFANNS methods in the abstract, and concrete examples such as Deep1M index size 183.11 MB versus 941.46 MB for iRangeGraph and 2173.31 MB for UNIFY. It also reports that cell ordering gives an average speedup of 47.2%, out-of-core overlap gives 51.4%, and cell scheduling reduces search latency by 38.9% on average (Li et al., 22 Apr 2026).

The principal limitations are equally explicit. WoW is designed for single-attribute range filtering, and multi-attribute filtering is left as future work. Its theory around the in-range fraction is described as idealized, and while deletion and in-place updates can be integrated using generic graph-repair methods, they are not a native core contribution (Wang et al., 26 Aug 2025). RNSG likewise targets one numerical attribute, supports contiguous intervals/windows, and is designed for static indexing; dynamic updates are future work (Zou et al., 13 Mar 2026). iRangeGraph does not address dynamic insertions or deletions and states that the graph assembled from elemental graphs is not necessarily identical to the ideal dedicated graph for the query range, because some edges may have been pruned in elemental graphs by out-of-range objects within those segments (Xu et al., 2024).

Taken together, these results establish a coherent research area rather than a single implementation pattern. One branch represents windows explicitly as attribute-local graph layers and uses selectivity-aware traversal, as in WoW (Wang et al., 26 Aug 2025). Another treats every query range as an interval-induced graph that should remain valid under restriction, as in RNSG (Zou et al., 13 Mar 2026). A third synthesizes query-specific window graphs from reusable interval graphs, as in iRangeGraph (Xu et al., 2024). A fourth extends the notion of windows to multi-attribute cells with local graphs and sparse cross-window transfer edges, as in Garfield (Li et al., 22 Apr 2026). The common principle is that RFANNS performance improves when the graph structure itself reflects the filter geometry, instead of applying attribute filtering only after ordinary ANN graph construction.