Lexical Representation-based Filtering (LRF)

• LRF is a technique that uses lexical signals to filter candidates and structure corpora in multimodal, web-scale, and dense retrieval systems.
• Implementations range from Stellar’s sparse inverted indexes to Luxical’s dense embeddings and DLR/DHR’s gated inner-product methods.
• LRF reduces computational cost by efficiently pruning candidate sets before expensive re-ranking and mitigating distortions from high lexical overlap.

Searching arXiv for the cited papers to ground the article. arxiv_search.query{"search_query":"id:(Guo et al., 18 Jun 2026) OR id:(DatologyAI et al., 9 Dec 2025) OR id:(Lin et al., 2022) OR id:(Rizwan et al., 1 Jun 2026)","max_results":10} arXiv search results retrieved. Searching for additional arXiv context on lexical/sparse retrieval formulations relevant to LRF. arxiv_search.query{"search_query":"all:(sparse lexical retrieval multimodal SPLADE lexical representations dense hybrid retrieval)","max_results":8,"sort_by":"relevance"} Lexical Representation-based Filtering (LRF) denotes a family of techniques in which lexical representations are used to filter candidates, organize corpora, or diagnose representation regimes before more expensive or more semantically sensitive processing. In recent arXiv literature, the term is not fully standardized: in multimodal retrieval it refers to a first-stage sparse lexical filter that prunes a corpus before late interaction; in web-scale text processing it refers to filtering with lexical-dense embeddings derived from TF–IDF features; in dense lexical retrieval it corresponds to top-$K$ candidate generation with dense lexical or dense hybrid vectors; and in representation analysis it denotes procedures that detect and control similarity driven by surface-form overlap rather than semantic content (Guo et al., 18 Jun 2026, DatologyAI et al., 9 Dec 2025, Lin et al., 2022, Rizwan et al., 1 Jun 2026).

1. Terminological scope and major formulations

Recent work uses LRF to describe related but non-identical operations. The common structure is a filtering step driven by lexical information, but the representation class, scoring rule, and downstream role differ substantially.

Formulation	Representation	Filtering role
Stellar LRF	Sparse lexical vectors in the MLLM vocabulary space	First-stage multimodal document pruning before Disk-backed Late Interaction
Luxical-based LRF	Dense 192-dimensional embeddings produced from sparse TF–IDF features	Web-scale similarity filtering, classifier-based filtering, or ANN retrieval
DLR/DHR-based LRF	Dense lexical or dense hybrid vectors with value/index structure	First-stage top-$K$ retrieval via approximate GIP or inner product
Lexicality-informed LRF	Layer, pooling, and validation choices over LLM representations	Detection and control of lexically dominated similarity

In the DLR/DHR framework, the source paper explicitly states that it does not use the term LRF; there, LRF is used to denote a two-stage retrieval pattern in which lexical signals drive high-recall pruning before re-ranking (Lin et al., 2022). By contrast, Stellar defines LRF as a concrete module inside a multimodal retrieval system (Guo et al., 18 Jun 2026). The representation-analysis paper uses LRF as a design pattern for selecting layers, pooling strategies, and validation protocols that reduce overlap-driven failures (Rizwan et al., 1 Jun 2026). This suggests that LRF is best treated as a research motif rather than a single canonical algorithm.

2. Sparse lexical filtering in multimodal retrieval

In Stellar, LRF is a first-stage, sparse lexical retrieval module that prunes the corpus to a small candidate set before token-level late interaction (Guo et al., 18 Jun 2026). The system fine-tunes Qwen2-VL-2B as a sparse encoder and projects both rendered document pages and natural-language queries into a shared vocabulary-sized lexical space. The MLLM processes document pages as images through a vision encoder, an adapter to language tokens, and the LLM decoder; queries are tokenized and passed through the same LLM. For any token hidden state $h_i$, the pre-trained language modeling head produces a lexical vector

$w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$

A sparsification-and-pooling mechanism then forms the final lexical representation:

$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$

The resulting document and query encodings are

$$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$

with active-term sets

$$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$

The score used during training and filtering is the weighted dot product

$$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$

and at filtering time the sparse form is

$$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$

Several properties of this design are central. First, the MLLM vocabulary acts as a shared lexical term space for both modalities, so visual content can activate semantically relevant lexical terms that overlap with query terms. Second, the vectors are extremely sparse: on average about $200$ active terms out of $K$0, or approximately $K$1 sparsity. Third, the representation uses no additional normalization, IDF, or BM25-like terms; sparsity is induced by the $K$2, max pooling, and the training loss rather than by post hoc weighting (Guo et al., 18 Jun 2026).

