🤖 AI

When Self-Consistency Backfires: Majority Vote Hurts the Majority of Hard Science Problems for Small LLMs

This paper demonstrates that for small instruction-tuned LLMs on hard science problems, self-consistency via majority voting often reduces accuracy compared to single-sample inference because high agreement among generated answers does not reliably correlate with correctness.

Original authors: Utkarsh Bahuguna

Published 2026-08-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Utkarsh Bahuguna

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 solve a really tricky riddle. You ask a friend for the answer, but they seem unsure. So, you ask them the same riddle ten times. If they give you the same answer eight times, you probably think, "Okay, they must be right!" This is a bit like how modern computer brains, called Large Language Models (LLMs), try to get smarter. Instead of just guessing once, they are often told to "think" about a problem many times, generating different chains of thoughts, and then pick the answer that shows up most often. This technique is called Self-Consistency. It's like asking a crowd for a vote; the idea is that the "majority vote" will almost always be the correct one.

Why does this matter? Because these computer brains are getting used to solve hard science problems, from biology to physics. If the "crowd voting" trick works, we can just let the computer think longer and harder to get better results. But what if the crowd is actually wrong? What if the computer is so confident in a wrong answer that asking it more times just makes it dig its heels in deeper? That is the scary question this paper asks. The researchers wanted to know: On the hardest science questions, does asking the computer to vote on its own answers actually help, or does it accidentally make things worse?

The Great Voting Backfire

In this study, the researchers tested two popular, smaller computer brains (one called Qwen2.5-7B and the other Llama-3-8B) on a very tough test called GPQA Diamond. This test has 198 graduate-level science questions in biology, chemistry, and physics. It's the kind of stuff that would make a college senior sweat.

The team used a clever, pre-planned method to see what happens when they let these models "vote" on their own answers. They asked the models to generate up to 64 different attempts at solving each problem and then took the most common answer (the majority vote).

Here is the twist: The majority vote backfired.

Instead of getting smarter, the computer brains actually got worse on most of the problems.

For the Qwen model, the voting method hurt the accuracy on 56.6% of the problems.
For the Llama model, it hurt 65.7% of the problems.

Think of it like this: Imagine a student taking a hard math test. They are unsure about a question, so they ask themselves, "What's the answer?" ten times. If they happen to make the same mistake in their head eight times, the "majority vote" tells them to pick that wrong answer with high confidence. The more they ask themselves, the more convinced they become of the wrong answer. The paper calls this "backfire." It turns out that on these hard science questions, the computer's confidence is a liar.

The "Oracle" Dream vs. Reality

The researchers then asked a practical question: "Can we build a cheap, smart filter to tell us when to vote and when to just guess once?"

They imagined a perfect "Oracle" (a magical guide that knows the right answer). If this Oracle could look at each problem and say, "For this one, vote 64 times," or "For that one, just guess once," the models could have improved their scores by 14 to 17 percentage points. That's a huge jump!

But the researchers tested two real-world, "verifier-free" signals to see if they could act as a cheap substitute for this magical Oracle:

The Agreement Gate: "If the answers agree with each other enough, trust the vote."
The Entropy Gate: "If the computer seems 'uncertain' (high entropy), don't vote; if it seems 'sure' (low entropy), vote."

The result? Both gates failed.
Neither method could get close to the magical Oracle's potential. In fact, using these gates didn't improve the score at all compared to just blindly voting 64 times. The "Agreement Gate" was so useless that it barely moved the needle (less than 0.002 difference). The "Entropy Gate" was also a dead end.

Why Did It Happen?

The paper explains that the problem is simple but frustrating: Confidence does not equal correctness.

On these hard science problems, the computer models often get stuck on a wrong answer. When they generate 64 answers, they might generate that same wrong answer 50 times. The "majority vote" sees 50 votes for the wrong answer and says, "This must be right!" The computer is confidently wrong.

The researchers looked at the data and found something funny about the Llama model: The problems where the answers agreed the most were actually the least accurate. The more the computer agreed with itself, the more likely it was to be wrong. It's like a group of friends all agreeing on a terrible movie plot; the more they agree, the more you know the plot is nonsense.

What This Means

The paper concludes that for these specific, hard science problems, you cannot just assume that "more thinking" or "voting" will help.

