From the Tibetan Plateau to California: Supercomputing reveals a hidden source of flood predictability
From the Tibetan Plateau to California: Supercomputing reveals a hidden source of flood predictability
previous arrow
previous arrow
next arrow
next arrow
Shadow
From the Tibetan Plateau to California: Supercomputing reveals a hidden source of flood predictability
Featured

From the Tibetan Plateau to California: Supercomputing reveals a hidden source of flood predictability

A computational experiment suggests that getting the Tibetan Plateau’s land-surface temperature right may dramatically change how climate models simulate California’s most extreme winter precipitation events.

What if a supercomputer trying to understand California’s winter precipitation was looking in the wrong place?

That is the intriguing possibility raised by new research published in Science Advances. A team led by Yongkang Xue at the University of California, Los Angeles, used numerical weather and climate simulations to investigate two extraordinary California precipitation seasons, winter 2016–2017 and winter 2022–2023, and found that a seemingly remote piece of the atmosphere-land system may have played an important role: unusually strong early-winter heating over the Tibetan Plateau.

The computational experiment is particularly interesting from a high-performance computing perspective because the researchers did not simply ask a climate model to reproduce what happened. They used controlled ensemble simulations to ask a much harder question:

What happens to California’s precipitation when the model’s representation of Tibetan Plateau land-surface temperature is changed?

The answer was striking.

After correcting the Tibetan Plateau temperature initialization, the simulations reproduced approximately 56% of the observed January 2017 extreme precipitation anomaly and 38% of the March 2023 anomaly over California and adjacent regions.

The result does not mean a supercomputer has discovered a single variable that can perfectly predict California floods. The researchers explicitly describe the work as a single-model case study and call for multimodel investigations.

But it does demonstrate something potentially more consequential for computational Earth-system science: model initialization can determine whether a remote physical mechanism becomes visible at all.

The computational problem: California was not supposed to behave this way

California’s winter precipitation is strongly influenced by large-scale atmospheric circulation and atmospheric rivers, long, narrow corridors of concentrated water vapor that can transport enormous quantities of moisture toward the West Coast.

Yet the winters Xue and colleagues examined presented an interesting forecasting puzzle.

Both 2016–2017 and 2022–2023 occurred during La Niña conditions, which are traditionally associated with relatively dry conditions in California. Nevertheless, both periods produced extraordinary precipitation.

That raises a fundamental computational question.

If a model is initialized with the observed state of the climate system, why can’t it reproduce the extreme precipitation?

The researchers approached the problem with numerical experiments using the National Centers for Environmental Prediction Global Forecast System, coupled with the second-generation Simplified Simple Biosphere land-surface model, known as GFS/SSiB2.

The atmospheric model was run at T126L64 resolution, corresponding to approximately 100 × 100 kilometers horizontally, with 64 vertical levels extending to 2 hPa.

That is nowhere near the kilometer-scale resolution increasingly used for specialized regional simulations. But at global-climate scale, the computational domain is enormous, and the model must represent atmospheric circulation, land-surface processes, ocean conditions, and interactions across the entire planet.

And the researchers weren’t running one simulation.

They were running ensembles.

Ten computers’ worth of possibilities, or more accurately, ten model realizations

The control experiments, designated CTRL2017 and CTRL2023, were initialized using land-surface and atmospheric information from the NCEP Climate Forecast System Reanalysis.

This included variables such as soil moisture, land temperature, and snow cover.

Each experiment consisted of a 10-member ensemble, allowing the researchers to examine the modeled response while reducing the influence of individual realizations of internal atmospheric variability.

This is one of the fundamental reasons HPC matters in modern climate research.

A single simulation gives researchers one trajectory through an enormously complicated nonlinear system.

An ensemble gives them a small computational population of alternative trajectories.

The distinction matters because atmospheric dynamics are chaotic. Tiny differences in initial conditions can grow rapidly, making it difficult to determine whether a particular event results from a predictable external influence or simply from the system’s internal variability.

The control experiments provided an important warning.

They did not reproduce the California precipitation extremes particularly well.

And they also exhibited substantial errors in Tibetan Plateau temperature.

That coincidence became the computational clue.

The model may have been initialized incorrectly where nobody was looking

The Tibetan Plateau is thousands of kilometers from California.

At first glance, changing its land temperature might seem unlikely to affect precipitation on the other side of the Pacific.

But the atmosphere doesn’t respect political or continental boundaries.

Large-scale heating anomalies can alter pressure fields and atmospheric circulation, generating planetary-scale wave responses that propagate through the atmosphere.

The researchers therefore designed another set of experiments.

Rather than simply accepting the model’s initial Tibetan Plateau temperature state, they modified the land temperature over the plateau using observed monthly mean anomalies and model errors relative to the 1980–2023 period.

The resulting experiments were designated LT2017 and LT2023.

Again, each consisted of a 10-member ensemble.

The goal was not merely to make the model produce more California precipitation. It was to test whether correcting the Tibetan Plateau’s thermal state could activate a physically plausible chain of atmospheric responses connecting Asia to North America.

And that is where the experiment became particularly interesting.

Follow the wave

The simulations point toward a large-scale atmospheric wave train connecting the Tibetan Plateau and the Rocky Mountain region.

The proposed sequence is approximately:

Tibetan Plateau heating → planetary-scale wave response → Rocky Mountain circulation → northeastern Pacific circulation → atmospheric-river modulation → California precipitation.

The mechanism involves changes in the large-scale atmospheric circulation and subsequent Rossby wave breaking over the northeastern Pacific and western North America.

In other words, the model wasn’t simply saying:

“Tibet got warmer, therefore California got wetter.”

The computational hypothesis was considerably more complicated.

