AlphaEvolve mit Gemini entdeckt Vorhersageansatz fuer Mehrfach-Katastrophen

📄 Published Paper (Open Access on Zenodo): Autonomous Discovery of Unified Multi-Hazard Prediction Theory from Netatmo IoT Weather Big Data Using AlphaEvolve 🔗 Full Paper URL: https://zenodo.org/records/23354598 💻 Sample Scripts Repository (GitHub): https://github.com/tanaikech/alphaevolve-multi-hazard

"The book of nature is written in the language of mathematics." — Galileo Galilei Today, that mathematical language can be autonomously written as an algorithm, assembled into a predictive model, and elevated into a physical theory by artificial intelligence.

Imagine sitting in a quiet office in downtown Tokyo or suburban Osaka on a hot, muggy summer afternoon. Outside, the sky appears calm. Within thirty minutes, however, the atmosphere darkens into pitch-black fury. A violent "guerrilla rainstorm"—an extreme localized convective cloudburst—dumps 80 millimeters of torrential rain in under an hour. Underground subway entrances are inundated, calm residential roads turn into raging rivers, and vehicles are trapped beneath flooded railway underpasses.

Or imagine an inland geological fault kilometers beneath our feet, quietly accumulating mechanical shear stress over decades. Without warning, the fault ruptures in an instant, generating devastating seismic shaking that levels homes before anyone can take cover.

Natural disasters—extreme convective downpours, deadly inland earthquakes, and explosive volcanic eruptions—are among the most formidable threats confronting human civilization. Every year, they claim thousands of lives and inflict hundreds of billions of dollars in economic devastation. Providing accurate, early warning for these events is one of the highest callings of modern applied science. Yet, it has long remained one of the most stubborn, mathematically vexing frontiers in geophysics.

For decades, the standard approach in atmospheric and Earth sciences has relied upon sparse, high-cost governmental observation networks. In Japan, for example, the official meteorological radar network and the automated surface station network (AMeDAS) operate with an average spacing of roughly 17 kilometers.

While 17 kilometers is well-suited for broad weather forecasting (such as tracking a 1,000-kilometer typhoon moving across the Pacific), it leaves vast spatial blind spots for micro-scale phenomena:

For years, I asked myself a question that kept me awake at night: What if the signals of nature’s impending fury are not absent, but simply hidden in plain sight—whispering across thousands of micro-sensors mounted on citizen balconies? And what if, instead of humans manually guessing thresholds, an AI could autonomously write the mathematical algorithms needed to build a predictive model and establish a unified physical theory?

In traditional science and engineering, building a disaster prediction theory requires a painstaking manual chain:

When humans do this by hand across multiple hazards, cognitive bias and mathematical complexity get in the way. Conversely, if you use a standard Deep Neural Network (DNN), the AI builds a "black-box" model of millions of inscrutable weights—meaning it cannot give you a transparent algorithm, nor can it build a human-readable physical theory.

