GMRA Mathematical Core & Predictive Engine

Welcome to the mathematical core of the Global Seismic Monitoring and Risk Assessment System (GMRA v1.0). This page details the open-source mathematical model, descriptions of the active triggers, variables, and formulas used to estimate stress accumulation in tectonic faults. Please note that the algorithms of the program operate exclusively on completed one-day cycles (24-hour). Therefore, the historical seismic window used for "today's" forecast physically ends "yesterday". The resulting calculated data narrows the possible event corridor, paving the way for more accurate forecasting (laying the groundwork for a potential GMRA-System v2.0 with a transition to shorter intervals).

The system is based on a dual-tier approach: identifying astronomical gravitational extremes and detecting global seismic anomalies. Instead of relying on static thresholds, GMRA uses dynamic backtesting calibration on events with a magnitude $\ge 6.9$ (a customizable parameter) to assign precise weights to various precursors based on historical data. Please note that GMRA version 1.0 is an experimental test model. It serves as a data-driven "sandbox" for validating geophysical theories, testing hypotheses, and calibrating predictive weights. To capture sustained energy accumulation trends, the algorithm evaluates data matrices across three distinct time windows: 3, 7, and 14 days (a customizable parameter).

I. Data Parsing & Fundamental Metrics

The foundational data are updated and processed daily via the ISC Data Calculator parser IscDataCalculator which calculates cumulative global metrics for seismic events worldwide.

1. Cumulative Benioff Strain

To track the accumulation and release of tectonic energy, we calculate the Benioff Strain for every recorded earthquake. The seismic energy ($E$) is first derived from the magnitude ($M$):

The Benioff Strain is the square root of this energy release:

In the system, sudden drops in the daily strain delta $\Delta$ (Quiescence) or exponential accelerations (AMR) act as critical precursors. Below is an excerpt of the calculated data from the GMRA-System database table (sorted by the 'max_magnitude' field).

In the Java-based backend, the mathematical logic for the calculations and table population is implemented as follows:

// IscDataCalculator.java: Benioff Strain & Aggregation
private static final double MC_THRESHOLD = 4.0; // Magnitude of Completeness

// ... Inside the parsing loop ...
if (magnitude > 0) {
    // E = 10^(1.5 * M + 4.8)
    double energy = Math.pow(10, 1.5 * magnitude + 4.8);
    double strain = Math.sqrt(energy);
    // Add to daily sum
    benioffByDate.put(date, benioffByDate.get(date) + strain); 
}

// Aggregating global data for the day
countByDate.put(date, countByDate.get(date) + 1);
sumDepth.put(date, sumDepth.get(date) + depth);
sumMagnitude.put(date, sumMagnitude.get(date) + magnitude);

if (magnitude > maxMagnitude.get(date)) {
    maxMagnitude.put(date, magnitude);
}

// Aggregate data ONLY for significant earthquakes (for b-value)
if (magnitude >= MC_THRESHOLD) {
    sumMagnitudeAboveMc.put(date, sumMagnitudeAboveMc.get(date) + magnitude);
    countAboveMc.put(date, countAboveMc.get(date) + 1);
}

2. Gutenberg-Richter b-value (Aki-Utsu Method)

The b-value represents the ratio of small to large earthquakes. We calculate this dynamically using the Maximum Likelihood Estimation (Aki-Utsu method) applied only to events at or above our Magnitude of Completeness ($M_c=4.0$).

Where $\bar{M}$ is the average magnitude of all events $\ge 4.0$. A dropping b-value (approaching the $0.5 - 1.0$ zone) indicates severe crustal locking, while a sudden rebound velocity ($\ge 0$) triggers a critical alarm.

// IscDataCalculator.java: Calculating b-value by Aki-Utsu method
int countMc = countAboveMc.getOrDefault(date, 0);
double sumMc = sumMagnitudeAboveMc.getOrDefault(date, 0.0);
 
if (countMc >= 3) { // Minimum 3 events ≥ 4.0
    double avgMagnitudeMc = sumMc / countMc;
    if (avgMagnitudeMc > MC_THRESHOLD) {
        double b = Math.log10(Math.E) / (avgMagnitudeMc - MC_THRESHOLD);
        bValueByDate.put(date, b);
    }
    else { 
        bValueByDate.put(date, 1.0); // Default norm
    }
} 
else { 
    bValueByDate.put(date, 1.0); // Background normal if countMc < 3
}

II. Seismic Anomaly Detection

The program algorithms serve as an analytical engine, processing the acquired data through various mathematical methods.

1. Tectonic Lock-In (Pearson & Spearman Correlation)

