evortran: a modern Fortran package for genetic algorithms with applications from LHC data fitting to LISA signal reconstruction

This paper introduces evortran, a modern, high-performance Fortran library for genetic algorithms that offers flexible, efficient evolutionary optimization tools and demonstrates its effectiveness through applications ranging from LHC data fitting to LISA gravitational wave signal reconstruction.

The Gist

Imagine you are trying to find the absolute best spot to build a house in a massive, foggy, and mountainous landscape. You can't see the whole map, and the ground is full of hidden valleys (local traps) that look like the bottom, but aren't. If you just walk downhill blindly, you might get stuck in a small dip and never find the true valley floor.

This is the problem Genetic Algorithms (GAs) solve. Instead of walking downhill, GAs act like a team of explorers (a population) sent out to map the terrain. They don't just walk; they evolve. They have babies (crossover), they make random mistakes (mutation), and the explorers who find the best spots get to have more babies (selection). Over time, the whole team gets better at finding the lowest point.

The paper you provided introduces evortran, a new, super-fast "explorer kit" written in the Fortran programming language. Here is a breakdown of what it does and why it matters, using simple analogies.

1. What is evortran?

Think of evortran as a high-performance toolbox for these evolutionary explorers.

• The Language: It's written in Fortran, which is like the "Formula 1 race car" of scientific computing languages. It's old-school but incredibly fast and efficient at crunching numbers.
• The Goal: It helps scientists solve problems where the answer isn't obvious, the math is messy, or the data is noisy (like static on a radio).
• The Flexibility: You can use it like a pre-built robot (just press "go") or like a mechanic (tweak the engine, change the tires, and build your own custom explorer).

2. How Does It Work? (The Explorer Team)

The paper explains that evortran manages a population of "individuals" (potential solutions). Here's how the team evolves:

• Selection (The Talent Scout): The team picks the best explorers (those with the lowest "fitness" score, meaning they found the best spot) to be parents.
• Crossover (Mixing DNA): Two parents combine their best traits to create new offspring. Imagine taking the "climbing skill" from one explorer and the "navigation skill" from another to make a super-explorer.
• Mutation (The Lucky Mistake): Sometimes, an explorer makes a random, wild jump. This prevents the whole team from getting stuck in the same small valley. It keeps the search fresh.
• Elitism (The VIP Pass): The very best explorers are guaranteed to survive to the next round, ensuring the team never forgets the best spot they've found so far.

3. The Special "Superpower": Migration

One of the coolest features of evortran is Migration.

• The Analogy: Imagine you send out 10 different teams of explorers to search 10 different parts of the mountain. Usually, they stay in their own zones. But with evortran, every now and then, the teams swap a few explorers.
• Why it helps: If Team A gets stuck in a local valley, a "migrant" from Team B (who found a different valley) can bring them a new idea. This helps the whole system find multiple good solutions, not just one. This is crucial for physics problems where there might be several different "correct" answers.

4. Real-World Applications: What Did They Do With It?

The authors tested evortran on two very different, high-stakes physics problems:

A. The LHC (The Particle Collider)

• The Problem: Scientists have a theory about new, hidden particles (the "Extended Higgs Sector"). They have a mountain of data from the Large Hadron Collider (LHC), but they need to find the specific settings (parameters) of their theory that match the data.
• The Challenge: There are too many variables (like a combination lock with 11 or 14 dials), and the data is full of "noise" (static).
• The Result: evortran acted like a master locksmith, spinning the dials until it found the combinations that perfectly matched the real-world data. It found not just one solution, but a whole map of possible "correct" universes.

B. The LISA (The Space Antenna)

• The Problem: The LISA mission will listen for "gravitational waves" (ripples in space-time) from the early universe. Scientists want to know: What kind of event caused this ripple? Was it a phase transition (like water freezing) in the early universe?
• The Challenge: The signal is buried under a lot of noise, and the math to reverse-engineer the event is incredibly complex.
• The Result: evortran listened to the "static" and successfully reconstructed the original signal. It figured out the strength, duration, and temperature of the ancient cosmic event that caused the ripple. It even showed that depending on how you set up the search (the "prior"), you might get different answers, teaching scientists to be careful about how they ask the question.

