self-verification
**Self-verification** is the technique of having a language model **check, critique, and validate its own generated answers** — using a separate inference pass (or structured self-evaluation) to identify errors, inconsistencies, or weaknesses in its initial response before presenting the final answer to the user.
**How Self-Verification Works**
1. **Initial Generation**: The model produces an answer to the question.
2. **Verification Prompt**: The model is then asked to evaluate its own answer:
- "Is this answer correct? Check each step."
- "What could be wrong with this answer?"
- "Verify this answer by solving the problem a different way."
3. **Evaluation**: The model identifies potential errors, gaps, or inconsistencies.
4. **Correction**: If errors are found, the model revises its answer.
5. **Final Output**: The corrected (or confirmed) answer is presented.
**Self-Verification Strategies**
- **Reverse Verification**: Solve the problem backward to check the answer.
- For math: "If the answer is 42, does plugging it back into the equation work?"
- For logic: "If the conclusion is X, do the premises support it?"
- **Alternative Solution**: Solve the problem using a different method.
- If both methods give the same answer → high confidence.
- If they disagree → investigate which is correct.
- **Step-by-Step Review**: Re-examine each reasoning step individually.
- "Is step 1 correct? Is step 2 correct? ..." — systematic validation.
- **Adversarial Self-Questioning**: Ask challenging questions about the answer.
- "What if the input were different? Would this approach still work?"
- "Can I find a counterexample to my answer?"
- **Confidence Assessment**: Rate confidence in each part of the answer.
- Low-confidence parts flagged for extra scrutiny or alternative approaches.
**Self-Verification Example**
```
Question: "Is 97 prime?"
Initial answer: "Yes, 97 is prime."
Self-verification:
"Let me verify. A prime number is divisible
only by 1 and itself.
Check divisibility:
97 / 2 = 48.5 (not divisible)
97 / 3 = 32.33 (not divisible)
97 / 5 = 19.4 (not divisible)
97 / 7 = 13.86 (not divisible)
Since √97 ≈ 9.85, I only need to check
primes up to 9: {2, 3, 5, 7}.
None divide 97 evenly.
Verified: Yes, 97 is prime." ✓
```
**When Self-Verification Helps**
- **Mathematical Reasoning**: Checking calculations by substitution, alternative methods, or estimation.
- **Factual Claims**: "Let me double-check this fact..." — the model reconsiders potentially hallucinated claims.
- **Logical Arguments**: Checking for logical fallacies, missing premises, or invalid inferences.
- **Code Generation**: "Let me trace through this code with a test case to verify it works."
**Limitations**
- **Model Blind Spots**: If the model doesn't know a fact, it can't verify it either — self-verification only catches errors the model can detect.
- **Overconfidence**: Models may verify incorrect answers as correct — they can be systematically wrong in both generation and verification.
- **Cost**: Self-verification requires additional inference calls — 2× or more the compute cost.
- **Circular Reasoning**: The same biases that caused the error may cause the model to confirm the error during verification.
**Improving Self-Verification**
- **Use different prompting strategies** for generation and verification — reduce the chance of repeating the same error.
- **Combine with external tools** — calculator for math, search for facts, code execution for logic.
- **Multiple verification passes** — each pass may catch errors the previous one missed.
Self-verification is a **practical and widely applicable technique** — it catches a meaningful fraction of errors at the cost of additional compute, making it a standard component of production LLM pipelines.