TL;DR
Formula-One Prompting (F-1) is a technique for tasks involving formulas and equations (finance, physics, metric calculations). It works in two steps inside a single prompt: first the model explicitly writes out the governing equations from the problem statement, then it picks its own strategy, direct calculation, step-by-step reasoning (CoT) or code (PoT), depending on the structure of the equations.
Standard methods (CoT, PoT) jump straight into solving and skip the "wait, which formulas actually apply here?" stage. In applied problems that hurts: the model confuses independence from a variable with a zero value, calculates correctly but outputs the wrong format, or tries to brute-force a proof without understanding the structure. Equations are the skeleton of the problem. Without explicit formalization, the model wanders blind even when it knows how to compute.
F-1 makes the model first write down the givens, the unknowns and the formulas, just like you were taught in school. Then it looks at the formulas: simple substitution → compute directly; multi-step derivation → Chain-of-Thought; iterative calculations → Program-of-Thought. The structure of the equations dictates the strategy. On financial calculations it gains +13.3% over plain CoT, on physics +2.55%, on pure math +0.44%: the method shines where formulas are central.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
Both steps in one prompt, one model call:
STEP 1: Formalize the problem
├─ Extract GIVENS: all values, conditions, constraints
├─ Define FIND: the target quantities
└─ Write EQUATIONS: the relationships between givens and unknowns
STEP 2: Adaptive solving
├─ Assess the structure of the equations
├─ Pick a strategy: Direct / CoT / PoT
├─ Solve using the chosen strategy
└─ Check the answer against the equations from Step 1
Example
Task: You're launching a subscription analytics service for small businesses. A customer pays $29/month, and the average lifetime is 14 months. Customer acquisition: $120 on ads, a $50 partner commission, and operating costs of $6/month per customer. Calculate the subscription's LTV, CAC and ROI.
Prompt:
Solve the problem using the Formula-One method.
Step 1: Formalization
1. Extract the GIVENS: all numeric values and conditions
2. Define what to FIND: which metrics need to be calculated
3. Write the EQUATIONS: the formulas for calculating those metrics
Step 2: Adaptive solving
1. Look at the structure of the equations
2. Pick a strategy:
- Direct: if it's a simple substitution into 1-2 formulas
- CoT: if it's a multi-step derivation with intermediate quantities
- PoT: if it involves complex iterative calculations
3. Solve the problem using the chosen strategy
4. Check the answer: plug it back into the original equations
Problem:
You're launching a subscription analytics service for small businesses. A customer pays $29/month, and the average lifetime is 14 months. Customer acquisition: $120 on ads, a $50 partner commission, and operating costs of $6/month per customer. Calculate the subscription's LTV, CAC and ROI.
Result:
The model gives a structured answer: in Step 1 it writes out the givens (price, lifetime, costs), what to find (LTV, CAC, ROI) and the formulas (LTV = revenue over the lifetime − operating costs, CAC = acquisition costs, ROI = (LTV − CAC) / CAC). In Step 2 it picks a strategy (most likely Direct, straight substitution) and produces the calculation with numbers. At the end it checks itself: plugs the results back into the formulas to make sure the math is right.
Why It Works
Models are bad at holding implicit structure. When a problem comes as text, an LLM tries to solve it "on the fly", mixing reasoning, calculation and formatting. The result: it calculates correctly but outputs 6.3% instead of 0.063. Or it confuses "independent of the variable" with "equal to zero". Or it starts brute-forcing a cryptographic theorem, ignoring that there's a standard sub-hybrid argument construction for it.
Models are great with structures. If you explicitly ask "write out givens → find → formulas", the model switches into formalization mode. The equations become a scaffold: it's clear what to plug in, what to derive and what format to compute in. A formula removes ambiguity. Write Φ'(x) = c and it's immediately clear that it's a constant, not zero. Write "revenue in dollars, answer in dollars" and you won't mix it up with percentages.
Adaptivity adds accuracy, but it's not the main thing. The ablation showed that formalizing the equations gives twice the gain (+8.5% on finance) of strategy selection (+6%). Strategy selection is a bonus: for simple substitutions the model doesn't waste tokens on reasoning, and for proofs it doesn't try to compute in code. But the core magic is making the model understand the problem's structure first, then act.
Control levers: - Formalization detail: say "write out all intermediate formulas" → the model won't skip steps - Strategy rigidity: you can explicitly say "use CoT only" → you lose adaptivity but control the process - Final check: remove the "check against the equations" step → you'll see raw output without self-verification (handy for debugging)
Prompt Template
Solve the problem using the Formula-One method.
Step 1: Formalization
1. Extract the GIVENS: all numeric values, conditions, constraints
2. Define what to FIND: the target quantities or statements to prove
3. Write the EQUATIONS: the mathematical relationships between givens and unknowns
Step 2: Adaptive solving
1. Assess the structure of the equations
2. Pick a strategy:
- Direct: if it's closed-form, 1-2 substitutions
- CoT: if it's a multi-step derivation or proof
- PoT: if it involves iterative calculations or complex arithmetic (>3 operations)
3. Solve the problem using the chosen strategy
4. Check the answer: plug the results into the original equations
Problem: {your_problem}
Placeholders:
- {your_problem}: any problem with numeric data, formulas or metrics. Especially good for financial calculations, physics problems, business metrics and efficiency assessments.
🚀 Quick start: paste this into the chat:
Here's the Formula-One Prompting template. Adapt it to my task: [your task].
Ask me questions to fill in the fields.
[paste the template above]
The LLM will ask what data you have, what you need to find and which formulas apply, because the method is built around explicit formalization. It'll take the two-step structure (givens-find-formulas → strategy choice → solution) and adapt it to your specific problem.
Limitations
⚠️ Pure math: On olympiad-style math problems the gain is minimal (+0.44%). The method is built for applied fields where formulas are the key to the solution, not for abstract puzzles.
⚠️ Problems that are too simple: If the problem takes one step ("convert dollars to euros at a rate of 0.92"), formalization is overkill. The model will handle it fine without it, and the template only adds tokens.
⚠️ Very hard problems: On IMO-Bench (the International Mathematical Olympiad), 90.7% of problems are solved by no method at all. Formalization won't help if the problem is beyond the model's abilities.
⚠️ Depends on the ability to formalize: The method requires the model to be able to extract and write down equations. The effect wasn't tested on small models (<30B parameters), so it may not work there.
How They Studied It
The team tested F-1 on four benchmarks (2,116 problems) and five models ranging from 30B to frontier level. The benchmark selection logic: they took only those where formulas are central to the solution: physics (OlympiadBench), finance (FinanceMath), cryptography (AICrypto) and math olympiads (IMO-Bench). They deliberately excluded arithmetic tasks like GSM8K, which are just sequential calculations, not equation formalization.
They compared against three baselines: Zero-Shot, Chain-of-Thought and Program-of-Thought. All are single-call methods, so it's a fair comparison. Temperature 0 (greedy decoding), one generation per problem. Scoring: regex for problems with numeric answers, LLM-as-Judge for proofs.
Key finding: the gain correlates directly with how "applied" the domain is. Finance +13.3%, cryptography +7.24%, physics +2.55%, pure math +0.44%. Why? The researchers suggest it comes down to the makeup of the training data. Applied content (textbooks, scientific papers) is naturally structured around equations: "given..., find..., using the formula...". Synthetic CoT datasets for olympiad math are built differently, with reasoning in prose and no explicit formalization. F-1 matches the natural structure of applied content → the model performs better.
The ablation revealed a hierarchy of value: removing equation formalization → a −8.5% drop on finance. Removing adaptive strategy selection → a −6% drop. Formalization matters twice as much as adaptivity. Even if you always use CoT, adding formalization up front already gives a big gain. Adaptivity is the cherry on top; the foundation is structuring through equations.
Strategy selection analysis: F-1 reaches 73% accuracy in picking the right strategy on FinanceMath and 69.9% on OlympiadBench. That's 81-84% of the theoretical ceiling (best achievable by any baseline). The remaining 16-19% gap is either formalization errors or problems where no strategy works.
Efficiency: F-1 adds only +68 tokens to the prompt (vs Zero-Shot) but outputs 212 fewer tokens on average because it picks the strategy more precisely. The resulting efficiency ratio (accuracy / tokens) = 1.51, 25.8% better than Zero-Shot, with higher accuracy to boot.
Original From the Paper
You will solve a mathematical problem following a two-phase approach:
Phase 1: Problem Formalization
- Identify Givens: Extract ALL explicitly stated values, conditions, and constraints
- Identify Targets: Determine what the problem asks to find or prove
- Formulate Equations: Express the mathematical relationships connecting givens to targets
Phase 2: Adaptive Solving
Based on the formalized equations, select ONE of the following strategies:
Strategy 1 - Direct Calculation:
Use for: Closed-form solutions, simple substitutions (≤2 steps)
Output: Direct numerical/symbolic answer
Strategy 2 - Chain-of-Thought (CoT):
Use for: Multi-step derivations, proofs, logical arguments
Output: Step-by-step reasoning in natural language
Strategy 3 - Program-of-Thought (PoT):
Use for: Iterative calculations, complex arithmetic (>3 operations)
Output: Python code (as reasoning structure, not for execution)
After solving, verify your answer against the formalized equations.
Problem: [problem statement here]
Context: The researchers used this single template for every benchmark. The only adaptations were in output format and domain terms (for cryptography they added "security game definitions", for finance "financial formulas"). The two-phase + three-strategy structure stayed the same.
Adaptations and Extrapolations
💡 Adaptation for content strategy: The method works for calculating media metrics: reach, engagement, cost per contact. Formalization forces it to write out all the formulas (CTR = clicks / impressions, CPM = budget / impressions × 1000), then the model picks a strategy and calculates correctly without mixing up percentages and absolute values.
Solve the problem using Formula-One.
Step 1: Formalization
1. Extract the GIVENS: all metrics and values
2. Define what to FIND: the target KPIs
3. Write the FORMULAS: how the metrics relate to each other
Step 2: Adaptive solving
[standard strategy selection block]
Problem:
We launched an ad campaign. Impressions: 450,000, clicks: 3,200, budget: $1,200, conversions: 140, average order value: $35. Calculate CTR, CPM, CPC, CR, CPA, ROI and ROMI.
🔧 Technique: add a visualization of the formulas → better for complex systems of equations
If the problem has many interrelated formulas (say, a system of 5+ equations), add this to Step 1:
3. Write the EQUATIONS:
- First, list all the formulas
- Then show how they connect: which formula uses the result of another
- Draw a dependency diagram if needed
This makes the model see the computation graph before solving. Especially useful when there are intermediate quantities reused across different formulas.
🔧 Technique: a fixed strategy for teamwork → consistency across a project
If a team is solving the problem and needs a single methodology, lock in the strategy:
Step 2: Solve with CoT
Use Chain-of-Thought: step-by-step reasoning in natural language.
Required:
- Each step on a new line
- Intermediate results in [square brackets]
- The logic connecting each step to the next spelled out explicitly
You give up adaptivity but gain predictability: everyone on the team sees the same solution structure, which makes it easier to review and improve.
Resources
Formula-One Prompting: Adaptive Reasoning Through Equations For Applied Mathematics
Natapong Nitarach, Pittawat Taveekitworachai, Kunat Pipatanakul
SCB 10X, SCBX Group
Relevant references from the paper: - Chain-of-Thought Prompting (Wei et al., 2022) - Program-of-Thought (Chen et al., 2023) - Plan-and-Solve Prompting (Wang et al., 2023)