We measure the statistical coupling (interaction) between global seismic magnitudes and depths. A high correlation combined with a sharp change in the delta is used as an indicator of tectonic changes in the Earth's crust.

// PredictionCalculator.java: Pearson Gradient Tracking
double pearsonToday = Math.abs(mathService.getPearsonCorrelation(windowMagnitudes, windowDepths));
double pearsonDelta = pearsonToday - pearsonYesterday;

if (pearsonToday >= 0.85 && Math.abs(pearsonDelta) >= 0.1) {
    currentScore += mathService.cachedWeights.weightPearsonMD;
    result.activeTriggers.add("Pearson: Mag vs Depth ≥ 0.85⬆️");
}

2. Depth Sigma Anomaly (Upward Migration)

Analyzing the vertical migration of global seismic stress and tracking the 1-day velocity vector where the depth delta $\Delta$ is strictly negative, the program identifies an upward-directed pressure (energy) buildup toward the Earth's crust ($\text{depthDelta} < 0$). The intensity of this upward movement is measured relative to the historical global standard deviation of depth $\sigma$.

// PredictionCalculator.java: Depth Vector Analysis
double depthDelta = depthToday - depthYesterday; 
            
if (depthDelta < 0) { // ONLY if the pressure upwards
    double normalDepthSigma = mathService.baselineSigma.get("global_depth");            
    double depthAccelerationRatio = Math.abs(depthDelta) / normalDepthSigma;

    if (depthAccelerationRatio > 0.5) { 
        currentScore += mathService.cachedWeights.weightDepthAnomaly;
        result.activeTriggers.add("Depth Anomaly: Violent Shift⬆️");
    }
}

3. Seismic Event Acceleration (ETAS)

To differentiate between random daily noise and true epidemic-type aftershock sequences (ETAS) or foreshock swarms, we use a two-level mathematical approach combining Macro-Trends (6-day linear regression slope) and Micro-Deltas (1-day acceleration ratio).

// PredictionCalculator.java: Two-level ETAS Regression
double currentEventSpeed = currentCount - windowEventCounts[windowEventCounts.length - 2];
double overallTrend = mathService.calculateTrendSlope(macroEventCounts); // subwindow linear regression

if (currentEventSpeed > 0) {
    // Sustained Swarm Acceleration
    boolean isSustainedSwarm = overallTrend > 0;
    // ... score processing
} else if (currentEventSpeed <= 0) {
    // Seismic silence (A sharp break in Up-trend or abnormally strong decline)
    double dropRatio = Math.abs(currentEventSpeed) / normalEventCountSigma;
    if (overallTrend > 0 || dropRatio > 0.07) {
        currentScore += mathService.cachedWeights.weightEventSwarm;
        result.activeTriggers.add("ETAS Swarm: U-turn / Lock-in");
    }
}

// MathCalculationService.java: Macro-Trend Linear Regression
public double calculateTrendSlope(double[] data) {
    if (data == null || data.length < 2) return 0.0;
    double sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
    int n = data.length;
    
    for (int i = 0; i < n; i++) {
        sumX += i;
        sumY += data[i];
        sumXY += (i * data[i]);
        sumX2 += (i * i);
    }
    return (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
}

III. The Synergy Engine & Red Zone Override

The final layer where all triggers are synthesized. The probability of an earthquake or volcanic eruption is not just the sum of its parts; it is driven by non-linear synergy. Please note that the program cannot yet distinguish between volcanoes and earthquakes. If the algorithm detects a highly specific alignment—a critical Pearson lock-in, a violent upward depth strike, and a b-value anomaly — it initiates a red zone override, setting the risk probability to 85.0% or adding a percentage, forcing the risk probability.

// PredictionCalculator.java: Red Zone Override
boolean hasCriticalPearson = false;
boolean hasCriticalDepth = false;
boolean hasCriticalBValue = false;

for (String t : result.activeTriggers) {
    if (t.contains("Pearson: Mag vs Depth ≥ 0.85⬆️")) hasCriticalPearson = true;
    if (t.contains("Depth Anomaly: Violent Shift⬆️")) hasCriticalDepth = true;
    if (t.contains("b-value Anomaly (0.5 - 1.0)")) hasCriticalBValue = true;
}

// RED ZONE OVERRIDE
if (hasCriticalPearson && hasCriticalDepth && hasCriticalBValue && currentScore <= 75.0) {
    result.activeTriggers.add("⚡ SYNERGY: Multi-Seismic Alignment ("+currentScore+"% ⇄ 85%)"); 
    currentScore = 85.0; 
}