The Bad News: If you rely on the computer's own agreement to decide if it's right, you might be tricked. The "majority" is often wrong.
The Good News: We know exactly why it fails (confidence doesn't track correctness), and we know that simple tricks like checking for agreement or uncertainty won't fix it.
The Open Question: The researchers didn't test the newest, "reasoning-native" models (the super-smart ones designed specifically for logic). They leave that as a mystery for the future. Maybe those new models won't backfire? We don't know yet.

In short, on the hardest science questions, asking a computer to vote on its own answers often just locks in its mistakes. To get the real benefits, we might need a smarter way to check the work, not just a louder vote.

Technical Summary: When Self-Consistency Backfires

Problem Statement

Self-consistency (SC), a technique where multiple chains of thought are sampled and the plurality answer is selected via majority vote, is widely assumed to be a low-risk method for improving Large Language Model (LLM) reasoning. The prevailing heuristic suggests that increasing the number of samples ( $N$ ) and voting will yield at least as good results as a single sample ( $N=1$ ).

This paper challenges that assumption on hard scientific reasoning tasks. It investigates whether majority voting can "backfire"—defined as a scenario where increasing $N$ reduces per-problem accuracy ( $mv\_gain = MV\_acc(64) - MV\_acc(1) < 0$ ). The author hypothesizes that on difficult problems, if a model's sampling distribution concentrates on an incorrect answer, additional samples merely entrench the error rather than correcting it. Furthermore, the paper asks whether cheap, verifier-free signals (such as agreement levels or token entropy) can effectively identify which problems should be voted on and which should be skipped to avoid this backfire.

Methodology

The study employs a pre-registered, confirmatory experimental design using the GPQA Diamond benchmark, consisting of 198 graduate-level multiple-choice questions in biology, chemistry, and physics.

Models: Two small, instruction-tuned, non-reasoning models were evaluated: Qwen2.5-7B-Instruct and Meta-Llama-3-8B-Instruct.
Sampling Protocol: For each problem, $N=64$ chains of thought were generated at a temperature of 0.7.
Experimental Split: The dataset was split into 47 exploratory problems (used to generate hypotheses) and 151 confirmatory problems. All hypotheses and thresholds were locked and git-tagged prior to confirmatory analysis.
Metrics:
- $MV\_acc(N)$ : Expected majority-vote accuracy over $N$ samples, estimated via Monte Carlo subsampling.
- Backfire: Defined as $MV\_acc(64) < MV\_acc(1)$ .
- Routing Gates: Two verifier-free signals were tested to route problems to an optimal $N$ $N$ :
  1. Plurality Agreement Gate: Returns the probe answer if the agreement fraction over $k$ samples exceeds a threshold $\tau$ ; otherwise, defaults to $N=64$ .
  2. Token Entropy Gate: Returns the probe answer if mean per-token entropy over $k$ samples is below a threshold; otherwise, defaults to $N=64$ .
Oracle Bounds: A "grid oracle" was constructed to establish a theoretical upper bound. This oracle routes each problem to the specific $N \in \{1, 2, 4, 8, 16, 32, 64\}$ that maximizes accuracy using ground truth.

Key Results

1. Prevalence of Backfire

Majority voting reduces accuracy on the majority of individual problems for both models, despite aggregate metrics appearing flat or slightly positive.

Qwen2.5-7B: Backfire occurs on 56.6% of the 198 problems.
Llama-3-8B: Backfire occurs on 65.7% of the problems.
Domain Breakdown: Chemistry showed the highest backfire rates (66.7% for Qwen, 68.8% for Llama), followed by Physics and Biology.
Aggregate vs. Individual: While aggregate accuracy saw a modest increase (e.g., Qwen from 0.342 to 0.369), this masks widespread per-problem degradation. The worst single problems lost ~47 accuracy points, while a few gained significantly, creating a misleading average.

2. Failure of Verifier-Free Gates

The study tested whether cheap signals could recover the "headroom" between fixed-budget voting ( $N=64$ ) and the oracle upper bound.

Oracle Potential: A grid oracle could improve accuracy by 14 points (Qwen) and 17 points (Llama) over $N=1$ .
Gate Performance: Neither the agreement gate nor the entropy gate significantly improved accuracy over a fixed $N=64$ $N = 64$ baseline.
- The agreement gate captured only 0.8% of the available headroom for Qwen and -1.6% for Llama (relative to $N=64$ ).
- The entropy gate similarly failed to recover significant headroom.
Conclusion: These gates do not provide a mechanism to distinguish between problems where voting helps and those where it hurts.

3. Mechanism: Confidence Does Not Track Correctness

The paper identifies the root cause of the failure: miscalibration.

Agreement $\neq$ Correctness: Even in the highest-agreement bin (where the model is most confident), the plurality answer is correct only ~52.5% of the time for Qwen and 28.6% for Llama.
Non-Monotonicity: For Llama, accuracy in the highest-agreement bin was actually lower than in the lowest-agreement bin. High self-consistency does not correlate with high accuracy on these hard problems.
Signal Failure: Because confidence (agreement or low entropy) does not track correctness, gates relying on these signals cannot effectively route compute.

Significance and Claims

The paper makes the following specific claims regarding its contribution:

Quantification of Backfire: It provides the first pre-registered, replicated quantification showing that self-consistency backfires on the majority of problems in a hard, graduate-level science benchmark across two model families.
Failure of Cheap Heuristics: It demonstrates that two natural, verifier-free signals (plurality agreement and token entropy) are insufficient to prevent backfire or recover the theoretical accuracy gains available via per-problem routing.
Mechanism Identification: It confirms that the failure is driven by the fact that confidence does not track correctness on hard inputs; high agreement often signals a confidently wrong answer.
Open Question: The paper explicitly states it does not test "reasoning-native" models (those with hidden chain-of-thought). Whether these architectures escape the backfire phenomenon remains the central open question, as preliminary attempts to evaluate them were hindered by token budget constraints.

The author concludes that on hard reasoning tasks, practitioners should not assume self-consistency is safe, nor should they expect internal model signals like agreement or entropy to indicate when it is beneficial. Recovering the lost accuracy likely requires external signals, such as trained verifiers or process reward models, rather than relying on the model's own sampling distribution.