acceptodds
Under review as a conference paper at ICLR 2027

FHEvolve: Constraint-Guided Evolution of Efficient FHE Programs

11 views

Abstract

Fully homomorphic encryption (FHE) enables computation on encrypted data, but efficient implementations require coordinated choices of approximation methods, data layouts, multiplication depth, and rotation keys. General-purpose evolutionary code search can spend evaluations on infeasible candidates or repeatedly refine one algorithmic approach. We introduce FHEvolve, a framework that guides evolutionary optimization with reusable FHE knowledge. Given a workload specification, cryptographic configuration, and initial seed programs, FHEvolve extracts constraints, filters a library of algorithm strategies, preserves different strategy families during search, and translates execution failures into repair guidance. Across eight workloads spanning CKKS and BFV, FHEvolve improves the combined accuracy–latency score over vanilla OpenEvolve on several workloads while obtaining similar scores on others. On Softmax, encrypted evaluation time decreases from 8.48 to 7.11 seconds at unchanged measured accuracy. On encrypted fraud classification, a candidate selected under an additional probability-error constraint achieves a speedup and preserves agreement on 100 fresh examples; a faster candidate selected under binary agreement alone generalizes less well, highlighting the importance of the optimization objective. Against three FHE compilers (Orion, HEIR, CHEHAB), FHEvolve is the only system that produces a within-budget program for all eight workloads without a human-written algorithm, although a hand-tuned compiler is more accurate on two of them. These results support constraint-guided search as a practical approach to improving FHE programs, with benefits that depend on the workload and evaluation requirements.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
FHE, Evolutionary framework, Code generation, privacy

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_bkv5OpenReview ↗
Rating
3
Confidence
3(+1)
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces FHEvolve, a constraint-guided evolutionary code optimization framework for fully homomorphic encryption (FHE) programs. The paper argues that generic LLM-based evolutionary coding systems struggle on FHE workloads because they lack explicit representations of cryptographic constraints, tend to remain within a single algorithmic strategy family, and receive unstructured FHE runtime failures. FHEvolve addresses these issues with four components: a Spec Compiler, a depth-tiered Strategy Library, a Hierarchical Strategy Evolver, and a Crypto-Typed Repair Classifier. The framework is evaluated on eight workloads spanning seven CKKS FHERMA challenges and one BFV matrix-vector multiplication task. Compared with Vanilla OpenEvolve, FHEvolve improves the combined accuracy-latency score on workloads with sufficient search headroom, while roughly matching Vanilla on depth-saturated workloads. The paper additionally reports component ablations, comparisons with FHE-Coder and three FHE compilers, convergence analysis, token/compute costs, and a held-out evaluation on encrypted fraud classification.

Critical strengths
  • Strong and well-controlled empirical validation. The comparison with Vanilla OpenEvolve is well controlled. The two systems share the same evolutionary engine, seeds, evaluator, and search budget, and FHEvolve adds domain-aware mechanisms. The main gains are concentrated on workloads with actual search headroom, making the observed pattern internally coherent.
  • The paper identifies an important failure mode of optimization agents. The Eth-Fraud study shows optimizing binary agreement alone is faster but less generalizable program, while adding a probability error constraint gives a speedup with preserved agreement on held-out examples. This is a useful insight for the broader design of LLM-based optimization systems.
Critical weaknesses
  • I'm wondering whether the main results are dependent on the chosen optimization objective. The combined metric is reasonable for the benchmark, but its scalarization and workload-specific reference latencies can affect which programs are selected. The Eth-Fraud study demonstrates that changing the selection criterion can lead to substantially different solutions and generalization behavior. It would therefore be useful to evaluate the robustness of the main conclusions under alternative reasonable accuracy–latency trade-offs.
  • The generalization of the curated strategy space is not fully established. The strategy library contains 13 manually defined FHE strategy templates, and the evaluated workloads largely fall into the corresponding workload families. This is a reasonable way to inject reusable FHE knowledge, but it leaves open how well the approach handles workloads requiring substantially different algorithmic strategies or strategy families that are not represented in the current library. The paper's broader claims about reusable strategy-guided search would therefore benefit from evaluation on such cases.
