🤖 AI

Reproducing and Stress-Testing Two Approaches to LLM Reasoning Reliability: Test-Time Probability Aggregation and Logic-Representation Editing

This paper independently reproduces and stress-tests two recent methods for enhancing LLM reasoning reliability—Test-Time Probability Aggregation (RPC) and Logic-Representation Editing (LCF)—across multiple models and domains, finding that RPC offers no significant advantage over standard self-consistency and LCF's logic-editing effects are weak, inconsistent, and often detrimental.

Original authors: Minhan Cho, Jimin Kweon

Published 2026-08-11

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Minhan Cho, Jimin Kweon

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a super-smart, but sometimes overly confident, robot how to solve puzzles. This robot is a Large Language Model (LLM), a type of AI that reads and writes like a human. The big problem scientists are trying to solve right now is "reliability." It's not just about whether the robot gets the answer right; it's about whether the robot knows it's right. Sometimes, the robot will confidently explain a wrong answer with perfect grammar, or it might hesitate on an easy one. We want a robot that is accurate and also trustworthy in its confidence. To fix this, researchers have been trying two very different tricks: one involves asking the robot to think about the same problem many times and voting on the best answer, while the other involves trying to reach inside the robot's brain and physically tweak the part of its "mind" that handles logic.

This paper is like a group of independent detectives who decided to test two new, flashy gadgets designed to make these AI robots more reliable. The first gadget, called RPC, is a "voting machine" that happens at the very end of the process. The second, called LCF, is a "brain surgeon" that tries to edit the robot's internal thoughts while it's working. The original creators of these gadgets claimed they were amazing, but no one else had tried to build them from scratch to see if they really worked. The authors of this paper decided to play the role of skeptics: they rebuilt both gadgets, tested them on new types of puzzles (like legal cases and math problems), and asked a simple question: "Do these actually work, or are they just lucky?"

The story starts with the first gadget, RPC. Imagine you ask a student to solve a math problem. If they get it wrong, they might still write a very convincing explanation. RPC is like asking that student to solve the problem 32 times, writing down every single attempt. Then, instead of just picking the answer that appears most often (a simple majority vote), RPC looks at how confident the student was in each attempt. It combines the "most popular answer" with the "most confident answer" to pick the winner. The researchers found that when they rebuilt this gadget exactly as the original authors described, it worked perfectly on the original math tests. However, when they took it to new territories—like translating text into database queries or analyzing legal documents—it didn't really beat the simple "majority vote" method. It was like a fancy car that drives great on a test track but doesn't go any faster than a regular car on the highway. In fact, on one specific test called BIRD, the gadget only showed a tiny advantage when the robot was allowed to think 32 times, but when the researchers tested it on a larger group of problems, that tiny advantage vanished completely. The main takeaway here is that RPC is a safe, harmless tool that never made things worse, but it also didn't provide the magic boost its creators promised on new types of tasks.

Then comes the second gadget, LCF, which is much more ambitious and risky. If RPC is a voting machine, LCF is a brain surgeon. The idea is that inside the robot's "brain" (its hidden layers of code), there are two separate streams of information: one for the content (the facts and words) and one for the logic (the rules of reasoning). The original paper claimed that if you could find the "logic" stream and push it toward a "valid" direction, you could force the robot to think more logically, regardless of what it was saying. The researchers tried to rebuild this from scratch because the original authors never shared their code. They found that a "logic" stream does exist, but it's very weak—like trying to hear a whisper in a noisy room. When they tried to push this stream to make the robot more logical, it mostly backfired. On three out of four different robot models they tested, the gadget actually made the robots less confident in their correct answers and more likely to make mistakes. The only time it seemed to help was on one specific robot model, but even then, the improvement was so small that it could have just been random luck. The researchers also tried to make this "brain surgery" work on any robot without needing to train a special tool first, but that failed too. In the end, the "brain surgeon" gadget turned out to be unreliable; it often broke the robots it was supposed to fix, and the one time it seemed to work, the evidence wasn't strong enough to call it a real success.

The final verdict from this study is a tale of two very different outcomes. The "voting machine" (RPC) is a boring but safe tool: it doesn't break anything, but it doesn't offer a huge advantage over simple methods either. The "brain surgeon" (LCF), on the other hand, is a high-risk experiment that failed to deliver on its promises. The researchers found that while the idea of editing a robot's logic stream sounds cool in theory, in practice, it's too weak and too specific to the type of robot you are using to be a reliable fix. For anyone looking to make AI more trustworthy right now, the study suggests that sticking with the safer, simpler method of asking the AI to think multiple times and voting is the better bet, while the fancy internal editing tricks need a lot more work before they can be trusted.

Technical Summary: Reproducing and Stress-Testing Two Approaches to LLM Reasoning Reliability

Problem Statement

Recent large language models (LLMs) exhibit deficiencies in reasoning reliability, specifically failing to calibrate confidence with accuracy and conflating surface plausibility with logical validity. Two recent methods proposed to address these issues are RPC (Zhou et al., 2025), which aggregates token probabilities and self-consistency at inference, and LCF (Wu et al., 2025), which trains projectors to disentangle "content" and "logic" subspaces in the residual stream, editing the logic vector toward a valid region.

The core problem addressed by this study is the lack of independent verification for these claims. RPC's evaluations were conducted solely by its authors on a fixed set of models, while LCF released no public code, making its central premise—a controllable logic direction—unverifiable. Furthermore, neither method had been stress-tested across diverse domains or model architectures to determine if their reported reliability gains are robust or artifacts of specific experimental setups.

