When a language model answers in Spanish, Chinese, or Tamil, we would like to flag the specific sentences or clauses that are false, rather than reject the whole answer. Today's tools for doing this work well mainly in English. Splitting text into individual claims relies on English-style punctuation rules, and the language-inference models that judge whether a claim is supported are weaker outside English. The model's own confidence, read from its token probabilities, is available in every language. The catch is that it can only be used if you know which tokens make up each claim. This proposal fills that gap by borrowing a tool from a different field. Cross-lingual label projection is the technique, developed for tasks like named-entity tagging, of carrying span annotations made on an English translation back onto the exact words of the original-language text.
Concretely, the method works in four steps. It translates the model's target-language answer into English. It splits that translation into claims and checks them with mature English tools. It then projects each English claim span back onto the tokens the model actually generated, using constrained decoding (a second decoding pass forced to reproduce a fixed target sentence while choosing where to insert span markers). Finally, it scores each projected span with the generating model's own token-level uncertainty. Two signals come out of this, one from English verification and one from the model's own confidence in the original language, and they are combined claim by claim. In short, projection lets English do the segmenting and the fact-checking, while the original-language logits supply the model's own confidence.
Core Claim
We claim that claim-level hallucination detection in non-English and especially non-Latin-script languages improves when two things are true. Claim boundaries should come from English segmentation projected onto the generated text. And the final score should combine English-side verification with original-language logit uncertainty computed over the projected span. Either signal alone should be worse: pivot-only verification inherits translation errors, and native-only uncertainty lacks a usable claim segmenter outside European scripts.
The motivating evidence comes from MUCH. MUCH benchmarks claim-level uncertainty for four open models in English, French, Spanish, and German. It reports a clear drop outside English, with language-inference-based methods struggling on Spanish. Its fast rule-based segmenter, which takes 6 seconds against 2,758 seconds of generation, is explicitly limited to Latin-script European languages.
The method comes from Constrained Decoding for Cross-lingual Label Projection (CODEC). CODEC treats a clean target sentence as an immutable template and places span markers on it by branch-and-bound search. In a translate-test setting, which is exactly our setup, it reports 70.4 average F1 across 18 MasakhaNER 2.0 languages versus 65.8 for alignment-based projection. CODEC and its LLM-prompting relative CLaP project entity and argument tags. Neither treats the projected unit as a factual assertion to be verified, and neither combines projection with the generating model's own uncertainty.
How This Differs From Existing Intersection Work
CCL-XCoT mitigates low-resource hallucination with contrastive continued pretraining plus English chain-of-thought. It reports a 55% hallucination-free rate in Tamil for an 8B model against 24% for Llama-3.1-70B-Instruct. That approach requires retraining and produces no claim-level flags. Our method is a post-hoc detector that works on frozen models.
ANHALTEN transfers token-level detection from English to German with encoder adapters. It finds that 876 gold German examples beat about 6,300 machine-translated ones, and it uses synthetic perturbations. We instead need no target-language labels and work on real generations.
MultiHal grounds generation in Wikidata paths and is a mitigation dataset. We use English-side checking, which could include its KG paths, only as one input to the detector.
Three probing studies constrain the design: Factual Consistency of Multilingual Pretrained Language Models, Cross-Lingual Consistency of Factual Knowledge, and How Do Multilingual Models Remember?. They show that factual knowledge is inconsistent across languages and that consistency tracks shared subword vocabulary rather than model scale. This warns us that the English verifier and the target-language generator may "know" different things. We therefore treat disagreement between the two signals as informative rather than collapsing to the English verdict.
Research Program
The pipeline starts from a frozen open-weight model's answer $y$ in a target language, with its per-token log-probabilities saved, as MUCH does. A translation system (NLLB, the backbone CODEC uses) produces an English version $e$. MUCH's deterministic segmenter splits $e$ into claims $c_1,\dots,c_k$. An English verifier assigns each claim a support score $v(c)$. The verifier is either an NLI model against retrieved English Wikipedia evidence or, as a variant, MultiHal-style KG paths.
Projection then maps each English claim to a token span $\pi(c)$ in the original $y$ via CODEC-style constrained decoding with $y$ as the fixed template. We extend CODEC in three ways that claims require. Claim spans are long and can be discontinuous, so we allow multiple marker pairs per claim. Every token of $y$ must be covered by at most one claim. And the search bound is adapted to the much smaller number of claims per sentence compared with entities per sentence.
On $\pi(c)$ we compute native uncertainty $u(c)$ using MUCH's white-box scorers: Token Entropy, and the adapted CCP. The final claim score is a logistic combination fit on a small development set:
$$ s(c) = \sigma\big(\alpha\, u(c) + \beta\, v(c) + \gamma\, a(c) + \delta\big), $$
Here $\sigma$ is the logistic function, $a(c)$ is the projection search's own confidence (the reranking score of the chosen span), and $\alpha,\beta,\gamma,\delta$ are four learned scalars. Including $a(c)$ lets the detector distrust claims whose projection was uncertain, which is where translation noise lives.
The program has three studies. The first measures projection fidelity on its own. The second measures detection quality. The third is an error analysis of when translation itself creates or erases a hallucination. To probe this, annotators label a subset of claims both in $y$ and in $e$, and we count label flips.
Data and Evaluation Setting
On European languages we use MUCH directly: 4,873 generations and 20,751 labelled claims in English, French, Spanish, and German. There, much_segmenter's native boundaries serve as a reference for projected boundaries, and the gold claim labels score detection.
For a pure projection test on hallucination spans we use ANHALTEN. Its German text is post-edited from English HADES with aligned perturbed spans, so projecting the English labels and comparing against the post-edited German spans directly measures span fidelity.
Non-Latin scripts are the main target, and the file contains no existing claim-level benchmark for them. We will build one by following MUCH's protocol. We generate answers in Chinese, Japanese, Arabic, and Tamil with the same four models, using the same style of factual, Wikipedia-linked questions. We annotate them with MUCH's GPT-4o/GPT-4.1 silver procedure, for which MUCH reports Cohen's kappa ≈ 0.82 on its languages. We also add a human-labelled gold subset per language, because that agreement figure has not been shown to hold for these scripts. Metrics follow MUCH: claim-level ROC-AUC, true-positive rate at a 10% false-positive rate, and compute overhead as a percentage of generation time. Projection is additionally scored by span F1 against reference boundaries.
Baselines
The naive reference point is the do-nothing detector from MUCH: Token Entropy over target-language claims. For European languages, claims come from much_segmenter. For non-Latin scripts they come from the most reasonable cheap segmenter available, splitting on script-appropriate sentence punctuation. MUCH reports this detector at ROC-AUC 0.737 with about 15 seconds of total overhead. Our method must clearly beat it to justify any extra machinery.
The strongest existing method is MUCH's adapted CCP. It is the best-performing scorer in that paper, at ROC-AUC 0.772, but costs 124% overhead relative to generation, and even it reaches only 48% true-positive rate at 10% false-positive rate. We will run CCP on the same generations, with the same saved top-24 logits and the same segmentation used for the naive baseline. Beating it means one of two things. Either higher ROC-AUC on the non-English and non-Latin subsets at comparable or lower total overhead, with translation and English verification counted in our cost. Or equal ROC-AUC at substantially lower overhead. Note that 0.772 is MUCH's figure on its four European languages. We found no reported result on Lacuna for claim-level detection in Chinese, Japanese, Arabic, or Tamil, so those numbers come from our own re-runs.
A pivot-only baseline translates the answer to English, verifies claims in English, and labels the containing target sentence with the result, so no projection is needed. This isolates whether claim-level projection matters at all.
A target-language LLM-as-judge baseline prompts a strong model to segment and flag claims directly in the target language. It is run on the same items, with cost reported.
ANHALTEN's adapter approach (XLM-R with the 876 gold German examples) is the supervised reference on German token-level spans. The file reports only relative gains for it, roughly 5% over zero-shot, and no absolute score, so we re-run it.
Three ablations isolate the key ingredients. The first swaps constrained-decoding projection for a statistical word aligner. The second drops $u(c)$, leaving pivot verification on projected spans. The third drops $v(c)$, leaving native uncertainty on projected spans. All learned components get the same development set and the same tuning budget.
Why not just…?
Why not just translate to English, detect there, and flag whole sentences? This is the cheapest serious competitor. If most hallucinated claims occupy their own sentence, it may be nearly as good. MUCH's motivation for claim-level scoring is that rejecting a sentence for one false clause discards valid content. Our pivot-only sentence baseline measures exactly how much claim-level projection buys. If the gap in ROC-AUC and in retained-valid-content is small, we will report that the projection step is unnecessary for detection. Its value would then be limited to enabling native uncertainty scoring.
Why not just run CCP or token entropy natively with a better segmenter? For French, Spanish, and German this is what MUCH already does, and it is our strongest baseline there. The open question is non-Latin scripts, where MUCH itself says its segmenter does not transfer. If a cheap script-aware splitter performs as well as projected boundaries, measured by span F1 against human boundaries and by downstream ROC-AUC, then projection is not needed for segmentation. The experiment settles this language by language.
Why not just use a word aligner instead of constrained decoding? This is a real threat. Claims are long spans, and alignment errors at their edges may matter less than they do for short entities. CODEC's 70.4 versus 65.8 margin was measured on entities, not claims. The aligner ablation decides the question. If the aligner matches constrained decoding within noise, we adopt it, since it is faster.
Why not just ask GPT-4o to find the false claims in the target language? MUCH reports that LLM-based segmentation and judging can double generation cost and is non-deterministic. MultiHal found that noisy LLM-mediated linking hurt performance unless heavily filtered. A judge may still be more accurate, so we report it alongside our method on the same items with cost. We frame our method as the option for monitoring under a compute budget, not as a replacement in offline auditing.
Decisive Checks
The idea succeeds if three things hold. Projected claim boundaries reach high span F1 against much_segmenter on European languages and against human boundaries on non-Latin scripts. The fused score beats native CCP on the non-English subsets of MUCH and on the new non-Latin set at no greater overhead. And both one-signal ablations are worse than the fusion, showing that English verification and native confidence carry complementary information, as the consistency studies would predict.
The idea fails, and we would say so, under two conditions. The first is that sentence-level pivot labelling or a simple script-aware native segmenter matches it. The second is that the translation label-flip rate is high enough that English-side verification systematically mislabels claims in the original answer.
References
- MUCH: A Multilingual Claim Hallucination Benchmark
- Constrained Decoding for Cross-lingual Label Projection
- Contextual Label Projection for Cross-Lingual Structured Prediction
- CCL-XCoT: An Efficient Cross-Lingual Knowledge Transfer Method for Mitigating Hallucination Generation
- ANHALTEN: Cross-Lingual Transfer for German Token-Level Reference-Free Hallucination Detection
- MultiHal: Multilingual Dataset for Knowledge-Graph Grounded Evaluation of LLM Hallucinations
- Factual Consistency of Multilingual Pretrained Language Models
- Cross-Lingual Consistency of Factual Knowledge in Multilingual Language Models
- How Do Multilingual Language Models Remember Facts?