Heating over the plateau altered the atmospheric circulation. That circulation generated a wave train extending downstream. The resulting circulation changes modified the environment in which atmospheric rivers formed and propagated toward the West Coast.

That provided a dynamical pathway by which a land-surface anomaly thousands of kilometers away could influence precipitation over California.

Atmospheric rivers become the computational messenger

The atmospheric-river component provides another useful HPC diagnostic.

Researchers examined changes in integrated vapor transport (IVT) and integrated moisture flux convergence (IMFC), quantities that help describe how atmospheric rivers transport and concentrate water vapor.

For the March 2023 case, the simulations indicated approximately a 15% enhancement in IVT and about a 30% increase in integrated moisture flux convergence associated with the Tibetan Plateau-induced wave response.

The January 2017 experiment showed an even stronger response in the relevant atmospheric-river diagnostics, with IVT increasing from approximately 90.8 to 126.0 kilograms per meter per second, while moisture-flux convergence increased by roughly 62%.

Those changes matter because atmospheric rivers are not simply atmospheric plumbing carrying moisture toward California.

Their impacts depend on where and how that moisture transport interacts with the larger-scale circulation.

A relatively modest change in moisture transport can therefore become consequential if the atmospheric circulation simultaneously changes where the moisture is concentrated and where it is forced upward.

That is exactly the kind of nonlinear interaction that numerical experiments are designed to expose.

The surprise wasn’t more computing power. It was better initialization.

There is a subtle HPC lesson buried inside this result.

When a model fails to reproduce an extreme event, the obvious response is often to ask whether the simulation needs higher resolution, a more sophisticated physical parameterization, a larger ensemble, or simply more computational horsepower.

Those are legitimate questions.

But this experiment points toward another possibility: The model may have enough computing power. It may simply have been given the wrong starting state.

The researchers’ control experiments contained substantial Tibetan Plateau temperature errors.

Once the land-temperature initialization was adjusted, the simulated atmospheric response changed substantially, and the model reproduced a significant fraction of the observed California precipitation anomalies.

This is a reminder that the computational pipeline for Earth-system modeling is not simply:

More FLOPS → better prediction.

It is closer to:

Observations → data assimilation/reanalysis → initialization → ensemble generation → numerical integration → diagnostics → physical interpretation.

If the initial state is wrong in a strategically important part of the Earth system, throwing additional floating-point operations at the simulation does not necessarily fix the problem.

The supercomputer can calculate the wrong answer extraordinarily accurately.

Why this matters for predictive skill

Seasonal-to-subseasonal prediction sits in an awkward computational space.

Weather forecasts operate over relatively short periods, while conventional climate projections examine much longer timescales.

Between them lies a difficult regime in which researchers want to know whether a particular atmospheric state provides useful predictive information weeks or months in advance.

California winter precipitation is particularly challenging because extreme events can depend on interactions among ocean conditions, atmospheric circulation, land-surface states, snow, moisture transport and internally generated atmospheric variability.

The researchers argue that the Tibetan Plateau may provide one previously underappreciated source of predictability.

That is potentially significant because land-surface conditions are among the components of the Earth system that can carry memory forward in time.

Soil temperature, soil moisture and snow conditions don’t necessarily reset instantly when the atmosphere changes.

They can therefore become part of the initial-condition problem for subseasonal-to-seasonal prediction.

A supercomputer as a laboratory

Perhaps the most interesting aspect of the study is that the computer simulation is functioning less like a forecasting machine and more like a laboratory.

Scientists cannot experimentally heat the Tibetan Plateau and wait to see what happens to California.

But they can construct a numerical world in which the Tibetan Plateau temperature is altered while attempting to hold other aspects of the experiment sufficiently controlled to isolate the response.

That allows them to ask a counterfactual question:

If the Tibetan Plateau had been initialized differently, would the downstream atmospheric circulation have evolved differently?

The answer from these simulations is yes.

The experiment therefore moves beyond correlation.

The researchers had previously observed statistical relationships between Tibetan Plateau conditions and downstream atmospheric behavior. The numerical experiments provide a way to investigate whether the proposed relationship is dynamically plausible.

That is a fundamentally computational form of scientific experimentation.

But don’t declare victory yet

There is an important caveat, and the paper itself emphasizes it.

This was a single-model case study.

The results are therefore model-dependent, and the authors say multimodel studies will be necessary to determine how robust the mechanism is.

The Tibetan Plateau heating mechanism also explains only part of the observed precipitation anomalies. Other processes, including internal atmospheric variability and changes involving snow, vegetation and soil moisture, may contribute as well.

That distinction is critical.

The study does not establish that Tibetan Plateau heating is the explanation for California’s extreme precipitation.

It establishes that, within this modeling framework, correcting Tibetan Plateau temperature initialization produces a substantial downstream response and reproduces a meaningful portion of the observed anomalies.

That’s a much more interesting scientific result than a simplistic claim of causation.

The next HPC experiment could be even bigger

The logical next step is not necessarily another 10-member ensemble.

It is broader computational experimentation.

Multiple atmospheric models.

Multiple land-surface models.

Higher spatial resolutions.

Larger ensembles.

Different initialization systems.

Longer hindcast periods.

And, critically, many more extreme precipitation cases.

If the same Tibetan Plateau–Rocky Mountain wave pathway appears across independent models, the evidence for a robust mechanism becomes much stronger.

If it disappears in some models, that would be equally valuable information.

It would tell researchers where model physics, land-surface initialization, resolution, or atmospheric dynamics are influencing the result.

That is where HPC becomes more than an accelerator.

It becomes the experimental apparatus.

From Tibet to California, one initialization variable changes the question

