Welcome back to the Deep Dive. Good to be here.
You know, this is where we try to tackle those really dense,
complicated ideas, right? And hopefully boil them down
into something well usable knowledge.
Exactly. Try and distill it.
And today, wow, we're definitely not just talking about abstract
math and a vacuum. We're stepping into the ring
with what might just be the ultimate intellectual challenge.
You must be the Millennium Prize problem.
That's exactly it. The seven huge unsolved
questions posed by the Clay Institute way back in 2000.
And each one comes with a $1 million bounty attached.
It's high stakes math for sure. It really is.
And what's kind of staggering is, since 2000, only one has
actually been solved. That's right, the Poincare
conjecture, Grigori Pearlman back in 2006.
An incredible achievement. Which leaves six giants still
standing decades later. They're resisting all the
traditional proof methods. So you have to ask if the best
minds haven't cracked these with standard approaches in what,
nearly 25 years? Maybe we need a different angle,
a shortcut? Precisely.
And that shortcut is what we're diving into today.
We're shifting focus from that image of the lone genius, you
know, staring at a blackboard for years towards what?
Towards a computational approach.
A strategy that Marco Saba introduced, and it's been
formalized more recently by XA, is Grok 4.
They called the Assume and Verify methodology, or A and V
for short. I love this idea.
It feels almost subversive instead of demanding this
perfect, timeless formal proof that covers everything.
Which might be impossible, or at least incredibly hard.
Right. Instead, you use the massive
computing power we have now, all the data, the fast algorithms,
the specialized software. And you turn these problems,
these huge conjectures, into, well, numerical laboratories.
You run experiments. It feels like it makes them more
accessible somehow. That's a big part of it.
It democratizes the inquiry. Now, we have to be super clear.
This doesn't replace formal proof.
OK, important distinction. Finite checks can't give
infinite certainty. Exactly.
But what AMV can do is build incredible empirical confidence.
It can sniff out counter examples much faster than theory
might. And it gives hints like
guideposts. Yes, critical heuristics.
It tells the theorists where the tricky parts are, where the
breakthroughs really need to focus.
So for you, the listener, the goal today is to understand this
empirical coherence, how computation builds a case for,
or maybe even against these massive conjectures.
OK, let's really unpack this assume and verify strategy.
The need for something new seems clear.
Progress on these problems has been, well, slow.
Glacial in some cases. But is this shift to computation
just about having faster computers than we did 30 years
ago, or is there more to it? Oh, it's definitely more than
just faster processors. I mean, that helps obviously,
but 30 years ago we really lacked the the integration and
the specialized tools. What kind of cools are we
talking about? Well, these problems are deep,
right? They touch on really complex
math, so you need sophisticated algorithms for one.
And crucially, you need high performance software libraries
that actually implement these algorithms efficiently.
So not just writing code from scratch in a basic language, you
need toolkits. Exactly.
Highly specialized packages, things like SIM, P and Python
are great for symbolic math, doing precise calculations on
smaller scales. Then for problems involving
logic like PBSNP you use things called SAT solvers.
There are libraries like Pisat that give you access to
state-of-the-art solvers. And for something like fluid
dynamics, Navier Stokes. There you need heavy machinery.
Packages like Dedalis are popular.
They use what are called spectral methods, which are very
accurate for those kinds of simulations.
These tools are what let us turn the abstract math into something
you can actually run. Got it.
So these tools enable this A&B strategy, which you said is like
proof by refutation. Yeah, trying to break it.
That's the core idea, yeah. It shifts the whole mindset.
Instead of asking, can I prove this is true everywhere forever,
which is daunting. You ask, can I find even one
instance where this breaks using all the computational power I
have? Exactly, and there's a clear
four step process. Step one is foundational.
OK, what's step one? Step one, assume the conjecture.
You start by taking the statement as given.
Or sometimes, like we'll see with PBSNP, you assume the
opposite is true. OK.
Assume it, then what? The really crucial part here,
the intellectual work, is translating that abstract
assumption into concrete computable consequences.
So not just assuming it, but figuring out if this is true,
what must we be able to measure or calculate?
Precisely what specific numerical bounds have to hold?
What scaling laws should we see? Are there mathematical
invariants that must be constant?
This is the bridge from the idea to the experiment.
OK, so take the Riemann Hypothesis.
That's about where the zeros of a function are, right?
Very abstract. Very abstract.
It's about the non trivial zeros of the Riemann Zeta function
lying on a specific line in the complex plane.
So if that's true, the computable consequence is
something about prime numbers. Exactly.
It implies a very specific limit on how much the actual count of
prime numbers can deviate from the best mathematical
approximation that deviation is measurable.
And that measurable thing is what you test in Step 2.
Absolutely. Step 2.
Generate testable predictions. You take those consequences, the
bounds, the scalings, and you formulate them as specific
hypotheses you can actually check with finite data.
Because we can't check infinite primes, but we can count primes
up to, say 10 to the power of 20.
Right. We can count primes up to
enormous numbers now, so we generate predictions verifiable
within that reachable finite domain.
And then Step 3 is where the computers earn their keep.
Step three, verify empirically. Now you use those specialized
software tools. Simpi Π SAT did list whatever
fits the problem, and you run the tests.
You check if the predictions hold up against actual
computation. What happens then?
Two possibilities. 2 main outcomes if the predictions hold
true. If the numbers match the theory
well, you gain empirical coherence.
Coherence, not proof. Not proof, but it's
significantly strengthens your confidence in that initial
assumption. It shows the conjecture behaves
as expected in the real world, as far as we can test.
But what if it doesn't hold? What if the computation breaks
the prediction? That's where it gets really
exciting. A failure isn't just a failure,
it's a refutation. It refutes the consequence you
tested. Which means it must also refute
the original assumption you started with.
Exactly. That failure is potentially a
massive discovery. It could be the counter example
everyone's been looking for. Which leads naturally to Step 4.
Iterate on falsity, right? This is basically the scientific
method in pure math if your initial assumption gets shot
down by the data. Say you find a prime
distribution error that violates the Riemann Hypothesis bound.
Then you immediately flip your assumption.
You start assuming the negation is true, and then you generate
new predictions based on that. You start actively hunting for
the properties of this counterexample you've just found
evidence for. OK, this framework makes sense,
but I have to push back on this coherence versus proof point.
If it's not proof, isn't there a risk?
What kind of risk? The risk that we spend, you
know, millions of CPU hours building up all this coherence,
but it's just, well, finding patterns in finite data that
don't actually hold up in the infinite case, a distraction
from the real theoretical work needed.
That's a very valid concern, and it's why we constantly stress
the distinction. This is not a replacement for
proof. Think of it like simulation in
physics or engineering. We simulate a new airplane wing
design under millions of conditions.
If it passes all tests, we have extremely high confidence it's
safe. Does it prove it will never fail
under some bizarre, untested circumstance?
No. But it builds enormous
confidence and tells us where the likely weak points aren't.
So A&V helps narrow the search base for the theorists.
Massively, if you check the Riemann hypothesis up to N 13
zeros, or verify its consequence for primes up to 1020 and find
nothing wrong. Which people have done.
Which people have done in just seconds for the prime check, by
the way. Then the burden shifts.
It tells the pure mathematician, look if there's a
counterexample. It's hiding way out there in the
asymptotic weeds. Don't waste time looking for
simple ones. And conversely, if a simulation
did find a glitch, then. Bam, you have a concrete
numerical counterexample, something tangible.
A theorist can grab that specific data point and analyze
why it breaks the pattern. It turns a philosophical maze
into analyzing a specific observable defect.
It's like giving the theorists a high-powered computational
compass, even if it's not the final map.
That's a great analogy. It guides the search
efficiently. All right.
I'm sold on the strategies potential.
Let's get into the specifics. Let's see A&V in action on the
actual Millennium problems. OK, first up, the big one, maybe
the most famous unsolved problem in math, the Riemann Hypothesis.
The king of number theory. Yeah, as we mentioned it's about
the location of the non trivial zeros of the Riemann Zeta
function. The conjecture is they all lie
on a specific line, the critical line, where the real part is 12.
And this seemingly obscure statement about complex numbers
has deep ties to how prime numbers are spread out.
Incredibly deep ties. It's fundamentally about the
regularity, or the lack thereof, in the distribution of primes.
If RH is true, the primes are distributed as regularly as
possible. And the envy strategy takes this
abstract idea and makes it concrete.
How? Through that bound you
mentioned. Exactly through the von Koch
Schoenfeld bound. This is the computable
consequence derived from assuming RH is true.
So remind us what that bound actually limits?
It limits the error you make when you estimate the number of
primes up to a certain number X. The best estimate we have is a
function called the logarithmic integral lead X.
The actual count is X. OK, lead X is the guess, Lex is
the reality, right? The bound says if RH is true,
then the absolute difference between the guess and the
reality X X has to be smaller than a specific quantity, The
square root of X times the logarithm of X all divided by 8.
So air X log X. Precisely.
But there is a catch in the formal statement.
Technically, that bound is only proven to hold if RH is true and
for very very large X. The paper mentions X greater
than or equal to 10 to the 28th power. 10 to the 28th, that's
astronomically large. How can we possibly test that
with computers? We can't reach that high, can
we? Not directly, no.
So the A&B experimental design adapts.
We don't test the bound at 10:28, instead we test it at the
largest values of X we can reach computationally.
And we check for coherence. We see if the error behaves as
if it's respecting that kind of limit.
Exactly. And we lean on the mountain of
existing evidence. Decades of computation have
already checked the zeros themselves.
Billions and billions of them. The latest checks are past
10,013 zeros, and none have been found off the critical line.
OK, so our A&B task here is twofold.
One verify that this consequence about prime counting holds for
the largest accessible numbers to keep pushing that
computational frontier, always hoping, maybe perversely, to be
the first to find a violation. We can see this really clearly
with a small example, right? Something runnable?
Let's say test X = 1,000,000. Yeah, X well, is one O 6.
That's easily doable. We can use simply for this,
because it handles the precision needed for the logarithmic
integral correctly, even if it's slower for huge numbers.
And running that, how long does it take?
What's the result? On a standard machine, maybe a
second or two, you calculate 1,000,000, the exact number of
primes up to 1,000,000, and you calculate Lil 1,000,000.
And the difference the actual error.
The output shows the error. The lex lex part comes out to be
around 23 point. Five OK 23.5 Now what does the
von Koch Schoenfeld formula predict?
The maximum allowable error should be at X = 1,000,000.
You plug XO is one O 6 into X log X.
That calculation gives you a bound of approximately 37.2.
So the actual error 23.5 is way less than the maximum allowed
error 37.2. Comfortably less so.
The coherence holds beautifully. The error is well within the
safety margin predicted by. Assuming RH is true, It behaves
exactly as expected. And this is where the tools
matter. That sippy check is great for
understanding the principle takes a second, but it won't
scale to checking X equal 10/20, right?
Absolutely not. Sippy is doing exact symbolic
math, which gets very slow to go to really large numbers like
1020. You need to switch gears to what
you switch to highly optimized C libraries that are specifically
designed for prime counting. The source mentioned prime count
as an example. These trade the symbolic
perfection for raw speed using clever algorithms.
And how fast are those checking up to 1020?
That sounds like it should take ages.
That's the amazing part. The source notes that checking
the prime count error relation up to X = 1020 takes only about
30 seconds using prime count. 30 seconds to check something
related to the Ryman hypothesis. Up to 10 to the 20.
Yep. Because the relationship itself,
the comparison between CLEX and legs and the bound, is
computationally simple once you have the prime count, and the
prime counting algorithms are incredibly refined, it's a
fantastic example of how computation provides extremely
strong coherence very quickly. OK, let's switch gears
completely from the smooth world of prime numbers and complex
functions to the jagged, discrete world of computational
complexity, P versus NP. Ah, yes, the question of
efficient computation. Can every problem whose solution
is easy to check, that's NP nondeterministic polynomial
time, also be easy to solve? That's P polynomial time.
If P did equal NP, the consequences would be, well,
world changing. We're absolutely transformative.
It would mean things we currently think are impossibly
hard, like breaking most modern encryption, finding optimal
solutions for logistics nightmares like the traveling
salesman problem, or solving complex protein folding.
All could potentially be solved efficiently in polynomial time.
But the gut feeling, the intuition in the field, leans
heavily the other way. The overwhelming consensus,
yeah, is that P does not equal NP, that there really are
problems that are easy to check but fundamentally hard to solve.
So for the A&V strategy, we actually start by assuming the
opposite of PNP. We assume P is not equal to NP.
Exactly. That's our starting assumption
for the test PNP. OK, if PNP is true, what's the
computable consequence? What should we be able to
measure? If PNP, then these hard NP
complete problems like the classic 3 SAT problem must
exhibit runtimes that scale exponentially or at least super
polynomially as the problem size increases.
They can't scale nicely like polynomial problems.
So we're looking for that exponential blow up in
computation time. That's the signal.
That's the signal we're hunting for.
The experimental design is quite clever here.
How does it work? First you need pest cases.
You generate random instances of a known NP complete problem,
typically three SAT. That's a Boolean satisfiability
problem. Trying to find if there's a
combination of true, false inputs that makes a logical
formula true. Exactly.
But you don't just generate any random three SAT instance, you
generate them very carefully, right at a specific density.
Density. What does that mean?
You mentioned a number 4.26. Right.
It turns out that for random three SAT, the hardness depends
critically on the ratio of clauses constraints to
variables. If you have too few clauses, the
problem is easy. Too many, and it's usually
impossible, unsatisfiable, and often easy to prove so.
But right around that magic number, about 4.26 clauses per
variable. That's the sweet spot, the
so-called phase transition region.
These instances are computationally the hardest.
They're often satisfiable, but finding the solution takes the
longest time. They're the most likely to show
that exponential scaling if PNP is true.
So you generate these maximally difficult instances, then what?
Then you throw them at a powerful SAT solver.
The source mentions Kisat as a modern high performance solver,
often used via a Python wrapper like Pisat and.
You measure how long it takes to solve them.
Different sizes, different N. Precisely, you run it for
instances with say N50 variables N 100, N 150, N 200 and so on,
carefully logging the CPU time for each successful solve.
OK, now you have data problem size N versus time.
How do you test the PNB assumption?
You do a statistical analysis. You try to fit that time data to
two different mathematical models.
Model 1. Polynomial scaling.
Right, that would look like log time is proportional to log NA
straight line on a log log plot. This would support PNB.
Model 2. Exponential scaling.
Yeah, that would look like log time is proportional to N
itself. A straight line on a semi log
plot log time versus linear N This supports PANP.
And you see which model fits the actual runtime data better.
Exactly. You look at measures like the
R-squared value, how well the curve fits the points.
So what do the results show for these tests run up to say and
200 variables? The results are pretty clear
cut. According to the source
material, the exponential model provides a much better fit to
the data than the polynomial model.
Really strong support for PNP then.
Very strong empirical support. The analysis even estimates the
constant in the exponent. It found that log time is
roughly proportional to .03 * n. What?
Does that .03 mean practically? It means for every single
variable you add to the problem, the runtime increases by a
multiplicative factor of E 0.03, which is a about 3% increase.
Doesn't sound like much, but it compounds exponentially at 100
variables and the time multiplies by E3, which is about
20 times harder. Wow, OK, that's the numerical
signature of that exponential barrier we expect if PANP.
It absolutely is. It's strongly reinforces the
consensus view. In this check up to any 200.
How long does that take? The source suggests this kind of
test, generating the instances and running the solver across
these sizes might take around 10 seconds on a modern machine. 10
seconds to get strong numerical evidence supporting one of the
biggest questions in computer science and mathematics.
It's pretty efficient, yeah. Now if the polynomial model had
fit better, that would have been earth shattering.
It would have immediately told researchers.
Hold on, maybe our intuition about PVSNP is wrong.
Start looking for polynomial algorithms.
But it didn't. And does this exponential
scaling hold up as you go to a much larger in?
That's the thing, the exponential nature becomes even
more apparent while the N 2 100 check takes seconds, stealing up
to say and 10,000 variables, which is common in serious
research. That 3% per variable really
starts to add up. Oh yeah, the runtime balloons
into minutes or even hours. Even using parallel computing,
the difficulty scales exactly as the PMP assumption predicts.
For these hard instances, the coherence is very strong.
OK, let's shift again. We've done numbers, we've done
computation theory. Now let's talk about fluid
dynamics, water, air turbulence, the Navier Stokes equations.
Right. These equations are fundamental
to describing how fluids move everything from, you know, water
flowing in a pipe to weather patterns to the air flowing over
an airplane wing. They're incredibly important in
science and engineering. But there's a catch a Millennium
problem hidden in there. There is.
It's about the smoothness of the solutions.
The question is if you start with a perfectly smooth, well
behaved initial state for the fluid, say perfectly defined
velocities everywhere. With perfectly Stillwater or a
very general predictable flow. Exactly.
Will the solution, the way the fluid evolves according to the
equations always remain smooth and well behaved for all future
times? Or could something catastrophic
happen? Could a singularity form a point
in space and time where the fluid velocity or pressure
suddenly becomes infinite? Or maybe the derivatives become
undefined? This is called a blow up.
Blow up? That sounds bad.
It would be mathematically profound if blow up can occur
from smooth initial data. It means the Naver Stokes
equations might be well incomplete or breakdown under
certain conditions. It would mean our fundamental
model of fluid flow has a hidden flaw.
So the Millennium conjecture is that blow up doesn't happen,
that smooth initial conditions always lead to smooth solutions
globally. That's the conjecture.
Basically global existence of smooth solutions.
OK, so how does assume and verify tackle this?
We assume smoothness holds. We assume the conjecture is true
that solutions stay smooth. And the test is to actively hunt
for a situation where that assumption breaks to try and
provoke a blow up in a simulation.
Precisely, you're using computation to search for the
spontaneous formation of a singularity.
How do you even set that up? Simulating fluid sounds
complicated. It is very complicated.
The experimental design usually involves simulating the fluid in
a simplified domain, often a 3D Taurus A.
Taurus like a doughnut shape. It's mathematically convenient.
A Taurus T333 is a box where the opposite faces are connected, so
if fluid flows out one side, it comes back in the opposite side.
It avoids having to deal with complex boundary conditions at
walls, letting you focus purely on the internal dynamics of the
fluid itself. OK, so simulate on a Taurus,
what do you start with? You start with random but
mathematically smooth initial velocity fields.
Then you let the Naver Stokes equations evolve the state
forward in time using numerical methods.
And you need good numerical methods, presumably.
Extremely good ones. The source specifically mentions
using high order spectral methods as implemented in
libraries like Daedalus. Spectral methods are known for
being very accurate for smooth flows, which is crucial if
you're trying to see if smoothness breaks.
Right, so the simulation rent, what are you watching for?
What's the red flag that screams potential blow up?
The key metric to monitor is often the maximum absolute
vorticity. Vorticity.
What's that? Vorticity measures the local
spinning motion of the fluid. Think of tiny whirlpools or
eddies. If energy starts to concentrate
intensely in a very small region, which is what you might
expect near a singularity, the vorticity in that region would
spike dramatically. So if vorticity goes through the
roof, that's the warning sign. That's the main indicator.
A common criterion used in these AMV test is if the maximum
corticity anywhere in the simulation suddenly double s or
triples or increases by some large factor over a very short
time, that signals you might be witnessing the onset of a blow
up. OK, makes sense.
So people run these sophisticated simulations.
What do they find? Does blow up happen often?
This is where it gets interesting.
The overwhelming result from countless simulations is no
intrinsic blow up from smooth initial data.
Seems to be very rare, if it happens at all in these
settings. So the simulations support the
conjecture. They support smoothness.
They provide strong empirical coherence for the smoothness
conjecture. Yes, the solutions tend to
remain well behaved. I sense a but coming.
There's a huge but and it's computational cost.
This problem highlights the limitations of AMV perhaps more
brutally than any other. The scalability issue again.
Massively so. You can run a course simulation,
maybe a 64 by 64 by 64 grid on a decent workstation in minutes or
hours and it will likely look smooth.
But that's not enough to be sure.
Not nearly enough. Turbulence involves interactions
across a vast range of scales, from large eddies down to tiny,
tiny dissipative structures. To be confident you're not
seeing a singularity that forms only at very small scales, you
need incredibly high resolution. Like what kind of resolution?
We're talking grids like 5-2 by 5 by two or five by 5 two or
even 10243 or higher resolving those tiny scales.
And simulating that. Takes enormous resources.
We're talking hours or even days running on large clusters with
many GPU's working in parallel. It's pushing the limits of even
supercomputers. So AMV tells us smoothness is
the norm and simulations we can afford to run.
Right. It builds confidence.
But it hasn't definitively ruled out that a blow up couldn't
happen in a scenario requiring resolution or simulation time
that's still beyond our current reach.
Exactly. We're compute bound.
The empirical evidence leans towards smoothness, but the
final word requires either a theoretical breakthrough or
vastly more powerful computation than we have today.
OK, so we've seen Ryman Hypothesis and P Visas MP where
AMV gets pretty quick strong coherence, then Navier Stokes
where it supports the conjecture but hits a massive computational
wall. A very different feel for each,
yeah? Let's apply that same detailed
A&V lens to the other three Millennium problems.
We need to make sure we unpack the jargon here, too.
There's Birch and Swinnerton, Dyer, Hodge and Yang Mills.
Right, covering number theory, algebraic geometry, and
fundamental physics. The AMD strategy translating the
abstract idea into a computable test applies to all of them, but
the specifics differ greatly. Hashtag tag, tag tag tag, The
Birch and Swinnerton Dyer conjecture.
BSD. Let's start with BSD, Birch and
Swinnerton Dyer. This one's back in number
theory, right? And it's about elliptic curves.
What are those in simple terms? Yeah, number theory again.
An elliptic curve isn't actually an ellipse.
It's typically defined by a cubic equation.
Something like Y2 cools by 3 + X + b.
They are smooth curves, and mathematicians are fascinated by
their points, specifically points where both X&Y are
rational numbers fractions. Finding fractional solutions to
this cubic equation. Exactly.
The BSD conjecture tries to connect two very different ways
of measuring the complexity or richness of these rational
points on the curve. Two different measures.
What are they? On one side you have the
algebraic rank. This is, roughly speaking, a
measure of how many independent rational points there are.
It's about counting 0 12A whole number describing the structure
of the rational points. OK, algebraic rank accounting
points. What's the other side?
The other side is the analytic rank.
This comes from calculus, specifically complex analysis.
You associate a special function called an L series to the
elliptic curve. It's a bit like the Raymond Zeta
function. The analytic rank is defined by
how this L series behaves right at a specific point, S1.
Specifically, it's the order of the zero of the L series at S1.
Whoa. OK, SO1 rank is from counting
fractional points. The other is from the behavior
of a fancy calculus function and BSD claims.
BSD claims these two ranks derived in completely different
mathematical universes are always equal.
The analytic rank equals the algebraic rank.
That sounds like a really deep connection.
How on earth do you test that with A&V?
This is a perfect case for A&V via massive data checking.
We have large databases of elliptic curves like the Cremona
database but. People have already cataloged
millions of these curves. Oh yes, their properties
computed. We use computational algebra
systems. Sage Math is a very powerful the
open source one mentioned that can access these databases.
And the test is. For a given curve in the
database, you compute its algebraic rank, which involves
sophisticated algorithms for finding points, and you compute
its analytic rank, which involves numerically evaluating
the L series and its derivatives near S1.
And you just check does integer A equal integer B.
That's the core empirical check. You do this for as many curves
as possible, especially those with low conductor, the measure
of complexity. What's the verdict from these
massive checks? The coherence is overwhelming.
The source material confirms that millions of curves have
been tested over the decades since the conjecture was
proposed, and for all the curves where both ranks could be
reliably computed, they match. No counterexamles found.
None have been confirmed. The computational evidence is
incredibly strong in favor of BSD.
A single check on one curve might take seconds or minutes
using Sage math, but the cumulative result built over
years provides enormous confidence.
Hashtag, tag tag hashtag The Hodge conjecture.
OK, Next up, the Hodge conjecture.
This one sounds intimidating. Algebraic geometry.
Yeah, this one dives deep into the geometry of shapes defined
by polynomial equations. These shapes are called
algebraic varieties. The Hodge conjecture is often
considered one of the most abstract and difficult of the
seven problems. What's the fundamental idea it's
trying to capture? OK, let's try to simplify.
When you study the topology of these geometric shapes, you can
break down certain mathematical structures associated with them.
They're cohomology groups into pieces called Hodge glasses.
Some pieces depend on the shapes complex structure.
OK, complex structure pieces. Then, separately, you can study
geometric substructures within the main shape that are
themselves defined by polynomial equations.
These are called algebraic cycles.
Think of lines or curves lying on a surface.
So algebraic cycles are polynomial substructures.
Right, the Hodge conjecture focuses on a specific type of
Hodge class, the ones called Hodge PP classes.
It claims that these specific topological pieces which seem
tied to the complex structure are actually always combinations
of these simpler, purely algebraic cycles.
It's saying something seemingly complex and analytic is actually
built from simpler algebraic blocks.
That's a good way to think about it.
It connects the deep analytic topology of the space back to
the polynomial equations that defined it in the first place.
How do you even begin to test something like that
computationally with A&V? You can't test it for all
varieties of course. The A&V approach here is to test
it on specific manageable examples.
You look at relatively low dimensional or low degree of
varieties of what the source mentions.
Things like cubic hyper surfaces, shapes defined by
degree 3, polynomials in five dimensional projective space
five. You need specialized software
for this kind of thing. Software Macaulay 2 is a
standard powerhouse in computational algebraic
geometry. You might use it through a
Python interface to make it easier to script the tests.
And what's the actual computation?
What numbers are you comparing? You compute properties related
to both sides of the conjecture. For your chosen variety, you'd
compute the structure of its Hodge classes, often summarized
in something called the Hodge diamond.
I get the Hodge. Diamond, and then you compute
the structure of its algebraic cycles represented by
mathematical objects called Chow groups.
The A&V test then essentially checks if the part of the Hodge
diamond corresponding to the P classes matches the structure
predicted by the Chow groups. Does the dimension match?
Do the generators correspond? It's a structural comparison.
Exactly, and the source notes that the conjecture is known to
hold true for many low dimensional and low degree cases
where these computations are feasible.
How long does a check like that take?
For a single, well chosen small example that's computable,
running the Macaulay 2 scripts might take seconds or minutes.
It verifies the principle holds in concrete cases.
The difficulty, like with Navier Stokes, is scaling this up to
more complex varieties where the computations become intractable
very quickly. But for the testable cases, the
coherence holds #tach Hashtag, the Yang Mills existence, and
Mascat. OK, our last problem, Yang Mills
existence and Mascat. It sounds like physics, Quantum
physics. Exactly this one is fundamental
to the standard Model of particle physics.
Yang Mills theories are the mathematical framework
describing fundamental forces, particularly the strong nuclear
force, which holds atomic nuclei together, and the weak nuclear
force. And the Millennium problem has
two parts, existence and mass gap.
That's right. The existence part is about
proving that the quantum version of Yang Mills theory is
mathematically well defined and consistent.
The mass gap part is a specific prediction of such a consistent
theory. What is the mass gap?
Predict. It predicts that the lightest
particles predicted by the theory excitations of the
quantum field, sometimes called glue balls in the context of the
strong force, must have a strictly positive minimum mass.
There must be a gap between the vacuum state 0 energy and the
energy of the lightest possible particle.
Let's call this minimum mass delta.
The conjecture is 0. Why is that important?
What if the mass gap was 0? If zero were zero, the theory
would predict massless force carriers interacting over long
distances. But we know the strong nuclear
force is short range. It doesn't leak out of the
nucleus. A positive mass gap is essential
for explaining this short range nature.
OK so the AMV test here assumes the theory exists and has a mass
gap yes? And the computer to consequence
is that simulations should actually find a non 0 mass for
the lightest particle. That's the core idea.
You need to simulate the quantum field theory and extract the
particle masses from the simulation.
How on earth do you simulate quantum field theory?
That sounds even harder than fluids.
It requires the most computationally intensive
technique we've discussed, lattice QCD or lattice quantum
chromo dynamics for the strong force case.
Lattice like a grid. Exactly.
You can't simulate continuous space-time directly, so you
approximate it with a discrete 4 dimensional grid, the lattice.
You then simulate the interactions of the fundamental
fields like gluons. For the strong force on the
points and links of this lattice.
It requires massive parallel computing.
So the experimental design is this huge lattice simulation.
What are you measuring in the simulation to find the mass gap?
You calculate things called glue ball correlators.
A correlator measures how the properties of a particle created
at one point in space-time are related to its properties at
another point. OK, for a massive particle this
correlation decays exponentially with distance.
The rate of that exponential decay is directly related to the
particles mass. So you simulate, calculate these
correlators, see how fast they decay, and that tells you the
mass. Precisely, you compute the
correlators for the lightest expected glue Ball State and you
fit their decay to an exponential function.
The mass comes from the exponent in that fit.
The A&V check is. Does this fitting procedure
consistently yield a positive non 0 mass?
And what is the data from these huge lattice QCD simulations
show? The empirical data is strongly
supportive of the mass gap conjecture.
Really, they find a positive mass.
Yes, large scale simulations, often using approximations like
quenched SU-3, Yang Mills theory, consistently produce
finite positive masses for the lightest glue ball states.
The source mentions estimates for the lightest scalar glue
ball lane plus Cree dollars are around 1.6 GV giga electron
volts. So the simulations confirm the
physical prediction needed for the theory to match reality.
That's the coherence. That's the A&V coherence
exactly, but again, we have to mention the cost.
Let me guess, GPU farms and lots of time?
You got it. While simplified toy models
might run quickly, getting reliable results from full scale
lattice QCD requires hours, days, or even weeks on dedicated
supercomputing resources, usually massive GPU farms.
It's another area where computation provides strong
evidence, but is incredibly demanding.
Wow. OK, that's an incredible tour
across 6 monumental problems. Ryman hypothesis, PBSNP, Navier,
Stokes, BSD, Hodge, Yang Mills all probe using this assume and
verify computational lens. It really shows the versatility
of the approach, doesn't it? The same core logic applies even
if the tools and details vary wildly.
Absolutely. So for someone listening, maybe
trying to get a handle on these fields efficiently, let's
quickly synthesize the big advantages of this A&V approach.
Why is it valuable? OK, advantage 1 speed.
We saw this clearly with RH and PVS and P tests that give strong
initial coherence can run in seconds or minutes.
This is orders of magnitude faster than waiting decades for
a potential theoretical proof of refutation.
It massively accelerates the learning and discovery cycle.
Right. Get feedback quickly advantage
too. It generates valuable resources.
The process itself creates things like benchmark data sets,
hard three SAT instances, databases of computed
properties, elliptic curve ranks, or well tested simulation
codes. These become tools for the
entire research community, even if the main conjecture remains
unsolved. That's a great side effect.
What else? Advantage 3 and maybe the most
powerful theoretically direct refutation potential.
If an AMV check fails. If the computation spits out a
number that violates the predicted consequence, that's
potentially hewed. It's not just inconclusive, it's
wrong assumption found. Exactly.
It provides a concrete counterexample, or at least
points precisely to where the theory breaks down numerically.
That's incredibly valuable information for theorists.
It tells them exactly where to focus their efforts.
And the last advantage may be more personal for the learner.
It builds critical intuition actually seeing the prime
counting error stay within the RH bound, or watching the SAT
solver time explode exponentially.
It gives you a gut feeling and experiential understanding of
the problems behavior that you just can't get from reading
abstract theorems. OK, speed, resources,
refutation, intuition. Powerful stuff, but we have to
be critical. We touched on limitations
throughout. Let's bring them together.
What are the big caveats? #1 Underline bolded flashing
lights. Finite checks are not infinite
proof. This is the absolute bedrock
limitation. We can check 10-13 zeros of the
Zeta function or simulate a fluid for a billion time steps,
but that doesn't prove the property holds for the 1013 plus
for zero or for all time. The asymptotic beast might still
be lurking just beyond our computational reach.
Always limitation 2. Algorithmic and implementation
errors. We're relying on complex
software. Prime count, Dedalus, lattice,
QCD codes. These are written by humans.
They can have bugs. So a seeming refutation could
actually just be a bug in the simulation code.
It's a real risk. Verifying the correctness of the
tools themselves is a major challenge.
A subtle bug could lead you entirely astray, giving false
coherence or false refutation. OK. 3rd limitation.
The scalability wall. We saw this starkly with the
Naver, Stokes and Yang Mills. To truly test the conjectures in
the regimes where interesting things might happen, very small
scales, very long times, very strong couplings, you need
computational resources that are often prohibitively expensive,
requiring dedicated supercomputers or GPU farms.
So for some problems, A&V can only explore a limited part of
the landscape effectively. Exactly.
The cost prevents us from doing the definitive computational
experiment in those cases. And the final, maybe most subtle
limitation. It's that empirical scaling
might be misleading. The behavior we observe in the
computable range might not be the true asymptotic behavior.
How so? Remember PVSNP?
We see clear exponential scaling for three SAT up to thousands of
variables. It looks convincingly like PAMP,
but is it theoretically impossible that at N10100
variables some completely different polynomial behavior
takes over? We can't rule it out just from
the simulations at smaller N. We can't.
What looks exponential in our lab might, in the infinite
limit, turn out to be just a very, very steep polynomial, or
something else entirely. We're extrapolating from finite
data, and that's always inherently risky.
These limitations really frame the results.
Let's make it concrete with those runtime examples.
Again, show the difference between what you, the listener,
might run on a laptop versus professional research.
OK Raymond hypothesis checking the prime count error.
Your laptop test may be up to X1 on 9 or 1010.
Using simpi might take a few seconds to confirm the
principle. OK.
The pro level. Using Optimize C++ a checking up
to X120 takes about 30 seconds. Here the scaling is fantastic,
huge increase in verification range for minimal extra time.
Right now PVSNPSAT solving. Your laptop test may be
generating and solving instances up to end 200 at the phase
transition. That takes around 10 seconds.
Strong evidence quickly pro level pushing to end tool 10,000
or more, which requires more sophisticated instance
generation and longer runs. That pushes into minutes, maybe
10s of minutes depending on the instances and the solver.
The exponential cost starts to bite.
And the big ones, Yang Mills or Navier Stokes.
Laptop level you can run a tiny toy lattice simulation, maybe 84
grid or a very low res fluid SIM 323 that might take seconds or
minutes. You can see the code works.
Maybe verify basic properties. It tells you almost nothing
about the actual Millennium problem.
Pretty much nothing definitive, no.
The professional level requires those huge grids, 523 fluids,
maybe 644 or larger lattices run for long simulation times.
That's hours, days, even weeks on dead indicated GP clusters
costing millions. The gap between accessible and
research grade is enormous there.
That comparison really highlights the different
characters of the problems computationally.
It does. Some yield strong coherence
quickly and cheaply. Others require herculean
computational effort to get meaningful results.
So let's synthesize what's the big take away here?
What does this AMV approach really mean for how we tackle
these problems? I think it fundamentally changes
the landscape. It transforms these abstract
mathematical mountains into essentially executable
experiments. It provides a powerful,
systematic way to build evidence, find flaws, and guide
theoretical work. It accelerates discovery.
And the evidence we've reviewed today, the empirical coherence,
it seems to strongly support some long held beliefs.
Very much so. The data strongly favors the
Ryman hypothesis being true. It strongly favors PNP.
It supports the Birch and Swinnerton Dyer conjecture and
the existence of a mass gap in Yang Mills theory.
The computational results align with the prevailing mathematical
and physical intuition in these cases.
But for others like Navier, Stokes, smoothness or maybe
Hodge, the computation supports the conjecture but also screams
we need more power or we need a new theoretical idea.
Precisely the limits of the A&V approach in those areas
highlight exactly where the next breakthroughs are most needed.
Whether they come from better algorithms, faster hardware, or
fundamentally new mathematical insights, A&V acts as the best
heuristic guide we currently have.
Now, looking forward, you mentioned the sort material
hints at the next frontier. What is it?
It's about bringing in another computational paradigm, machine
learning. AI how would that fit into
assume and verify? Think about those problems where
we hit the scalability wall, like Navier Stokes.
We generate petabytes of simulation data, but we're often
just looking for simple signals like did vorticity double?
Right, a fairly crude check. Machine learning offers a way to
analyze that simulation data much more deeply.
Instead of setting simple thresholds, you could train ML
models, maybe deep neural networks, to detect subtle
complex emergent patterns in the flow data that might be the
precursors to a singularity. So the AI could spot the warning
signs much earlier, or patterns that a human analyst or a simple
rule would completely miss. That's the hope.
It could act as a highly sophisticated anomaly detector
within the ANV framework. It could sift through the
massive data sets generated by the simulations and flag the
truly interesting, potentially dangerous events that warrant
closer inspection or even higher resolution follow up
simulations. That could potentially get us
around the raw computational power bottleneck to some extent
by making the search smarter. It could make the search vastly
more efficient. Instead of simulating everything
at maximum resolution, you simulate broadly.
Let the ML find the suspicious regions and then zoom in
computationally just on those. It could be the key to probing
those hard to reach regimes. Turning the numerical lab into
an intelligent hunting ground for counter examples.
That's a fascinating prospect. It really feels like the next
logical step, integrating data-driven AI insights with the
physics based A&V simulations. So our final thought for you,
the listener really comes back. This idea of accessibility, this
whole assume and verify approach, from the quick RH
checks to the complex physics simulations, it's all built on
code. Code that in many cases,
particularly for the basic setups, is becoming increasingly
open and available. Which means these monumental
challenges, the deepest questions in mathematics and
physics, they aren't solely confined to the ivory tower
anymore. They're not just philosophical
debates. They've become, in a very real
sense, executable, verifiable computational problems.
And the amazing implication is that the path towards
understanding, contributing, maybe even finding that
$1,000,000 insight, it might just start with downloading some
code, understanding it, and running an experiment on the
computer you have right in front of you.
The journey begins with computation.