5. Why Should You Care?

• Speed: Because it's written in Fortran and uses modern parallel processing (using all the cores of your computer at once), it solves these problems much faster than older tools or pure Python scripts.
• Accessibility: It's easy to install (like downloading an app) and even has a "bridge" to Python, so you can use the speed of Fortran while writing code in Python.
• Versatility: Whether you are designing a bridge, optimizing a financial portfolio, or trying to understand the Big Bang, if your problem is too messy for standard math, evortran gives you a smart, evolutionary way to find the answer.

In a nutshell: evortran is a modern, high-speed engine for "evolutionary search." It helps scientists navigate the foggy mountains of complex data to find the hidden treasures of truth, whether that's a new particle or the sound of the Big Bang.

Technical Summary

1. Problem Statement

Optimization in high-energy physics (HEP) and cosmology often involves navigating complex, high-dimensional, non-convex, and discontinuous parameter spaces. Traditional gradient-based methods (e.g., gradient descent) frequently fail in these scenarios due to:

• Non-differentiability: Constraints often involve hard cutoffs or discrete features (e.g., exclusion limits from the Large Hadron Collider).
• Local Minima: The fitness landscapes are often multimodal with many local optima, causing gradient methods to converge prematurely.
• Noise: Experimental data often contains instrumental noise, making the fitness function stochastic.
• Multiple Solutions: In many physics problems (e.g., BSM model scans), the goal is not just to find a single global minimum but to identify multiple distinct, viable regions of parameter space that satisfy constraints.

While Genetic Algorithms (GAs) are well-suited for these challenges due to their stochastic, population-based nature, existing libraries often lack a balance between modern performance, ease of use, and flexibility. Specifically, there was a need for a high-performance, modern Fortran library that integrates seamlessly with the scientific Fortran ecosystem (via fpm) while offering Python interoperability.

2. Methodology: The evortran Library

The paper introduces evortran, a modern Fortran library designed for high-performance evolutionary optimization. Its design philosophy centers on modularity, flexibility, and efficiency.

Core Architecture

• Object-Oriented Design: The library uses derived types to represent Individuals (candidate solutions) and Populations. It supports two data types:
  • Integer Individuals: For discrete gene values (binary or multi-valued).
  • Float Individuals: For continuous gene values, with user-defined lower/upper bounds.
• Multi-Level Abstraction: Users can interact with the library at three levels:
  1. Individual Level: Direct manipulation of single candidates (useful for debugging or custom operators).
  2. Population Level: Managing a single population through selection, crossover, mutation, and elitism.
  3. Migration Level: Evolving multiple independent populations in parallel with periodic migration of individuals between them. This is crucial for finding multiple distinct solutions (multi-modal optimization).
• Genetic Operators: The library provides a modular suite of operators:
  • Selection: Tournament, Rank, and a modified Roulette Wheel selection.
  • Crossover: One-point, Two-point, Uniform (for integers/floats), Blend (BLX-$\alpha$), and Simulated Binary Crossover (SBX) for continuous spaces.
  • Mutation: Uniform, Shuffle, and Gaussian mutation.
  • Elitism: Preservation of the best individuals across generations.

Performance and Parallelization

• OpenMP Support: evortran utilizes OpenMP for shared-memory parallelization.
  • At the population level, it parallelizes operations over individuals (e.g., fitness evaluation).
  • At the migration level, it parallelizes the evolution of distinct populations.
• Thread Safety: The library employs a thread-safe implementation of the Mersenne Twister (MT19937-64) pseudo-random number generator to ensure reproducibility in parallel environments.
• Python Interface: A Python wrapper (pyevortran) allows users to call the core Fortran optimization routines from Python, leveraging Fortran's speed while maintaining Python's ease of use for defining fitness functions.

3. Key Contributions