The filtering stage builds a standard inverted index,

$K$3

and at query time traverses only the postings for $K$4, accumulating partial scores by document identifier. If $K$5 and $K$6, traversal cost is $K$7 and heap-based top-$K$8 selection is $K$9, where $h_i$0 is the number of touched documents. Stellar uses $h_i$1 by default, so on LargeDoc with $h_i$2 documents only $h_i$3 of the corpus is forwarded to the late-interaction stage (Guo et al., 18 Jun 2026).

3. Lexical-dense and dense lexical variants in text-domain filtering

A different LRF formulation appears in Luxical, which introduces “lexical-dense” embeddings: dense vectors produced from sparse lexical features via a small ReLU MLP, trained by distilling the similarity geometry of a transformer teacher (DatologyAI et al., 9 Dec 2025). Documents are tokenized with the BERT uncased tokenizer; the vocabulary consists of the approximately $h_i$4 most frequent $h_i$5-grams mined from FineWeb via the Space-Saving algorithm; and IDF is defined as

$h_i$6

With term counts $h_i$7, Luxical forms

$h_i$8

then applies $h_i$9 normalization:

$w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$0

The network architecture is $w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$1, with ReLU and $w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$2 normalization after each projection; the output is a 192-dimensional unit vector. Since the final embedding is normalized, the similarity-based filter is simply the dot product:

$w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$3

The paper also describes multi-query or topic filtering with a centroid set $w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$4, aggregated by max or weighted sum, and classifier-based filtering with

$w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$5

A multi-stage pipeline may begin with an optional BM25 or TF–IDF lexical prefilter, followed by Luxical embeddings, ANN indexing, and threshold-based decisions (DatologyAI et al., 9 Dec 2025).

The DLR/DHR framework offers a third variant. Starting from any lexical vector $w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$6, it slices the vector into $w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$7 slices of width $w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$8, keeps the maximum value and its index in each slice, and produces value and index vectors such as $w_i = f_{\text{head}}(h_i) \in \mathbb{R}^{|V|}.$9 and $$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$0 (Lin et al., 2022). The lexical score is approximated by the gated inner product

$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$1

For LRF, the framework uses either approximate GIP over the subset

$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$2

or a standard inner product over the value vectors,

$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$3

to retrieve top-$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$4 candidates, typically $$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$5, followed by exact GIP re-ranking (Lin et al., 2022). In dense hybrid representations, the same mechanism is extended to fused lexical-semantic scoring through concatenation of lexical values and semantic vectors, allowing a single dense-vector stack rather than separate lexical and semantic infrastructures.

4. Optimization, indexing, and execution patterns

The optimization target in LRF depends on the representation family. Stellar trains its sparse encoder with a contrastive InfoNCE objective with in-batch negatives and temperature $$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$6:

$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$7

To induce sparsity it adds SPLADE-style FLOPs regularization on documents and queries,

$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$8

and minimizes

$$z_j = \max_i \log(1 + \mathrm{ReLU}(w_{ij})), \quad j = 1, \ldots, |V|.$$9

with $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$0 and $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$1. LoRA with rank $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$2 is applied to all linear layers inside Transformer blocks and to $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$3; no $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$4 penalty, top-$$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$5 gating, or straight-through estimators are used (Guo et al., 18 Jun 2026).

Luxical instead uses teacher-student distillation of similarity geometry. For a batch of $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$6 documents, with normalized student embeddings $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$7 and teacher embeddings $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$8, the paper forms Gram matrices $$\mathrm{enc}_{\text{spa}}(d) = z(d), \qquad \mathrm{enc}_{\text{spa}}(q) = z(q),$$9 and $$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$0, removes the diagonals, applies temperature scaling, and minimizes a row-wise KL divergence

$$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$1

with $$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$2 (DatologyAI et al., 9 Dec 2025). Training uses $$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$3 million English FineWeb documents pre-embedded by the teacher, three epochs, CPU-only Adam, batch size $$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$4, a peak learning rate of $$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$5, warmup for $$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$6 of steps, and linear decay to zero during the last $$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$7 of training. Implementation relies on a Rust “arrow-tokenize” extension that returns PyArrow arrays, together with Numba-optimized kernels for sparse gather-and-scale and IDF application (DatologyAI et al., 9 Dec 2025).

The DLR/DHR framework separates densification from training. DLR can densify BM25, uniCOIL, SPLADE, DeepImpact, or other lexical vectors without training. If joint training is used, the paper defines a DeLADE lexical component,