The broader implications of this study are profound. A global climate model functions as a complex dynamical system, and its output is fundamentally contingent upon its initial conditions. In these experiments, a temperature bias over the Tibetan Plateau inhibited the model's ability to replicate extreme precipitation events thousands of miles away. By correcting this initialization, researchers successfully induced an atmospheric wave train that significantly altered circulation patterns and moisture transport, ultimately leading to a more accurate representation of California's precipitation anomalies.

The computer functioned as more than a simple forecasting instrument; it enabled researchers to conduct a counterfactual experiment that would be impossible to replicate in the physical world. This finding raises a compelling question for the next generation of supercomputing-based Earth-system models: how many events currently categorized as unpredictable might actually be foreseeable, provided the models are initialized correctly in the regions that have previously been overlooked? For HPC researchers, this may prove to be the most significant implication of the study.

Fugaku goes inside the molecular machine: Supercomputer simulations reveal how kinesin knows which way to step
Featured

Fugaku goes inside the molecular machine: Supercomputer simulations reveal how kinesin knows which way to step

What if one of the most important questions about a molecular motor is not where it goes, but how it knows which way to turn? Researchers in Japan used the Fugaku supercomputer to investigate that question, running massive all-atom molecular dynamics simulations of kinesin-1. This molecular motor walks along microtubules carrying cargo through living cells. The result is a remarkably detailed look at a tiny piece of molecular machinery that has remained difficult to resolve experimentally.
 
The simulations suggest that a previously unresolved region of kinesin, called the neck, physically interacts with the microtubule surface and helps bias the motor's stepping trajectory. Rather than simply moving directly over the leading motor head, the rear head preferentially swings around its right side in a counterclockwise trajectory. But the scientific result is only half of the story. The other half is the machine that made the investigation possible.
 
The researchers built a molecular system containing approximately three million atoms and used the GENESIS molecular dynamics package on Fugaku to follow the behavior of the system at atomic resolution. For the difficult conformational-sampling problem, they employed generalized replica exchange with solute tempering, or gREST, while running simulations under two independent molecular-mechanics force fields.
 
The question becomes almost irresistible for an HPC audience: How much supercomputing does it take to make a molecular machine reveal how it walks?

A molecular motor with a steering problem

Kinesin-1 is a biological machine that converts chemical energy from ATP hydrolysis into mechanical motion. It moves along microtubules, long protein filaments that function as intracellular tracks, and transports cellular cargo. Kinesin generally operates as a dimer, with two motor heads alternately interacting with the microtubule in a hand-over-hand stepping process.
 
At first glance, that might seem straightforward. One foot attaches. The other moves forward. Then they switch. Repeat.
 
But molecular-scale mechanics rarely cooperate with such simple descriptions. The two kinesin heads are connected through a region containing a flexible neck linker of roughly 12 amino acids and a subsequent neck helix of about 30 amino acids. The neck linker changes conformation depending on the nucleotide state of the motor head, while the neck helix contributes to formation of the coiled-coil connecting the two motor domains. That neck is therefore not just biological plumbing. It is part of the mechanical transmission system. And scientists had lacked a sufficiently detailed atomic-level picture of how that region behaves while kinesin is actually attached to its microtubule track.
 
Experimental structural methods can reveal extraordinary detail, but flexible molecular regions can remain difficult to resolve. That left researchers with a particularly computational question: If the microscope cannot easily show the missing structure, can a supercomputer calculate it?

Enter Fugaku

The research team, led by Song-Ho Chong of Kumamoto University and Ryota Iino of the Institute for Molecular Science and SOKENDAI in Japan, turned to molecular dynamics. Their paper, published in Biophysical Journal, reports that all of the molecular dynamics simulations were performed using GENESIS on the Fugaku supercomputer.
 
That choice is significant.
 
Fugaku is not simply a large machine in the conventional sense. The system contains 158,976 nodes, each built around a Fujitsu A64FX processor. Each node provides 48 computational cores, 32 GiB of HBM2 memory, and approximately 1 TB/s of memory bandwidth. The complete system has about 4.85 PiB of memory and a theoretical double-precision peak of 537 PFLOPS in boost mode. Its processors are connected using the Tofu Interconnect D, a high-performance network designed for large-scale distributed computing.
 
But the researchers did not need to run the entire machine to make their scientific point. The paper does not report the number of Fugaku nodes used, so it would be wrong to translate the experiment directly into a Fugaku-wide FLOPS figure. What the paper does reveal is more interesting scientifically: the computation required several different forms of parallel molecular exploration.

Three million atoms is where the fun begins

The researchers constructed a model of dimeric human kinesin-1 attached to a structurally realistic microtubule. The full simulation system contained approximately three million atoms. For some of the enhanced-sampling calculations, the researchers reduced the model to roughly two million atoms by removing selected tubulin subunits that were not required for studying the neck region.
 
That is an enormous number of interacting particles.
 
Every atom contributes to the molecular system through interactions with other atoms, with the calculation repeatedly evaluating forces and updating positions and velocities. The researchers used a periodic cubic water box approximately 300 Å on each side, added potassium and chloride ions to neutralize the system, and set the salt concentration to approximately 100 mM to represent physiological conditions.
 
The simulation was equilibrated at 310 K and 1 atmosphere before production calculations.
 
And then comes a detail that HPC engineers will immediately recognize. The simulation timestep was only 3.5 femtoseconds.
 
That is
[
3.5\times10^{-15}\ {\rm seconds}.
]
 
The researchers used hydrogen-mass repartitioning to enable this relatively long timestep while maintaining appropriate integration behavior. A microsecond of simulated molecular time therefore requires an extraordinary number of integration steps:
[
\frac{10^{-6}}{3.5\times10^{-15}}
\approx 2.86\times10^8
]
 
or approximately 286 million timesteps per microsecond. And that is for only one trajectory.