1. Modern Fortran Implementation: A lightweight, fpm-compatible package that replaces older Fortran GA codes (like Pikaia) with a modern, object-oriented interface, supporting double and quadruple precision.
2. Flexible Migration Framework: A unique feature allowing the simultaneous evolution of multiple populations with migration. This is specifically highlighted as a powerful tool for identifying multiple degenerate solutions in complex parameter spaces, a common requirement in BSM physics.
3. Comprehensive Benchmarking: The library was rigorously tested against standard multimodal benchmark functions (Rastrigin, Michalewicz, Himmelblau, Drop-Wave) to demonstrate robustness in finding global minima in rugged landscapes.
4. Real-World Physics Applications: The paper demonstrates the library's utility in two distinct, high-stakes physics scenarios:
   • LHC Data Fitting: Scanning the parameter space of the Singlet-extended Two-Higgs-Doublet Model (S2HDM).
   • LISA Signal Reconstruction: Reconstructing gravitational wave spectra from mock data of the Laser Interferometer Space Antenna (LISA).

4. Results

Benchmark Performance

• Rastrigin Function: Successfully minimized up to 20 dimensions. Parallelization via evolve_migration showed superior scaling compared to evolve_population for computationally cheap fitness functions.
• Michalewicz Function: evortran found minima comparable to or deeper than the established Pikaia library across dimensions $n=2$ to $n=100$.
• Himmelblau Function: Using the migration framework with 20 independent populations, the library successfully identified all four distinct global minima in a single run, demonstrating its ability to handle multi-modal objectives.
• Drop-Wave Function: evortran successfully located the global minimum up to 8 dimensions, outperforming Pikaia in higher dimensions where Pikaia failed to converge within the generation limit.

Physics Application 1: Extended Higgs Sector (LHC)

• Task: Fit the S2HDM (11 and 14 free parameters) to LHC data, including 125 GeV Higgs signal strengths and exclusion limits for new scalars.
• Outcome: The GA successfully identified viable parameter regions consistent with experimental constraints.
  • In Scenario 1 (Type I Yukawa), it found regions where the 125 GeV Higgs mimics the Standard Model.
  • In Scenario 2 (Flavor-Aligned), it discovered a "wrong-sign" Yukawa coupling regime (opposite signs for top and bottom quark couplings) that was consistent with data but would likely be missed by local gradient-based optimizers.

Physics Application 2: LISA Gravitational Wave Reconstruction

• Task: Reconstruct parameters of a cosmological phase transition ($\alpha, \beta/H, T_*, g_*, v_w$) from noisy LISA mock data.
• Outcome:
  • Degeneracy Analysis: The GA revealed strong degeneracies between parameters (e.g., $\alpha, \beta/H, T_*$), showing that different physical scenarios could produce indistinguishable signals given current noise levels.
  • Prior Sensitivity: The study highlighted the critical importance of prior distributions (linear vs. logarithmic) in GA initialization. A logarithmic prior on the transition strength $\alpha$ was shown to be essential for recovering the true injected parameters in multi-scale problems.
  • Comparison: Results were compared with Bayesian inference tools (PolyChordLite, copa), showing that while GAs efficiently find the global best-fit and explore the space, they complement Bayesian methods by identifying regions that statistical samplers might miss.

5. Significance

• Bridging the Gap: evortran fills a critical gap in the Fortran ecosystem by providing a modern, high-performance GA library that is easy to install and integrate, addressing the need for derivative-free optimization in scientific computing.
• Handling Complexity: The library proves particularly effective for problems where the solution space is non-smooth, noisy, or contains multiple isolated viable regions—scenarios where gradient-based methods struggle.
• Scalability: The demonstrated speedup via OpenMP (up to 300x in specific LISA reconstruction scenarios) makes evortran viable for computationally expensive, large-scale physics simulations.
• Scientific Impact: By successfully applying GAs to LHC data fitting and LISA signal reconstruction, the paper validates the library as a robust tool for next-generation physics research, enabling more comprehensive exploration of Beyond-the-Standard-Model theories and cosmological models.

In conclusion, evortran represents a significant step forward in making evolutionary optimization accessible and efficient for the Fortran-based scientific community, offering a flexible framework that adapts to the specific needs of complex, real-world physics problems.