Mathematics is scientific computation. It always has been.
Using FP64 for mathematical reasoning is not a luxury.
It is the natural, self-evident, and obvious choice.
The Question Nobody Is Asking
In 2026, OpenAI deployed 10,000 AI agents at FP16/INT8 precision for
88 hours at a cost of approximately 15 million USD to attack the
Navier-Stokes Millennium Prize Problem.
The result remains unverified. The 1 million USD prize remains unclaimed.
Meanwhile, every scientific computing textbook states without ambiguity
that solving Navier-Stokes equations requires FP64.
The question nobody is asking: what if the bottleneck is not the model,
not the data, not the architecture — but the precision itself?
The Category Error
Domain
What it is
Industry label
Precision
Weather simulation
Numerical PDE
Scientific computing
FP64
Molecular dynamics
Numerical integration
Scientific computing
FP64
Fluid dynamics
Navier-Stokes
Scientific computing
FP64
LLM math reasoning
Numerical computation
“Language task”
INT4/FP16
Mathematics does not cease to be scientific computation merely because
it is computed inside a Transformer.
When a Fortran program computes 1234 x 5678 x 4321, the scientific
computing community demands FP64. When GPT computes the same expression,
the AI community quantizes to INT4 and calls it a language task.
What Major Labs Are Actually Running
Every frontier system achieving world-shocking math results runs at
FP8 or lower. Not one uses FP64.
System
Math Achievement
Precision
FP64?
OpenAI o1/o3
MATH-500: 92-99%
FP16/INT8
No
OpenAI (Erdos conjecture)
Disproved 80-year conjecture
FP16/INT8
No
GPT-5.6 Sol Ultra
Cycle Double Cover (50 yrs)
FP16/INT8
No
OpenAI (Navier-Stokes)
Millennium Problem (unverified)
FP16/INT8
No
OpenAI (722 papers)
372 open math problems
FP16/INT8
No
DeepSeek R1
GSM8K 89%, MATH 85%
FP8/FP16
No
AlphaProof (DeepMind)
IMO silver-gold
FP16 + Lean
No*
Gemini DeepThink
IMO gold 35/42
FP16/BF16
No
*AlphaProof compensates with external Lean proof verification —
a high-precision exoskeleton for a low-precision brain.
OpenAI’s Enormous Detour
IMO Gold (2025)
Model: o1/o3 at FP16/INT8
Method: natural language chain-of-thought
Result: 35/42 (gold medal level)
Erdos Conjecture (May 2026)
Model: internal reasoning model at FP16/INT8
First attempt failed (GPT-5 just looked up known answers)
Navier-Stokes is the crown jewel of scientific computing. Every CFD
engineer knows: solve NS in FP64 or the solution is meaningless.
OpenAI attacked this with 10,000 FP16/INT8 agents in natural language.
722 Papers (October 2026)
372 open math problems, 722 manuscripts
Only 162 (43%) have Lean formal verification
210 (57%) have NO verification
The Detour Visualized
What happened:
Mathematical problem
|
v
Treat as "language task"
|
v
FP16/INT8 generates proof (unreliable)
|
v
Deploy 64 agents to generate candidates
|
v
Deploy 8 verifiers to filter
|
v
Deploy adversarial agents to double-check
|
v
Wrap in Lean external verification
|
v
Scale to 10,000 agents for harder problems
|
v
Spend 15M USD, get unverified results
What should have happened:
Mathematical problem
|
v
Recognize as scientific computation
|
v
Use FP64 (as physics demands)
|
v
Verified results
Our Experiment: The Precision Cliff
Platform: Phytium FT-2000/4 (ARM64, 4 cores, 16GB) + pure Python/NumPy.
Finding 1: Accumulated Error
100,000 sequential multiplications of 1.000001:
Precision
Relative Error
Amplification
FP64
1.25e-14
1x
FP32
5.15e-03
400 billion x
FP16
9.52e-02
7.6 trillion x
FP16 accumulates 7.6 trillion times more error than FP64.
Finding 2: Large Number Absorption
(big + 1.0) - big should equal 1.0. Failure points:
Precision
Fails at
FP64
10^16
FP32
10^8
FP16
10^4
Finding 3: Reasoning Chain (50 steps)
Precision
Deviation
Status
FP64
0.0 (exact)
Perfect
FP32
1.83e-05
Drift
FP16
1.45e-01
Visible errors
Finding 4: Neural Network Training Freeze
MLP learning multiplication table:
Metric
FP64
FP32
FP16
Loss
0.020
0.014
0.890
Accuracy
100%
100%
15%
Status
Converging
Converging
FROZEN
Time
85s
89s
225s
FP16 training freezes at epoch 10,000. The loss curve becomes a flat
line. The gradient signal is overwhelmed by rounding noise.
This is not learning more slowly. This is not learning at all.
Why the Agent Approach Is Wasteful
Running 10,000 imprecise agents does not produce one precise result.
It produces 10,000 imprecise results and hopes statistics compensate.
Approach
Agents
Precision
Cost
Verified
Time
OpenAI (NS)
10,000
FP16/INT8
15M
No
88h
OpenAI (CDC)
76+
FP16/INT8
100K
Lean
1h
AlphaProof
1+Lean
FP16+sym
1M
Lean
days
FP64 (ours)
1
FP64
~1K
Native
min
It is cheaper to use the right ruler once than to measure with the
wrong ruler 10,000 times and average the results.
The agent approach is the linguistic paradigm applied to mathematics:
when you cannot compute precisely, you speak louder.
The Self-Evident Truth
Mathematics is the foundation of scientific computing.
Scientific computing has used FP64 for 60 years — because math demands it.
LLM mathematical reasoning IS scientific computation.
Therefore FP64 for math reasoning is the obvious, necessary choice.
The industry is running climate simulations at INT4 and wondering
why the forecast is wrong.
Using FP64 for mathematics is not a luxury.
It is not a suggestion.
It is as natural and self-evident as using a ruler to measure length.
The question is not “why should we use FP64 for math?”
The question is “why on earth are we not?”
arXiv:2506.09501. “Give Me FP32 or Give Me Death?”
Nature. “AlphaProof: AI for mathematical theorem proving.” DeepMind, 2025.
License
MIT
Mathematics is not a language task. It never was.
Give it the precision it deserves.
The Pencil Analogy
Choosing low precision for mathematical computation is like choosing
an HB pencil over a 2B pencil on an exam to save a few cents.
The HB pencil saves 0.5 yuan.
The faint marks cause the optical scanner to misread.
The correct answer gets marked wrong.
The student loses 20 points.
The cost saving is trivial.
The loss is catastrophic.
The AI industry saves 50% compute by using FP16 instead of FP64.
Then it deploys 10,000 agents at 15 million USD to compensate
for what the right precision would have solved directly.
Both scientific computing and neural network computation are
mathematics. Mathematics does not care about your GPU budget.
Mathematics cares about being correct.
And being correct is non-negotiable.
PI: The Ultimate Precision Benchmark
Every digit of pi requires approximately 3.3 bits of numerical precision.
The digits of pi are the digits of precision itself.
pi = 3.14159265358979323846264338327950288419716939937510...
FP64: 52 mantissa bits -> 15 decimal digits -> pi correct to 15 places
FP32: 23 mantissa bits -> 7 decimal digits -> pi correct to 7 places
FP16: 10 mantissa bits -> 3 decimal digits -> pi correct to 3 places
FP64: 3.141592653589793 (all correct)
FP32: 3.1415927 (7 digits)
FP16: 3.140625 (3 digits, then noise)
This is not a model limitation. This is arithmetic. No amount of
training data, parameters, or agents can overcome a representational
ceiling. A neural network cannot learn what its arithmetic cannot
represent.
Computing pi is the purest form of scientific computation. It is
also the purest form of the precision cliff: one number, directly
readable, showing exactly where each precision format stops.
Mathematics is computation. Computation requires precision.
Give it the precision it deserves.
Mathematics is not a language task. It never was.
Give it the precision it deserves.
关于
Math is scientific computation, not a language task.
The Dislocation of Mathematics
The Question Nobody Is Asking
In 2026, OpenAI deployed 10,000 AI agents at FP16/INT8 precision for 88 hours at a cost of approximately 15 million USD to attack the Navier-Stokes Millennium Prize Problem.
The result remains unverified. The 1 million USD prize remains unclaimed.
Meanwhile, every scientific computing textbook states without ambiguity that solving Navier-Stokes equations requires FP64.
The question nobody is asking: what if the bottleneck is not the model, not the data, not the architecture — but the precision itself?
The Category Error
Mathematics does not cease to be scientific computation merely because it is computed inside a Transformer.
When a Fortran program computes 1234 x 5678 x 4321, the scientific computing community demands FP64. When GPT computes the same expression, the AI community quantizes to INT4 and calls it a language task.
What Major Labs Are Actually Running
Every frontier system achieving world-shocking math results runs at FP8 or lower. Not one uses FP64.
*AlphaProof compensates with external Lean proof verification — a high-precision exoskeleton for a low-precision brain.
OpenAI’s Enormous Detour
IMO Gold (2025)
Erdos Conjecture (May 2026)
Cycle Double Cover (July 2026)
Navier-Stokes Millennium Problem (September 2026)
Navier-Stokes is the crown jewel of scientific computing. Every CFD engineer knows: solve NS in FP64 or the solution is meaningless. OpenAI attacked this with 10,000 FP16/INT8 agents in natural language.
722 Papers (October 2026)
The Detour Visualized
What happened:
What should have happened:
Our Experiment: The Precision Cliff
Platform: Phytium FT-2000/4 (ARM64, 4 cores, 16GB) + pure Python/NumPy.
Finding 1: Accumulated Error
100,000 sequential multiplications of 1.000001:
FP16 accumulates 7.6 trillion times more error than FP64.
Finding 2: Large Number Absorption
(big + 1.0) - big should equal 1.0. Failure points:
Finding 3: Reasoning Chain (50 steps)
Finding 4: Neural Network Training Freeze
MLP learning multiplication table:
FP16 training freezes at epoch 10,000. The loss curve becomes a flat line. The gradient signal is overwhelmed by rounding noise.
This is not learning more slowly. This is not learning at all.
Why the Agent Approach Is Wasteful
Running 10,000 imprecise agents does not produce one precise result. It produces 10,000 imprecise results and hopes statistics compensate.
It is cheaper to use the right ruler once than to measure with the wrong ruler 10,000 times and average the results.
The agent approach is the linguistic paradigm applied to mathematics: when you cannot compute precisely, you speak louder.
The Self-Evident Truth
Using FP64 for mathematics is not a luxury. It is not a suggestion. It is as natural and self-evident as using a ruler to measure length.
The question is not “why should we use FP64 for math?” The question is “why on earth are we not?”
Reproduce
All experiments complete in under 30 minutes on a 4-core ARM CPU.
A Note on Category Errors
Every category error persists because people optimize within the wrong category and wonder why results plateau.
Mathematics requires precision. Give it the precision it deserves.
References
License
MIT
Mathematics is not a language task. It never was. Give it the precision it deserves.
The Pencil Analogy
Choosing low precision for mathematical computation is like choosing an HB pencil over a 2B pencil on an exam to save a few cents.
The HB pencil saves 0.5 yuan. The faint marks cause the optical scanner to misread. The correct answer gets marked wrong. The student loses 20 points.
The cost saving is trivial. The loss is catastrophic.
The AI industry saves 50% compute by using FP16 instead of FP64. Then it deploys 10,000 agents at 15 million USD to compensate for what the right precision would have solved directly.
Both scientific computing and neural network computation are mathematics. Mathematics does not care about your GPU budget. Mathematics cares about being correct.
And being correct is non-negotiable.
PI: The Ultimate Precision Benchmark
Every digit of pi requires approximately 3.3 bits of numerical precision. The digits of pi are the digits of precision itself.
This is not a model limitation. This is arithmetic. No amount of training data, parameters, or agents can overcome a representational ceiling. A neural network cannot learn what its arithmetic cannot represent.
Computing pi is the purest form of scientific computation. It is also the purest form of the precision cliff: one number, directly readable, showing exactly where each precision format stops.
Mathematics is computation. Computation requires precision. Give it the precision it deserves.
Mathematics is not a language task. It never was. Give it the precision it deserves.