Questions for authors
  • How do the main improvements generalize to unseen inputs? Since most FHERMA workloads are evaluated on the same fixed vectors used during search, do the authors have additional held-out evaluations or random test inputs for Softmax, ReLU, Sign, and the other workloads?
  • How sensitive are the main comparisons to the choice of optimization metric? In particular, would FHEvolve still consistently outperform Vanilla OpenEvolve under alternative reasonable accuracy-latency scalarizations or under a constrained formulation?
  • How does FHEvolve behave when the optimal solution is not covered by the current strategy library? In particular, can the system discover or expand to a new strategy family without additional manually authored templates, or is the library intended to define the search space?
4 comments

Response to Reviewer bkv5

We thank the reviewer for the constructive questions. We ran two new experiments: an evaluation on random test inputs and a comparison under alternative scalarizations and a constrained formulation. Questions 2 and 3 also answer the two weaknesses.

Question 1. How do the main improvements generalize to unseen inputs? Since most FHERMA workloads are evaluated on the same fixed vectors used during search, do the authors have additional held-out evaluations or random test inputs for Softmax, ReLU, Sign, and the other workloads?

ReLU, Sign, Sigmoid, and GeLU generalize to unseen inputs. Softmax is more sensitive to the input vector, for both methods. As Section 2.2 (lines 146-148) states, only Eth-Fraud has a held-out set, and the FHERMA workloads ship one fixed vector each. We therefore evaluated the other workloads on random test inputs.

We scored each method's best program on random test inputs not used during search, with the workload's evaluator and the 1e-3 tolerance. For ReLU, Sign, Sigmoid, and GeLU, we drew one input vector uniformly over the range of the fixed vector. For Softmax, we drew 20 input vectors from a normal fitted to the fixed vector.

WorkloadFHEvolve: fixed vector / random inputsVanilla: fixed vector / random inputs
ReLU98.97% / 98.82%99.25% / 99.21%
Sign95.53% / 95.39%95.53% / 95.39%
Sigmoid100% / 100%100% / 100%
GeLU100% / 100%100% / 100%
Softmax (mean of 20 vectors)100% / 89.9%100% / 96.2%

On the first four workloads, accuracy on random test inputs is within 0.15 points of accuracy on the fixed vector for both methods, because these programs approximate the function over the whole input range. Both Softmax programs subtract a constant taken from the fixed vector in place of the input maximum (FHEvolve 25.86, Vanilla 25.0). Accuracy on a random vector tracks how close its maximum is to this constant. In the revised draft, we will add this table to the appendix and refer to it from Section 2.2 (lines 146-148).

Question 2. How sensitive are the main comparisons to the choice of optimization metric? In particular, would FHEvolve still consistently outperform Vanilla OpenEvolve under alternative reasonable accuracy-latency scalarizations or under a constrained formulation?

The main comparisons do not depend on the scalarization. The one exception is Sign under an accuracy-first scalarization.

We re-ranked all explored candidates of both methods under four alternatives to the metric of Section 2.2 (line 149) and Appendix C (lines 696-699): reference latency halved (M1) and doubled (M2), accuracy first with latency as tie-break (M3), and the constrained formulation accuracy >= 0.99 with minimum latency (M4). Under the paper's metric, this re-ranking reproduces Table 1.

WorkloadM1M2M3M4
ReLUFHEvolveFHEvolveFHEvolveFHEvolve
SoftmaxFHEvolveFHEvolveFHEvolveFHEvolve
SignFHEvolveFHEvolveVanillano feasible program
Sigmoidtietietietie
GeLUtietietietie

Sigmoid and GeLU tie within noise, as in Section 5.3 (lines 325-327). Under M3, Vanilla's best Sign programs reach 0.972 accuracy at about three times FHEvolve's latency. An accuracy-first scalarization favors slower programs, so it selects a different accuracy-latency trade-off. In the revised draft, we will add this table and analysis to Appendix C, next to the metric definition.

Question 3. How does FHEvolve behave when the optimal solution is not covered by the current strategy library? In particular, can the system discover or expand to a new strategy family without additional manually authored templates, or is the library intended to define the search space?

The library is not intended to define the search space. It filters the strategies the prompt offers to those within the FHE budget (Section 4, lines 221-230). Mutations edit the program directly, not the templates, so the model can write code outside the current strategy library.

Our evaluation has no workload whose optimal solution is not covered by the library. Our limitations (Section 7, line 483) state that the author-written seeds and the thirteen-entry library bound FHEvolve's autonomy.

