C2-Faith: Benchmarking LLM Judges for Causal and Coverage Faithfulness in Chain-of-Thought Reasoning

This paper introduces C2-Faith, a benchmark derived from PRM800K that evaluates LLM judges on their ability to assess causal and coverage faithfulness in chain-of-thought reasoning, revealing that their performance varies significantly by task and that they struggle to localize errors or accurately score incomplete reasoning.

The Gist

Imagine you are a teacher grading a student's math homework. The student has written down a long, step-by-step solution to a problem.

In the past, teachers (and AI models) mostly cared about one thing: Did they get the right answer? If the final number was correct, the student got an A.

But recently, we've realized that's not enough. A student might get the right answer by guessing, by copying the answer key, or by writing a bunch of nonsense that sounds smart but doesn't actually make sense. This is called being unfaithful. They have the right destination, but the map they drew to get there is broken.

This paper introduces a new tool called C2-Faith to test how good AI "teachers" (Judges) are at spotting these broken maps.

The Two Ways a Map Can Be Broken

The authors realized there are two main ways a student's reasoning can be "unfaithful," and they named them Causality and Coverage.

1. Causality (The "Domino Effect" Test):
   Imagine a line of dominoes. If you knock over the first one, the second must fall because of the first.

   • The Test: Does Step B logically happen because of Step A?
   • The Failure: If the student writes, "I multiplied by 5," and the next step says, "Therefore, I added 2," that's a broken domino. The second step didn't follow from the first. It's a Causal error.

2. Coverage (The "Missing Puzzle Pieces" Test):
   Imagine a puzzle where the student jumps from the picture on the box to the finished picture, skipping 50 pieces in the middle.

   • The Test: Did the student show all the necessary steps to get there?
   • The Failure: If the student says, "The answer is 42," but skipped the part where they did the actual math, they have low Coverage. The reasoning is incomplete, even if the final number is right.

The Experiment: Tricking the AI Teachers

To test if AI judges are good at spotting these errors, the researchers created a "fake exam."

• The Setup: They took perfect, correct math solutions from a huge database.
• The Trick: They secretly swapped out one step with a fake, nonsensical one (breaking Causality) OR they deleted a bunch of steps in the middle (breaking Coverage).
• The Challenge: They asked three top-tier AI models (GPT-4.1, DeepSeek-V3.1, and o4-mini) to act as judges and find the errors.

The Surprising Results

The results were like a game of "Rock, Paper, Scissors." No single AI was the best at everything.

• The "Spotter" (DeepSeek-V3.1):
  This AI was amazing at looking at two specific steps and saying, "Hey, these don't match!" It was the best at spotting the Causal errors.

  • Analogy: It's like a mechanic who is great at checking if two specific gears fit together, but maybe not so good at looking at the whole engine.

• The "Detective" (o4-mini):
  This AI was the best at looking at the entire long chain of reasoning and finding exactly where the mistake happened. It was also the most balanced overall.

  • Analogy: It's like a detective who can read a whole novel and point to the exact page where the plot hole is.

• The "Optimist" (All of them):
  When it came to Coverage (missing steps), all the AI judges were too nice. Even when the student deleted 70% of the math steps, the AI judges still gave them high scores.

  • Analogy: It's like a teacher who sees a student's essay with half the words missing, but because the first and last sentences sound good, the teacher gives it an A. The AI judges were fooled by the "surface look" of the answer.

The "Early Bird" Bias

The researchers also found something funny: When the AI judges tried to find the broken step, they almost always guessed it happened earlier than it actually did.

• Analogy: If the mistake was in the middle of the story, the AI would say, "I think the problem started in the first chapter!" They are always suspicious of the beginning.

Why This Matters

This paper tells us that we can't just trust an AI to grade another AI's thinking blindly.

• If you need to check if a specific step makes sense, use DeepSeek.
• If you need to check the whole chain of logic or find missing pieces, use o4-mini.
• Warning: Don't trust AI judges to tell you if a reasoning process is "complete" if a lot of steps are missing; they will likely be too generous.

In short: We now have a better way to measure if an AI is actually thinking through a problem, or just pretending to. And we learned that different AI "teachers" have different strengths and weaknesses, just like human teachers do.

Technical Summary

Here is a detailed technical summary of the paper "C2-Faith: Benchmarking LLM Judges for Causal and Coverage Faithfulness in Chain-of-Thought Reasoning."

1. Problem Statement

Large Language Models (LLMs) are increasingly deployed as "judges" to evaluate the reasoning quality (Chain-of-Thought or CoT) of other models. However, a critical gap exists: current evaluation methods often conflate answer plausibility with process faithfulness.

• The Core Issue: An LLM judge may correctly identify that a reasoning trace leads to the right answer, even if the intermediate steps are logically invalid, skip essential inferences, or are post-hoc rationalizations.
• The Gap: Existing benchmarks focus on answer quality or style, lacking ground-truth mechanisms to test if judges can detect specific structural failures in reasoning:
  1. Causality: Does each step logically follow from the previous context?
  2. Coverage: Are all critical intermediate inferences present, or are steps missing?