The problem wasn't simply simulating the molecule, it was finding the right conformation

Here is where the computational strategy becomes particularly interesting. The missing neck structure is flexible. A conventional molecular dynamics trajectory can spend a long time trapped in one region of conformational space.
 
If the system rarely crosses the energetic barriers separating important configurations, simply running longer may not be an efficient way to discover them. The researchers therefore used generalized replica exchange with solute tempering, or gREST. The technique selectively modifies the effective temperature or interaction scaling of a chosen molecular region while keeping the remainder of the molecular environment at physiological conditions.
 
In this experiment, the target was the kinesin neck-linker region. The objective was to make the difficult part of the molecule explore conformational space more aggressively without effectively heating the entire three-million-atom biological system.
 
That is an elegant HPC workload. Instead of simply throwing more timesteps at the problem, the researchers changed the sampling strategy.

Twelve replicas explore the molecular landscape

The gREST calculation used 12 replicas.
 
Their effective solute temperatures were:
[
310,\ 332,\ 357,\ 385,\ 415,\ 449,\ 486,\ 530,\ 577,\ 630,\ 690,\ 760\ {\rm K}.
]
 
Importantly, these were effective temperatures applied to the selected solute region. The solvent and nonsolute regions remained at 310 K. Replica exchange between adjacent temperatures was attempted every 3,000 molecular-dynamics steps, with the temperature spacing selected to achieve an exchange acceptance ratio of approximately 0.25. Each replica ran for 1 microsecond. And the researchers repeated the entire 12-replica calculation using two different force fields:
  • AMBER ff99SB-ILDN
  • CHARMM36m
That produced 24 microseconds of aggregate simulation time for the gREST calculations. 
 
In other words, the supercomputer was not being asked a simple question such as: "Where is the neck?" 
 
It was being asked:
"Across a large ensemble of thermally enhanced trajectories, force-field assumptions and conformational states, which structures does this flexible region actually occupy, and which ones remain physically stable when the full molecular environment is considered?"
That is a much harder computational problem.

The HPC trick: parallel replicas, shared scientific question

Replica-exchange molecular dynamics is naturally suited to parallel computing. Each replica can perform its own molecular-dynamics trajectory independently for most of the calculation. Periodically, neighboring replicas exchange information according to the statistical mechanics of the method.
 
Conceptually:
[
R_1(T_1)
\leftrightarrow
R_2(T_2)
\leftrightarrow
R_3(T_3)
\leftrightarrow
\cdots
\leftrightarrow
R_{12}(T_{12}).
]
 
The trajectories are therefore largely parallel, but the replicas occasionally communicate. This is exactly the sort of workload for which a massively parallel system such as Fugaku is useful: large computational kernels execute concurrently while high-speed interconnects handle the synchronization and exchange operations.
 
The researchers used GENESIS, a molecular-dynamics package designed for hybrid-parallel and multiscale biomolecular simulations. The software has specifically been developed for multiple computational platforms and enhanced-sampling algorithms.

The simulation did not simply produce a picture

The output from these trajectories was not a single molecular snapshot. It was an enormous statistical sample of molecular configurations. The researchers tracked the position of the neck helix and then applied principal-component analysis to reduce the dimensionality of the sampled conformational data. They subsequently applied k-means clustering. The resulting conformational ensemble separated primarily into two major clusters. Cluster 1 was sampled more frequently than cluster 2.
 
This is another important computational-science point. The supercomputer generates trajectories.
 
The scientists then need statistical and dimensionality-reduction methods to determine what those trajectories actually mean.
 
The workflow therefore becomes:
[
\text{MD}
\rightarrow
\text{sampling}
\rightarrow
\text{PCA}
\rightarrow
\text{clustering}
\rightarrow
\text{representative structures}.
]
 
The supercomputer is effectively converting an astronomical number of microscopic interactions into a manageable set of physically interpretable states.

The same answer survived two force fields

Perhaps the most reassuring result came from repeating the enhanced-sampling analysis with a second molecular-mechanics force field. The dominant conformation appeared under both AMBER ff99SB-ILDN and CHARMM36m. In that state, the neck helix was oriented approximately perpendicular to the long axis of the microtubule and positioned close to its surface. That cross-model consistency matters because molecular dynamics does not calculate "nature" directly. It calculates the behavior implied by a chosen force field. Different force fields encode different approximations of the underlying molecular interactions. If two independent parameterizations produce substantially different structural conclusions, confidence in the prediction falls. Here, the dominant structural state was reproduced.
 
There was, however, an important computational caveat.
 
The CHARMM simulation exhibited partial destabilization of the microtubule architecture during its 1-microsecond trajectory. The researchers therefore used the AMBER model for the subsequent walking simulations to preserve structural integrity.
 
That is precisely the kind of detail that is easy to lose in a conventional science story but important to computational scientists. The supercomputer did not magically eliminate model uncertainty. It exposed it.

Then Fugaku had to make the molecule walk

Finding the neck conformation was only the first computational challenge. The researchers next wanted to know whether that structure actually influenced kinesin's motion. This turned the calculation into a different kind of HPC workload. The complete kinesin walking cycle is computationally expensive and occurs on timescales that are difficult to reach through straightforward atomistic molecular dynamics. The researchers therefore focused on the initial stage of stepping, in which the rear kinesin head moves forward approximately half a step. They initially attempted 20 independent simulations, each lasting several hundred nanoseconds. But the result was a computational reality check.
 
The rear head did not spontaneously detach in any of those trajectories. The researchers concluded that the required detachment dynamics likely occurred on timescales beyond what was practical with their available computational resources.
 
So they changed the computational experiment.

Sometimes the fastest route through a supercomputer is to remove something