To expand to a new strategy family without additional manually authored templates, the system can detect evolved programs that match no library entry and add them as new entries. The rule-based strategy classifier (Section 4, lines 241-244) can do this detection. In the revised draft, we will state in Section 4 that the library does not define the search space, and add library expansion as future work in Section 7.

The authors have provided useful additional experiments and clarifications. The analysis substantially addresses my concern about dependence on the optimization objective, and the random-input evaluations provide useful evidence beyond the fixed search vectors. The clarification that the strategy library guides generation rather than strictly defining the search space is also helpful. The additional tests support generalization on several activation workloads, although Softmax remains sensitive to the input.

Overall, the additional evidence strengthens the empirical evaluation and clarifies the remaining limitations. I will maintain my current rating with greater confidence.

Reviewer_CD1JOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper starts from some observations of LLM-based FHE code generation, identifying current limitations such as search stagnation, reliance on task-specific expert prompts, and unstructured failure feedback. Motivated by these observations, it proposes FHEvolve, which extends OpenEvolve with automatic constraint extration, strategy library, presevation of strategy-family diversity, and typed repair feedback. Together, these mechanisms incorporate FHE domain knowledge into the evolutionary search process. Experiments on eight workloads spanning CKKS and BFV show that the resulting framework improves the accuracy–latency trade-off over vanilla OpenEvolve on several tasks while achieving comparable performance on others.

Critical strengths

The paper first analyzes difficulties in LLM-based FHE code generation, including search stagnation, reliance on task-specific expert prompts, and unstructured failure feedback. It translates these observations into corresponding designs for constraint extraction, strategy guidance, preservation of algorithm diversity, and typed repair. The clear connection between the identified problems and the proposed solutions provides a strong rationale for the framework's design and offers useful insights into incorporating domain knowledge into evolutionary code optimization.

Critical weaknesses

The main experiments rely on GPT-5, released in August 2025, and GPT 5.6 was released in July 2026, nearly three months before the submission date. With advances in model parameters, capabilities and agent harness, it remains unclear whether FHEvolve would provide comparable additional benefits over strong baselines. I would like to suggest the authors to further evaluating representative workloads with a newer model.

Questions for authors
  1. Could you evaluate FHEvolve with a newer model?
3 comments

Response to Reviewer CD1J

We thank the reviewer for their time on the review. We ran the requested experiment. It also answers the weakness on newer models.

Question 1. Could you evaluate FHEvolve with a newer model?

Yes. We evaluated three representative workloads with a newer model, GPT-6, for FHEvolve and Vanilla OpenEvolve. FHEvolve keeps its additional benefit on Softmax, and its benefit on Eth-Fraud grows. On Sign, the two systems tie.

Both systems used the same seeds, evaluator, 200-iteration budget, and island and archive settings as in Section 5.2 (lines 310-316). We chose the paper's three largest FHEvolve-vs-Vanilla gaps: Softmax, Sign, and Eth-Fraud. For Eth-Fraud, we report the best candidate whose maximum probability error is below 0.01, as in Section 5.3 (line 338).

WorkloadFHEvolve (GPT-6)Vanilla (GPT-6)Paper (GPT-5)
Softmax0.7410.7180.738 vs 0.702
Sign0.7670.7750.727 vs 0.658
Eth-Fraud (probability error < 0.01)0.9220.818 (seed)1.3x speedup

On Eth-Fraud, only 3 of Vanilla's 104 programs keep the probability error below 0.01, and all 3 are seeds. FHEvolve keeps 52 of 124 below it. A newer model writes better candidates, but it does not change what the search rewards. FHEvolve's constraint extraction and probability-error selection act on that objective, so their benefit holds as models improve. In the revised draft, we will add the GPT-6 table and the program counts (52 of 124 vs 3 of 104) to the appendix, and refer to them from Section 5.2.

We thank the reviewer again for the review. As requested, we evaluated FHEvolve with a newer model (GPT-6), and the results are in our response above. As the discussion period ends soon, we would appreciate it if the reviewer could let us know whether this addresses the question.

Best, Authors

It solves my concern. Thanks!