Methodology

The study employs a rigorous reproducibility framework, treating each method's reported reliability gain as a hypothesis to be re-tested under independent implementation across multiple models and domains.

1. RPC (Test-Time Probability Aggregation)

Reproduction: The authors re-ran RPC's published aggregation logic on the original authors' released reasoning paths for four mathematics benchmarks (MATH, Math-Odyssey, Olympiad-Bench, AIME).
Extension: The method was extended to four new domains: text-to-SQL (BIRD), legal citation extraction (KO-VER), precedent grading (KCC), and fallacy identification (LFUD).
Stress-Testing: A sample-budget study was conducted on BIRD, varying the number of sampled chains ( $K$ ) from 8 to 32 to isolate when RPC outperforms standard self-consistency (SC).
Baselines: RPC was compared against Self-Consistency (majority vote) and Perplexity (PPL) selection.

2. LCF (Logic-Representation Editing)

Re-implementation: Since LCF code was unavailable, the authors re-implemented the full pipeline from scratch: training projectors to split hidden states into content and logic vectors, a cross-attention decoder for reconstruction, and an InfoNCE contrastive objective.
Intervention: At inference, the logic vector is shifted toward a "valid" region using a scale parameter $\eta$ and decoded back into the residual stream.
Substitutions: Due to the unreleased validity discriminator in the original paper, the authors substituted an auditable GPT-4 judge and a DistilBERT classifier, flagging where these substitutions affect metrics.
Model-Agnostic Attempt: The study attempted to replace the trained LCF projector with a training-free Contrastive Activation Addition (CAA) approach with a conditional gate (K-CAST), testing it on fallacy identification and a controlled syllogism task.
Probing: A linear probe was used to measure the separability of valid vs. invalid conclusions in the hidden states, comparing the logic signal against a semantic control (suicide risk detection).

Key Results

RPC: Exact Reproduction, Limited Generalization

Original Grid: On the authors' released math paths, RPC reproduced the original results exactly (Accuracy: 26.15% vs. reported 26.11%; ECE: 12.32% vs. 12.37%), confirming the method's implementation is sound.
New Domains: Across four new domains (BIRD, KO-VER, KCC, LFUD) with a small sample budget ( $K=8$ ), RPC showed no statistically significant advantage over Self-Consistency (paired $p \ge 0.28$ ). It tied SC in most cases.
Budget Scaling: On BIRD, RPC's advantage over SC grew with the sample budget, reaching +2.5% accuracy at $K=32$ . However, this gap was not statistically significant ( $p=0.16$ ) and relied on only 2 of 80 items. When the sample size was expanded to $n=200$ , the advantage reversed to $-0.25\%$ ( $p=0.85$ ), suggesting the original gain was a small-sample fluctuation.
Conclusion: RPC is a safe intervention that never significantly degraded performance but offers no significant reliability gain over standard self-consistency in the tested domains.

LCF: Weak Signal, Poor Controllability, and Model Dependence

Logic Validity Direction: A linear probe confirmed a logic-validity direction exists but is weak. It achieved 0.82 separability at the single best sub-layer (compared to 0.95 for a semantic attribute control) but collapsed to chance (0.52) when pooled over the layers edited by LCF.
Intervention Failure: The additive intervention (shifting the logic vector) failed to produce consistent gains.
- Qwen3-8B: Showed a non-significant increase in $\Delta$ Prob (probability margin on the valid option) from 6.11 to 7.83 ( $p=0.56$ ).
- Llama-2 & Mistral: Significantly degraded performance, reducing $\Delta$ Prob by 8.1 and 11.0 points respectively ( $p < 0.001$ and $p=0.002$ ).
- Vicuna: Showed a borderline non-significant drop.
Generalization: The positive effect on Qwen3 did not transfer to public logic benchmarks (FOLIO), where it degraded performance.
Model-Agnostic Attempts: Training-free contrastive steering (K-CAST) failed on the fallacy task, degrading both models. It only succeeded on a controlled syllogism task under narrow conditions (matched distribution, ablating content rather than adding validity, and only on a model already capable of the task).
Metric Reliability: The original paper's claim of 96.56% validity control relied on an unreleased discriminator. The authors' auditable substitute showed no gain, and the original metric could not be reproduced.

Significance and Claims

The paper concludes that there is a fundamental asymmetry between the two approaches:

RPC (Test-Time Aggregation): This method reproduces exactly and is robust; it never significantly degraded accuracy across any tested domain. While its edge over self-consistency on new domains did not reach statistical significance, it represents a safer, zero-cost intervention that aligns with theoretical preconditions (sufficient budget, answer diversity).
LCF (Representation Editing): This method does not reproduce as a reliable, model-agnostic intervention. The logic-validity signal is real but weak and locally encoded, making it difficult to control via additive interventions. The reported gains are model-dependent (only observed on Qwen3, and even there, not statistically significant) and often harmful to other models. The flagship reliability claims rely on unauditable components.

Final Takeaway: Based on the evidence from 7–8B models and small evaluation sets, test-time aggregation (RPC) is the more trustworthy mechanism for improving reasoning reliability, whereas logic representation editing (LCF) fails to generalize and introduces significant risks of degradation. The study emphasizes that reliability gains reported only by method authors should be treated as hypotheses until independently verified across models and domains.