Everything happens in one prompt:

STEP 1: Define the final goal
→ What needs to be found? Call it X

STEP 2: List the required conditions
→ What must be known in order to find X?
→ List: Condition_1, Condition_2, ..., Condition_N

STEP 3: Check whether each condition is available
→ For each condition:
   - Given explicitly in the problem? → available
   - Can be inferred from context? → available
   - Nowhere to be found? → MISSING

CONCLUSION: If at least one condition is missing → list exactly which ones

Task: You're sanity-checking a friend's business idea — opening a coffee shop in a residential neighborhood. He says: "Average ticket is $6, foot traffic is 200 people a day, conversion is 15%. Rent is $4,000, and two baristas at $3,000 each. Will it pay for itself in six months?" You want to know: is there enough data to run the numbers, or is something critical missing?

Prompt:

Use reverse thinking to check whether the data is complete:

PROBLEM: {Open a coffee shop in a residential neighborhood. Average ticket $6,
foot traffic 200 people/day, conversion 15%. Rent $4,000/month,
two baristas at $3,000 each. Will it pay for itself in six months?}

STEP 1 — Final goal:
Define what needs to be found to answer the question.

STEP 2 — Required conditions:
List ALL the parameters that must be known to calculate payback.
For each parameter, specify: numeric values, formulas, relationships.

STEP 3 — Availability check:
For each condition on the list, check:
- Is it given explicitly in the problem?
- Can it be inferred from context?
- Is there no information anywhere?

CONCLUSION:
If all conditions are available → "The data is sufficient"
If some are missing → list specifically what's missing and why it's critical

Result:

The model will show a step-by-step analysis: it defines the goal (calculating the payback point), lists all the required parameters (revenue, operating expenses, upfront investment, taxes, cost of goods for the drinks), and checks each one against the problem. At the end it outputs a list of what's missing: cost of coffee and supplies, utilities, the size of the upfront investment (equipment, build-out), the tax setup, other operating expenses. And it explains why the calculation is impossible without each item.

By default, an LLM generates text forward — from start to finish, from data to conclusion. When the model sees a problem, it immediately tries to solve it with what it has. If the data falls short, it fills in the blanks, guesses, or misses the problem entirely. It has no natural incentive to stop and ask, "Do I really have everything?" Forward reasoning assumes the input data is complete.

The reverse direction turns gap-hunting into a routine task. Models are good at breaking a goal into components ("to compute X, you need A, B, C") and comparing lists ("is A in the problem? what about B?"). That's much easier than noticing mid-solution that some parameter was never given. Reverse thinking makes the completeness check explicit and structured rather than a side effect of trying to solve the problem.

Prompt control knobs:

