Paper deep dive
Static Pruning Across Sparse Retrieval Regimes: What Transfers, What Breaks, and What Still Helps
Zirui Song, Yuye Zhu, Yang Yang
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 8/23/2026, 1:49:16 AM
Summary
This study evaluates the portability of static pruning strategies across three sparse retrieval engines (Controlled C++, BMP, SEISMIC) and two encoders (SPLADE, V3-GTE). It finds that index-side pruning (document and posting-list) is portable and effective because sparse retrieval is memory-bound, reducing latency and index size. In contrast, query pruning is largely redundant in modern engines like BMP and SEISMIC because they already internalize query-term selection via mechanisms like beta and query_cut. Static pruning complements dynamic pruning, and NDCG@10 saturation at ~85-95% Recall@10 provides a portable stopping criterion.
Entities (13)
Relation Signals (12)
Static Pruning → includes → Query Pruning
confidence 95% · Static pruning—removing low-weight query terms online
Static Pruning → includes → Posting-list Pruning
confidence 95% · removing low-impact document/posting entries from the index offline
Static Pruning → includes → Document Pruning
confidence 95% · Static pruning—removing low-weight query terms online, or low-impact document/posting entries from the index offline
BMP → usesmechanism → Beta
confidence 95% · BMP’s beta is the dominant query lever... BMP’s beta parameter is itself a query-pruning mechanism
SEISMIC → usesmechanism → Query Cut
confidence 95% · SEISMIC’s query_cut already incorporates query-term selection
Static Pruning → complements → Dynamic Pruning
confidence 94% · Static pruning complements dynamic pruning: on BMP, combining document and query reduction yields 2.5x speedup
Sparse Retrieval → is → Memory-bound
confidence 93% · sparse retrieval is memory-bound - a conclusion we support with cache-miss, TLB, and IPC profiling
Query Pruning → isredundantin → SEISMIC
confidence 92% · query pruning overlaps with SEISMIC’s internal query_cut
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Static pruning is widely used to accelerate sparse neural retrieval, yet existing studies each validate their conclusions within a single custom pipeline, leaving it unclear which findings transfer to modern engines with different index organizations and dynamic pruning mechanisms. We present the first cross-engine pruning portability study, evaluating static pruning strategies across three engines - a controlled C++ pipeline (exhaustive inverted index), BMP (block-max pruning), and SEISMIC (clustered inverted indexes) - on two benchmarks (MS MARCO, Natural Questions) with two encoders spanning opposite query-density regimes (SPLADE: 44 avg. query terms; V3-GTE: 7 avg. query terms), totaling 1,140 experimental configurations, with an additional deep-judgment validation on TREC DL 2019/2020. We find that index-side pruning (document and posting-list) is portable: it consistently reduces latency (1.2-6.6$\times$) and index size (18-82%) across all engines because sparse retrieval is memory-bound - a conclusion we support with cache-miss, TLB, and IPC profiling. In contrast, query pruning is already internalized by modern engines: it yields 4-11$\times$ speedup on the exhaustive pipeline but is subsumed by BMP's $\beta$ and SEISMIC's query_cut. Static pruning complements dynamic pruning: on BMP, combining document and query reduction yields 2.5$\times$ speedup with NDCG@10 within 0.003 of the exact baseline. Finally, NDCG@10 saturates while Recall@10 is still in the ${\sim}$85-95% range across all three engines, providing a portable stopping criterion: practitioners can push pruning to this knee without visible ranking degradation. Together, these findings answer what transfers (index-side pruning), what breaks (query pruning), and what still helps (static atop dynamic pruning).
Tags
Links
- Source: https://arxiv.org/abs/2608.16309v1
- Canonical: https://arxiv.org/abs/2608.16309v1
Trouble viewing inline? Open PDF directly →
Full Text
58,907 characters extracted from source content.
Expand or collapse full text
Static Pruning Across Sparse Retrieval Regimes: What Transfers, What Breaks, and What Still HelpsConference: Proceedings of the 35th ACM International Conference on Information and Knowledge Management; November 07–11, 2026; Rome, ItalyProceedings of the 35th ACM International Conference on Information and Knowledge Management (CIKM ’26), November 07–11, 2026, Rome, ItalyDOI: 10.1145/3799682.3840771ISBN: 979-8-4007-2539-5/2026/11CCS: Information systems Evaluation of retrieval results Zirui Song OrcID: 0009-0004-7984-1626 Affiliation: Amazon Web Services , Shanghai , China email: zrsong@amazon.com , Yuye Zhu OrcID: 0009-0007-0746-1837 Affiliation: Amazon Web Services , Shanghai , China email: yuyezhu@amazon.com and Yang Yang OrcID: 0009-0005-2480-3339 Affiliation: Amazon Web Services , Shanghai , China email: yych@amazon.com 2026; © c Abstract. Static pruning is widely used to accelerate sparse neural retrieval, yet existing studies each validate their conclusions within a single custom pipeline, leaving it unclear which findings transfer to modern engines with different index organizations and dynamic pruning mechanisms. We present the first cross-engine pruning portability study, evaluating static pruning strategies across three engines—a controlled C++ pipeline (exhaustive inverted index), BMP (block-max pruning), and SEISMIC (clustered inverted indexes)—on two benchmarks (MS MARCO, Natural Questions) with two encoders spanning opposite query-density regimes (SPLADE: 44 avg. query terms; V3-GTE: 7 avg. query terms), totaling 1,140 experimental configurations, with an additional deep-judgment validation on TREC DL 2019/2020. We find that index-side pruning (document and posting-list) is portable: it consistently reduces latency (1.2–6.6×) and index size (18–82%) across all engines because sparse retrieval is memory-bound—a conclusion we support with cache-miss, TLB, and IPC profiling. In contrast, query pruning is already internalized by modern engines: it yields 4–11× speedup on the exhaustive pipeline but is subsumed by BMP’s β and SEISMIC’s query_cut. Static pruning complements dynamic pruning: on BMP, combining document and query reduction yields 2.5× speedup with NDCG@10 within 0.003 of the exact baseline. Finally, NDCG@10 saturates while Recall@10 is still in the ∼ 85–95% range across all three engines, providing a portable stopping criterion: practitioners can push pruning to this knee without visible ranking degradation. Together, these findings answer what transfers (index-side pruning), what breaks (query pruning), and what still helps (static atop dynamic pruning). Code is available at https://github.com/zirui-song-18/cross_engine_static_pruning. Keywords: Sparse neural retrieval; static pruning; inverted indexes; cross-engine evaluation †c-license: by 1. Introduction Sparse neural retrieval integrates neural text encoders with the inverted index, enabling term-based lookup while capturing semantic matching through learned sparse representations (16). Models such as SPLADE (17), DeepImpact (27), and uniCOIL (24) assign high-dimensional sparse weight vectors to queries and documents, where non-zero entries and their magnitudes can be interpreted as learned impacts. Compared with classic bag-of-words retrieval, learned sparse models improve semantic matching but often increase practical costs: they activate substantially more query terms, each posting carries a real-valued learned weight, and the resulting impact distributions deviate from the sharply Zipfian patterns that traditional top-k optimizations exploit (7). Naïve deployments of these models on standard inverted-index engines can incur substantially higher latency than BM25 baselines (20; 25). Static pruning—removing low-weight query terms online, or low-impact document/posting entries from the index offline—is widely adopted to close this efficiency gap (22), shrinking the index and the per-query working set. But choosing what to prune, how aggressively, and whether the chosen strategy remains effective across different retrieval engines are all first-order deployment decisions that the literature has not jointly addressed. Lassance et al. (22) provided the most comprehensive taxonomy, showing that learned sparse indexes tolerate aggressive pruning because their impact distributions are less sharply Zipfian. However, all existing studies validate on custom pipelines with exhaustive scoring—no work has tested whether these conclusions transfer to modern engines with built-in dynamic pruning. This gap is consequential: BMP (30) exposes a query-term fraction β that itself acts as query pruning, and SEISMIC (7) limits active terms via query_cut. Both engines already internalize query-term selection, yet no prior work has tested whether external static pruning adds value atop these mechanisms, whether static and dynamic pruning are complementary or redundant, or whether NDCG@10’s saturation before Recall@10 generalizes beyond custom pipelines. We present the first cross-engine pruning portability study for sparse neural retrieval. We systematically evaluate query, document, and posting-list pruning under two score-aware criteria (α-Mass and Max-Ratio) across three engines (a controlled C++ pipeline with window-switch accumulator, BMP, and SEISMIC), two datasets (MS MARCO with 8.8M passages and Natural Questions with 2.7M passages), and two encoders spanning distinct query-density regimes (SPLADE with ∼ 44 query terms and V3-GTE with ∼ 6.9 query terms)—1,140 experimental configurations in total. A unified memory-bound thesis connects all three research questions: sparse retrieval is fundamentally limited by memory traffic, and this single fact explains which pruning transfers across engines, why static pruning complements dynamic pruning, and why NDCG saturates before Recall. Our three interconnected contributions are: (1) Portability analysis (Section 5). Index-side pruning (document and posting-list) is portable across all tested engines—it reduces both index size and latency consistently, with document pruning as the safest default. Query pruning is regime-dependent: largely redundant with engines that already internalize query-term selection. (2) Static–dynamic complementarity (Section 6). Static and dynamic pruning target orthogonal bottlenecks and yield combined speedups exceeding individual gains—a conclusion supported by micro-architectural profiling confirming the memory-bound thesis. (3) Portable stopping criterion (Section 7). NDCG@10 saturates at ∼ 85–95% Recall@10 (engine-dependent) across all three tested engines, providing a portable empirical stopping criterion that we validate under both shallow and deep (TREC DL) judgments. 2. Background and Related Work Sparse Neural Retrieval Models. Sparse neural retrievers encode queries and documents as high-dimensional sparse vectors whose non-zero entries carry learned impact weights (16). Compared with classic bag-of-words scoring, learned sparse representations often activate substantially more terms due to expansion, and the resulting posting weights deviate from the traditional tf-idf distribution (7). Bi-encoder models such as SPLADE (15) apply learned expansion to both queries and documents, producing moderately dense representations (SPLADE: avg. 44 query terms, 120 doc terms on MS MARCO). Inference-free encoders such as V3-GTE (18) use tokenization-only query construction (avg. 6.9 terms) but expand documents more aggressively (avg. 180 terms). These contrasting sparsity profiles create fundamentally different retrieval workloads: the dense-query regime generates more lists to traverse per query, while the sparse-query regime concentrates score mass on fewer terms, making each query term more critical. Our study spans both regimes to disentangle encoder-specific artifacts from engine-portable patterns. Static Pruning for Learned Sparse Retrieval. Static pruning has a long history in IR, spanning term-centric approaches that remove low-utility vocabulary terms (10; 4), document-centric strategies that prune per-document entries (8; 13), and global methods that remove postings based on corpus-level statistics (31; 1). Probabilistic and information-theoretic accounts have further refined the understanding of when pruning preserves retrieval quality (5; 11). For learned sparse retrievers specifically, Lassance et al. (22) revisited these families and showed that aggressive pruning is feasible with two-stage pipelines, and that learned sparse indexes tolerate more aggressive pruning than traditional indexes because their impact distributions are less sharply Zipfian. However, their study—like all prior pruning work for learned sparse models—validates on a custom pipeline with exhaustive scoring, not on modern engines with built-in dynamic pruning. Our work extends this framework to BMP and SEISMIC, testing whether the conclusions are portable or pipeline-specific. Dynamic Pruning and Modern Engines. Dynamic pruning avoids scoring documents that cannot enter the top-k: WAND (6) uses term-wise upper bounds, Block-Max WAND (14) refines with block-level bounds, and impact-ordered designs enable early termination (2). These techniques underpin production systems (Lucene (19), PISA (29)) and specialized learned-sparse engines (28; 32; 26). BMP (30) extends Block-Max WAND with parameters α (approximation quality) and β (query-term fraction—prunes terms with weight <β⋅wmax<β· w_ ); reducing β from 1.0 to 0.5 cuts latency by ∼1.8× 1.8× on dense-query workloads (30). SEISMIC (7) clusters posting lists with quantized summaries, exposing query_cut (qc) and heap_factor (hf); at qc = 5 it achieves sub-millisecond retrieval. DSP (9) and SINDI (23) represent further designs; we select BMP and SEISMIC as exemplars of two dominant paradigms (block-max and clustered). No prior work has systematically tested whether external static pruning adds value atop these engines’ built-in mechanisms. Memory Locality and System-Level Acceleration. Score accumulation is a sparse vector operation with low arithmetic intensity and irregular access patterns (34). Modern CPU deployments are often limited by memory stalls—irregular accesses to postings and accumulator arrays—rather than raw arithmetic throughput, making locality-aware traversal central to speedups (29; 34). This memory-bound character is critical to understanding our cross-engine results: pruning that reduces memory traffic (e.g., document pruning that shortens posting lists) should transfer across engines regardless of their internal architecture, while pruning that reduces computation (e.g., query pruning that reduces the number of lists traversed) may not help when the engine is already memory-stalled. Positioning. Prior work studies pruning within a single engine (22; 30; 7). We study pruning across engines, yielding a portability matrix that replaces engine-specific heuristics with cross-validated guidance. 3. Pruning Strategies We formalize two score-aware pruning criteria and three pruning families. We omit Fixed-Top selection, whose integer cutoffs prune objects of different lengths unevenly and cannot produce the continuous parameter sweeps that α-Mass and Max-Ratio provide. 3.1. Pruning Criteria Let (x)T(x) denote the set of non-zero terms in a sparse object x with weights wtt∈(x)\w_t\_t (x) (where x=qx=q for a query or x=dx=d for a document). For posting-list pruning, the same criteria apply over the posting weights wt,dw_t,d within each list LtL_t, selecting a subset of documents to retain. We define two criteria that select a pruned support pruned(x)⊆(x)T^pruned(x) (x): α-Mass (AM) Sort weights in descending order and keep the smallest prefix reaching α of the ℓ1 _1 mass: pruned(x)=t1,…,tmT^pruned(x)=\t_1,…,t_m\ such that ∑i=1mwti≥α∑t∈(x)wt _i=1^mw_t_i≥α _t (x)w_t, with α∈(0,1]α∈(0,1]. This criterion yields adaptive support size—high-entropy objects retain more terms. Max-Ratio (MR) Keep terms whose weight is at least a fraction τ of the maximum: pruned(x)=t∈(x)∣wt≥τ⋅wmaxT^pruned(x)=\t (x) w_t≥τ· w_ \, where wmax=maxt∈(x)wtw_ = _t (x)w_t and τ∈[0,1)τ∈[0,1). (We use τ to distinguish from BMP’s β parameter.) This criterion is scale-invariant and produces continuous trade-off curves. 3.2. Pruning Families Query pruning (online). Pruned object: query vector q (support (q)T(q)). Mechanism: apply a criterion to obtain pruned(q)T^pruned(q) and traverse only the corresponding posting lists. Cost path reduced: number of lists traversed (and thus accumulator updates). Query pruning is performed on-the-fly per query and does not modify the index. On engines with built-in query selection (BMP’s β, SEISMIC’s query_cut), external query pruning may be partially or fully redundant. Document pruning (offline, per-document). Pruned object: each document vector d independently prior to indexing (22). Mechanism: apply a criterion to obtain pruned(d)T^pruned(d) and build the inverted index from pruned documents. Cost path reduced: per-list work and RAM footprint (fewer postings overall), shrinking the working set. Document pruning is irreversible at query time. Because it reduces memory traffic rather than computation, we hypothesize that it transfers across all engine architectures. Posting-list pruning (offline, per-term). Pruned object: each posting list LtL_t independently. Mechanism: apply a criterion to keep only high-impact postings in LtL_t (7). Cost path reduced: per-list work and RAM (shorter lists), yielding large savings when queries hit frequent terms. Like document pruning, deletions are irreversible. Posting-list pruning achieves the largest RAM savings but exhibits more rapid Recall degradation under aggressive settings than document pruning. 4. Experimental Setup Datasets. We evaluate on two benchmarks: MS MARCO passage retrieval (3) (∼ 8.8M passages, 6,980 dev queries), the standard sparse retrieval benchmark with shallow relevance judgments (1–2 per query); and Natural Questions (NQ) (33) from BEIR (∼ 2.7M passages, 3,452 queries), providing cross-dataset validation under different corpus size and judgment characteristics. Encoders. We evaluate two encoders with opposite query-density regimes (Table 1): SPLADE-CoCondenser-EnsembleDistil (15), a bi-encoder that expands both queries and documents (dense-query regime), and opensearch-neural-sparse-encoding-doc-v3-gte (V3-GTE) (18), an inference-free encoder with tokenized-only queries but aggressive document expansion (sparse-query regime). This lets us disentangle query density from encoder architecture. Table 1. Dataset and encoder statistics. Avg. non-zero counts (nnz) per query and document, corpus size, baseline NDCG@10 on the controlled pipeline, and baseline NDCG@10 on the deep-judgment TREC DL 2019/2020 topics (mean over both years; MS MARCO corpus). Configuration Query nnz Doc nnz Docs NDCG@10 DL’19/20 MS MARCO + SPLADE 43.95 119.96 8.8M 0.449 0.726 MS MARCO + V3-GTE 6.89 180.41 8.8M 0.428 0.720 NQ + SPLADE 46.97 147.52 2.7M 0.539 — NQ + V3-GTE 7.20 185.00 2.7M 0.582 — Engine 1: Controlled C++ Pipeline. We build a single-threaded, core-pinned inverted-index engine in C++ implementing a window-switch accumulator (Ψ ). Documents are partitioned into windows of size W; postings are stored per (term, window) pair with local IDs, keeping the accumulator cache-resident at O(W)O(W) rather than O(N)O(N). Queries score exhaustively against the (possibly pruned) index, then optionally re-rank the top-k′=50k =50 candidates using the full (unpruned) document vectors. Since BMP and SEISMIC operate single-stage, Appendix C reports a no-rerank ablation confirming that the qualitative portability findings are not driven by the re-ranker. Section 6.3 and Appendix A introduce two additional accumulator variants (Φ , Ξ ) designed to isolate the memory-bound bottleneck via controlled profiling. Engine 2: BMP Block-max dynamic pruning engine (30). Indexes are built from CIFF format with 8-bit quantized impacts. Parameters: α (approximation quality) and β (query-term fraction—retains terms with weight ≥β⋅wmax≥β· w_ ). BMP’s β parameter is itself a query-pruning mechanism; we test whether external static pruning adds value beyond it. Engine 3: SEISMIC Clustered inverted-index engine (7). Parameters: query_cut (qc, limits active query terms) and heap_factor (hf, controls dynamic skipping aggressiveness). SEISMIC achieves sub-millisecond retrieval through clustering and quantized summaries; its query_cut already incorporates query-term selection, analogous to BMP’s β. Metrics. We report four metrics serving complementary purposes. Recall@k: oracle fidelity (|Ak∩Gk|/k|A_k∩ G_k|/k, where GkG_k is the model’s exact top-k). NDCG@k: qrels-based ranking quality with top-heavy logarithmic discounting (21). Success@k: qrels-based coverage ([Ak∩R(q)≠∅]I[A_k∩ R(q)≠ ], where R(q)R(q) is the set of judged-relevant documents). Latency: mean (BMP/SEISMIC); mean, p95, and p99 (controlled pipeline). Index size is reported as in-memory inverted-index footprint (GB). Protocol. All experiments run single-threaded with CPU core pinning on an AMD EPYC 9R14 processor (3.7 GHz, 1.5 TB RAM). Each configuration uses 5 warm-up runs followed by timed runs; we report mean latency. Default k=10k=10 for all metrics unless stated. 5. Portability of Pruning Strategies RQ1: Which static pruning conclusions are portable across engine designs and query-density profiles? Answer: Index-side pruning (document and posting-list) transfers across all tested engines because it reduces memory traffic—the binding bottleneck—whereas query pruning is regime-dependent, subsumed by engines that already internalize query-term selection. Figure 1 previews this on the controlled C++ pipeline: document pruning provides the most stable high-recall frontier across both encoders, a finding confirmed by the engine-specific results (Sections 5.2–5.3). Six Pareto curves comparing pruning families on two encoder regimes. Document pruning provides the most stable frontier in both. Figure 1. Custom C++ Pareto frontiers on MS MARCO: speedup vs. Recall@10 for all six pruning families (Doc, Query, Posting × Alpha-Mass, Max-Ratio). Left: SPLADE. Right: V3-GTE. Document pruning provides the most stable high-recall frontier across both encoders.Six Pareto curves comparing pruning families on two encoder regimes. Document pruning provides the most stable frontier in both. 5.1. Controlled Pipeline Results Baselines. Table 2 reports baseline latencies, ranging from 11.3 ms (NQ+V3-GTE) to 70.1 ms (MS+SPLADE), all at Recall@10 = 1.0 (exhaustive scoring). Query pruning is highly effective on exhaustive pipelines. Query α-Mass pruning yields 4–11× speedups on the controlled pipeline (Table 2), but with a regime-dependent cost: SPLADE retains near-perfect NDCG (0.448 vs. 0.449) at α = 0.50, while V3-GTE suffers steep Recall loss (0.775) because its ∼ 7 query terms each carry critical score mass. The key question is whether these gains survive on engines with built-in query-term selection. Document pruning is consistently effective. Document pruning achieves nearly identical speedup ratios across SPLADE and V3-GTE (Table 2), confirming it targets memory traffic rather than per-query computation—making it encoder-agnostic. Posting-list pruning: RAM-efficient but faster degradation. Posting pruning achieves comparable speedups to document pruning (Table 2) with even larger index reductions (73–81%). It degrades Recall faster, however: document pruning keeps each document’s own top-weighted terms, whereas posting-list pruning thresholds each term globally, so a document whose weight for a query’s key term falls just below the cutoff is dropped entirely—even when relevant. It thus suits RAM-constrained deployments, with the threshold tuned under a validation constraint. Table 2. Controlled pipeline (Ψ ): representative operating points with two-stage re-rank (k′k = 50). Speedup relative to unpruned baseline. Idx is the in-memory inverted-index size. Dataset+Enc. Pruning Lat. (ms) Spd. Idx (GB) R@10 NDCG MRR MS+SPL Baseline 70.1 1.0× 8.15 1.000 0.449 0.383 Q AM 0.50 11.5 6.1× 8.15 0.964 0.448 0.383 Doc AM 0.50 11.7 6.0× 1.53 0.928 0.443 0.379 Doc MR 0.30 18.1 3.9× 2.16 0.974 0.447 0.381 Post MR 0.30 15.6 4.5× 2.00 0.979 0.447 0.382 MS+GTE Baseline 29.5 1.0× 12.23 1.000 0.428 0.362 Q AM 0.50 2.6 11.3× 12.23 0.775 0.389 0.332 Doc AM 0.50 5.2 5.6× 2.32 0.969 0.426 0.360 Doc MR 0.30 6.2 4.8× 2.90 0.983 0.427 0.361 Post MR 0.30 4.4 6.7× 2.29 0.983 0.427 0.361 NQ+SPL Baseline 29.0 1.0× 3.04 1.000 0.539 0.488 Q AM 0.50 6.8 4.3× 3.04 0.972 0.537 0.487 Doc AM 0.50 5.7 5.1× 0.58 0.894 0.530 0.482 Doc MR 0.30 10.2 2.8× 0.81 0.962 0.537 0.487 Post MR 0.30 10.5 2.8× 0.84 0.978 0.538 0.487 NQ+GTE Baseline 11.3 1.0× 4.26 1.000 0.582 0.535 Q AM 0.50 1.5 7.4× 4.26 0.800 0.550 0.511 Doc AM 0.50 3.0 3.7× 0.84 0.969 0.579 0.533 Doc MR 0.30 2.5 4.5× 1.09 0.983 0.580 0.534 Post MR 0.30 2.5 4.5× 0.91 0.980 0.580 0.534 5.2. BMP Validation BMP baselines. BMP baselines range from 1,087 μ (NQ+V3-GTE) to 8,915 μ (MS+SPLADE) at exact retrieval (Table 3). BMP’s β is the dominant query lever. BMP’s internal β already internalizes the same query-term selection that yields 4–11× on the pipeline. External static query pruning (MR 0.10) provides 1.9× on MS+SPLADE (Table 3)—partially overlapping with β’s effect rather than adding a new independent optimization dimension. Document pruning transfers to BMP Document pruning reduces the BMP index (−-34–36%) and latency (1.2–1.4×) with NDCG@10 within 0.007 of the unpruned baseline (Table 3). The mechanism is clear: shorter posting lists tighten BMP’s block-max upper bounds, improving both cache locality and dynamic skipping efficiency. The pattern holds across both datasets and encoders. Posting pruning also transfers. Posting pruning provides index reduction comparable to document pruning (−-34–37%) with similar latency gains on BMP (Table 3). Consistent with controlled-pipeline findings, it degrades Recall faster than document pruning under aggressive settings. V3-GTE on BMP: document pruning is the safer choice. On V3-GTE, β = 0.5 causes steep Recall degradation (0.706–0.778) because each of the ∼ 7 query terms carries critical score mass. In contrast, Doc AM 0.90 retains Recall@10 ≥ 0.966 with 36% index reduction (Table 7). For sparse-query encoders, document pruning is the safer, more predictable choice on BMP. 5.3. SEISMIC Validation SEISMIC baselines: sub-millisecond retrieval. SEISMIC at qc = 5 already achieves sub-millisecond retrieval (186–360 μ across configurations), orders of magnitude faster than the controlled pipeline (Figure 2). SEISMIC Pareto curves showing document pruning provides consistent gains while query pruning overlaps with internal query cut. Figure 2. SEISMIC Pareto frontiers (qc = 5): speedup vs. Recall@10 under document and query pruning for both encoders. Document pruning provides consistent gains; query pruning overlaps with SEISMIC’s internal query_cut.SEISMIC Pareto curves showing document pruning provides consistent gains while query pruning overlaps with internal query cut. Query pruning provides marginal benefit. Static query MR 0.10 at qc = 5 on MS MARCO reduces latency from 186 to 161 μ but Recall@10 drops to 0.924. At qc = 20, MR 0.10 provides 1.31× (413 → 315 μ ). SEISMIC’s query_cut already limits active query terms, so external pruning partially overlaps—analogous to BMP’s β. On V3-GTE, the same pattern holds: query MR 0.10 at qc = 5 yields 244 μ vs. 255 μ baseline, a marginal 1.05× gain. Document pruning reduces index size with modest latency gain. Doc AM 0.90 yields 15–34% latency reduction with 16–29% index savings across all configurations (Table 8). Latency gains are smaller than BMP’s because SEISMIC is already near its memory-bound floor; the primary benefit is index reduction for RAM-constrained deployment. Posting pruning also transfers to SEISMIC Posting MR 0.10 provides comparable index reduction and speedup to document pruning on SEISMIC, with similar Recall at matched operating points (Table 3). Both index-side families yield consistent latency and RAM benefits across all four configurations. 5.4. Cross-Engine Portability Matrix Table 3 synthesizes findings across all three engines into a portability matrix—the core contribution of RQ1. Table 3. Portability Matrix: three pruning methods × four configurations, each evaluated on three engines. Speedup is relative to each engine’s unpruned baseline. Δ and Δ show absolute change vs. the exact baseline (negative = degradation); Δ tracks Δ throughout. C++ uses two-stage re-ranking (k′k = 50); C++† shows single-stage (no re-ranking) for direct comparison with BMP/SEISMIC. ∗BMP external query MR at β = 1.0. Speedup Recall@10 Δ @10 Δ @10 Config Pruning C++ C++† BMP SEIS. C++ C++† BMP SEIS. C++ C++† BMP SEIS. C++ C++† BMP SEIS. MS+SPL Doc AM 0.90 1.49× 1.48× 1.43× 1.18× 1.000 .946 .948 .868 .000 −-.003 −-.003 −-.005 .000 −-.003 −-.002 −-.005 Post MR 0.10 1.56× 1.54× 1.47× 1.17× 1.000 .947 .948 .871 .000 −-.002 −-.001 −-.004 .000 −-.002 −-.002 −-.004 Query MR 0.10 1.68× 1.65× 1.91×∗ 1.17× 1.000 .945 .935 .924 .000 .000 .000 +.001 .000 −-.001 .000 .000 MS+GTE Doc AM 0.90 1.78× 1.61× 1.23× 1.42× 1.000 .969 .969 .937 .000 −-.001 −-.001 −-.002 .000 .000 −-.001 −-.001 Post MR 0.10 1.86× 1.68× 1.27× 1.58× 1.000 .970 .969 .939 .000 −-.002 −-.002 −-.002 .000 −-.001 −-.002 −-.002 Query MR 0.10 1.36× 1.27× 1.19×∗ 1.03× 1.000 .982 .980 .975 .000 +.001 +.001 +.001 .000 +.001 +.001 +.001 NQ+SPL Doc AM 0.90 1.37× 1.34× 1.33× 1.24× 1.000 .935 .936 .853 .000 −-.003 −-.002 −-.002 .000 −-.002 −-.001 .000 Post MR 0.10 1.34× 1.32× 1.30× 1.20× 1.000 .954 .952 .865 .000 −-.002 −-.002 −-.001 .000 .000 −-.001 +.001 Query MR 0.10 1.42× 1.39× 1.60×∗ 1.20× 1.000 .956 .947 .908 .000 −-.005 −-.006 −-.004 .000 −-.004 −-.006 −-.004 NQ+GTE Doc AM 0.90 1.43× 1.43× 1.19× 1.51× 1.000 .965 .966 .950 .000 −-.005 −-.001 −-.007 .000 −-.005 −-.004 −-.006 Post MR 0.10 1.49× 1.49× 1.22× 1.57× 1.000 .966 .966 .951 .000 −-.005 −-.005 −-.006 .000 −-.005 −-.005 −-.006 Query MR 0.10 1.17× 1.17× 1.13×∗ 1.08× 1.000 .990 .989 .984 .000 −-.001 −-.002 −-.001 .000 −-.002 −-.003 −-.001 Synthesis. Table 3 shows that index-side pruning is the transferable family: document and posting-list pruning consistently reduce memory traffic with small NDCG loss, while query pruning is largely internalized by BMP’s β and SEISMIC’s query_cut. The C++† column further confirms that the cross-engine gap is not merely a re-ranker artifact: without re-ranking, C++ aligns closely with BMP, whereas SEISMIC exhibits larger Recall loss under the same threshold—indicating higher effective pruning severity under clustered traversal (Figure 7). 5.5. Per-Query Latency Stability Using document pruning as a representative example, static pruning compresses the entire latency distribution rather than merely shifting the mean (Figure 3): IQR drops substantially at αd _d = 0.9, the P95/P50 ratio decreases monotonically, and no heavy tail emerges even at αd _d = 0.5—aggressive pruning does not create a subpopulation of severely degraded queries. Histogram strips showing per-query latency distributions at four pruning levels with KDE outlines and percentile markers. Figure 3. Per-query latency histogram strips on MS MARCO+SPLADE (controlled pipeline) at four document-pruning levels. The P50/P90/P95 markers show progressive IQR compression: moderate pruning (αd _d = 0.9) narrows the distribution while aggressive pruning (αd _d = 0.5) concentrates it tightly with minimal tail degradation.Histogram strips showing per-query latency distributions at four pruning levels with KDE outlines and percentile markers. 6. Static–Dynamic Complementarity RQ2: Does static pruning complement or conflict with dynamic pruning? Answer: Static and dynamic pruning are complementary—they target orthogonal bottlenecks (memory footprint vs. wasted traversal), yielding combined gains that exceed either mechanism alone. 6.1. BMP Factorial Design We adopt a 2×2 factorial design on BMP (MS MARCO+SPLADE, α = 1.0, k = 10): full vs. pruned index (Doc AM 0.90), crossed with full vs. pruned queries (static MR 0.10). Table 4 reports results. Table 4. BMP 2×2 factorial on MS MARCO+SPLADE (α = 1.0). Speedup relative to the full-index, full-query baseline. Index size in GB. Index Query Lat. (μ ) Spd. R@10 NDCG MRR Idx Full Full 8,915 1.00× 1.000 0.449 0.382 15.7 Full Q MR 0.10 4,680 1.91× 0.935 0.449 0.382 15.7 Pruned Full 6,235 1.43× 0.948 0.446 0.380 10.1 Pruned Q MR 0.10 3,537 2.52× 0.917 0.446 0.379 10.1 Bar chart showing four BMP conditions with latency bars and recall values. Combined pruning achieves the best speedup. Figure 4. BMP 2×2 factorial on MS MARCO+SPLADE: latency under four conditions (full/pruned index × full/pruned queries). Recall@10 shown inside each bar. Combined pruning achieves the largest speedup (2.52×) with minimal NDCG loss (Δ = −-0.003).Bar chart showing four BMP conditions with latency bars and recall values. Combined pruning achieves the best speedup. Combined pruning is stackable. The combined condition achieves 2.52× speedup (Table 4, Figure 4) with NDCG@10 within 0.003 of baseline. The gain is submultiplicative (ρ=0.92ρ=0.92), indicating overlapping but not fully redundant cost components. The two mechanisms target orthogonal dimensions: static pruning reduces memory footprint (shorter lists, better cache locality); dynamic pruning reduces wasted traversal (skips non-competitive blocks). BMP’s upper bounds become tighter with shorter posting lists, yielding synergistic gains. On NQ+SPLADE the pattern repeats (2.02×); V3-GTE shows lower but still complementary gains due to less query-pruning headroom. 6.2. SEISMIC Static–Internal Interaction Table 5 reports the SEISMIC factorial (MS MARCO+SPLADE, qc = 5, hf = 1.0). Table 5. SEISMIC on MS MARCO+SPLADE (qc = 5, hf = 1.0). Speedup relative to the unpruned baseline at qc = 5. Index size in GB. Index Query Lat. (μ ) Spd. R@10 NDCG MRR Idx Full Full 185 1.00× 0.977 0.443 0.379 8.1 Full Q MR 0.10 161 1.15× 0.924 0.444 0.379 8.1 Pruned Full 158 1.17× 0.868 0.438 0.374 6.0 Pruned Q MR 0.10 133 1.39× 0.856 0.440 0.376 6.0 Complementary, but primarily through index reduction. Combined pruning yields 1.39× on MS+SPLADE (Table 5), smaller than BMP’s 2.52× because SEISMIC’s sub-millisecond baseline is near the memory-bound floor—the latency set by unavoidable index traversal once data movement is minimized. With little memory traffic left to eliminate, pruning’s primary benefit becomes RAM reduction (−-26%) rather than speedup. 6.3. Mechanistic Explanation: Memory-Bound Retrieval The factorial experiments above demonstrate that static and dynamic pruning are complementary, but do not explain why. If sparse retrieval were compute-bound, reducing arithmetic work (query pruning) and reducing wasted computation (dynamic skipping) would overlap. If it is memory-bound, shrinking the working set (static document pruning) and avoiding unnecessary block reads (dynamic pruning) would target independent cost components. We resolve this with controlled micro-architectural profiling, holding the index and queries fixed while varying only the accumulator architecture: • Φ (scatter-add): global accumulator array of N scores—O(N)O(N) working set, cache-hostile. • Ψ (window-switch): windowed accumulator of size W—O(W)O(W) working set, cache-friendly. Used throughout the paper. • Ξ (SIMD multiply): same global array as Φ with SIMD vectorization — tests whether arithmetic throughput matters. Linux perf (12) on MS MARCO+SPLADE (Table 6, top rows) confirms: the locality-aware Ψ achieves 2.4× latency reduction by virtually eliminating cache and TLB misses (2.7% vs. 30%), while the SIMD-focused Ξ provides no measurable benefit (Figure 5)—confirming the workload is memory-bound, not compute-bound. Four-panel profiling figure: bar charts for cache-miss rate, IPC, and dTLB-miss rate, plus a scatter plot of latency versus cache-miss rate with regression line. Figure 5. Micro-architectural profiling of Φ /Ψ /Ξ with Linux perf on multiple pruning configurations: (a) cache-miss rate, (b) IPC, (c) dTLB-miss rate, (d) per-query latency vs. cache-miss rate (R2R^2 = 0.84). Latency is tightly coupled to memory locality, not arithmetic throughput.Four-panel profiling figure: bar charts for cache-miss rate, IPC, and dTLB-miss rate, plus a scatter plot of latency versus cache-miss rate with regression line. Connection to complementarity. Static pruning reduces memory traffic (shorter posting lists, smaller working set); dynamic pruning reduces wasted traversal (skipping non-competitive blocks/clusters). Table 6 extends the profiling to BMP and SEISMIC: per-query latency tracks absolute cache misses on both engines, and configurations with smaller indexes consistently exhibit fewer misses per query—confirming that index-side pruning reduces memory traffic across all tested architectures. SEISMIC’s ∼ 17× lower cache misses per query (6.5K vs. BMP’s 114K) stem primarily from candidate selection, not cheaper per-document access: at qc=5 it scores only the 5 highest-weight query terms’ clusters versus all ∼ 44 SPLADE terms traversed by the exhaustive pipeline and BMP—an 8.8× reduction in candidate breadth. Normalized per query-term list, SEISMIC (1.3K misses/list) and the exhaustive Ψ (1.5K) differ by only ∼ 1.2×, so the cluster-contiguous layout is second-order; within SEISMIC, varying only query_cut on a fixed access path, misses scale near-linearly with active terms (r=0.992)—confirming selection, not dot-product implementation, as the dominant lever. Table 6. Micro-architectural profile across engines (MS MARCO+SPLADE). Cache-miss and dTLB-miss are rates; CacheMiss/Q is the absolute count per query driving latency. Engine Config IPC Cache% dTLB% CacheMiss/Q C++ Φ scatter-add 1.58 30.0 97.0 740,000 C++ Ψ window-switch 2.50 2.7 2.6 67,000 BMP β=1.0 3.37 1.3 28.4 114,000 BMP β=0.5 3.37 1.8 25.0 89,000 SEISMIC qc=20 3.01 10.9 40.9 12,500 SEISMIC qc=5 3.29 7.7 37.7 6,500 7. How Far to Push: Operating Point Selection RQ1 established what to prune (documents: portable; queries: regime-dependent) and RQ2 showed how to combine pruning mechanisms (static and dynamic are complementary). The remaining deployment question RQ3 is how aggressively to prune. We show that NDCG@10 provides a portable stopping criterion across engines. 7.1. NDCG@10 Saturates Before Recall@10—Portably Across all three engines and both datasets, NDCG@10 plateaus while Recall@10 continues to change. On all of them, NDCG@10 remains within 0.008 of baseline while (oracle) Recall@10 drops by up to 14 points (Figure 6)—i.e. NDCG saturates while Recall is still in the high-0.8 to mid-0.9 range, long before the aggressive-pruning regime. For example, BMP retains NDCG=0.449 at Recall=0.932 (β=0.5). Crucially, the saturation replicates under the deep, graded judgments of TREC DL 2019/2020 (∼ 210 judged docs/query): index-side pruning retaining ∼ 90% mass stays within 0.006 NDCG@10 of the exact baseline on all three engines (Appendix D), so it is not an artifact of MS MARCO’s sparse relevance labels. This convergence across architecturally distinct engines suggests the saturation is a robust property of learned sparse retrieval under qrels-based evaluation, not an engine-specific artifact. Success@10 saturates later than NDCG but earlier than Recall, remaining above 0.96 on BMP across the full β sweep—confirming that moderate pruning preserves candidate-generation viability. On MS MARCO dev, MRR@10 tracks NDCG@10 in lockstep across every engine and operating point (MRR@10 columns in Tables 2, 4, 5 and Appendix B): index-side pruning at the saturation point preserves it while only aggressive pruning degrades it, so the saturation is not an NDCG-specific artifact. 7.2. Root Cause and Stopping Point Six panels: three engines (columns) by two dataset--encoder regimes (rows). A dashed line marks the NDCG knee in each panel; the gold-shaded region to its right highlights where NDCG has saturated while Recall keeps rising. Figure 6. Latency vs. quality across three engines (columns) and two dataset–encoder regimes (rows: MS MARCO+SPLADE, top; NQ+V3-GTE, bottom). The dashed line marks the NDCG@10 knee (the most aggressive point within 0.005 of the unpruned baseline); the gold-shaded region to its right is where NDCG@10 has saturated while Recall@10 keeps rising, confirming the metric gap is engine-independent.Six panels: three engines (columns) by two dataset–encoder regimes (rows). A dashed line marks the NDCG knee in each panel; the gold-shaded region to its right highlights where NDCG has saturated while Recall keeps rising. The saturation arises because pruning tends to swap top-ranked documents for near-duplicate passages of equal relevance grade (or for unjudged near-duplicates): the graded-gain vector over ranks 1–10 is left essentially invariant even though the exact top-k set (and thus oracle Recall) changes, so NDCG@10 is blind to the reshuffle (verified on a deep-judgment DL 2019 query where all churned top-10 documents are judged equally relevant; Appendix D). We define the NDCG knee as the most aggressive operating point whose NDCG@10 stays within 0.005 of the unpruned baseline (a ∼ 1% relative tolerance), marked by the dashed line in Figure 6. Across all three engines and both encoders, on dev and the deep-judgment DL 2019/2020 sets, this knee falls where oracle Recall@10 lies in the ∼ 85–95% range (engine-dependent). Depending on the deployment objective, practitioners should select operating points as follows: (1) System profiling: Use Recall@10—it remains sensitive even in the high-accuracy regime (e.g., 0.97 vs. 0.99), diagnosing approximation fidelity. (2) User-facing ranking: Target the NDCG@10 knee (∼ 85–95% Recall, engine-dependent). On BMP, β=0.5 (NDCG=0.449, Recall=0.93) is near-optimal; on SEISMIC, qc=5 (NDCG=0.443, Recall=0.98) operates in the saturated region. (3) Candidate generation: Use Success@10 to ensure coverage of judged-relevant items; at doc AM 0.5 on the controlled pipeline, Success@10 ≥ 0.95 suffices for downstream re-ranking. The NDCG knee is portable across all three engines, completing the decision framework: what to prune (RQ1: documents), how to combine (RQ2: static + dynamic), and how far to push (RQ3: to the NDCG knee at ∼ 85–95% Recall). 8. Discussion and Practitioner Guidance Decision framework: What, How, How Far. Our cross-engine results distill into a deployment workflow: (1) Start with document pruning (Doc AM 0.90; tune the system to Δ ≤ 0.005). (2) Use built-in query reduction (BMP β, SEISMIC qc); external query pruning is secondary. (3) Add posting-list pruning when RAM is the binding constraint; tune the threshold under a validation constraint, as Recall degrades faster than document pruning on some engine/encoder combinations. (4) Combine under tight latency budgets (BMP 2.52×, SEISMIC 1.39×). Limitations. The controlled C++ pipeline uses two-stage re-ranking while BMP and SEISMIC are single-stage; Table 3 therefore reports a C++† no-rerank variant, which preserves the qualitative portability conclusion but lowers absolute Recall. Our portability claims are established across three engine paradigms (exhaustive scoring, block-max dynamic pruning, and clustered inverted indexes), two learned-sparse encoders spanning opposite query-density regimes (SPLADE ∼ 44 vs. V3-GTE ∼ 7 query terms), two web-search benchmarks (MS MARCO, NQ) plus the deep-judgment TREC DL 2019/2020 sets, and k=10 under single-threaded execution. We do not claim generality to all learned-sparse models, non-web domains (broader BEIR coverage is bounded by CPU-only encoding cost and left to future work), batched/multi-threaded settings, deeper k, or additional engines (DSP, SINDI). LLM-as-a-judge evaluation is an alternative-validity path we do not pursue, as the deep DL judgments already directly test the shallow-label concern. The saturation point is a qrels-based operating criterion (validated under both shallow dev and deep DL judgments), not a direct user-satisfaction threshold. 9. Conclusion Across 1,140 configurations on three engines, two datasets, and two encoders, we find that index-side pruning is portable (1.2–6.6× speedup, 18–82% index reduction), query pruning is subsumed by engine-internal mechanisms (BMP’s β, SEISMIC’s query_cut), and static pruning complements dynamic pruning (combined 2.52× on BMP). The NDCG knee at ∼ 85–95% Recall provides a portable empirical stopping criterion that replicates under deep TREC DL judgments. Micro-architectural profiling confirms all tested engines are memory-traffic-limited, explaining why index-size reduction transfers across architectures. A no-rerank ablation further shows that the cross-engine recall gap reflects traversal semantics rather than re-ranker protection. Future work should extend to k=100+, additional engines (DSP, SINDI), impact quantization interactions, and multi-threaded execution. Appendix A Accumulator Variants We implement three accumulator strategies in the controlled C++ pipeline to isolate the memory-bound bottleneck. The key difference is working-set size: Φ maintains a global accumulator of N scores (random access, cache-hostile); Ψ partitions the document space into windows of size W (localized, cache-friendly); Ξ adds SIMD vectorization to Φ ’s multiply step, yielding <<1% improvement—confirming the workload is memory-bound, not compute-bound. All controlled-pipeline experiments use Ψ unless noted. Both score query q against inverted index I then re-rank the top-k′k with full dot products; they differ only in the accumulator. Φ Scatter-Add (baseline). One global array S[0…N−1]S[0… N-1]: for each term (t,qt)(t,q_t), for each posting (d,wd)∈I[t](d,w_d)∈ I[t]: S[d]+=qtwdS[d] +=q_tw_d. Working set O(N)≈O(N)≈33 MB. Ψ Window-Switch (used throughout). for each window w of W docs: reset local S[0…W−1]S[0… W-1], accumulate as above over I[t][w]I[t][w], then push the window’s positives to a global heap. Working set O(W)≈O(W)≈400 KB, cache-resident. Appendix B Detailed Experimental Results Tables 7 and 8 report the full per-configuration BMP and SEISMIC sweeps (index size, latency, Recall@10, NDCG@10, MRR@10) underlying the main portability findings; controlled-pipeline operating points appear in Table 2. Table 7. BMP document/posting/query pruning across all four dataset–encoder combinations (α=1.0). Speedup relative to each config’s unpruned baseline. Config Pruning Idx (GB) Lat (μ ) R@10 NDCG MRR Spdup MS+SPL None 15.7 8,915 1.000 0.449 0.382 1.00× AM 0.50 4.3 2,869 0.685 0.398 0.335 3.11× AM 0.70 6.4 4,166 0.832 0.431 0.366 2.14× AM 0.90 10.1 6,235 0.948 0.446 0.380 1.43× AM 0.95 11.7 7,111 0.972 0.448 0.381 1.25× MR 0.10 10.4 6,281 0.951 0.446 0.380 1.42× NQ+SPL None 5.5 4,272 1.000 0.539 0.489 1.00× AM 0.50 1.5 1,412 0.624 0.454 0.407 3.02× AM 0.70 2.3 2,277 0.800 0.518 0.470 1.88× AM 0.90 3.6 3,222 0.936 0.537 0.488 1.33× AM 0.95 4.1 3,573 0.968 0.538 0.488 1.20× MR 0.10 3.7 3,336 0.951 0.535 0.487 1.28× MS+GTE None 22.4 2,453 1.000 0.429 0.363 1.00× β=0.5 22.4 1,061 0.706 0.365 0.302 2.31× Doc AM 0.90 14.4 1,994 0.969 0.428 0.362 1.23× Post MR 0.10 13.8 1,934 0.969 0.427 0.361 1.27× NQ+GTE None 7.1 1,087 1.000 0.583 0.536 1.00× β=0.5 7.1 571 0.778 0.543 0.498 1.90× Doc AM 0.90 4.7 917 0.966 0.579 0.532 1.19× Post MR 0.10 4.7 890 0.966 0.578 0.531 1.22× Four-panel figure comparing Recall@10 under document alpha-mass pruning for C++ with reranking, C++ without reranking, BMP, and SEISMIC. Figure 7. Recall@10 under document pruning across the four dataset–encoder combinations. The two-stage C++ curve shows the effect of full-vector re-ranking, while the no-rerank C++ curve closely tracks BMP at the main operating point (AM=0.90). SEISMIC exhibits a larger Recall drop under the same static pruning threshold, indicating that pruning thresholds have different effective severity under cluster-based traversal. The gray band marks Recall@10 ≥0.90≥ 0.90.Four-panel figure comparing Recall@10 under document alpha-mass pruning for C++ with reranking, C++ without reranking, BMP, and SEISMIC. Table 8. SEISMIC document pruning across all configurations (qc=5, hf=1.0). Config Pruning Idx (GB) Lat (μ ) R@10 NDCG MRR MS+SPL None 8.1 186 0.977 0.443 0.379 AM 0.70 4.3 140 0.769 0.424 0.361 AM 0.90 6.0 158 0.868 0.438 0.374 AM 0.95 6.7 167 0.889 0.441 0.378 NQ+SPL None 7.0 234 0.937 0.533 0.485 AM 0.70 4.5 167 0.727 0.505 0.460 AM 0.90 5.9 190 0.853 0.531 0.484 AM 0.95 6.3 204 0.880 0.534 0.486 MS+GTE None 10.3 255 0.993 0.422 0.358 AM 0.70 5.0 144 0.867 0.413 0.350 AM 0.90 7.3 179 0.937 0.420 0.357 AM 0.95 8.2 207 0.951 0.420 0.356 NQ+GTE None 8.3 360 0.995 0.581 0.534 AM 0.70 5.1 208 0.875 0.563 0.518 AM 0.90 6.8 239 0.950 0.574 0.528 AM 0.95 7.4 271 0.966 0.577 0.530 Appendix C Re-Ranking Ablation The controlled C++ pipeline uses two-stage re-ranking (k′k =50) while BMP and SEISMIC are single-stage. Figure 7 shows that at the operating point (Doc AM 0.90) removing re-ranking costs only 3–6 Recall@10 points—bringing C++ in line with BMP (cf. the C++† column of Table 3)—while at aggressive Doc AM 0.50 it recovers 17–28 points, confirming its value only beyond the recommended range. Table 9. TREC DL 2019/2020 mean NDCG@10 (DL19+DL20 pooled). Query pruning uses each engine’s native mechanism (C++ MR 0.10; BMP β=0.5; SEISMIC query_cut=5) SPLADE V3-GTE Config C++ BMP SEIS. C++ BMP SEIS. Baseline .726 .726 .721 .720 .718 .721 Doc AM 0.90 .717 .719 .707 .721 .721 .718 Post MR 0.10 .720 .723 .716 .720 .719 .721 Doc AM 0.50 .680 .691 .675 .688 .685 .676 Query prune .728 .728 .722 .723 .620 .720 Appendix D TREC DL 2019/2020 Deep-Judgment Validation MS MARCO dev labels only one or two relevant passages per query, so we re-evaluate on TREC DL 2019/2020, which pools ∼ 210 documents per query and grades each on a 0–3 relevance scale. Table 9 confirms both main-text findings under deep judgments: index-side pruning is lossless, and the query-pruning regime split (free on SPLADE, catastrophic on V3-GTE) is if anything sharper. Because these sets judge ∼ 210 documents per query rather than one or two, a genuine quality loss would register here; that NDCG@10 stays essentially flat through pruning confirms the saturation in Section 7 is a property of the ranking, not of sparse labels. GenAI Usage Disclosure Generative AI tools were used only to polish author-written text; they were not used to generate ideas, design experiments, produce or analyze results, write code, or create figures/tables. The authors reviewed all affected text and take full responsibility for this paper. References Altingovde et al. (2012) I. S. Altingovde, R. Ozcan, and Ö. Ulusoy Static index pruning in web search engines: combining term and document popularities with query views. ACM Trans. Inf. Syst. 30 (1). External Links: ISSN 1046-8188, Link, Document Cited by: §2. Anh and Moffat (2006) V. N. Anh and A. Moffat Pruned query evaluation using pre-computed impacts. In Proceedings of the 29th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’06, New York, NY, USA, p. 372–379. External Links: ISBN 1595933697, Link, Document Cited by: §2. Bajaj et al. (2018) P. Bajaj, D. Campos, N. Craswell, L. Deng, J. Gao, X. Liu, R. Majumder, A. McNamara, B. Mitra, T. Nguyen, M. Rosenberg, X. Song, A. Stoica, S. Tiwary, and T. Wang MS marco: a human generated machine reading comprehension dataset. External Links: 1611.09268, Link Cited by: §4. Blanco and Barreiro (2007) R. Blanco and Á. Barreiro Static pruning of terms in inverted files. In Advances in Information Retrieval, G. Amati, C. Carpineto, and G. Romano (Eds.), Berlin, Heidelberg, p. 64–75. External Links: ISBN 978-3-540-71496-5 Cited by: §2. Blanco and Barreiro (2010) R. Blanco and A. Barreiro Probabilistic static pruning of inverted files. ACM Trans. Inf. Syst. 28 (1). External Links: ISSN 1046-8188, Link, Document Cited by: §2. Broder et al. (2003) A. Z. Broder, D. Carmel, M. Herscovici, A. Soffer, and J. Zien Efficient query evaluation using a two-level retrieval process. In Proceedings of the Twelfth International Conference on Information and Knowledge Management, CIKM ’03, New York, NY, USA, p. 426–434. External Links: ISBN 1581137230, Link, Document Cited by: §2. Bruch et al. (2024) S. Bruch, F. M. Nardini, C. Rulli, and R. Venturini Efficient inverted indexes for approximate retrieval over learned sparse representations. In Proceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’24, New York, NY, USA, p. 152–162. External Links: ISBN 9798400704314, Link, Document Cited by: §1, §1, §2, §2, §2, §3.2, §4. Büttcher and Clarke (2006) S. Büttcher and C. L. A. Clarke A document-centric approach to static index pruning in text retrieval systems. In Proceedings of the 15th ACM International Conference on Information and Knowledge Management, CIKM ’06, New York, NY, USA, p. 182–189. External Links: ISBN 1595934332, Link, Document Cited by: §2. Carlson et al. (2025) P. Carlson, W. Xie, S. He, and T. Yang Dynamic superblock pruning for fast learned sparse retrieval. In Proceedings of the 48th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’25, New York, NY, USA, p. 3004–3009. External Links: ISBN 9798400715921, Link, Document Cited by: §2. Carmel et al. (2001) D. Carmel, D. Cohen, R. Fagin, E. Farchi, M. Herscovici, Y. S. Maarek, and A. Soffer Static index pruning for information retrieval systems. In Proceedings of the 24th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’01, New York, NY, USA, p. 43–50. External Links: ISBN 1581133316, Link, Document Cited by: §2. Chen and Lee (2013) R. Chen and C. Lee An information-theoretic account of static index pruning. In Proceedings of the 36th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’13, New York, NY, USA, p. 163–172. External Links: ISBN 9781450320344, Link, Document Cited by: §2. De Melo (2010) A. C. De Melo The new Linux ‘perf’ tools. In Slides from Linux Kongress, Vol. 18. Cited by: §6.3. de Moura et al. (2005) E. S. de Moura, C. F. dos Santos, D. R. Fernandes, A. S. Silva, P. Calado, and M. A. Nascimento Improving web search efficiency via a locality based static pruning method. In Proceedings of the 14th International Conference on World Wide Web, W ’05, New York, NY, USA, p. 235–244. External Links: ISBN 1595930469, Link, Document Cited by: §2. Ding and Suel (2011) S. Ding and T. Suel Faster top-k document retrieval using block-max indexes. In Proceedings of the 34th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’11, New York, NY, USA, p. 993–1002. External Links: ISBN 9781450307574, Link, Document Cited by: §2. Formal et al. (2022) T. Formal, C. Lassance, B. Piwowarski, and S. Clinchant From distillation to hard negative sampling: making sparse neural ir models more effective. In Proceedings of the 45th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’22, New York, NY, USA, p. 2353–2359. External Links: ISBN 9781450387323, Link, Document Cited by: §2, §4. Formal et al. (2024) T. Formal, C. Lassance, B. Piwowarski, and S. Clinchant Towards effective and efficient sparse neural information retrieval. ACM Trans. Inf. Syst. 42 (5). External Links: ISSN 1046-8188, Link, Document Cited by: §1, §2. Formal et al. (2021) T. Formal, B. Piwowarski, and S. Clinchant SPLADE: sparse lexical and expansion model for first stage ranking. In Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’21, New York, NY, USA, p. 2288–2292. External Links: ISBN 9781450380379, Link, Document Cited by: §1. Geng et al. (2025) Z. Geng, Y. Wang, D. Ru, and Y. Yang Towards competitive search relevance for inference-free learned sparse retrievers. External Links: 2411.04403, Link Cited by: §2, §4. Grand et al. (2020) A. Grand, R. Muir, J. Ferenczi, and J. Lin From maxscore to block-max wand: the story of how lucene significantly improved query evaluation performance. In Advances in Information Retrieval, J. M. Jose, E. Yilmaz, J. Magalhães, P. Castells, N. Ferro, M. J. Silva, and F. Martins (Eds.), Cham, p. 20–27. External Links: ISBN 978-3-030-45442-5 Cited by: §2. Hofstätter and Hanbury (2019) S. Hofstätter and A. Hanbury Let’s measure run time! extending the ir replicability infrastructure to include performance aspects. External Links: 1907.04614, Link Cited by: §1. Järvelin and Kekäläinen (2002) K. Järvelin and J. Kekäläinen Cumulated gain-based evaluation of ir techniques. ACM Trans. Inf. Syst. 20 (4), p. 422–446. External Links: ISSN 1046-8188, Link, Document Cited by: §4. Lassance et al. (2023) C. Lassance, S. Lupart, H. Déjean, S. Clinchant, and N. Tonellotto A static pruning study on sparse neural retrievers. In Proceedings of the 46th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’23, New York, NY, USA, p. 1771–1775. External Links: ISBN 9781450394086, Link, Document Cited by: §1, §1, §2, §2, §3.2. Li et al. (2026) R. Li, X. Zhong, J. Jin, P. Cheng, W. Ni, Z. Shen, W. Jia, X. Wang, H. T. Shen, and J. Song SINDI: an efficient index for approximate maximum inner product search on sparse vectors. External Links: 2509.08395, Link Cited by: §2. Lin and Ma (2021) J. Lin and X. Ma A few brief notes on deepimpact, coil, and a conceptual framework for information retrieval techniques. External Links: 2106.14807, Link Cited by: §1. MacAvaney et al. (2019) S. MacAvaney, A. Yates, A. Cohan, and N. Goharian CEDR: contextualized embeddings for document ranking. In Proceedings of the 42nd International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR’19, New York, NY, USA, p. 1101–1104. External Links: ISBN 9781450361729, Link, Document Cited by: §1. Mackenzie et al. (2022) J. Mackenzie, A. Mallia, A. Moffat, and M. Petri Accelerating learned sparse indexes via term impact decomposition. In Findings of the Association for Computational Linguistics: EMNLP 2022, Y. Goldberg, Z. Kozareva, and Y. Zhang (Eds.), Abu Dhabi, United Arab Emirates, p. 2830–2842. External Links: Link, Document Cited by: §2. Mallia et al. (2021) A. Mallia, O. Khattab, T. Suel, and N. Tonellotto Learning passage impacts for inverted indexes. In Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’21, New York, NY, USA, p. 1723–1727. External Links: ISBN 9781450380379, Link, Document Cited by: §1. Mallia et al. (2022) A. Mallia, J. Mackenzie, T. Suel, and N. Tonellotto Faster learned sparse retrieval with guided traversal. In Proceedings of the 45th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’22, New York, NY, USA, p. 1901–1905. External Links: ISBN 9781450387323, Link, Document Cited by: §2. [29] A. Mallia, M. Siedlaczek, J. Mackenzie, and T. Suel PISA: performant indexes and search for academia. Proceedings of the Open-Source IR Replicability Challenge. External Links: Link Cited by: §2, §2. Mallia et al. (2024) A. Mallia, T. Suel, and N. Tonellotto Faster learned sparse retrieval with block-max pruning. In Proceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’24, New York, NY, USA, p. 2411–2415. External Links: ISBN 9798400704314, Link, Document Cited by: §1, §2, §2, §4. Ntoulas and Cho (2007) A. Ntoulas and J. Cho Pruning policies for two-tiered inverted index with correctness guarantee. In Proceedings of the 30th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’07, New York, NY, USA, p. 191–198. External Links: ISBN 9781595935977, Link, Document Cited by: §2. Qiao et al. (2023) Y. Qiao, Y. Yang, H. Lin, and T. Yang Optimizing guided traversal for fast learned sparse retrieval. In Proceedings of the ACM Web Conference 2023, W ’23, New York, NY, USA, p. 3375–3385. External Links: ISBN 9781450394161, Link, Document Cited by: §2. Thakur et al. (2021) N. Thakur, N. Reimers, A. Rücklé, A. Srivastava, and I. Gurevych BEIR: a heterogenous benchmark for zero-shot evaluation of information retrieval models. External Links: 2104.08663, Link Cited by: §4. Zhang et al. (2008) J. Zhang, X. Long, and T. Suel Performance of compressed inverted list caching in search engines. In Proceedings of the 17th International Conference on World Wide Web, W ’08, New York, NY, USA, p. 387–396. External Links: ISBN 9781605580852, Link, Document Cited by: §2.