To make the stepping event observable, the researchers created a controlled local void beneath the rear kinesin head by removing the underlying tubulin subunit and neighboring subunits.
 
They also used an ADP-bound rear head, which has weaker microtubule affinity.
 
The artificial setup was designed to isolate the mechanical effect of strain transmitted through the neck linker.
 
This is a useful lesson for computational science.
 
The objective of a simulation is not always to reproduce every physical event exactly as it occurs in nature.
 
Sometimes the correct strategy is to construct a controlled computational experiment that isolates the physical mechanism being tested.
 
In this case, the researchers were not attempting to simulate an entire biological lifetime.
 
They were asking a narrower question: Given a particular neck conformation, what trajectory does the rear head prefer when it is allowed to step?

Twenty trajectories become the experiment

The team then ran 20 independent simulations starting from the dominant cluster-1 neck conformation.
 
In many trajectories, the rear head moved toward the microtubule plus end within approximately 100 nanoseconds.
 
The trajectories were not identical.
 
Some passed near the microtubule surface.
 
Others moved over the top.
 
A few even showed clockwise deviations.
 
But statistically, a clear directional tendency emerged: the rear head preferentially traveled around the right side of the front head, corresponding to counterclockwise stepping when viewed from above.
 
That is where the supercomputer's value becomes visible.
 
One trajectory could be an accident.
 
Twenty independent trajectories provide an ensemble from which a directional tendency can begin to emerge.

And then they removed the favorable neck conformation

The researchers performed another computational control experiment. They started 20 simulations from the alternative cluster-2 neck conformation. This structure folded back and interacted only weakly with the microtubule surface. The rear head failed to move forward in any of those trajectories. That comparison is powerful. It suggests that internal strain in the kinesin neck is not sufficient by itself. The neck also needs the appropriate physical interaction with the microtubule surface.
 
The supercomputer therefore helped turn an observational question into a mechanistic one:
[
\text{neck conformation}
+
\text{microtubule interaction}
\rightarrow
\text{stepping trajectory}.
]

What Fugaku actually contributed

It would be easy to describe this as another example of "a supercomputer simulating a protein."
 
That undersells what happened.
 
The computational challenge involved several layers:
 
Atomic scale
Approximately three million atoms were represented in the complete system.
 
Time scale
The molecular dynamics used a 3.5-femtosecond integration timestep.
 
Sampling problem
The neck region could occupy many conformations, requiring enhanced sampling.
 
Parallelism
Twelve replicas explored different effective solute-temperature states.
 
Model uncertainty
Two independent force fields were tested.
 
Statistical analysis
Principal-component analysis and clustering were used to identify dominant conformational states.
 
Ensemble dynamics
Twenty independent stepping trajectories were then used to investigate directional behavior.
 
This is not simply computational horsepower.
 
It is computational methodology built around the architecture of the supercomputer.

Fugaku is particularly interesting for molecular dynamics

Fugaku's architecture is well suited to workloads in which enormous numbers of arithmetic operations must be performed on large collections of interacting particles. Its A64FX processors use Armv8.2-A with 512-bit SVE vector processing, while each node provides high-bandwidth HBM2 memory. The system's network connects its nodes through Tofu Interconnect D.
 
For molecular dynamics, memory bandwidth and communication efficiency can be just as important as theoretical floating-point peak. A simulation repeatedly performs operations involving particle coordinates, velocities, forces, neighbor information and molecular interaction terms. The workload must therefore move data efficiently while maintaining the synchronization required by a distributed molecular system.
 
Fugaku provides approximately 1,024 GB/s of memory bandwidth per node, a feature RIKEN identifies as one of the system's characteristics. Its 158,976-node architecture provides a very large computational envelope for applications that can scale across the machine.
 
The researchers' use of GENESIS demonstrates how such a system can be converted from raw compute capacity into a scientific instrument.

The surprising part: the supercomputer did not replace the experiment

The simulation did something experiments could not easily do. It exposed a possible atomic-level mechanism for the steering behavior. But the researchers are careful about the limitations. The model used a truncated kinesin construct. The stepping calculation artificially removed microtubule subunits to trigger detachment. And the model omitted flexible E-hooks, disordered, negatively charged C-terminal regions of tubulin that can influence the molecular environment around the microtubule surface. The authors therefore do not present the simulation as the final word on kinesin's complete walking cycle.
 
In fact, the full walking cycle remains computationally difficult. That may be one of the most revealing conclusions of the study. Even with a machine capable of hundreds of petaflops, a three-million-atom model and sophisticated enhanced sampling, the complete biological process remains difficult to reproduce atom by atom over its full timescale.
 
The problem is not simply that today's computers are too slow.
 
It is that biological systems contain multiple interacting spatial and temporal scales.

From atoms to supercomputing

A kinesin motor operates at nanometer scales. Its structural components are only a few dozen amino acids long. Yet understanding the motor requires calculations involving millions of atoms and trajectories extending across hundreds of nanoseconds or microseconds. That mismatch between tiny physical objects and enormous computational requirements is precisely why molecular science has become a major HPC application.
 
The research also illustrates why future advances in molecular simulation will depend on more than faster processors.
 
They will require:
  • better force fields,
  • more efficient molecular-dynamics kernels,
  • improved sampling algorithms,
  • higher-bandwidth memory,
  • faster interconnects,
  • larger parallel ensembles,
  • better statistical analysis,
  • and ultimately multiscale methods that connect atomistic simulations to much longer biological timescales.
The supercomputer becomes the platform on which all of those methods interact.

The next question is much harder

The researchers have established a compelling computational mechanism for the initial directional bias of kinesin stepping.
 
But the obvious next question is almost painfully simple: Can Fugaku, or its successors, simulate the whole walk?
 
