acceptodds
Under review as a conference paper at ICLR 2027

Accelerating SAT Solving via Differentiable Decision Heuristics

Abstract

Boolean satisfiability (SAT) is a fundamental computational primitive underlying verification, planning, synthesis, and automated reasoning. Modern CDCL SAT solvers are highly optimized, but their initial branching and phase heuristics are still largely solver-internal defaults that do not explicitly adapt to the structure of each input formula. We introduce optimization-guided initialization framework that uses a GPU-accelerated model to extract formula-level guidance and warm-start key CDCL heuristics, including phase selection and variable activity. The resulting solver preserves the original CDCL search procedure and remains complete, making the method a drop-in enhancement rather than a replacement for state-of-the-art SAT solving. We evaluate on SAT Competition benchmarks and compare against strong competition solvers in both single-threaded and parallel settings. In the single-threaded setting, our best individual initialization achieves a PAR-2 speedup over Kissat with fallback, while the virtual best configuration reaches a PAR-2 speedup and improves 207 instances. Our variants rescue 9 Kissat timeouts, including both SAT and UNSAT formulas. In the parallel setting, a 32-thread phase portfolio achieves a PAR-2 speedup over MallobSat(32T), improves 107 of 167 SAT instances, and solves 15 of the 18 instances on which Kissat times out. These results show that optimization-guided initialization can provide practical, structure-aware diversification for both single-threaded CDCL search and parallel SAT portfolios.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
Boolean Satisfiability, Differentiable Optimization

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_HgtDOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes an optimization-guided initialization framework for CDCL SAT solvers. Namely, the authors optimize a differentiable MaxSAT objective on a GPU for each input formula and use the resulting assignment preferences and gradient-derived variable scores to initialize phase selection and branching activities in Kissat. The actual CDCL procedure remains unchanged. The same idea is extended to parallel solving by perturbing the optimized logits to obtain different initial phases for a portfolio of solver workers. Experiments on SAT Competition 2024 instances demonstrate improvements over standard Kissat, as well as an advantage over MallobSat on satisfiable instances in the parallel setting.

Overall, I am slightly on the positive side. The paper is easy to follow, the approach is interesting, and the experiments demonstrate some practical benefit. The contribution is somewhat incremental and the evaluation could and should be strengthened, but I think the paper could be accepted.

Critical strengths
  • Overall, the paper is quite well written. Although I am no machine learner and I typically struggle with ML-based approaches to SAT and other combinatorial problems, I found this paper relatively simple to follow. The main concepts are defined and the steps of the approach are explained clearly.

  • The idea of using differentiable optimization to bootstrap the execution of an otherwise standard SAT solver is interesting. In particular, the optimization is performed separately for each formula and does not require a collection of labelled training instances. The resulting "values" are then plugged in to initialize existing heuristics effectively bootstrapping the SAT solver, which makes the approach reasonably simple and preserves the underlying solver's correctness.

  • The authors evaluate the approach with strong practical baselines, including Kissat and MallobSat. The single-threaded improvements are observed on both satisfiable and unsatisfiable instances, and the reported total runtimes include the GPU optimization overhead. While the gains are not particularly large, improving a highly optimized SAT solver is certainly not an easy task. Having said that, it does not strike me that the approach is better aligned with satisfiable instances given that it focuses on optimizing a MaxSAT objective.