Reviewer_LqvUOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents FHEvolve, a framework for optimizing fully homomorphic encryption programs through language-model-guided evolutionary search. It extends OpenEvolve with a specification compiler, a library of 13 FHE strategies, a mechanism that preserves diversity across strategy families, and a module that converts execution failures into repair hints.

The evaluation covers seven CKKS workloads and one BFV dot-product workload. It compares FHEvolve with direct code generation, vanilla OpenEvolve, FHE-Coder, human reference solutions, and several FHE compilers. The paper reports improvements on workloads with room for optimization and small or negligible gains on several other workloads. It also examines the difference between preserving binary decisions and preserving probability outputs on the Eth-Fraud task. Under the additional probability-error requirement, the paper reports a 1.3-fold speedup.

Critical strengths
  1. The method connects program search with depth budgets, available rotation keys, approximation choices, and execution errors. These constraints directly affect whether a generated program works and how fast it runs. The comparison with vanilla OpenEvolve uses the same search engine, language model, initial programs, and iteration budget, which makes it a useful comparison. Softmax provides a clear example: the reported runtime decreases from 8.48 seconds to 7.11 seconds while the measured slot accuracy remains 100% under the evaluation tolerance. This supports the practical value of adding FHE-specific guidance.

  2. The Eth-Fraud analysis distinguishes agreement with the reference model’s binary decisions from fidelity to its probability outputs. The paper reports that the 3.6-fold speedup changes probabilities and reaches agreement on only 94 of 100 held-out samples. With an additional probability-error requirement, the reported speedup is 1.3-fold, with agreement on all 100 held-out samples. This analysis is consequential because it identifies an important condition for interpreting the optimization results.

Critical weaknesses
  1. The correctness evidence does not adequately support several central optimization and certification claims. Appendix E explains the removal of two rotation stages through the binary representation of 45. This explanation does not justify removing those stages from a standard rotate-and-add reduction. With the stated remaining rotation offsets, the standard construction combines 16 positions, rather than all 45 feature positions. A different layout, sparse weights, or additional intermediate sums can change this conclusion, but the paper does not provide enough detail to establish such a case. This concern directly affects the interpretation of the Eth-Fraud optimization, including whether the reported 1.3-fold candidate preserves the intended computation.

  2. The experiments do not clearly isolate the contribution or support the full scope of the comparison claims. The paper makes strong claims about the absence of suitable mechanisms in prior systems. However, OpenEvolve already supports custom archive dimensions and evaluation artifacts that carry feedback, as its documentation describes. FHE-Coder also includes structured validation feedback. The paper needs a more precise account of what the FHE-specific rules and descriptors add to these existing mechanisms.

Questions for authors
  1. What exact code, data layout, and weight structure justify removing the two rotation stages in Eth-Fraud? Does the candidate with the reported 1.3-fold speedup use this reduction? What are the results for the linear scores before the sigmoid on all 45 basis-vector inputs?

  2. What exact polynomial coefficients and degree define the ReLU approximation? How does the certification procedure handle the zero endpoint? Does the reported bound cover only polynomial approximation error, or does it also include CKKS evaluation error?

3 comments

Response to Reviewer LqvU

We thank the reviewer for the careful technical reading. We answer each question below with new measurements.

Question 1. What exact code, data layout, and weight structure justify removing the two rotation stages in Eth-Fraud? Does the candidate with the reported 1.3-fold speedup use this reduction? What are the results for the linear scores before the sigmoid on all 45 basis-vector inputs?

Thank you for pointing this out. We would like to clarify that the 1.3-fold candidate does not use this reduction. It keeps all six rotation stages and computes the exact linear score on all 45 basis-vector inputs. Only the 3.6-fold candidate removes the two rotation stages. The model made this change during search. It is not part of FHEvolve's design. Section 5.3 (lines 338-339) already reports that this candidate changes the probabilities and agrees on only 94 of 100 held-out samples.

We ran all 45 basis-vector inputs e_j through three saved programs under OpenFHE, with the evaluation's parameters. We compared the decrypted linear score before the sigmoid at slot 0 with w_j + B:

CandidateRotation stagesExact basis-vector inputs (of 45)Max abs. linear-score error
3.6-fold{32, 8, 4, 1}182.821
1.3-fold{32, 16, 8, 4, 2, 1}454.0e-10
Seed{32, 16, 8, 4, 2, 1}453.9e-10