That means restoring the missing molecular components, eliminating the artificial detachment mechanism, including flexible microtubule E-hooks, and extending the trajectories far enough to capture the full nucleotide-dependent stepping cycle. The computational cost rises rapidly. The current study already found that spontaneous detachment was not observed in 20 several-hundred-nanosecond trajectories. A complete walking cycle could therefore require vastly more sampling, more sophisticated enhanced-sampling methods, or a combination of simulation approaches.
 
And that is where the story gets particularly interesting for HPC.
 
The next breakthrough may not come from simply running the same simulation on a larger machine. It may come from changing how the simulation searches molecular state space.

A supercomputer becomes a microscope

There is something almost poetic about the result. Researchers were trying to see something too small and too dynamic for conventional structural techniques to resolve completely. So they built it computationally. They gave the molecular system millions of atoms. They gave it physical interactions. They gave it temperature. They gave it time. Then they asked Fugaku to follow what happened.
 
The result was not merely a prettier molecular picture. It was a proposed mechanical explanation for how kinesin biases its next step. The researchers' simulations indicate that the neck region forms a coiled-coil structure positioned close to the microtubule surface, and that this interaction helps steer the rear motor head around the right side of the leading head. For a molecular biologist, that is a new piece of the kinesin mechanism. For an HPC engineer, it is something else: a demonstration of how a petascale supercomputer can turn an experimentally inaccessible molecular timescale into a computationally explorable one.
 
And perhaps that is the most curious part of all.
 
Fugaku did not merely calculate where a molecular motor was.
 
It helped reveal why the motor chooses where to go next.
10,000 AI agents, 130 billion tokens and 88 hours: How OpenAI turned Navier–Stokes into a supercomputing workload
Featured

10,000 AI agents, 130 billion tokens and 88 hours: How OpenAI turned Navier–Stokes into a supercomputing workload

For nearly a century, the Navier–Stokes equations have stood as one of mathematics’ most formidable unresolved challenges. Now OpenAI says an internal artificial intelligence system has produced an analytical proof showing that the three-dimensional incompressible Navier–Stokes equations can develop a singularity in finite time, a result that would resolve one of the seven Millennium Prize Problems.

But for the supercomputing community, the most important part of the announcement may not be the mathematics itself. It is how the mathematics was discovered.

OpenAI says it attacked the problem with a coordinated system of about 10,000 concurrent AI agents, generating about 2.7 million inter-agent messages and about 130 billion output tokens during the Navier–Stokes effort. The agents reached their resolution approximately 88 hours after the project began, followed by another 17 hours of Lean formalization and verification using GPT-6 Astra.

The result represents something potentially more consequential for scientific computing than a single mathematical proof: a demonstration of what happens when reasoning itself becomes a massively parallel workload.

The problem is not writing down Navier–Stokes

The Navier–Stokes equations describe fluid motion by applying Newtonian mechanics to a continuous fluid.

For an incompressible fluid with constant density, a commonly used form is

[
\frac{\partial \mathbf{u}}{\partial t}
+
(\mathbf{u}\cdot\nabla)\mathbf{u}

-\frac{1}{\rho}\nabla p
+
\nu\nabla^2\mathbf{u}
+
\mathbf{f},
]

with

[
\nabla\cdot\mathbf{u}=0.
]

Here, (\mathbf{u}) is the velocity field, (p) is pressure, (\rho) is density, (\nu) is kinematic viscosity and (\mathbf{f}) represents external forcing.

The equation is deceptively compact.

The difficulty is the nonlinear advection term,

[
(\mathbf{u}\cdot\nabla)\mathbf{u},
]

which allows the velocity field to interact with its own gradients. At the same time, viscosity represented by

[
\nu\nabla^2\mathbf{u}
]

acts to smooth the flow.

The Millennium Prize question is whether a smooth three-dimensional solution that begins from smooth initial conditions must remain smooth for all time, or whether the velocity can become unbounded in finite time.

That is the central tension: nonlinear amplification versus viscous dissipation.

OpenAI’s proposed construction involves a vortex that spirals inward and becomes increasingly elongated. As the central region contracts, the fluid velocity increases without bound while the total energy remains finite. 

That distinction is critical.

A trivial way to make velocity blow up would be to simply inject an infinite force into the system. The actual mathematical challenge is to produce the singularity from the dynamics of the Navier–Stokes equations themselves while maintaining a smooth external force.

OpenAI says its solution achieves that by arranging for the acceleration, pressure gradient, momentum transfer and viscous terms to become large while canceling one another with sufficient precision to leave a smooth forcing function even as the velocity diverges. 

The breakthrough was not one AI thinking really hard

The conventional mental model of an AI solving a difficult mathematical problem is straightforward:

Question → giant model → answer.

That is not what OpenAI describes.

Instead, the company constructed a multi-agent computational system.

The agents were powered by an internal model that OpenAI says was significantly more capable than GPT-6 Astra. They could execute code, access a cached version of the internet and communicate within groups. The groups were deliberately varied in size and approach. 

For Navier–Stokes, approximately 10,000 agents were running concurrently.

That changes the computational problem completely.

Rather than asking one model to explore a gigantic mathematical search space sequentially, OpenAI effectively created thousands of simultaneous research trajectories.

One agent could investigate a vortex construction.

Another could attack its regularity assumptions.

Another could search for an energy estimate.

Another could attempt a contradiction.

Another could investigate scaling.

Another could test whether a proposed lemma actually followed from the equations.

Another could attempt to formalize an argument.

Most of those paths could fail.

That was acceptable.

The objective was not to make every worker succeed. The objective was to make the aggregate search process succeed.

Mathematics becomes a parallel workload

This is where the OpenAI experiment starts looking surprisingly familiar to HPC engineers.

