STEP 1: CoT → get the reasoning and the answer

STEP 2: Decomposition → split into pairs (sub-question₁, sub-answer₁), (sub-question₂, sub-answer₂)...

STEP 3: Verify each step:
        └─ Re-solve the sub-question M times (without the answer's context)
        └─ Compare with the original sub-answer
        └─ Confidence = share of matches

STEP 4: Find the step with the lowest confidence

STEP 5: Fix that step via majority voting → new answer

[Repeat STEPS 2-5 K times]

Each step runs as a separate LLM request.

Task: You're building a financial model for an investor pitch. You need to work out the unit economics of a new food delivery service in Austin, from customer acquisition cost to break-even.

Prompt (decomposition after the first solution):

Here is my solution to the problem and the answer:

[paste the problem]

[paste your solution with the calculations]

Break this reasoning down into a sequence of subtasks. For each step, state:
- Sub-question: what exactly are we calculating or determining in this step?
- Sub-answer: what result did we get?

Format:
Step 1:
- Sub-question: [...]
- Sub-answer: [...]

Step 2:
...

Prompt (verifying a single step):

Context from previous steps:
- Customer acquisition cost (CAC): $12
- Average order value: $30
- Margin per order: 25%

Sub-question: How many orders does one customer need to place to pay back the cost of acquiring them?

Solve this sub-question using only the data above. Give only the numerical answer.

Result: The model will produce a decomposition into 5-7 steps (CAC → average order value → margin → LTV → payback period → break-even). Then for each step you'll get several independent solutions. If on the "margin calculation" step 3 out of 5 re-solves give $7.50 while the original gave $6.25, that's a red flag. The model will point to exactly that step as unreliable and suggest a fix.

The LLM weakness: A model is bad at finding its own mistakes when it looks at the whole answer at once. It tends to confirm its own conclusions: confirmation bias. Especially when the error happened in the middle of a long chain: everything looks logical because the later steps follow from the faulty one.

The LLM strength: A model is good at solving isolated problems with clear context. Give it only the sub-question and the necessary data, without its own previous answer, and it will solve it "from a clean slate". If the solutions disagree, that's a signal.

How the method exploits this: SSR turns checking from "look at your solution" into "re-solve each subtask independently". The model doesn't know it's checking itself; it's just solving sub-questions. Disagreements expose unreliable steps, and majority voting yields a more reliable answer.

Control levers:

• Number of re-solves (M): more = a more accurate confidence estimate, but more expensive. 3-5 is enough for most tasks
• Number of iterations (K): how many times to repeat the check-and-fix loop. 2-3 iterations is the sweet spot
• Decomposition granularity: finer steps = more precise error localization, but more overhead. 5-7 steps is the balance

Decomposition

Here is the problem and my solution:

Problem: {problem}

Solution: {solution}

Answer: {answer}

Break the reasoning down into a sequence of subtasks (no more than {max_steps} steps). For each step, state:
- Sub-question: what are we calculating or determining?
- Sub-answer: what result did we get?

Format:
Step 1:
- Sub-question: [...]
- Sub-answer: [...]

Step Verification

Context (results of previous steps):
{previous_steps_context}

Sub-question: {sub_question}

Solve this sub-question using only the data from the context. Give a brief answer.