Large language models are now routinely used as judges: they read a source document and a generated text, then decide whether the text is faithful to the source. A judge that actually checks support should reject any claim the source does not back, whether or not the claim sounds believable. There is growing evidence that judges instead lean on what they already believe about the world. Checkers fall back on memorized facts rather than the given context (Knowledge-Centric Hallucination Detection). Judge uncertainty on factual consistency spans nearly the whole 1–5 scale (Diagnosing LLM Judge Reliability). We propose to measure this failure directly and then fix it. The measuring instrument is a knowledge graph embedding (KGE), a model that places every entity and relation of a fact database in a vector space so that any candidate fact (subject, relation, object) gets a continuous "how plausible is this given everything else in the graph" score.
The core idea fits in two sentences. Take a faithful text, swap one fact for a wrong one, and use the KGE score to choose wrong facts at controlled levels of world-plausibility, from absurd to nearly indistinguishable from the truth. If judges check support, their error rate should be flat across plausibility levels. If it climbs with plausibility, the judge is grading plausibility rather than support. That gap can then be trained away with graded hard negatives and with "true in the source, implausible in the world" positives.
Core Claim
Our claim is that judge failures on faithfulness are largely a plausibility leak. The chance that a judge accepts an unsupported claim rises steeply and smoothly with the claim's graph plausibility, and the chance it rejects a supported claim rises as that claim's plausibility falls. A KGE gives a scale for this effect that is continuous, independent of any judge, and computable for any candidate substitute. Self-adversarial sampling in RotatE already shows that KGE scores rank hard negatives well enough to train on. RotatE models relations as rotations in complex space, and the model scores the hardest wrong facts using its own current scores. We expect that judges trained on negatives drawn along this scale will generalize to human-annotated hallucinations better than judges trained on random or type-matched entity swaps.
Relation to Prior Work
Three lines of work motivate the proposal. Justice or Prejudice? catalogs 12 judge biases with an attack-and-detect protocol, but its perturbations are rhetorical: length, fake citations, politeness, position. It never varies the content of a wrong claim along a plausibility axis, and our test adds that missing axis to the same methodology. Knowledge-Centric Hallucination Detection breaks responses into claim triplets, names the internal-knowledge bias, and releases KNOWHALBENCH. It shows the bias exists but does not measure how much it grows with plausibility or correct for it. The conformal analysis in Diagnosing LLM Judge Reliability shows that consistency is the criterion where judges are least certain. Our hypothesis offers one mechanistic reason for that.
Three papers supply methods we reuse. Can LLMs be Good Graph Judge for Knowledge Graph Construction? fine-tunes a 7B model to verify triples using entity-swap negatives and finds it beats GPT-4o. FactSpotter trains a faithfulness classifier on entity swaps and token dropouts for graph-to-text generation. Both use swaps with no control over plausibility, which is the variable we manipulate. EGIT does use pretrained KGEs (TransE, ComplEx, SimKGC) to mine hard negative entities, but only to train an entity reranker for link completion on FB15k-237 and WN18RR. It never asks whether those negatives expose or repair a judge of free text. We take its mining idea and apply it to evaluation.
One adjacent paper constrains the design. GNN-as-Judge uses a graph model to overrule an LLM on node classification. We deliberately do not let the KGE vote on faithfulness. Plausibility in the world is the wrong target for faithfulness to a source, and using it as a verdict would build the very bias we want to remove. The KGE serves only as a ruler and as a source of training data.
Research Program
The natural testbed is graph-to-text generation, because its sources are already knowledge-graph triples over DBpedia entities. We will use WebNLG 2020 and DART. We train RotatE and ComplEx on a DBpedia subgraph covering the two-hop neighborhood of all benchmark entities. As a sanity check, we first confirm our training pipeline reproduces the published FB15k-237 result, RotatE MRR 0.338 (RotatE).
For each faithful reference text, we pick one verbalized triple and replace its object (or subject) in the text with an entity drawn from a given plausibility percentile of the KGE's ranking for that slot. We exclude any entity that would make a true fact under the graph and require type agreement, so that only plausibility varies. This produces negatives in five plausibility bins.
We also build the mirror set. We edit the source triples to state an implausible-but-specified fact and regenerate a text that faithfully states it. A support-checking judge must accept these. A plausibility-grading judge will reject them.
We then run off-the-shelf judges: GPT-4o-mini, LLaMA-3.1-70B, Qwen-2.5-72B, and a 7B open model. Each uses rubric prompting, chain-of-thought prompting, and triplet-level checking in the style of REFCHECKER. From these runs we estimate a plausibility-leak slope: the change in the log-odds of accepting a claim per plausibility bin, fitted on both negatives and mirror positives. We control for entity frequency, text length, and the judge's own closed-book belief in the substituted fact.
Finally, we fine-tune the 7B judge in the GraphJudge recipe under four data regimes, matched in size and training compute. The first uses random swaps, the second type-matched swaps, the third KGE-graded negatives, and the fourth KGE-graded negatives plus mirror positives. We compare them on human-annotated data the KGE never touched.
Baselines
The naive reference point is a judge prompted zero-shot with a standard consistency rubric. It is the default in practice, and it fixes what "no fix" looks like on each human-annotated benchmark. It runs on identical inputs with identical decoding.
The strongest existing detector is REFCHECKER's triplet extractor-plus-checker (Knowledge-Centric Hallucination Detection). It is the strongest competitor because it already checks at triplet granularity against the reference, and it reports gains of 18.2 to 27.2 points over SelfCheckGPT and FacTool on KNOWHALBENCH, plus a 10-point Macro-F1 advantage of triplet over sentence checking. The file gives no absolute Macro-F1 for it, so we will re-run it with the same checker backbone as our judges. Beating it means a higher KNOWHALBENCH Macro-F1 with the same backbone, especially in the Noisy and Zero-context splits where internal-knowledge bias should dominate.
The strongest trained competitor is a GraphJudge-style fine-tuned 7B verifier (Can LLMs be Good Graph Judge) trained on its native entity-swap negatives. No reported result was found on Lacuna for its F1 values. We give it the same base model, the same number of training examples, and the same tuning budget as our regimes.
For graph-to-text, we include FactSpotter, retrained on the same splits. No reported result was found on Lacuna for its WebNLG correlation with humans. The file reports only DART FactS scores, which are a different quantity.
We add AlignScore (AlignScore) as a non-LLM consistency metric. On HaluEval summarization, we report against ChatGPT's 58.53% detection accuracy (HaluEval).
The ablation that isolates our key ingredient is the type-matched-swap regime: same entity types, same size, no plausibility grading. A second ablation drops the mirror positives, to separate "harder negatives" from "decoupling acceptance from plausibility."
Why not just…?
Why not just use a bigger model or chain-of-thought prompting? The bias catalog in Justice or Prejudice? finds that GPT-4o, Claude-3.5 and Qwen2-72B all share its biases. The conformal sets for consistency stay near 4.9 of 5 across 70B-scale models (Diagnosing LLM Judge Reliability). We do not assume the answer, though. The stress test reports the leak slope separately for each model size and prompting style. If chain-of-thought flattens the slope, that is a publishable finding in itself, and the training half of the proposal becomes unnecessary.
Why not just have an LLM write plausible distractors? This is cheap and may produce fluent negatives. However, distractor plausibility then depends on the generator's own beliefs, which overlap with the judges' beliefs, and self-enhancement bias contaminates the comparison when generator and judge share a family. The method also gives no graded, reproducible dose. We include LLM-written distractors as an extra negative source and test whether their KGE scores explain their difficulty. If they are as hard as our top bin and train an equally good judge, the KGE's value shrinks to measurement only, and we will say so.
Why not just pick negatives the judge itself believes (closed-book belief) instead of a KGE? This is the most serious threat to the claim that the KGE is a useful ruler, since a judge's own belief is the most direct proxy for its internal knowledge. Our answer is that closed-book selection is adversarial to one judge and yields a different benchmark per judge, whereas the KGE yields one shared scale across judges. The experiment settles the question empirically. We regress judge errors on KGE plausibility and closed-book belief together. If KGE plausibility carries no predictive power once belief is included, the measurement claim fails. In that case we fall back to judge-belief selection, keeping only the mirror-positive training idea.
Why not just use type-matched random swaps? Types capture much of plausibility, and that is exactly why this is our main ablation. The KGE has to earn its place: graded negatives must outperform type-matched ones on held-out human data, not just on our synthetic set.
Decisive Checks
The idea stands or falls on four results. First, judge acceptance of unsupported claims must rise monotonically across KGE plausibility bins, with a slope clearly above zero after controls, for at least most judges. A flat curve kills the hypothesis. Second, rejection of supported-but-implausible mirror positives must be well above rejection of ordinary supported claims. Third, KGE plausibility must still predict errors after the judge's closed-book belief is controlled for. Fourth, the graded-negatives-plus-mirror judge must beat both the type-matched-swap and GraphJudge-recipe judges on KNOWHALBENCH Macro-F1, on WebNLG 2020 human faithfulness correlation, and on HaluEval. The gains should concentrate in the high-plausibility errors that the leak slope predicts. If they appear only on our synthetic set, the result shows we taught the judge our generator, not support checking.
References
- Knowledge-Centric Hallucination Detection
- Diagnosing LLM Judge Reliability: Conformal Prediction Sets and Transitivity Violations
- RotatE: Knowledge Graph Embedding by Relational Rotation in Complex Space
- Justice or Prejudice? Quantifying Biases in LLM-as-a-Judge
- Can LLMs be Good Graph Judge for Knowledge Graph Construction?
- FactSpotter: Evaluating the Factual Faithfulness of Graph-to-Text Generation
- Mitigating Hallucinations in Knowledge Graph Completion via Embedding-Guided Instruction Tuning
- GNN-as-Judge: Unleashing the Power of LLMs for Graph Learning with GNN Feedback
- HaluEval: A Large-Scale Hallucination Evaluation Benchmark for Large Language Models