A conventional supercomputer takes a large computational problem and decomposes it into many pieces.

A computational fluid dynamics application might divide a three-dimensional domain across thousands of processors. Each process works on its local portion of the numerical domain and periodically exchanges information with neighboring processes.

The OpenAI system performed a different kind of decomposition.

It did not divide the physical fluid domain.

It divided the space of possible mathematical arguments.

Instead of exchanging pressure and velocity values, the agents exchanged mathematical information:

  • conjectures,
  • lemmas,
  • proof fragments,
  • counterexamples,
  • constructions,
  • failed approaches,
  • transformations,
  • estimates,
  • and refinements.

In that sense, OpenAI’s experiment can be viewed as a primitive form of distributed reasoning architecture.

The computational domain was not physical space.

It was proof space.

The Euler equations provided the first foothold

The system did not immediately throw all available resources at the full Navier–Stokes problem.

OpenAI also gave the agents easier related problems.

One was the regularity problem for the Euler equations, obtained by removing the viscosity term from Navier–Stokes.

The Euler equations can be written schematically as

[
\frac{\partial\mathbf{u}}{\partial t}
+
(\mathbf{u}\cdot\nabla)\mathbf{u}

-\frac{1}{\rho}\nabla p.
]

The missing viscous term makes the problem different, and in some respects more tractable.

Nearly 100 agents worked on the unforced Euler regularity problem for approximately 50 hours and produced what OpenAI describes as a disproof. 

That result became strategically important.

Once the Euler result appeared, OpenAI redirected resources toward Navier–Stokes and supplied the agents with the Euler resolution as an input to their subsequent reasoning. 

This is analogous to a common HPC and numerical-science strategy:

solve a reduced problem → identify structure → use that structure to attack the full problem.

The AI system was not simply generating random mathematical guesses.

It was accumulating computationally discovered structure.

Diversity was an engineering feature

OpenAI says it deliberately encouraged different agent groups to pursue diverse approaches.

That matters because thousands of identical agents would not necessarily provide thousands of times the intellectual coverage.

If 10,000 agents all follow the same reasoning path, the system can simply produce 10,000 copies of the same failure.

Diversity increases the probability that some workers will escape local minima in the mathematical search space.

The system therefore used different formulations of the Millennium problem.

Groups were given versions labeled A and B, where establishing the relevant proposition would constitute a proof, while other groups were given C and D, where the objective was to establish a disproof. 

That effectively created competing computational hypotheses.

The architecture resembles an ensemble search:

[
H_1,H_2,H_3,\ldots,H_N
]

where each (H_i) represents a different mathematical route.

The system does not know in advance which route will work.

It explores many.

Then the system started cross-pollinating ideas

One of the most interesting details in OpenAI’s description is the use of Codex to consolidate useful intermediate results from different groups.

This created a feedback loop.

The workflow was approximately:

parallel exploration

↓

partial mathematical discoveries

↓

consolidation

↓

new prompts informed by those discoveries

↓

another round of parallel exploration

↓

candidate proof

The importance of that architecture cannot be overstated.

Without information sharing, the 10,000 agents would largely be independent researchers.

With controlled information sharing, the system becomes an evolving computational network.

A discovery made by one group can become the starting point for thousands of other investigations.

That is conceptually similar to iterative distributed optimization, except the object being optimized is not a numerical objective function.

It is a mathematical argument.

2.7 million messages are part of the computation

During the Navier–Stokes effort, OpenAI reports that its agents exchanged approximately 2.7 million messages and generated approximately 130 billion output tokens. 

Those numbers illustrate why this should not be thought of as a conventional chatbot interaction.

The system was effectively operating a large-scale computational workload in which language became the medium for transmitting mathematical state.

A conventional HPC application might communicate something like:

[
u_{i,j,k}^{(t)}
]

between processes.

The AI system instead communicates things closer to:

This estimate fails under this scaling assumption.

or:

This transformation preserves incompressibility.

or:

This construction causes the energy integral to diverge.

or:

This lemma closes the remaining regularity gap.

The payload is semantic rather than numerical.

That creates a fascinating new category of distributed computing.

130 billion tokens are not 130 billion FLOPS

There is an important distinction for HPC readers.

OpenAI’s 130-billion-token figure should not be interpreted as 130 billion floating-point operations.

A token is an output unit generated by a language model.

The underlying computation includes neural-network matrix operations, memory movement, accelerator utilization, synchronization, networking, and orchestration overhead.

OpenAI has not publicly disclosed enough information in this announcement to calculate a reliable FLOPS count, accelerator count, GPU-hour total or energy consumption for the Navier–Stokes run.

That means comparisons with traditional supercomputers based purely on the token figure would be speculative.

But the token count is still useful because it establishes the scale of the reasoning workload.

Approximately 130 billion generated tokens were used in exploring the mathematical problem.

The significant point is that scientific reasoning itself became compute-intensive.

The real accelerator was concurrency

The 88-hour figure is impressive, but it needs context.

OpenAI did not compress approximately 90 years of mathematical history into 88 hours by making a single AI think 90 years faster.

It changed the topology of the work.

Traditional mathematical research is heavily sequential:

[
\text{idea}
\rightarrow
\text{proof attempt}
\rightarrow
\text{failure}
\rightarrow
\text{new idea}
\rightarrow
\text{proof attempt}.
]

The OpenAI system can execute thousands of these loops simultaneously:

[
\begin{array}{cccc}
A_1 & A_2 & A_3 & \cdots A_{10,000}\
\downarrow & \downarrow & \downarrow & \
P_1 & P_2 & P_3 & \cdots P_{10,000}
\end{array}
]

where each (A_i) represents an agent and (P_i) its current mathematical search path.

The overwhelming majority can fail.

The system only needs some fraction to generate useful information.