$$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$8

with

$$I_d = \{j \mid z_j(d) > 0\}, \qquad I_q = \{j \mid z_j(q) > 0\}.$$9

and optimizes a hybrid NLL over positive and negative documents (Lin et al., 2022). Operationally, LRF becomes a two-stage dense retrieval pipeline: approximate GIP or value-vector inner product for candidate generation, followed by exact GIP on the candidate set.

5. Reported performance and operating regimes

The reported gains of LRF are strongly tied to the retrieval regime for which it is designed. In Stellar, LRF is the mechanism that makes disk-backed late interaction practical at scale. On LargeDoc with $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$0 documents, Stellar’s end-to-end peak memory is $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$1 MB and latency is $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$2 ms, compared with ColPali’s $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$3 MB and $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$4 ms and QColPali’s $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$5 MB and $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$6 ms. On medium-scale datasets such as ArXivQA and PlotQA, Stellar uses $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$7–$$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$8 MB and approximately $$\mathrm{sim}(q,d) = \mathrm{enc}_{\text{spa}}(q) \cdot \mathrm{enc}_{\text{spa}}(d) = \sum_{j=1}^{|V|} z_j(q) z_j(d),$$9–$$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$0 ms, whereas ColPali uses $$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$1–$$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$2 GB and $$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$3–$$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$4 ms, and QColPali uses $$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$5–$$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$$6 MB and $\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$7–$\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$8 ms. On LargeDoc, Stellar reports $\mathrm{score}_{\text{spa}}(q,d) = \sum_{j \in I_q \cap I_d} z_j(q) z_j(d).$9, $200$0, and $200$1; on DocVQA, it reports $200$2, $200$3, and $200$4 (Guo et al., 18 Jun 2026).

Luxical is evaluated in a different operating regime: coarse-grained web-scale organization. The paper reports speedups ranging from $200$5 to $200$6 over varying-sized neural baselines, and states that even GPU-accelerated Qwen3-0.6B embeds nearly two orders of magnitude slower than Luxical. In a quality filtering pipeline, Luxical-based scoring achieves $200$7 MiB/s, compared with FastText at $200$8 MiB/s and the transformer FineWeb-Edu scorer at $200$9 MiB/s. When a $K$00B transformer LLM is trained on datasets curated by the different scorers, Luxical and FineWeb-Edu yield identical downstream MMLU accuracy of $K$01 (DatologyAI et al., 9 Dec 2025). In symmetric document-half matching, Luxical-One trails larger transformer models at strict top-$K$02, but as the retrieval window grows it outperforms MiniLM-L6-v2 substantially and approaches larger models at broader windows (DatologyAI et al., 9 Dec 2025).

The DLR/DHR results emphasize approximation quality and single-stack efficiency. On MS MARCO dev, uniCOIL with an inverted index achieves MRR@10 $K$03 and R@1K $K$04, while uniCOIL DLR $K$05-D achieves MRR@10 $K$06 and R@1K $K$07; SPLADE with an inverted index achieves MRR@10 $K$08 and R@1K $K$09, while SPLADE DLR $K$10-D achieves MRR@10 $K$11 and R@1K $K$12 (Lin et al., 2022). For hybrid retrieval, DHR with uniCOIL $K$13 + ANCE reports MRR@10 $K$14 and latency $K$15 ms, compared with a linear Lucene+Faiss fusion at MRR@10 $K$16 and latency $K$17 ms. In single-model fusion, DeLADE+[CLS]$K$18 reports MRR@10 $K$19, latency $K$20 ms, index size $K$21 GB, and R@1K $K$22 (Lin et al., 2022). The paper further reports that on a single A6000 GPU, approximate-GIP with $K$23 plus exact GIP re-ranking of $K$24 candidates yields $K$25 ms total latency with the same MRR@10 and R@1K as exact GIP (Lin et al., 2022).

These evaluations are not directly interchangeable because they target different tasks: multimodal page retrieval, symmetric document similarity, language-model data curation, and passage retrieval. What they share is the claim that lexical filtering, when encoded appropriately, can shift the computational burden away from expensive full-corpus interaction.

6. Lexical dominance as a filtering target in LLM representations

A distinct strand of work treats LRF not as candidate generation, but as a method for controlling lexicality in representations. The relevant paper defines lexical overlap as surface-form similarity driven by shared tokens, n-grams, named entities, attributes, or local lexical patterns, and semantic content as sequence-level meaning that should be preserved under paraphrase (Rizwan et al., 1 Jun 2026). Its core stress test uses triplets $K$26 consisting of an anchor, a meaning-preserving paraphrase, and a lexical distractor. With layer-wise normalized sentence embeddings $K$27 and distance

