Eterna is Solved (2505.02110v1)

Abstract: RNA design consists of discovering a nucleotide sequence that folds into a target secondary structure. It is useful for synthetic biology, medicine, and nanotechnology. We propose Montparnasse, a Multi Objective Generalized Nested Rollout Policy Adaptation with Limited Repetition (MOGNRPALR) RNA design algorithm. It solves the Eterna benchmark.

• The paper introduces Montparnasse, a framework that uses the MOGNRPALR algorithm to solve the inverse RNA folding problem on the Eterna benchmark.
• The paper applies advanced Monte Carlo Search with multi-objective evaluation, leveraging metrics like Base Pair Distance, ensemble defect, and GC-content.
• The paper demonstrates that parallel computation enables solving all 100 RNA design challenges within a day, outperforming traditional local search methods.

The paper "Eterna is Solved" (2505.02110) introduces Montparnasse, a framework for solving the Inverse RNA Folding problem. This problem involves finding a nucleotide sequence (composed of A, C, G, U) that folds into a specific target secondary structure. Solving this is critical for fields like synthetic biology, medicine, and nanotechnology, but it is a computationally difficult combinatorial problem. The paper claims to solve the Eterna benchmark, a standard set of 100 challenging RNA design problems, by finding a sequence for every target structure in the benchmark within a day using parallel computation.

The core contribution of the paper is the Multi Objective Generalized Nested Rollout Policy Adaptation with Limited Repetitions (MOGNRPALR) algorithm, an advanced Monte Carlo Search (MCTS) method. The Montparnasse framework also includes Multi Objective Greedy Randomized Local Search (MOGRLS) and Progressive Narrowing (PN), which are simpler local search approaches used for comparison and, in the case of PN, as a refined baseline.

Multi Objective Greedy Randomized Local Search (MOGRLS)

MOGRLS is presented as a simplification of the state-of-the-art GREED-RNA algorithm. It starts with an initial sequence and iteratively applies mutations (greedy in early stages, random later). The key is the multi-objective evaluation used to determine if a mutated sequence is better than the current best. The objectives include Base Pair Distance (BPD) to the target structure, Hamming Distance, probability over ensemble, partition function, ensemble defect, and GC-content distance. Sequences are compared using these objectives in a lexicographical or prioritized manner. The algorithm continues indefinitely until a perfect solution (BPD=0) is found or a resource limit is reached.

Implementing MOGRLS would involve:

1. Sequence Representation: Representing RNA sequences as strings or lists of characters (A, C, G, U).
2. Mutation Operations: Implementing functions for greedy and random mutations. Greedy mutations might focus on changing nucleotides involved in incorrect base pairs to GC/CG, while random mutations replace nucleotides or pairs randomly.
3. RNA Folding Prediction: Using an external library or implemented logic (like the dynamic programming algorithms based on Turner energy parameters) to predict the secondary structure of a given sequence. The paper mentions using Turner 1999 parameters. Libraries like ViennaRNA Package are commonly used for this.
4. Multi-Objective Evaluation: Calculating each of the defined metrics for a sequence given the target structure. BPD is the number of base pairs in the predicted structure that are not in the target structure. Ensemble defect quantifies the average number of incorrectly paired bases in the predicted structure's thermodynamic ensemble.
5. Comparison Logic: Implementing the multi-objective comparison function to decide whether a new sequence is an improvement over the current best.
6. Search Loop: Implementing the main loop that applies mutations and updates the best sequence based on the comparison.

Progressive Narrowing (PN)

PN is an enhancement of MOGRLS. Instead of searching from a single best sequence, it maintains a pool of "best sequences" and iteratively applies mutations to each of them. Periodically, it prunes the pool, removing the worst-performing sequences based on their evaluation metrics after a certain number of evaluations (profile [n]). The search progressively "narrows" the pool size until only one sequence remains or a solution is found. The paper describes a method for tuning the parameters of this narrowing process (specifically, when to remove sequences from the pool) by sampling from previous MOGRLS runs.

Implementing PN requires:

1. All components of MOGRLS.
2. Maintaining a Pool: Storing a list of sequences being explored simultaneously.
3. Parallel Mutation/Evaluation: Applying mutation and evaluation steps to sequences within the pool.
4. Ranking and Pruning: Implementing logic to rank sequences in the pool using the multi-objective comparison and remove lower-ranked sequences according to the defined profile.
5. Parameter Tuning Logic: Implementing the search algorithm described (Algorithm 3 and 4 in the paper) to find optimal profile parameters based on historical performance data.

Multi Objective Generalized Nested Rollout Policy Adaptation with Limited Repetitions (MOGNRPALR)

This is the primary algorithm that achieves the benchmark solution. It combines Nested Monte Carlo Search (NMCS) principles with learned playout policies and the multi-objective evaluation.