The search scored candidates under the challenge's binary-agreement metric on 16 samples. With the contiguous feature layout, the remaining stages combine 16 positions, as the reviewer notes, and the table confirms this. The metric did not penalize the change, because the 16 binary decisions stayed the same. This is the behavior Section 5.3 (lines 344-345) describes: improving the search score can fail to preserve the intended output. It is also why the paper selects under the probability-error requirement. That requirement rejects the 3.6-fold candidate and selects the 1.3-fold candidate (line 341). The 1.3-fold candidate gets its speedup from changes outside the matrix-vector product: the tanh decomposition of the sigmoid and scalar encodings for the bias and constants. Its maximum probability error on the 100 held-out samples is 6.4e-4. In the revised draft, we will update the rotation paragraph of Appendix E (lines 756-759) to describe the removal as a change the model made under the binary-agreement metric, and add the 1.3-fold code and the basis-vector table to Appendix E.

Question 2. What exact polynomial coefficients and degree define the ReLU approximation? How does the certification procedure handle the zero endpoint? Does the reported bound cover only polynomial approximation error, or does it also include CKKS evaluation error?

The ReLU approximation is relu(x) = 0.5 (x + s(x^2)), where s is the degree-47 Chebyshev interpolant of the square root on [0, 1] (Appendix J, lines 929-931). The first coefficients are 0.636648, 0.424356, -0.084826, 0.036321, -0.020153, 0.012804. To handle the zero endpoint, the certification procedure runs in x, not in y = x^2. The reported bound covers polynomial approximation error only, as Appendix J (lines 909-912) states. We measured CKKS evaluation error separately.