In my latest research paper, "Autonomous Discovery of Unified Multi-Hazard Prediction Theory from Netatmo IoT Weather Big Data Using AlphaEvolve", now published on Zenodo ( https://zenodo.org/records/23354598 ) alongside our open-source sample scripts on GitHub ( https://github.com/tanaikech/alphaevolve-multi-hazard ), I demonstrated a third path using Google DeepMind’s AlphaEvolve and Gemini 3.8 Flash:

In this article, I will walk you through the physics of citizen weather data, how AlphaEvolve works, how to use AlphaEvolve in practice, how we fed 175,363 real disaster observations into AlphaEvolve, and the physical laws the AI discovered on its own.

To ordinary citizens, a personal weather station mounted on an apartment balcony is just a gadget that tells them if they need an umbrella. To a geophysicist, however, it is an ultra-sensitive, high-frequency stethoscope pressed against the living skin of planet Earth.

Over the past decade, crowdsourced Internet of Things (IoT) weather networks—most notably the global Netatmo Personal Weather Station (PWS) ecosystem—have quietly revolutionized observational geography. Unlike sparse governmental towers, hundreds of thousands of citizen-owned Netatmo stations blanket dense urban centers. In metropolitan Tokyo and Kansai, the average distance between stations shrinks from 17 kilometers down to just 1 to 2 kilometers, continuously logging barometric pressure, ambient temperature, relative humidity, and wind gusts every few minutes.

Figure 1 | How Balcony Weather IoT Decodes Natural Disasters. The Micro-Atmospheric Stethoscope: Resolving extreme hazards invisible to sparse governmental radars across three physical domains.

As illustrated in Figure 1, crowdsourced IoT weather networks can capture physical precursors across three wildly different geophysical domains because the Earth's lithosphere, surface, and atmosphere are fundamentally coupled:

The data was there. The physics was there. But writing the exact mathematical algorithms to combine all of this into a unified predictive model—and a unified theory—without false alarms was where human craftsmanship hit a wall.

Before turning to autonomous AI, I spent years tackling these hazards through manual theoretical physics and empirical derivation across four separate papers [6, 7, 8, 9].

Figure 2 | Research Objective, Historical Context, and Autonomous Inquiry Framework. Tracing the evolution from my four isolated manual frameworks (left) to closed-loop AI algorithm creation with AlphaEvolve and Gemini 3.8 Flash (center), culminating in a unified predictive model and physical laws (right).

Figure 2 visualizes why manual model building struggled and why autonomous algorithm generation was needed:

When you try to manually write algorithms to combine four separate physical models on live atmospheric data, chaos ensues:

The human mind, constrained by cognitive biases and habit, tends to write simple linear thresholds ( if x > 5.0 ). We struggle to invent the higher-dimensional, non-linear mathematical functions that cleanly separate all three hazards simultaneously. I needed an AI system that could autonomously create the algorithms to build the model for me.

In 2024, Google DeepMind published FunSearch, demonstrating that large language models paired with evolutionary program search could discover new mathematical theorems and combinatorial algorithms beyond the reach of human mathematicians.

Building upon this philosophy, Google DeepMind introduced AlphaEvolve —an evolutionary coding agent powered by Gemini that autonomously writes, mutates, tests, and refines complex algorithmic codebases.

Figure 3 | AlphaEvolve Architecture, Mechanism, and Application Domains. Left: The 4-station cyclic engine: Seed population, Gemini 3.8 Flash AST mutator, 3-tier defensive evaluation gauntlet, and Pareto archive. Right: Core scientific use cases, quantitative benchmark comparison against deep neural networks, and anti-reward hacking forensics.

A common question from developers is: Why use AlphaEvolve to write Python algorithms when you could just train a Deep Neural Network (such as an LSTM or Transformer) on the sensor data?

As shown in the benchmark comparison on the right side of Figure 3, the distinction is fundamental to scientific theory building:

Figure 4 | Inside the AI Discovery Engine: From Raw Code to Universal Equations. Tracing how AlphaEvolve replaces fragile human heuristics (Column 1) via Gemini 3.8 Flash AST refactoring and the -5,000 point Popperian falsification crucible (Column 2) to autonomously synthesize the multi-hazard predictive model and physical laws (Column 3).

Figure 4 illustrates the internal mechanics of how AlphaEvolve autonomously constructs the disaster prediction algorithm:

How do you actually set up and run AlphaEvolve so that it autonomously creates algorithms to build a scientific model? Even if you have never used evolutionary code search before, the workflow boils down to three clean architectural steps.

Figure 5 | How to Use AlphaEvolve: Autonomous Algorithm Creation Workflow. Column 1: Defining the Python seed skeleton with # EVOLVE-BLOCK markers. Column 2: Running the closed-loop cycle between the deterministic evaluator harness and the Gemini 3.8 Flash semantic mutator. Column 3: The 3-level autonomous elevation from AI-generated algorithm to predictive model to unified physical theory.

As illustrated in Figure 5, using AlphaEvolve requires setting up two files—a Seed Skeleton and an Evaluator Harness —and then letting the Gemini Closed-Loop Engine do the heavy lifting:

To use AlphaEvolve, you do not ask the LLM to write an entire software application from scratch. Instead, you write a standard Python skeleton where the outer infrastructure (imports, data types, and function signatures) is locked, and the core mathematical algorithm you want the AI to discover is enclosed inside # EVOLVE-BLOCK START and # EVOLVE-BLOCK END comments:

import numpy as np # Locked outside the evolve block # >>>>>>>>>>>>>>>>>>>>>>>> # EVOLVE-BLOCK START <<<<<<<<<<<<<<<<<<<<<<<<<<<< def compute_rain_convective_score ( theta_e_k: float, dtheta_e_dt_k_h: float, pressure_drop_10min_hpa: float, gust_ratio: float ) -> float: """ AlphaEvolve will autonomously rewrite the math inside this function! """ z = ( - 0.15 * dtheta_e_dt_k_h ) + ( 1.2 * pressure_drop_10min_hpa ) + ( 0.8 * ( gust_ratio - 1.0 )) if theta_e_k > 340.0: z += 1.5 return float ( 1.0 / ( 1.0 + np. exp ( - np. clip ( z, - 10.0, 10.0 )))) def evaluate_laic_and_gate ( delta_theta_e_k: float, lpar: float, dp_dt_abs_hpa_h: float, regional_std_k: float ) -> bool: """ AlphaEvolve will autonomously discover how to reject storm false alarms! """ return bool ( delta_theta_e_k >= 8.0 and lpar >= 2.5 ) #... (additional hazard functions and dispatcher)... # >>>>>>>>>>>>>>>>>>>>>>>>> # EVOLVE-BLOCK END <<<<<<<<<<<<<<<<<<<<<<<<<<<<< Enter fullscreen mode Exit fullscreen mode As highlighted in the bottom card of Figure 5 (Column 1), the developer's only job in Step 1 is to specify the input arguments (the physical observables) and the output return format.

You do not need to know the optimal mathematical formula or threshold weights—AlphaEvolve will invent those autonomously.

Next, you write an evaluator class ( evaluator.evaluate(code_str) ) that takes a candidate Python string generated by Gemini, executes it against your dataset, and returns two things:

Look at the cycle diagram in the center of Figure 5 (Column 2). Unlike traditional genetic algorithms that mutate code blindly at random, AlphaEvolve feeds both the parent's EVOLVE-BLOCK code and these diagnostic failure insights into Gemini 3.8 Flash via the Google GenAI SDK ( google-genai ). Gemini reads the diagnostics, reasons like a physicist about why the equation failed, and rewrites the Python AST to fix the flaw in the next generation!

To launch the entire evolutionary campaign from your terminal, you simply set your Gemini API key and run the campaign script:

export GEMINI_API_KEY = "your_api_key_here" python3 scripts/04_run_alpha_evolve_campaign.py --model gemini-3.8-flash --generations 100 Enter fullscreen mode Exit fullscreen mode Step 3: The 3-Level Autonomous Elevation — Algorithm to Model to Theory (Figure 5, Column 3) Column 3 of Figure 5 illustrates why this paradigm is so transformative for science. As AlphaEvolve iterates through generations, it autonomously completes a three-level hierarchy:

A critical question for any developer or data scientist is: How do you take messy, real-world IoT sensor logs from 21 historical disasters and format them so AlphaEvolve can test thousands of algorithms in milliseconds without the AI cheating?

If you ask an evolutionary AI to read raw CSV files or compute Fast Fourier Transforms (FFTs) from scratch on 175,363 rows during every single generation, each evaluation would take several minutes—and worse, a clever AI might try to "reward hack" by peeking at file timestamps or overwriting the data arrays in memory.

To solve this, I engineered a five-script empirical pipeline (publicly available in our sample repository at https://github.com/tanaikech/alphaevolve-multi-hazard ) that prepares, authenticates, pre-computes, and locks the experimental data before handing it to AlphaEvolve.

Figure 6 | How Experimental Disaster Big Data Is Fed Into AlphaEvolve. The 5-Script Empirical Pipeline: Transforming 175,363 raw Netatmo IoT observations into hardware-authenticated, read-only NumPy feature tensors ( flags.writeable = False ) for sub-millisecond evaluation across the 3-Tier Defensive Evaluator Harness.

Figure 6 maps out the exact software engineering pipeline used in our study to bridge raw citizen weather data with AlphaEvolve:

First, 01_fetch_multi_hazard_data.py extracts 175,363 crowdsourced Netatmo observations across 23 distinct empirical catalogs:

To guarantee 100% authentic empirical data (Zero Dummy Data Policy), this script verifies that every station's hardware MAC address begins with the official Netatmo IEEE OUI prefix ( 70:ee:50 ), filters out indoor sensor anomalies, and seals every CSV catalog with a cryptographic SHA-256 hash inside data_manifest.json.

Next, 02_immutable_physics_core.py transforms the raw meteorological readings (temperature in Celsius, relative humidity in percent, sea-level pressure in hectopascals, and wind speed in meters per second) into standardized first-principles physical feature matrices for each hazard category:

The Crucial Engineering Trick (Figure 6, Column 1 Bottom Badge): Once 02_immutable_physics_core.py computes these NumPy feature tensors, it locks their memory buffers as strictly read-only before caching them to disk ( temp/processed_cache/*.pkl ):

# Lock NumPy tensor memory buffer so evolved AI code can NEVER modify empirical data feature_matrix. flags. writeable = False Enter fullscreen mode Exit fullscreen mode This single architectural decision accomplishes two vital goals:

As shown in Column 2 of Figure 6, 03_alpha_evolve_dispatcher_evaluator.py loads the 23 read-only feature tensors into memory and tests every AI-generated candidate across three strict defensive tiers:

Finally, as shown in Column 3 of Figure 6:

Figure 7 | The 4-Stage Experimental Methodology and Closed-Loop Research Pipeline. Visualizing the complete scientific workflow from IEEE OUI hardware-authenticated data ingestion (Stage 1), multi-generation AST optimization (Stage 2), continuum theory elevation (Stage 3), to independent deterministic verification (Stage 4).

Figure 7 summarizes how our five-script software pipeline maps directly onto the four macro-stages of autonomous scientific discovery:

At Generation 68, the champion Python algorithm autonomously created by AlphaEvolve and Gemini 3.8 Flash emerged not as bloated spaghetti code, but as twelve lines of transparent mathematical harmony:

# ========================================================================= # CHAMPION PYTHON ALGORITHM AUTONOMOUSLY CREATED BY ALPHAEVOLVE (GEN 68) # # Input telemetry schema (from pre-cached read-only feature tensors): # dtheta_e_dt: Equivalent potential temp time derivative [K/h] # dp_10min: 10-minute micro-barometric surge [hPa/10min] # gust_ratio: Peak gust ratio u_gust / u_mean [-] # theta_e: Ambient surface equivalent potential temp [K] # dp_dt_hpa_h: Hourly barometric pressure derivative [hPa/h] # delta_theta_e: Thermal anomaly relative to background [K] # c_app: Apparent wave propagation speed [m/s] # semblance: Normalized multi-channel coherence semblance [-] # ========================================================================= # 1. Continuous Logistic Torrential Rain Kernel z = ( 0.35 * max ( 0.0, - dtheta_e_dt ) + 1.50 * max ( 0.0, dp_10min ) + 1.20 * max ( 0.0, gust_ratio - 1.0 ) - 1.5 + 1.50 * ( 1.0 if theta_e >= 350.0 else 0.0 )) rain_score = 1.0 / ( 1.0 + np. exp ( - np. clip ( z, - 10.0, 10.0 ))) # 2. Dynamic Isobaric Pre-Seismic (Earthquake) Gate isobaric_stable = abs ( dp_dt_hpa_h ) <= 2.0 thermal_floor = theta_e >= 332.0 eq_gate_open = isobaric_stable and thermal_floor eq_score = min ( 1.0, delta_theta_e / 50.0 ) # 3.

Multi-Hazard Kinematic Priority Dispatcher if 300.0 <= c_app <= 330.0 and semblance >= 0.80: return { ' alert ': ' VOLCANO_LAMB_WAVE ', ' conf ': semblance } elif rain_score >= 0.70: return { ' alert ': ' CONVECTIVE_TORRENTIAL_RAIN ', ' conf ': rain_score } elif eq_gate_open and delta_theta_e >= 30.0: return { ' alert ': ' EARTHQUAKE_LAIC_PRECURSOR ', ' conf ': eq_score } return { ' alert ': ' NORMAL_ATMOSPHERE ', ' conf ': 0.0 } Enter fullscreen mode Exit fullscreen mode

Figure 8 | Discovered Symbolic Algorithm and Elevated Unified Geophysical Theory. Part A (Left): The champion Python algorithm autonomously synthesized by AlphaEvolve. Theory Elevation Bridge (Center): Deductive mathematical translation of the AI's predictive model into continuum field equations. Part B (Right): The three formulated universal physical laws: Continuous Enthalpy Potential Theory, Kinematic-Barometric Orthogonality, and Emergent Dynamic Semblance Inversion.

Look closely at the three-part progression in Figure 8. Because AlphaEvolve autonomously wrote explicit symbolic Python rules (Figure 8, Part A) to construct our multi-hazard predictive model, we can pass those rules across the Theory Elevation Bridge (Figure 8, Center) to formulate a unified geophysical theory consisting of four continuum principles (Figure 8, Part B):

In my earlier manual work, I used rigid step-function thresholds that failed when humid maritime air masses triggered downpours without a sharp initial temperature cliff. AlphaEvolve autonomously discarded step functions and constructed a continuous logistic manifold. The probability of convective initiation is modeled by a smooth logistic sigmoid function taking the weighted sum of three physical terms:

Crucially, the AI discovered on its own that this potential energy barrier should equal 1.5 under normal conditions, but drop by 1.5 down to zero whenever ambient equivalent potential temperature reaches or exceeds 350.0 Kelvin. Physically, when the urban boundary layer is already saturated with extreme moist static energy (350 Kelvin or higher), the activation energy required to trigger convective collapse vanishes! This allowed the model to sense impending downbursts during the pre-condensation phase, long before raindrops form aloft.

To eliminate the 6.8% storm false-alarm rate that plagued my earlier earthquake precursor model, AlphaEvolve autonomously discovered a Kinematic-Barometric Orthogonality Gate. Before a spatial thermal anomaly (delta theta_e of 30 Kelvin or greater) is allowed to trigger an earthquake alert, the algorithm enforces two simultaneous physical gates:

For explosive volcanic eruptions, the AI synthesized a joint acoustic filter requiring apparent horizontal propagation speeds between 300.0 and 330.0 meters per second alongside multi-channel array semblance coherence of at least 0.80. Because tropospheric Lamb waves propagate at the speed of sound (approximately 310 meters per second), true volcanic shockwaves interfere constructively across hundreds of balcony barometers, while local wind gusts cancel out asymptotically.

Finally, how did the AI's algorithm prevent alert collisions when multiple signals occur at once? Look at lines 191 to 197 of the discovered code: AlphaEvolve autonomously ordered the if / elif dispatch hierarchy strictly by physical wave propagation velocity:

Without being taught geophysical wave mechanics, AlphaEvolve discovered that sorting hazards by propagation speed completely eliminates cross-hazard interference!

A scientific theory is only as good as its empirical predictions. Using 05_predict_multi_hazard.py, we tested the predictive model built by AlphaEvolve's champion algorithm across all 23 historical catalogs (175,363 authentic Netatmo observations).

Figure 9 | Early Warning Paradigm Shift: Performance & Timeline Scorecard. Column 1: Timeline comparison for the 2017 Nerima downpour showing a 34.2-minute lead time (+84.9% longer than manual models). Column 2: Quantitative performance scorecard across all 21 historical disasters (100% sensitivity). Column 3: Control baseline verification confirming 0.0% false alarms and cryptographic SHA-256 data provenance.

Figure 10 | Empirical Verification Results Across 23 Catalogs. (a) Cold pool thermodynamic collapse during the 2017 Nerima rainstorm, achieving 34.2 min lead time. (b) Pre-seismic thermal anomaly 6.0 hours before the 2018 Osaka M5.6 earthquake under perfect isobaric calm. (c) Volcanic Lamb wave linear moveout across 598 Netatmo stations during the 2018 Kusatsu-Shirane eruption (apparent speed 310.64 m/s, R-squared 0.985). Lower panels: 100% sensitivity table, normalized confusion matrix showing 0.0% false alarms, and cryptographic SHA-256 verification.

The quantitative verification results shown in Figure 9 and Figure 10 confirm the power of the AI-constructed predictive model:

Stepping back from the numbers, this experiment demonstrates a profound transformation in how humanity can build scientific models and theories.

Figure 11 | Four-Domain Deep Comparison: Prior Manual Frameworks vs. AlphaEvolve Unified Theory. Visualizing the transition from fragile human-written step heuristics to AI-discovered continuous manifolds across rainstorms (Row 1), earthquakes (Row 2), volcanic eruptions (Row 3), and operational system architectures (Row 4).

Figure 11 contrasts my four years of manual model building against the unified algorithm autonomously created by AlphaEvolve:

Figure 12 | Scientific Workflow Paradigm Shift: Traditional Manual Pipeline vs. Autonomous AI Closed-Loop. Top (Amber): Months of manual data collection, intuition-based formula drafting, spreadsheet slider tuning, and isolated silo deployment. Bottom (Neon Green): Automated IoT tensor caching, sub-second Gemini 3.8 Flash AST algorithm creation, ruthless Popperian falsification, and unified theory synthesis.

Look at the contrast between the two workflows in Figure 12:

We are standing at the threshold of a new Renaissance in empirical science.

By proving that AlphaEvolve can take 175,363 noisy citizen weather observations and autonomously create the algorithms that build the predictive model and establish a unified multi-hazard disaster theory, we have unlocked a blueprint that extends far beyond meteorology and seismology:

To my fellow developers and researchers: AI is not here to replace the human scientist.

AlphaEvolve did not replace me; it liberated me. It took the exhausting, error-prone burden of manual algorithm writing, parameter tuning, and trial-and-error off my shoulders, allowing me to focus on physical architecture, data integrity, and theoretical synthesis.

Nature has spent billions of years weaving intricate physical laws across the Earth and the cosmos. Today, for the first time in history, we have an intelligent partner capable of listening to the digital whispers of thousands of balcony sensors, autonomously writing the mathematical algorithms to model them, and helping us discover the laws of nature to protect human lives.

For the complete mathematical derivations, the 4-stage AlphaEvolve discovery architecture, the full empirical verification results across all 23 historical catalogs, and the sample Python scripts, please visit our open-access paper on Zenodo and our GitHub repository:

Bolton, D. (1980). The computation of equivalent potential temperature. Monthly Weather Review, 108(7), 1046–1053.

Matoza, R. S., et al. (2022). Atmospheric waves and global seismoacoustic observations of the January 2022 Hunga eruption, Tonga.

Science, 377(6601), 95–100. Napoly, A., et al. (2018). Development and application of a crowdsourced weather station quality control tool: Netatmo station dataset in Berlin.

Frontiers in Earth Science, 6, 118. Pulinets, S., & Ouzounov, D. (2011). Lithosphere-Atmosphere-Ionosphere Coupling (LAIC) model: An unified concept for earthquake precursors validation.

Journal of Asian Earth Sciences, 41(4–5), 371–382. Romera-Paredes, B., et al. (2024). Mathematical discoveries from program search with large language models.

Nature, 625(7995), 468–475. Tanaike, K. (2026a). Early Detection of Guerrilla Rainstorms from Crowdsourced IoT Weather Networks: The Urban Heat Convection (UHC) Thermodynamic Framework.

ESS Open Archive. Tanaike, K. (2026b). Direct Pre-Seismic Precursor Detection from Crowdsourced IoT Atmospheric Sensor Networks: Theoretical Unification with Lithosphere-Atmosphere-Ionosphere Coupling (LAIC).

ESS Open Archive. Tanaike, K. (2026c). Volcanic Explosion and Infrasonic Lamb Wave Moveout Analysis via Dense Crowdsourced IoT Barometric Sensor Networks.

ESS Open Archive. Tanaike, K. (2026d). Micro-Scale Convective Rain Prediction via High-Density IoT Weather Sensor Networks and Localized Fluid Dynamics.

ESS Open Archive. Tanaike, K. (2026e). Autonomous Discovery of Unified Multi-Hazard Prediction Theory from Netatmo IoT Weather Big Data Using AlphaEvolve.

Zenodo. https://zenodo.org/records/23354598