Specialized memory chips can compare a query against every stored vector at once, which makes nearest-neighbor search far faster and cheaper than on a GPU. They get this speed by storing short binary or low-bit codes and by computing similarity with analog circuits, which add noise. That is harmless when the correct document clearly outscores everything else. It is harmful when the correct document barely wins. We argue that multilingual multi-hop question answering is exactly the setting where the correct document barely wins. A complex question is split into a chain of small sub-questions ("decomposition"). Later sub-questions are often code-mixed, for example a Bengali question frame wrapped around an English entity name returned by the previous hop. The multilingual encoder was jointly trained on clean parallel text and rarely saw inputs like these. Our hypothesis is that such sub-queries sit much closer to their distractors, so hardware noise flips their rankings far more often than it flips English ones. Each flip puts an irrelevant passage into the context, and those errors multiply along the chain.
This note proposes to measure that effect and then to fix it where it originates, in the retriever. The retrieval encoder would be jointly trained across languages on decomposed and code-mixed sub-queries, with hardware-style noise injected during training. A per-hop rule would send only the low-confidence sub-queries back to exact full-precision search. The goal is not a faster chip. The goal is to find out whether the cheap, noisy, massively parallel search these chips offer can be made safe for non-English multi-hop reasoning, and at what cost in exact fallback.
Core Claim
For a sub-query $q$, define its retrieval margin as
$$m(q) = s(q, d^{+}) - \max_{d^{-}} s(q, d^{-}),$$
where $s$ is cosine similarity, $d^{+}$ is the gold passage for that hop, and $d^{-}$ ranges over all other passages. Model the noisy hardware as adding independent Gaussian error of standard deviation $\sigma$ to each score. The chance that the hardest distractor overtakes the gold passage is then approximately $\Phi(-m/(\sigma\sqrt{2}))$, because the difference of two independent noisy scores has standard deviation $\sigma\sqrt{2}$. For an $H$-hop chain, the probability that every hop succeeds is roughly the product of the per-hop success probabilities.
The claim has three parts. First, margins shrink systematically for non-English and code-mixed sub-queries, and they shrink more at later hops. Second, this shrinkage explains most of the gap between languages in end-to-end accuracy under low-precision search. Third, joint multilingual training that targets the margin of decomposed sub-queries under simulated noise closes most of that gap at a small fraction of exact-search cost.
What is new here is the margin-under-noise diagnosis, applied per language and per hop, together with a training objective and a fallback rule built around it. Neither faster sub-query execution nor reader-side noise filtering is the contribution.
Where This Sits
Each of four bodies of work supplies a piece of this problem, and none combines them.
The motivation comes from decomposition-based retrieval. Question Decomposition for Retrieval-Augmented Generation splits multi-hop questions into sub-queries and then prunes the enlarged candidate pool with a cross-encoder reranker. The authors observe that rerankers score lexical distractors highly on out-of-domain and cross-lingual text. BrowseNet walks an entity-linked graph of document chunks along an LLM-generated plan of sub-queries. It attributes 33% of its failures to decomposition errors. Both systems are English-only and use full-precision search, so neither can tell us how sub-query retrieval behaves across languages or under hardware noise.
The constraint comes from the hardware work. COSIME builds in-memory cosine search from ferroelectric transistor cells, a memory device whose stored state also performs the comparison. It reports that Hamming-distance accelerators lose about 7% accuracy, and that 10% device variation still leaves about 90% worst-case search accuracy. Those results come from simple classification benchmarks, where margins are large. The memristor compute-in-memory work shows that recovering higher precision requires costly analog-to-digital conversion. Together these define the regime we must work in: low bit-width and non-zero noise. Kitano and Higuchi's IXM2 system already showed that associative hardware is a natural match for translation, and that its capacity forces a fallback when moving to open domains. Our exact-search escalation is the modern form of that fallback.
The method comes from multilingual joint training. The Multilingual Universal Sentence Encoder shows that training one dual encoder on many languages yields a shared semantic space. It also documents subword fragmentation in non-Latin scripts under a shared vocabulary, which is one plausible cause of small margins. XGLUE reports that pooling labeled data from all target languages beats transfer from a single source language. We reuse that recipe, but the pooled data are decomposed sub-queries rather than whole questions.
Two papers could appear to undercut the retrieval-side framing. Bridging the Language Gap finds that multilingual multi-hop failures come from attention heads routing information incorrectly, not from missing facts. Its tests, however, are closed-book, with no retrieval involved. We treat routing and retrieval as competing explanations and separate them experimentally. On the reader side, Distraction-aware Answer Selection and Superposition Prompting make readers robust to irrelevant passages in English. We ask whether that robustness survives when the distractors come from another language and arrive through a noisy retriever.
Research Program
The first step is measurement. We will build a cross-lingual multi-hop retrieval set by translating MuSiQue-Ans questions (MuSiQue) into the seven XOR-TyDi languages. A human-verified subset will check translation quality. MuSiQue is chosen because it filters out single-hop shortcuts. Retrieval runs over English Wikipedia, and hop-level gold passages come from MuSiQue's decompositions.
Sub-queries will be produced in two ways: by an LLM decomposer, and by the gold decompositions translated into each language. Comparing the two separates encoder margin effects from decomposer errors. For every hop and language we will compute margins under two encoders: a jointly trained multilingual dual encoder, and an English encoder applied after translation.
We will then simulate the hardware in two forms. One is binarized Hamming search. The other is a COSIME-style analog noise model, calibrated so that it reproduces COSIME's reported degradation under 10% device variation. From these we record per-hop rank flips, recall@k, and end-to-end answer F1.
The second step is the fix. We will continue joint training of the multilingual encoder on sub-queries pooled across all eight languages, in both monolingual and code-mixed forms. The code-mixed forms are made by inserting English bridge entities into target-language question frames. The loss is a contrastive objective with mined hard negatives. It is applied after straight-through binarization and with Gaussian score noise at the calibrated $\sigma$, so that it explicitly widens margins under the conditions the hardware will impose.
At inference, each sub-query first runs through the noisy parallel search. If its observed top-1 versus top-2 gap falls below a threshold $\tau$, it is escalated to exact full-precision search. Sweeping $\tau$ traces a curve of accuracy against escalation rate, and that curve is the main deliverable.
Baselines
The naive reference point is a jointly trained multilingual encoder using the same LLM decomposer and reader, with exact floating-point search. This is the accuracy ceiling for any low-precision method. Its "do nothing" counterpart is the same encoder binarized or noised with no retraining and no fallback. The gap between these two defines the problem.
The strongest simple competitor is two-stage search: noisy low-bit retrieval of the top $k$ candidates, followed by exact floating-point rescoring of those $k$. For a fair comparison it gets the same encoder, the same decomposer and reader, and a sweep over $k$. We compare at matched numbers of exact similarity computations per query. The proposal beats it only if it reaches the exact-search ceiling within one F1 point while performing fewer exact computations than the smallest $k$ that does so.
The strongest published pipeline is QD+RR from Question Decomposition for Retrieval-Augmented Generation. It reports 28.1 EM and 35.0 F1 on HotpotQA, and 87.2% Hits@10 with 0.635 MRR@10 on MultiHop-RAG, with retrieval latency of about 18.9 seconds per query. We will rerun it on our translated set with its cross-encoder unchanged. This tests the claim that rerankers fail on cross-lingual distractors.
For the cross-lingual end-to-end reference we use translate-test, as in XOR QA. There, the best XOR-Full system reached 18.7 average F1. On our translated MuSiQue there is no reported result found on Lacuna, so we will run translate-test ourselves with the same reader. We will also report XOR-Retrieve recall. No reported result was found on Lacuna for XOR-Retrieve recall numbers in the file, so we report our own.
Two ablations isolate the key ingredient. The first trains the noise-aware encoder on English sub-queries only, which tests whether joint training matters. The second trains it without code-mixed sub-queries, which tests whether the hop-level distribution shift matters. A third comparison replaces the margin-triggered fallback with random escalation at the same rate.
Why not just…?
Why not just translate every sub-query to English and search there? XOR QA's translate-test system reached only 18.7 F1 on XOR-Full, and the authors report compounding translation errors. In a chain, a mistranslated bridge entity at hop one also corrupts hop two. Translation adds a serial model call at every hop, which removes the latency benefit of parallel search. Even so, translation could plausibly produce English-like margins. We will measure margins after translation directly. If translate-then-binarize matches our encoder at equal cost, we will report that joint training is unnecessary.
Why not just retrieve a larger top-k with the noisy search and rescore it exactly? This is the real threat. If the gold passage almost always lands within a modest $k$, the problem is solved without retraining. The margin analysis predicts where this breaks: at later hops and for code-mixed queries, the required $k$ should grow sharply, and the growth concentrates in low-resource scripts. The matched-compute comparison in the baselines settles the question. If fixed-$k$ rescoring wins, the contribution reduces to the per-language, per-hop measurement, and we will say so.
Why not just use GPU exact search, given that vector search is not the bottleneck? We concede the latency point. In QD+RR, naive retrieval takes 0.03 seconds, and most of the 18.9 seconds goes to decomposition and reranking. The case for associative hardware rests on energy and on-device deployment. COSIME reports 98.5× energy efficiency over a GTX 1080. Our question is whether answer quality survives that choice. It is not whether the hardware makes the pipeline faster.
Why not just harden the reader with distraction-aware selection or superposition prompting? Those methods prune bad passages but cannot recover a gold passage that retrieval never returned. We will run DAS-style scoring on top of every condition. If it closes the language gap by itself, the retrieval-side fix is unnecessary. If the gold passage is simply missing, it cannot.
Proposed Experiments
The first decisive check is correlational. Across languages and hops, does the measured noise-free margin predict the rate of rank flips under noise? We would expect it to follow the $\Phi(-m/(\sigma\sqrt{2}))$ form. Does the per-hop failure rate then predict chain-level F1 through the product rule? If margins do not differ by language, the premise is false and the project stops at a negative result.
The second check is causal, and it is the attribution check. With gold passages injected at every hop, removing retrieval entirely, does the remaining language gap in reader accuracy match the closed-book routing failures reported in Bridging the Language Gap? The portion of the gap that disappears under oracle retrieval is the portion our method can address.
The third check is the accuracy-versus-escalation curve on translated MuSiQue, with English HotpotQA and 2WikiMQA as controls. The noise-aware jointly trained encoder with margin-triggered fallback should dominate both fixed-$k$ rescoring and translate-test. Its advantage should be largest for Bengali and Telugu, the scripts where mUSE documents the worst fragmentation. We will also sweep the noise level $\sigma$ up to the 10% device variation COSIME tested, to locate where each method breaks down.
References
- Question Decomposition for Retrieval-Augmented Generation
- BrowseNet: Graph-Based Associative Memory for Contextual Information Retrieval
- COSIME: FeFET Based Associative Memory for In-Memory Cosine Similarity Search
- Memristor-based adaptive analog-to-digital conversion for efficient and accurate compute-in-memory
- High Performance Memory-Based Translation on IXM2 Massively Parallel Associative Memory Processor
- Multilingual Universal Sentence Encoder for Semantic Retrieval
- XGLUE: A New Benchmark Datasetfor Cross-lingual Pre-training, Understanding and Generation
- Bridging the Language Gap: Uncovering and Aligning Shared Circuits for Multi-Hop Reasoning in Multilingual LLMs
- Improving Zero-shot Reader by Reducing Distractions from Irrelevant Documents in Open-Domain Question Answering
- Superposition Prompting: Improving and Accelerating Retrieval-Augmented Generation
- ♫ MuSiQue: Multihop Questions via Single-hop Question Composition
- XOR QA: Cross-lingual Open-Retrieval Question Answering