Key concepts and implementation aspects:

1. Nested Search: The algorithm operates at multiple levels. A call to MOGNRPALR(level, policy) recursively calls MOGNRPALR(level-1, policy) multiple times. Level 0 is the base case, executing a playout.
2. Policy Adaptation: At each level > 0, the algorithm maintains a policy (an array of weights for possible moves/nucleotide choices). After each recursive call to the lower level returns a sequence and its scores, the policy at the current level is updated (adapt function) to reinforce the moves that led to the best sequence found so far at this level. The adaptation rule increases weights for selected moves and decreases weights for others.

   %%%%0%%%%

   where $p_m$ is the probability of move $m$ from the current state, $\delta_{bm}$ is 1 if $m$ is the move taken in the best sequence and 0 otherwise, and $\alpha$ is a learning rate.
3. Playout Function: At level 0, a sequence is generated by repeatedly choosing the next nucleotide. Choices are made using Boltzmann sampling biased by the policy weights and predefined biases $\beta_m$.

   %%%%7%%%%

   The playout continues until a full sequence is formed. The sequence and its multi-objective scores (calculated via folding prediction and evaluation) are returned.
4. Multi-Objective Evaluation: The same multi-objective function used in MOGRLS/PN is used to score generated sequences and rank them (e.g., in bestSequences.sort()).
5. Limited Repetitions (LR): The "Limited Repetitions" aspect means that at a given level, if a recursive call to the lower level returns the same best sequence that was already found earlier at this level, the algorithm for this level terminates early and returns that sequence. This prevents the policy from becoming too deterministic and helps explore diverse sequences.
6. Biases: The paper specifies using fixed biases ($\beta_m$) for certain nucleotide choices (5.0 for GC, CG, A, 0.0 otherwise). These act as a prior, favoring certain types of pairs or unpaired nucleotides.
7. Stabilized NRPA: Adaptation is only started after a few iterations at higher levels (line 16 in Algorithm 3), which is a known technique for stabilizing NRPA training.

Implementing MOGNRPALR is substantially more complex than MOGRLS/PN and requires a deep understanding of MCTS and policy learning. Key components include:

1. State Representation: The state in the search could represent a partially built RNA sequence.
2. Move Representation: A move is the choice of the next nucleotide to append to the sequence.
3. Policy Representation: An array or dictionary to store weights for each possible move from each possible state (or a parameterized function approximating this). Given the variable sequence length and combinatorial state space, a practical implementation might use a more compact representation or focus adaptation on recent moves.
4. Recursive Function: Implementing the nested MOGNRPALR function with base case (playout) and recursive step (calling lower level, adapting policy, tracking best sequences).
5. Playout Function: Implementing the playout function using Boltzmann sampling with weights and biases.
6. Adapt Function: Implementing the adapt function to update policy weights based on the best sequence path.
7. Multi-Objective Evaluation: Reusing the evaluation function from MOGRLS.
8. RNA Folding: Dependence on an external RNA folding predictor.
9. Handling Limited Repetitions: Checking for duplicate best sequences at each level to trigger early termination.

Real-World Application and Implementation Considerations:

• RNA Design: The direct application is designing synthetic RNA molecules with desired secondary structures for applications like building riboswitches, ribozymes, or RNA nanostructures.
• Computational Resources: The paper highlights the need for parallel processing (200 processes) to solve the full Eterna benchmark within a day. This implies significant CPU requirements, as RNA folding and evaluation can be computationally intensive, especially for longer sequences.
• Scaling: The effectiveness of MOGNRPALR relies on the ability of MCTS and policy adaptation to navigate the vast search space. For much larger RNA molecules or more complex target structures (e.g., with pseudoknots, though Eterna v1 does not have them), the problem difficulty increases. The current approach might require more computational resources or further algorithmic enhancements.
• Multi-Objective Trade-offs: The multi-objective evaluation function requires careful consideration of the relative importance of different metrics (BPD vs. stability metrics like ensemble defect). The prioritized comparison in the paper is one way to handle this. In practice, depending on the specific application, different weightings or comparison strategies might be needed.
• General Combinatorial Optimization: While applied to RNA design, the MOGNRPALR algorithm is a general Monte Carlo search technique. Its principles (nested search, policy adaptation, limited repetitions, multi-objective evaluation) could be applied to other complex combinatorial optimization problems where a solution can be built step-by-step (sequence generation) and evaluated. Examples mentioned in the literature include vehicle routing, constraint satisfaction, and game playing.

The paper demonstrates that MOGNRPALR is significantly more effective than the local search methods (MOGRLS, PN, GREED-RNA) on difficult Eterna problems, successfully solving all 100 problems within the tested limits using parallel execution. This suggests that guided exploration via learned policies within a nested search framework is a powerful approach for this challenging inverse design problem.