The square root is not Lipschitz at 0, but the ReLU error 0.5 |s(x^2) - |x|| is Lipschitz in x on [-1, 1], with L <= 1.06 (from Markov's inequality for polynomials). We sample the error at 2x10^7 + 1 points, including x = 0. The correction between grid points, L h / 2, is 5.3e-8. The largest error is at x = 0, so we measure the zero endpoint directly. For CKKS evaluation error, we ran 1,000 encrypted evaluations, each with fresh keys, on 16,384 inputs near zero. Over these 16.4 million evaluations, the maximum CKKS evaluation error is 2.7e-9, more than five orders of magnitude below the 1e-3 tolerance. This also confirms that OpenFHE evaluates these coefficients.

The polynomial approximation error exceeds 1e-3 only near x = 0. This is why the measured accuracy is 98.97% (Appendix J, lines 933-936). In the revised draft, we will add the full coefficients, the zero-endpoint procedure, and the measured CKKS evaluation error to Appendix J.

Weakness 2. The paper needs a more precise account of what the FHE-specific rules and descriptors add to these existing mechanisms.

OpenEvolve's custom archive dimensions and evaluation artifacts, and FHE-Coder's structured validation feedback, exist in prior systems. The FHE-specific rules and descriptors that FHEvolve supplies to them do not. Our sentence in Section 4 (line 202), "None has a counterpart in OpenEvolve or AlphaEvolve", refers to these four components, not to the existing mechanisms.

We first tried to adapt OpenEvolve to FHE with its existing mechanisms alone. This adaptation is the Vanilla OpenEvolve baseline in Table 1: the same mechanisms, engine, seeds, evaluator, and budget (Section 5.2, lines 310-316), with hand-written FHE prompts in place of our components. It falls short in two ways, and FHEvolve fills this gap. First, with a newer model (GPT-6, our answer to Reviewer CD1J), only 3 of Vanilla's 104 Eth-Fraud programs meet the probability-error requirement, and all 3 are seeds. FHEvolve keeps 52 of 124 within it and raises the best score within it from 0.818 to 0.922. Second, Vanilla needs a hand-written FHE prompt of 89 to 105 lines per workload. FHEvolve needs no new prompt (Section 1, lines 94-96) and a two-line configuration. FHEvolve also scores higher than FHE-Coder on every workload (Table 1, Section 6, lines 470-471).

OpenEvolve's custom archive dimensions and evaluation artifacts accept any content the user supplies. FHEvolve supplies the strategy-family descriptors, the extracted FHE constraints, and the FHE-typed failure classes. FHE-Coder's structured validation feedback reports which check failed. Our repair classifier reports which FHE constraint failed (for example, depth_exhausted or rotation_key_missing) and gives a repair hint for each. FHE-Coder also refines one candidate at a time, with no population (Section 6, lines 468-470). In the revised draft, we will state in Section 4 that the sentence on line 202 refers to the four components, and add the prompt-line counts and the GPT-6 results to the appendix.

Comments on the paper

1 comment

Thanking all the reviewers and summary of concerns and resolution for AC

We thank the reviewers for their constructive feedback. We have uploaded a revised manuscript and detailed responses. All changes in the revised manuscript are in blue. Below is a summary of the questions raised in the reviews, our new experimental results, and the outcome of each discussion.

We appreciate the reviewers' recognition of our work along the following dimensions:

  • Well-controlled empirical validation: The comparison with Vanilla OpenEvolve uses the same search engine, language model, seed programs, evaluator, and budget, and the gains are on the workloads with search headroom (Reviewer bkv5, Reviewer LqvU).
  • Clear rationale for the design: The paper identifies the difficulties of LLM-based FHE code generation and translates each one into a corresponding component (Reviewer CD1J).
  • Practical value of FHE-specific guidance: The method connects program search with depth budgets, rotation keys, approximation choices, and execution errors (Reviewer LqvU).
  • A useful insight on optimization objectives: The Eth-Fraud study separates agreement with binary decisions from fidelity to probability outputs (Reviewer bkv5, Reviewer LqvU).

Regarding the reviewers' concerns, we have addressed all raised issues in our detailed responses and revised the manuscript accordingly. For easy navigation, we indicate the corresponding locations in our responses (Reviewer ID + Question Number) in parentheses.

  1. Generalization to unseen inputs: We evaluated each method's best program on random test inputs not used during search. ReLU, Sign, Sigmoid, and GeLU stay within 0.15 points of their accuracy on the fixed vector for both methods. Softmax is more sensitive to the input vector for both methods, and we state the cause (see Reviewer bkv5 Q1, revised Appendix O).

  2. Dependence on the optimization metric: We re-ranked all explored candidates under two alternative scalarizations, an accuracy-first ranking, and a constrained formulation. The main comparisons do not depend on the scalarization. The one exception is Sign under the accuracy-first ranking, which we report (see Reviewer bkv5 Q2, revised Appendix C).

  3. Scope of the strategy library: We clarified that the library guides generation and does not define the search space, because mutations edit the program directly. We added library expansion as future work (see Reviewer bkv5 Q3, revised Section 4 and Section 7).

  4. Evaluation with a newer model: We evaluated Softmax, Sign, and Eth-Fraud with GPT-6 for FHEvolve and Vanilla OpenEvolve. FHEvolve keeps its benefit on Softmax. On Eth-Fraud, 52 of 124 FHEvolve programs keep the probability error below 0.01, compared with 3 of 104 for Vanilla (see Reviewer CD1J Q1, revised Appendix P).

  5. Correctness of the Eth-Fraud optimization: We clarified that the 1.3-fold candidate keeps all six rotation stages. We ran all 45 basis-vector inputs under OpenFHE, and this candidate computes the exact linear score on all 45. The removal of two rotation stages occurs only in the 3.6-fold candidate, which the probability-error requirement rejects (see Reviewer LqvU Q1, revised Appendix E).

  6. ReLU error bound near zero: We gave the full coefficients, the procedure at the zero endpoint, and a corrected bound of 5.211e-3 on [-1, 1]. The error exceeds the 1e-3 tolerance only for |x| < 0.0114. We measured CKKS evaluation error separately (see Reviewer LqvU Q2 and follow-up point 2, revised Section 5.5 and Appendix J).

  7. Contribution of the proposed components over existing OpenEvolve mechanisms: We clarified that our statement in Section 4 refers to the four components, not to OpenEvolve's custom archive dimensions and evaluation artifacts. The Vanilla OpenEvolve baseline already uses both mechanisms. Our responses give the evidence that separates the two (see Reviewer LqvU Weakness 2 and follow-up point 1, revised Section 4).

After the discussion, Reviewer LqvU raised the score from 2 to 3. Reviewer bkv5 maintained the rating with greater confidence. Reviewer CD1J confirmed that the response solves the concern.

We once again thank the reviewers, the Area Chair, and the Program Committee for their time and thoughtful evaluation. We have updated the manuscript incorporating all the promised changes, with changes highlighted in blue.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.