This is exactly the kind of strategy that has driven scientific computing for decades:

replace a long serial computation with a much larger parallel computation.

The difference is that the computational units are now AI researchers rather than conventional numerical kernels.

The vortex is the mathematical payoff

The final construction is particularly interesting from a computational-fluid-dynamics perspective.

OpenAI describes the solution as a vortex that spirals inward while becoming increasingly elongated.

The central region contracts.

Its rotational speed increases.

Its geometry stretches.

Yet its total energy remains finite.

That creates the critical singular behavior:

[
|\mathbf{u}| \rightarrow \infty
]

as

[
t\rightarrow T^-,
]

where (T) is a finite time.

The remarkable aspect is that the divergence occurs while the overall energy remains finite.

This is where the nonlinear terms become decisive.

The velocity field is simultaneously producing stronger gradients and stronger nonlinear transport while viscosity attempts to dissipate those gradients.

The proposed solution requires these competing contributions to become large but cancel with extraordinary precision.

OpenAI describes the resulting flow as a central vortex whose shrinking and acceleration produce the finite-time singularity while maintaining finite energy. 

For numerical scientists, this is precisely the kind of regime in which straightforward simulation becomes extraordinarily difficult.

The relevant scales can separate dramatically, gradients become increasingly sharp, and numerical resolution requirements can become prohibitive.

The proof therefore matters not because a supercomputer can simply simulate the singularity.

It matters because the mathematical construction establishes what the equations themselves permit.

From probabilistic AI to deterministic proof checking

There is another layer that may ultimately prove even more important.

Large language models are probabilistic systems.

They can generate highly plausible mathematical statements that are wrong.

OpenAI therefore used a second stage: formal verification in Lean.

The agents produced an analytical proof.

That proof was then formalized and verified using Lean, with GPT-6 Astra completing the formalization and verification in approximately 17 additional hours.

The architecture can therefore be thought of as:

AI discovery

→

candidate mathematical proof

→

formalization

→

machine-checked proof

That is a powerful division of labor.

The AI is the heuristic search engine.

The formal proof system is the correctness gate.

The first stage explores an enormous space of possible arguments.

The second stage rejects arguments that do not satisfy the formal rules.

For scientific computing, that distinction is enormously important.

This could be a new model for scientific computing

Traditional HPC has generally focused on accelerating numerical computation.

The emerging AI-HPC model may instead accelerate scientific workflows.

Consider a future research system:

AI agents

generate hypotheses.

HPC simulation

tests them.

AI agents

analyze the simulation output.

Formal mathematics

checks theoretical claims.

HPC

runs higher-resolution simulations based on the surviving hypotheses.

AI agents

repeat the cycle.

That creates a closed computational loop:

[
\text{Hypothesis}
\rightarrow
\text{Simulation}
\rightarrow
\text{Analysis}
\rightarrow
\text{Theory}
\rightarrow
\text{Verification}
\rightarrow
\text{New Hypothesis}.

]

The OpenAI Navier–Stokes effort represents an early example of one portion of that loop becoming massively parallel.

Supercomputers may increasingly compute ideas, not just numbers

This may ultimately be the biggest takeaway.

For decades, the performance race in HPC has been measured in FLOPS.

Scientific applications have been optimized around vectorization, parallel decomposition, memory bandwidth, interconnect latency and accelerator utilization.

AI introduces another resource:

reasoning throughput.

A future scientific supercomputer may therefore contain conventional CPU/GPU resources alongside enormous fleets of inference accelerators running thousands, or potentially millions, of autonomous scientific agents.

The computational workload would not simply be:

Calculate 10 trillion pressure values.

It could be:

Explore 100 million possible mathematical explanations for why this simulation behaves this way.

That is a fundamentally different conception of supercomputing.

The caveat: a proof announcement is not the end of mathematical review

There is an important distinction between OpenAI producing and formally checking a proof and the broader mathematical community accepting the result as the definitive resolution of a Millennium Prize Problem.

OpenAI says it is releasing an analytical proof together with a Lean formalization, but also explicitly says it does not intend to claim the $1 million Millennium Prize. 

That restraint is significant.

The result will require scrutiny by mathematicians who were not involved in the system, including examination of the assumptions, construction, formalization and relationship between the formal proof and the official Clay Mathematics Institute formulation.

OpenAI also acknowledges concurrent work by Levent Alpöge and NYU mathematician Tristan Buckmaster, although it says their work concerned the forced Euler problem and differed substantially from OpenAI’s result. 

So the appropriate description at this stage is an AI-generated proposed resolution backed by a formal Lean verification, rather than declaring that mathematical history has already closed the book.

The bigger race is now computational

The Navier–Stokes announcement may ultimately be remembered for the mathematical breakthrough, but the supercomputing industry should focus on the underlying methodology. OpenAI demonstrated a system where 10,000 autonomous AI agents simultaneously navigated a complex scientific landscape, exchanging intermediate findings, consolidating successful approaches, and producing a verifiable solution in just 88 hours. 

With 130 billion output tokens and 2.7 million inter-agent messages, this workflow represents a fundamental shift: we are moving from chatbots to distributed scientific-computing workloads. The computational unit is no longer limited to threads, processes, or GPU kernels; it now encompasses autonomous reasoning agents, while the communication fabric now transmits semantic mathematical insights rather than just floating-point arrays. 

This experiment signals a new era of high-performance computing. If AI can reliably decompose scientific challenges, iterate through competing hypotheses, and leverage formal verification, the next generation of supercomputers will do more than simulate the physical world; they will accelerate our ability to reason about it. Ultimately, the benchmark of the future may not be how many calculations a machine can perform per second, but how many scientifically meaningful ideas it can explore and synthesize before the next deadline.