$K$28

triplet success rate is

$K$29

Low success rate indicates that lexical overlap is dominating semantics (Rizwan et al., 1 Jun 2026).

The paper combines this with lexical decodability probes and MTEB layer-wise semantic evaluations. Lexical decodability is measured by an affine probe over token hidden states,

$K$30

scored against the input embedding matrix and trained with

$K$31

where $K$32 (Rizwan et al., 1 Jun 2026). Across architectures, training regimes, and objective functions, the paper reports a mid-depth region where both lexical and semantic signals degrade simultaneously. Prompt entropy exhibits a low-entropy bottleneck at approximately $K$33–$K$34 relative depth, coinciding with the valley in both probes and stress-test success rates (Rizwan et al., 1 Jun 2026).

From this evidence, the paper proposes LRF as a design pattern. It recommends avoiding the mid-depth valley, preferring post-bottleneck late layers, and using mean-pooled sentence embeddings for pretrained and instruction-tuned models rather than last-token embeddings. It further recommends validation on both CounterFact and SugarCrepe++ (SCPP), especially the attribute and relation perturbation subtasks, because CounterFact alone can overstate semantic robustness (Rizwan et al., 1 Jun 2026).

The downstream consequences are quantified. In summarization evaluation on XSum with adversarial lexical non-summaries, BERTScore has failure rate $K$35, with distractor score $K$36 versus gold score $K$37; BARTScore has $K$38, with $K$39 versus $K$40 (Rizwan et al., 1 Jun 2026). In a modified CounterFact locality experiment for model editing, lexically similar locality prompts induce larger distributional shifts than lexically dissimilar ones; at Top-K-100, the paper reports JSD $K$41 versus $K$42, TV $K$43 versus $K$44, Kendall’s $K$45 $K$46 versus $K$47, Edited-Target Presence $K$48 versus $K$49, and Top-1 Flip $K$50 versus $K$51 (Rizwan et al., 1 Jun 2026). In this usage, filtering means suppressing or rerouting decisions that are driven by lexical overlap rather than meaning.

7. Limitations, misconceptions, and open questions

One recurring misconception is that LRF is synonymous with sparse inverted-index retrieval. The current literature does not support that interpretation. Stellar uses a sparse lexical inverted index, but Luxical uses dense 192-dimensional vectors derived from sparse TF–IDF features, and DLR/DHR uses dense lexical or dense hybrid vectors with gated inner products (Guo et al., 18 Jun 2026, DatologyAI et al., 9 Dec 2025, Lin et al., 2022). Another misconception is that high lexical overlap is a reliable proxy for semantic fidelity; adversarial semantic stress tests show that overlap can systematically distort representation geometry, including in models trained for semantic similarity (Rizwan et al., 1 Jun 2026).

The limitations are also formulation-specific. Stellar does not include a dedicated analysis of failures on queries requiring subtle semantics beyond lexical alignment, extremely rare terms, or complex cross-modal mismatches; it does not report sensitivity to $K$52, $K$53, vocabulary truncation, or alternate MLLMs, and all experiments use Qwen2-VL-2B (Guo et al., 18 Jun 2026). Luxical is evaluated on English only, is described as less suitable for fine-grained ranking or reasoning-heavy tasks, and approximates rich compositional semantics through a fixed-vocabulary TF–IDF front end and shallow ReLU MLP (DatologyAI et al., 9 Dec 2025). In DLR/DHR, rare-term collisions from densification can reduce recall, and extremely rare or novel vocabulary remains a failure mode; the paper recommends increasing $K$54, decreasing $K$55, increasing $K$56, or using expansion models such as DeLADE or SPLADE-style lexical models to mitigate such effects (Lin et al., 2022). In the lexicality-analysis setting, low entropy is explicitly not a proxy for strong semantics; it is only a locator of the bottleneck, and the recommended target is the later re-expansion regime where triplet success rate rises (Rizwan et al., 1 Jun 2026).

Taken together, these results suggest that LRF is best understood as a systems and representation-design pattern: lexical information is used either to achieve high-recall pruning before expensive interaction, or to identify and avoid representation regimes in which surface form masquerades as meaning. The literature does not yet provide a single unified theory of LRF, but it does establish a coherent set of design choices—sparse lexical indexing, lexical-dense embedding, dense lexical approximation, and lexicality-aware layer selection—that address the same operational problem from different angles.