2. Methodology: The C2-Faith Benchmark

The authors introduce C2-Faith, a diagnostic benchmark built upon the PRM800K dataset (a large-scale process-supervised dataset with human step-level labels). The benchmark uses controlled perturbations on verified, "perfect" reasoning chains (chains where every step was human-validated as correct) to create ground-truth errors.

A. Data Construction

• Source: 450 reference chains from PRM800K, filtered to contain only steps labeled as positive (+1, advancing the solution) and having at least 5 steps.
• Causality Perturbations:
  • A single step in the "middle region" (30%–90% of the chain) is replaced with an acausal variant.
  • The replacement is generated by an LLM to be surface-plausible but logically inconsistent with the preceding context.
  • Ground Truth: The index of the corrupted step is known.
• Coverage Perturbations:
  • A fraction $d$ of middle-region steps is uniformly deleted ($d \in \{0.1, 0.3, 0.5, 0.7\}$).
  • Remaining steps preserve order to maintain surface coherence.
  • Ground Truth: The deletion rate is known, and reference scores are generated by GPT-4.1 using a 0–4 rubric (based on Emmons et al., 2025).

B. Evaluation Tasks

The benchmark evaluates judges across three tasks of increasing difficulty:

1. Binary Causal Detection (Exp 1): Given context + a target step, does the step follow logically? (Output: 0 or 1).
2. Causal Step Localization (Exp 2): Given a full perturbed chain, identify the index of the first unfaithful step. (Output: Index or -1).
3. Coverage Scoring: Given a degraded chain, assign a score from 0 to 4 indicating reasoning completeness.

C. Models Evaluated

Three frontier LLMs were tested as judges:

• GPT-4.1
• DeepSeek-V3.1
• o4-mini

3. Key Contributions

1. First Controlled Benchmark for Faithfulness: C2-Faith is the first benchmark to combine controlled causal injections and controlled coverage deletions with exact ground-truth labels, moving beyond behavioral probes.
2. Decomposition of Faithfulness: It explicitly separates faithfulness into Causality (logical flow) and Coverage (completeness), revealing that these are distinct capabilities.
3. Discovery of the Detection-Localization Gap: The paper identifies that while judges can often detect an error exists, they struggle significantly to pinpoint the exact step.
4. Identification of Systematic Biases:
   • Score Inflation: Judges systematically over-credit incomplete chains (high scores even when 70% of steps are missing).
   • Early-Prediction Bias: Judges consistently predict the error occurs earlier in the chain than it actually does.

4. Key Results

A. Task-Dependent Rankings

No single model dominates all tasks; rankings invert based on the task framing:

• Binary Detection (Exp 1): DeepSeek-V3.1 is the strongest (94.7% detection rate), significantly outperforming GPT-4.1 (82.7%).
• Step Localization (Exp 2): o4-mini is the strongest (68.0% exact match), outperforming DeepSeek (55.8%) and GPT-4.1 (57.6%).
• Coverage Scoring: o4-mini and GPT-4.1 show similar, modest correlations with ground truth, while DeepSeek-V3.1 fails significantly at low deletion rates (near-zero correlation), exhibiting a "ceiling collapse" where it assigns maximum scores even to incomplete chains.

B. The Detection-Localization Gap

All models show a large gap between detecting an error and localizing it:

• Example: o4-mini detects errors 94.2% of the time but only localizes the exact step 68.0% of the time.
• Implication: Judges maintain a useful signal ("something is wrong here") even when they cannot identify the precise step.

C. Structural Predictors of Success

Analysis of o4-mini's failures reveals:

• Math Symbol Density: Steps with high mathematical symbol density (e.g., equations, fractions) are easier to detect because they offer concrete anchors for verification.
• Natural Language Edits: Perturbations involving only semantic changes in natural language (without symbolic contradictions) are the hardest to detect.
• Moderate Rewrites: These are the most difficult to detect, as they alter enough structure to break simple token matching but remain superficially plausible.

5. Significance and Practical Guidance

The paper provides actionable guidelines for deploying LLM judges in process-level evaluation:

1. Model Selection:
   • Use DeepSeek-V3.1 for step-level causal validation where the context is isolated (Oracle setting).
   • Use o4-mini for full-trace auditing and coverage assessment, as it handles long-context attribution better.
2. Caution on Coverage Scores: Coverage judgments are systematically inflated. Scores above 3.5 are unreliable, especially when >50% of steps are missing.
3. Bias Correction: Automated systems using judge-identified step indices for chain correction must account for the "early-prediction bias" (judges tend to flag steps too early).
4. Future Directions: The findings suggest that coverage assessment requires different approaches, such as step-count-aware scoring or explicit decomposition, rather than holistic fluency evaluation.

Conclusion

C2-Faith demonstrates that LLM judges are not monolithic; their ability to assess faithfulness is highly task-dependent. While they are generally good at spotting that a reasoning chain is flawed, they struggle with precise localization and accurately assessing completeness. This benchmark provides the necessary diagnostic tools to select the right judge for specific evaluation pipelines and highlights the need for more robust, calibration-aware evaluation metrics.