• Decomposition depth — ask it to "list second-level conditions" (what's needed for the prerequisites themselves) → you'll find deeper gaps, at the cost of more tokens
• Strictness of the check — add "only count it as missing if it can't be inferred in any way" → fewer false alarms
• Output format — drop "for each condition, check" and ask for the list of missing items directly → faster, but less transparent

Use reverse thinking to check whether the data is complete:

PROBLEM: {problem description}

STEP 1 — Final goal:
Define what needs to be found or solved in this problem.

STEP 2 — Required conditions:
List ALL the conditions, parameters, data, and relationships
that must be known to reach the goal.

STEP 3 — Availability check:
For each condition, check:
- Is it given explicitly in the problem?
- Can it be inferred from the available information?
- Is the information missing?

CONCLUSION:
If all conditions are available → write "The data is sufficient to solve this"
If some are missing → list specifically WHAT is missing and WHY it's critical

Fill in: - {problem description} — any task where you need to calculate, estimate, verify, or make a decision

🚀 Quick start — paste into a chat:

Here's an RT-ICA template for checking data completeness. Adapt it to my task: [your task].
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask about the specifics of your task, because different domains call for different kinds of conditions (finance needs one set of parameters, technical specs another). It'll take the reverse-thinking pattern from the template and tune it to your context.

⚠️ False alarms: The model may flag as "missing" something that's implicitly given or derivable from general knowledge. For example, if a proportion problem doesn't state one quantity explicitly but it can be computed from the others, the model may still say "not enough data". This is especially an issue with problems that have multiple equivalent formulations — when the task can be solved several ways using different sets of data.

⚠️ Vague gap descriptions: When the model correctly finds what's missing, it sometimes describes it in overly general terms ("additional information is needed") instead of pinpointing it ("the unit cost of the product isn't specified"). The reader has to fill in the specifics themselves.

⚠️ More tokens: The method uses 2.3x more tokens than standard Chain-of-Thought and runs 1.8x longer. For complex problems with a long list of conditions, the bill can add up.

The researchers took two math benchmarks (GSM8K and Math500) and deliberately broke some of the problems by hand — removing critical data from the problem statements. That produced 105 problems from GSM8K (52 incomplete + 53 normal) and 101 from Math500 (39 incomplete + 62 normal). Several annotators checked each broken problem to make sure the data really was missing and couldn't be inferred from context.

The models' job was to determine whether there's a gap, without access to the correct answer. They tested three models: GPT-4, GPT-3.5-turbo, DeepSeek-V3. They tracked three metrics: overall accuracy (correct call on any problem), accuracy on incomplete problems ("yes, something's missing"), and accuracy on complete problems ("no, it's all there").

The results were most impressive for the weaker models: GPT-3.5-turbo on the GSM8K dataset jumped from 30.77% to 82.69% at spotting incomplete problems — nearly tripling. For GPT-4 the gain was more modest (from 61.54% to 76.92%) but still significant. Why the difference? Strong models already partly "sense" what's missing thanks to their training, while weaker ones need an explicit thinking structure. Reverse thinking gives them that structure.

An interesting finding: the method barely hurt the ability to recognize complete problems (where everything is there). DeepSeek-V3 even improved from 82.26% to 98.39% on the complete Math500 problems. That means reverse thinking doesn't turn the model into a paranoid that sees gaps everywhere — it just adds rigor.

The authors were upfront about the trade-off: 2.3x more tokens. But that's the price of a model that no longer hallucinates answers to questions it lacks the data for, and instead honestly says "I'm missing X and Y".

🔧 Technique: Two-level check → finds dependencies deeper down

Add after STEP 2:

Copy

STEP 2.5 — Check second-level conditions:
For each condition from STEP 2, ask: "What's needed for this condition ITSELF to be satisfiable?"
List the second-order prerequisites.

This finds hidden dependencies — for example, "calculating profit requires cost of goods" → "cost of goods requires supplier prices and purchase volumes". Useful for complex, multi-layered problems.

🔧 Technique: Critical items only → fewer false alarms

In STEP 3, add:

Copy

Mark something as missing ONLY if:
1. The information can't be derived from the available data in any way
2. The calculation is impossible without it (not just "it would be more convenient")

Cuts down on false alarms about implicitly given information.

🔧 Combining with Chain-of-Thought: check completeness first, then solve

Copy

STAGE 1 — Completeness check (reverse thinking):
[RT-ICA template]

STAGE 2 — Solution (forward reasoning):
If the data is sufficient:
Solve the problem step by step, explaining each step.

If the data is NOT sufficient:
Solve the problem under the following ASSUMPTIONS: [plug in reasonable values for what's missing]
Clearly state that these are assumptions, not facts.

Useful when you need some kind of answer even if data is missing — the model will give an estimate but will honestly say "this assumes X is roughly Y".

Reverse Thinking Enhances Missing Information Detection in Large Language Models
Yuxin Liu, Chaojie Gu, Yihang Zhang, Bin Qian, Shibo He
Zhejiang University

References from the study: - Chain-of-Thought Prompting [Wei et al., 2022] - Tree-of-Thought [Yao et al., 2023]
- Fill-in-the-blank reasoning [Deb et al., 2024] - Reverse-enhanced thinking [Chen et al., 2024] - GSM8K benchmark [Cobbe et al., 2021] - Math500 benchmark [Hendrycks et al., 2021]