Critical weaknesses
  • The relation with traditional static branching and polarity heuristics deserves a much better discussion. Initializing a solver using formula-dependent information is not a new idea: Jeroslow–Wang and literal-count heuristics provide immediate connections, both for choosing variables and for selecting their initial polarities. For example, PicoSAT used Jeroslow–Wang scores for initial phase selection. While Appendix A.1 includes JW, MOMS and degree-based baselines, this connection is largely absent from the main discussion, and the appendix does not explain how these baselines initialize phases and activities. Furthermore, the comparison is restricted to 111 instances selected according to Kissat's runtime, which to my taste does not look satisfactory. A comparison on the full benchmark set would help establish the benefit over these much simpler alternatives. The idea is nice but not particularly deep, and its novelty should be positioned more carefully.

  • The experimental results are positive but somewhat modest. The best individual single-threaded configurations achieve PAR-2 speedups of about 1.18 on SAT and 1.07 on UNSAT instances. These are useful improvements, but I would like a clearer picture of where they come from. PAR-2 penalizes a timeout by twice the cutoff, so a few changes in solved status can substantially affect the overall score. I find the absence of standard cactus plots and, more importantly, pairwise runtime scatter plots hard to justify. These would show the behaviour of the solvers much more clearly than binned speedup distributions.

  • The parallel results require some discussion. The proposed portfolio improves over MallobSat on satisfiable instances, but on unsatisfiable instances it solves 155 cases compared with MallobSat's 168 and has a significantly worse PAR-2 score. The authors acknowledge this limitation and the absence of clause sharing, which is good. However, whether or not the absence of clause sharing is the culprit is yet to be understood. As a result, the parallel results can be seen to add a bit of grain of salt here.

  • The choice of benchmarks leaves much to be desired. Why are only SAT Competition 2024 instances considered? Why not include the 2025 and 2026 benchmarks? Evaluation across several competition years would make the practical conclusions more convincing. The choice of the 368-instance evaluation set should also be explained.

  • The interaction with preprocessing and inprocessing is unclear to me. Kissat may eliminate variables and clauses, substitute variables, and otherwise change the formula before and during search. The paper should explain whether the optimization is applied to the original formula or a preprocessed one, when the phases and activities are injected, and how the variable mapping is maintained. This does not necessarily invalidate the approach, but it may affect how useful the bootstrapping actually is. As far as I can see, the current description does not make this clear.

Questions for authors
  1. Can you clarify how JW, MOMS and static initialization in Appendix A.1 are implemented? Do they initialize phases, branching activities, or both? Can you extend this comparison to the full benchmark set?

  2. Can you provide cactus and pairwise scatter plots rather than focusing on improved-case speedups?

  3. Why was SAT Competition 2024 chosen as the only benchmark source, and how were the 368 instances selected?

  4. At what point relative to Kissat's preprocessing are the optimization and heuristic initialization performed? How are eliminated or substituted variables handled?

  5. In the parallel setting, how much of the benefit comes from the optimized logits rather than phase diversification alone? A comparison with an otherwise identical portfolio using random initial phases would be useful.

2 comments
AuthorsOpenReview ↗

Answers to questions

Thank you for the comments. We apologize for the delay while we completed the additional experiments on SAT Competition 2026 benchmarks.

  1. The Appendix A.1 configurations initialize different parts of the solver state: Method | Phase initialization | Branching activity initialization | |---|:---:|:---:| | JW | Yes | No | | MOMS | Yes | No | | Degree | No | Yes | | BMM | Yes | Yes | | Ours (Phase+VSIDS-Norm) | Yes | Yes |

JW computes a score for each literal, J(l) = sum_{C containing l} 2^(-|C|), and selects the polarity with the larger score. MOMS selects the polarity by comparing positive and negative literal counts in the shortest nonempty clauses. Both initialize phases only in our experiments. Degree ranks variables by total occurrence count. For BMM, we follow the method proposed in the original paper. For Degree, BMM, and our method, the top 50 ranked variables receive an initial activity of 10,000. We will discuss the connection to traditional initialization heuristics in the main text and clarify the role of our saliency scoring and degree normalization. Due to limited computing resources and the number of configurations being evaluated, we restricted the comparison to 111 instances. We will state this scope and the instance-selection criterion explicitly in the appendix.

  1. We provide separate SAT and UNSAT cactus plots for the 2024 and 2026 experiments: Link to single thread 2024 cactus plot: https://drive.google.com/file/d/1ZsK-iS_Zwm44pWgxczxPRxehZ313r0-B/view?usp=drive_link Link to multi-thread 2024 cactus plot: https://drive.google.com/file/d/1nf0bAUR9avps-1H3oWiqmZAgpCWIuieT/view?usp=sharing Link to single thread 2026 cactus plot: https://drive.google.com/file/d/16UJi0-J6mB6Bv7_zwHG2Je4hMxCfwE43/view?usp=drive_link We will also add pairwise runtime scatter plots, with timeouts marked explicitly. To explain the PAR-2 changes, we will report runtime changes on instances solved by both configurations separately from instances solved by only one.

  2. We evaluated 368 instances, excluding those with more than 10 million variables or 50 million clauses after conversion to 3-SAT. Our implementation reuses GaloisSAT’s GPU optimization code. The size thresholds were chosen to avoid excessive GPU initialization overhead under the memory and compute constraints of our RTX 4090 setup. We apologize for not stating this criterion and will provide the full list of excluded instances. GaloisSAT demonstrates that this optimization can handle substantially larger instances with greater GPU resources. It reports near-linear training speedup when scaling from 2×A100 to 8×A100 (GaloisSAT, Table 3: https://arxiv.org/html/2603.28796#S3.T3). For an instance with approximately 131 million clauses, training time decreased from 884.79 s to 238.18 s. These results support using larger GPU configurations to extend our evaluation beyond the current size limits. We extended our single-thread evaluation to 333 instances from the SAT Competition 2026 benchmark, comprising 172 SAT and 161 UNSAT instances. The table below reports PAR-2 scores with a 5,000-second timeout and a 10,000-second penalty for each unsolved instance. The corresponding SAT and UNSAT cactus plots are provided in our response to Comment 3. | Instances | Number of instances | Kissat PAR-2 (s) / Solved| Ours (Phase+VSIDS norm, mapped) PAR-2 (s) / Solved| | :--- | ---: | ---: | ---: | | SAT | 172 | 3,590.63 / 118 | 3,593.11 / 117 | | UNSAT | 161 | 3,945.46 / 106 | 3,965.09 /107|

  3. Guidance is generated from the CNF supplied to Kissat, before Kissat’s own preprocessing. We map hint variable IDs obtained from GPU to Kissat's internal variables through solver->import, correcting phase signs and skipping unimported or eliminated variables. Phases are written to the target and best arrays, leaving saved phases unchanged. The same mapping preserves the VSIDS ranking. The top 50 valid variables receive 10,000. Hints are injected once before Kissat’s preprocessing. Subsequent preprocessing and inprocessing proceed normally, without regenerating or reloading guidance.

  4. We prioritized the additional SAT Competition 2026 experiments with the available computing resources and have not yet completed the random-phase portfolio comparison. We therefore cannot isolate how much of the benefit comes from optimized logits rather than phase diversification alone. We will also clarify that the absence of clause sharing is a possible explanation for the weaker UNSAT results, but its effect has not been isolated experimentally.

Thank you for the answers. I appreciate it.

Reviewer_eH2FOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposed a differentiable heuristic for the CDCL SAT solver initialization, and extended it from single-thread solving to parallel portfolio solving. By comparing the performance metrics (#solved instances, PAR2) with Kissat and MallobSat, respectively, they concluded that their techniques outperformed the others.

Critical strengths

The paper proposed a differential heuristic that can be integrated into a GPU. Considering the tendency of computation transformation from CPU to GPU, this point is interesting. As traditional SAT solvers are mainly focused on CPU running, even though there are some GPU-based SAT solvers, like ParaFROST[1], GPUShareSat[2], and so on. Relatively, this is a minority.

[1] Certified SAT solving with GPU-accelerated inprocessing, [2] Leveraging GPUs for Effective Clause Sharing in Parallel SAT Solving

Critical weaknesses

In general, I have to confess that this paper contributes too little and it does not investigate/experiement the proposed techniques in a rigorous way.

  1. Positioning of the paper: The initialization heuristics can be regarded as a pre-processing technique. But I didn't see related work cited or discussed at all, nor was the comparison ever mentioned. Please go to the Handbook of Satisfiability; there are detailed chapters discussing this, where you will find a lot.

  2. The novelty of the initialization heuristic: the authors' differentiable technique is runnable on the GPU. But besides that, why should the SAT solver community accept/adopt this? If it is due to the high performance, I would say the current experiment is too superficial. Why are you comparing the performance with Kissat? Of course, you did initialization techniques before running Kissat, and it is natural to get better results. How about the results with AE-Kissat-MAB? This is the actual winner.

  3. The experiment's soundness: I am quite surprised that the authors do not even present the cactus plot for the evaluation. Only the final tables filter too much information. In almost every year's SAT competition report, organizers will show this, which can indicate convergence, premature convergence, long-term capability, and so on.

  4. Experimental settings: I assume the authors are not careful about the competition setting at all. There are many flaws, for example, the authors think 5000 seconds is the timeout used during the competition. This is only partially true, as you also claim parallel outperformance, but the capped time for parallel solving of 1000 is actually used in the competition. Please follow the rules strictly.

  5. Extensiveness of the experiments: Even the organizers of the SAT competition will use different instances each year, how could the authors show their outperformance only with one year of competition instances? And the year is not the most recent year of the competition. Furthermore, there is no reasonable comparison at all. As I explained before, like the pre-processing algorithms, and the new competition winner. If authors check the 2026 competition results carefully, they will find a significant gain this year from symmetry-breaking techniques that led to the final winner. And there are other interesting points, like the organizer divided the AI-assisted solver, which is even better than the human-track solvers. Could the authors complete these ones?

  6. The submission is in a hurry: Please reorganize the whole presentation. Even the tables are wobbly; for example, the texts overlap in Table 2. And there are many other details that are too numerous to mention one by one.

  7. Casual citations: Please ensure you cite the suitable paper for your motivation. For example, Carla's paper is cited as a source of restart strategies, but only partially so, as it focuses on heavy-tailed instances. It is better to cite the paper by Armin and Andreas (Evaluating CDCL Restart Schemes, POS, 2015). Human checking of all papers is necessary before the citation!

Questions for authors

Please refer to the weaknesses.

2 comments

Thank you for your comments. We apologize for the delayed response, as the additional experiments on the SAT Competition 2026 benchmark took longer than expected. Below, we clarify our methodological choices and experimental setup, and provide updates on the additional experiments.

  1. We will add a paragraph discussing prior initialization techniques and their relationship to preprocessing, including methods from the Handbook of Satisfiability. We will clarify that our guidance initializes phase preferences and variable activities without adding constraints to the CNF passed to the solver.

  2. Our contribution is the guidance mechanism, including saliency scoring and degree normalization for phase and activity initialization. We selected Kissat as a state-of-the-art CDCL solver and used it as the baseline to isolate the effect of our guidance. The guidance-generation component is independent of the solver backend. It produces phase preferences and initial variable activities that can be passed to the solver through an initialization interface. This design makes our method straightforward to integrate into other CDCL solvers that use phase heuristics and VSIDS. We have also implemented this interface in CaDiCaL. Also, initialization does not guarantee faster solving. Misisleading guidance can increase search time. The runtimes reported in our original evaluation include GPU initialization. AE-Kissat-MAB adaptively selects between VSIDS and CHB during stable-mode restarts. Integrating our activity guidance into this mechanism requires further validation of its interaction with both heuristics. We therefore prioritized integrating our guidance with satsuma-iter+Kissat, the SAT Competition 2026 Main track winner, to evaluate whether it provides additional benefits alongside symmetry breaking.

  3. We will add cactus plots for the 2024 and 2026 benchmarks, with separate SAT and UNSAT results, alongside solved counts and PAR-2 scores. The tables below report cumulative solved counts at selected time budgets, corresponding to the linked cactus plots. SAT and UNSAT results are reported separately.

Link to single thread 2024 cactus plot: https://drive.google.com/file/d/1ZsK-iS_Zwm44pWgxczxPRxehZ313r0-B/view?usp=drive_link

Link to multi-thread 2024 cactus plot: https://drive.google.com/file/d/1nf0bAUR9avps-1H3oWiqmZAgpCWIuieT/view?usp=sharing

Link to single thread 2026 cactus plot: https://drive.google.com/file/d/16UJi0-J6mB6Bv7_zwHG2Je4hMxCfwE43/view?usp=drive_link

The tables below report cumulative solved counts at selected time budgets, corresponding to the linked cactus plots. SAT and UNSAT results are reported separately. PAR-2 is calculated with a 5,000-second timeout, assigning 10,000 seconds to each unsolved instance.

2024 single-thread — SAT (167 instances)

Time budget (s)KissatOurs (Phase+VSIDS norm)
10085100
500127137
1,000134139
2,000140144
3,000143146
4,000147149
5,000149152
PAR-2 (s)1,421.281,201.08

2024 single-thread — UNSAT (201 instances)

Time budget (s)KissatOurs (Phase+VSIDS norm)
1005056
500103111
1,000127131
2,000140143
3,000141145
4,000145148
5,000147151
PAR-2 (s)3,062.242,870.07

2024 multi-thread comparison — SAT (167 instances)

Time budget (s)Kissat (1T)MallobSat (32T)Ours Phase (32T)
10085126128
500127151146
1,000134153152
2,000140158157
3,000143159159
4,000147160162
5,000149161164
PAR-2 (s)1,421.28529.51425.34

2024 multi-thread comparison — UNSAT (201 instances)

Time budget (s)Kissat (1T)MallobSat (32T)Ours Phase (32T)
1005011262
500103144117
1,000127151134
2,000140157142
3,000141164149
4,000145165152
5,000147168155
PAR-2 (s)3,062.241,930.882,679.62

2026 single-thread — SAT (172 instances)

Time budget (s)KissatOurs (Phase+VSIDS norm)
1005456
5007779
1,0009196
2,000105107
3,000112111
4,000116115
5,000118117
PAR-2 (s)3,590.633,593.11

2026 single-thread — UNSAT (161 instances)

Time budget (s)KissatOurs (Phase+VSIDS norm)
1003736
5006767
1,0008080
2,0008684
3,0009993
4,000105103
5,000106107
PAR-2 (s)3,945.463,965.09
  1. Our original evaluation uses the SAT Competition 2024 benchmark, whose official Parallel track had a 5000 second wall-clock limit. The limit was reduced to 1000 seconds in 2025 and remains 1000 seconds in 2026. We will make the year-specific limits explicit.

  2. We extended our single-thread evaluation to 333 instances from the SAT Competition 2026 benchmark, comprising 172 SAT and 161 UNSAT instances. The table below reports PAR-2 scores with a 5,000-second timeout and a 10,000-second penalty for each unsolved instance. The corresponding SAT and UNSAT cactus plots are provided in our response to Comment 3.

InstancesNumber of instancesKissat PAR-2 (s) / SolvedOurs (Phase+VSIDS norm, mapped) PAR-2 (s) / Solved
SAT1723,590.63 / 1183,593.11 / 117
UNSAT1613,945.46 / 1063,965.09 /107

We also evaluated our guidance alongside the symmetry-breaking approach used by the SAT Competition 2026 winner, using Satsuma iterative preprocessing followed by Kissat 4.0.3, on 24 selected instances (12 SAT and 12 UNSAT). The preprocessing options follow the official iterative configuration, although we use Kissat 4.0.3 rather than 4.0.4. GPU guidance is generated from the Satsuma-preprocessed CNF, and both configurations receive the same preprocessed formula. The results were mixed. Our guidance increased the UNSAT solved count from 10 to 12, including two lightsout instances that otherwise timed out, but reduced the SAT solved count from 11 to 8. These measurements cover downstream solver time, including guide loading and injection, but exclude Satsuma preprocessing and GPU guide generation. We propose our method as an initialization approach that can be integrated into CDCL solvers. This experiment demonstrates compatibility with Satsuma preprocessing. The guidance is applied to the resulting CNF, while the five UNSAT instances already resolved by Satsuma require no guidance and retain their outcomes. This compatibility is useful, although the current results do not show an overall performance improvement.

6–7. We will fix the overlapping text in Table 2 and other formatting issues, and make the method and experimental setup clearer. We will add the reference to the restart discussion and recheck the remaining citations.

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

This paper uses GPU-based differentiable MaxSAT optimization on each input instance to generate phase preferences and variable saliency scores. These are used to initialize phase and VSIDS heuristics in CDCL solvers, with an extension to a parallel phase portfolio. The results show single-threaded improvements and better SAT performance than 32-thread MallobSat, although parallel UNSAT performance is worse.

Critical strengths
  1. Using assignment preferences for phase initialization and variable saliency for VSIDS initialization makes sense. The method guides early search while preserving the completeness of the underlying CDCL solver. Averaging probabilities across batches and normalizing scores by variable degree are also reasonable design choices.
  2. Comparing three initialization configurations within the same Kissat implementation helps show what each component contributes. Reporting SAT and UNSAT results separately, along with a comparison against 32-thread MallobSat, also helps show where the method works well and where it remains limited.
Critical weaknesses
  1. The paper discusses its differences from prior work, but the contributions section could be clearer about what is new. Please clarify how the proposed method differs from related prior approaches such as NeuroBack and TurboSAT, and highlight the novel contributions in the saliency score, degree normalization, and their use for phase/VSIDS initialization.
  2. The paper does not mention GaloisSAT, but the supplementary README says that the code uses the GaloisSAT framework. Please explain how this submission is related to GaloisSAT and which parts are reused or new.
Questions for authors
  1. Could you add experiments on CaDiCaL to evaluate the applicability of the method across solvers?
  2. Why did you use only 368 of the 400 SAT Competition 2024 instances? Please explain the selection criteria and list the excluded instances.
  3. MallobSat was the PAR-2 winner of the SAT Competition 2025 parallel track. Could you report results on SAT Competition 2025 to further demonstrate the method’s effectiveness?
  4. Could you add comparisons with NeuroBack and TurboSAT? They are closely related to your initialization approach, and TurboSAT also used the 2024 benchmarks.
1 comment
AuthorsOpenReview ↗

Answer to questions

Thank you for the helpful comments. We apologize for the delay while we secured computing resources and completed the additional experiments.

First, we agree that the manuscript should more clearly distinguish our contributions from NeuroBack, TurboSAT, and GaloisSAT. NeuroBack uses a pretrained GNN to predict variable phases for initializing Kissat. Our contribution lies in how the guidance is constructed and used to initialize both phase preferences and variable activities. TurboSAT and GaloisSAT’s SAT workflow fix predicted assignments as unit clauses, allowing guided workers to search smaller subspaces. This can accelerate solution finding, but incorrect predictions may exclude all satisfying assignments from a given subproblem. Our method instead uses predictions only to initialize phase preferences and variable activities, preserving the full search space and completeness of each CDCL worker. This difference should be considered when interpreting performance comparisons. We reuse GaloisSAT’s GPU optimization code. Our additions are the phase and decision guide generation, including saliency scoring and degree normalization, and the Kissat modifications that accept these guides. We will make this distinction explicit in the paper and README. We evaluated 368 instances, excluding those with more than 10 million variables or 50 million clauses after conversion to 3-SAT. Our implementation reuses GaloisSAT’s GPU optimization code. The size thresholds were chosen to avoid excessive GPU initialization overhead under the memory and compute constraints of our RTX 4090 setup. We apologize for not stating this criterion and will provide the full list of excluded instances. GaloisSAT demonstrates that this optimization can handle substantially larger instances with greater GPU resources. It reports near-linear training speedup when scaling from 2×A100 to 8×A100 (GaloisSAT, §3.3.1 and Table 3: https://arxiv.org/html/2603.28796#S3.T3). For an instance with approximately 131 million clauses, training time decreased from 884.79 s to 238.18 s. These results support using larger GPU configurations to extend our evaluation beyond the current size limits.The 32 excluded instances are listed below: 12 satisfiable and 20 unsatisfiable instances. This leaves 167 SAT and 201 UNSAT instances in our evaluation. SAT (12 instances) 128_100.sanitized 32_200.sanitized 32_350.sanitized 64_150.sanitized 64_200.sanitized circuit_32in32out_with_64gates_8in6out_dist128_seed2.sanitized circuit_32in32out_with_96gates_7in7out_dist128_seed1.sanitized circuit_48in24out_with_100gates_7in7out_dist128_seed1.sanitized lru_10.sanitized lru_7.sanitized lru_8.sanitized lru_9.sanitized

UNSAT (20 instances) 128_100.sanitized 32_200.sanitized 32_350.sanitized 64_150.sanitized 64_200.sanitized circuit_32in32out_with_64gates_8in6out_dist128_seed2.sanitized circuit_32in32out_with_96gates_7in7out_dist128_seed1.sanitized circuit_48in24out_with_100gates_7in7out_dist128_seed1.sanitized lru_10.sanitized lru_7.sanitized lru_8.sanitized lru_9.sanitized

We agree that experiments with CaDiCaL would help assess whether the benefits extend to other solvers. With limited computing resources, we prioritized experiments on the latest SAT Competition 2026 benchmark using Kissat, the SOTA solver used in our main evaluation. Also, of the 66 benchmark families represented in SAT Competition 2024, 47 also appear in the 2025 benchmark. Given this family overlap and our existing comparison with MallobSat on the 2024 benchmark, we focused our additional experiments on the 2026 benchmark. We therefore did not conduct a separate 2025 evaluation or a full CaDiCaL study.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.