acceptodds
Under review as a conference paper at ICLR 2027

ReCoDe: Re-Conditioned Decoding for Generative Logic Synthesis

Abstract

Generative neural models are a promising approach to logic synthesis, yet on difficult sub-circuits they still lag behind strong classical optimizers such as &deepsyn. How best to spend inference-time compute on these models is an open question: existing search, typically Monte Carlo tree search over decoder tokens, runs from a single fixed encoding of the input, and so can only refine the circuits that one representation makes likely. We show that re-encoding a circuit that is functionally identical but structurally different yields different outputs. Re-Conditioned Decoding (ReCoDe) exploits this by iteratively re-encoding a model's own intermediate outputs as new decoder conditioning, with a population parallelizing the search. We evaluate on several thousand IWLS fanout-free windows at K=8, 10 and 12 inputs, the latter two larger than prior neural synthesis has handled. Under exact equivalence, ReCoDe reduces the size of the hardest windows by 16–22% relative to a single decode at every width, outperforms token-level search given ten times the budget, and is the only neural method to surpass &deepsyn.

Primary area:
generative models
Keywords:
inference-time search, logic synthesis, population-based search

Reviews

Among:
Shape:
1234this paper, Top 32%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.50 over 4 reviews, above 68% of the others.
Reviewer_3mgAOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

This paper proposes Re-Conditioned Decoding (ReCoDe), an inference-time search framework for generative logic synthesis. Unlike existing token-level search methods such as CT+MCTS, which explore decoder continuations from a fixed encoding, ReCoDe iteratively re-encodes intermediate circuits to explore alternative conditioning representations. The method integrates this strategy with a population-based genetic algorithm employing truncation selection and stochastic sampling, without modifying the underlying model. The authors evaluate ReCoDe on IWLS fanout-free windows with 8, 10, and 12 inputs, as well as using a second backbone (GTAC) and in approximate synthesis. The results demonstrate improvements over single-pass decoding and MCTS, with competitive performance against classical synthesis methods.

Critical strengths
  1. The paper identifies the limitations of fixed-conditioning token-level search and presents a well-motivated alternative. The comparison with MCTS-1000 under an equal decoding budget is particularly relevant.
  2. ReCoDe demonstrates improvements across different window sizes and two model backbones. At K=8, ReCoDe-100 also achieves comparable performance to MCTS-100 while running 5.6 times faster.
Critical weaknesses
  1. ReCoDe combines iterative re-encoding with population-based search, but their individual contributions remain unclear. A fixed-conditioning best-of-N baseline with matched sampling strategies is missing, and MCTS-1000 employs a different search procedure. The existing ablation also modifies the decoding strategy, making it difficult to distinguish the benefits of re-conditioning from those of sampling diversity and selection.
  2. Runtime comparisons between ReCoDe-1000 and &deepsyn are missing, leaving computational fairness unclear. Furthermore, the reported advantage over &deepsyn depends on excluding decoding failures. When all windows are included (Table 2), their performance is approximately equivalent, weakening the claim of superiority.
Questions for authors
  1. Could the authors provide a fixed-conditioning best-of-1000 sampling baseline and a controlled ablation that separates the effects of re-encoding and population-based selection?
  2. What are the runtimes of ReCoDe-1000 and &deepsyn? Could the authors compare their performance under matched wall-clock budgets, including all decoding failures?
  3. Could the authors extend the key ablations to a larger set of circuits with statistical analysis and investigate whether the improvements translate to a complete synthesis flow?
4 comments
AuthorsOpenReview ↗

Response to Reviewer 3mgA

We thank the reviewer for the thoughtful review, and are glad they found ReCoDe a well-motivated alternative to fixed-conditioning search. The reviewer's questions helped strengthen the paper. All changes are in the revised PDF and marked in red.

W1 / Q1. Fixed-conditioning baseline and controlled ablation. We added the requested best-of-1,000 baseline and a controlled ablation on 200 windows per width with 3 seeds (Figure 1E). Every variant uses the same 1,000 decodes, the same sampling strategies and the same batched decoding as ReCoDe, and changes one factor. Fixed encoding always decodes from the original encoding and keeps the best result, removing re-encoding. Population size 1 keeps a single parent per generation, and random selection picks the 20 parents at random instead of the 20 smallest.

Removing re-encoding (mean #AND, 200 windows, 3 seeds)

MethodK=8K=10K=12
CT+ReCoDe-100019.14 ± 0.0517.11 ± 0.0921.56 ± 0.08
CT, fixed encoding, best of 1,00019.77 ± 0.0117.29 ± 0.0621.68 ± 0.02

Changing population and selection (same windows and seeds)

MethodK=8K=10K=12
CT+ReCoDe-100019.14 ± 0.0517.11 ± 0.0921.56 ± 0.08
Population size 119.25 ± 0.0617.16 ± 0.0821.55 ± 0.01
Random selection19.29 ± 0.0517.17 ± 0.0521.56 ± 0.03

This separates re-encoding from sampling and selection. Removing re-encoding raises the mean by 0.63, 0.18 and 0.12 AND per window at K=8, 10 and 12. This is significant at every width (paired 95% CI) and larger than the effect of the population or selection rule.

W2 / Q2. All windows, runtime and matched wall clock. Figure 1 (page 7) now counts every window, including decode failures. CT+ReCoDe-1000 is below &deepsyn at every width, significantly at K=10 and K=12 (paired 95% CI).

Mean #AND, all windows (2,600, 3,000, 3,000)

MethodK=8K=10K=12
&deepsyn19.3417.1521.49
CT+ReCoDe-100018.8616.9721.36

The tie in the submission came from windows where no decode completed. We added a decode-failure step to ReCoDe’s search process for these windows. When no initial decode completes, ReCoDe continues its re-encoding search from a circuit reassembled from separately decoded logic cones (Algorithm 1). With the same splitting applied to CT+MCTS, CT+ReCoDe still produces smaller circuits with both 100 and 1,000 decodes at every width.

&deepsyn runs with a 1 s time limit on one CPU core, and CT+ReCoDe-1000 takes 172–248 s per window on one H100 (Table 2). For matched wall clock, we ran &deepsyn with time limits up to CT+ReCoDe-3000's time per window (Figure 5). Its mean size changes by less than 1%, while CT+ReCoDe keeps improving and ends smaller at every width.

Q3. Larger sets and a complete synthesis flow. In the submission, the ablation used five hard windows, the CT+MCTS-1000 comparison five windows per bucket, and only CT+ReCoDe-1000 had 3 seeds. Now the ablations use 200 windows per width, the CT+MCTS-1000 comparison 800 (Table 1), and Figure 1 all 2,600 to 3,000 windows. Every stochastic method has 3 seeds (CT+MCTS-1000 on the 200 windows of Figure 5), and we use paired per-window tests. Table 1's standard deviation is at most 0.04. We are continuing to add windows for the final version.

We also added a complete synthesis flow on EPFL designs (Table 3). To compare every method on each design, including CT+MCTS-1000 at 25–30 minutes per window (570 GPU-hours for mem_ctrl), we evaluate on int2float, router, ctrl and mem_ctrl. All methods optimize the same K=8 windows, with ABC cec on the whole design after every substitution, and &deepsyn gets a 10 s limit per window. CT+ReCoDe-1000 gives the smallest or tied-smallest design on all four. On int2float, the neural methods beat both heuristics. On router and ctrl, mostly easy windows, all methods are within one AND.

mem_ctrl after the complete flow

Method#ANDArea (µm²)Delay (ps)Time (h)
resyn24673029627.66053.40.01
&deepsyn4665629555.86054.01.2
CT+MCTS-1004665129569.66042.818.1
CT+MCTS-10004664329573.96095.0570.3
CT+ReCoDe-1004665229609.06095.41.4
CT+ReCoDe-10004664129546.26045.410.4

Of the 26 mem_ctrl windows where it and &deepsyn differ, CT+ReCoDe-1000 is smaller on 25 (sign test, p < 0.001). It matches CT+MCTS-1000 on size with lower delay (p = 0.013) and the lowest area of every method, using 55× less GPU time. We obtain these area and delay gains without targeting them, since both CT's training targets and ReCoDe's selection consider only #AND.

We hope these additions address each of the reviewer's points, and we would be grateful if the reviewer would consider raising their score. We are happy to answer further questions.

AuthorsOpenReview ↗

Follow-up to Reviewer 3mgA

As the discussion period closes on November 18 (AoE), we wanted to check in. Thank you again for your thoughtful review. Our previous response reported the baseline, ablations and complete synthesis flow you asked about.

We extended the key ablations from five hard windows to 200 windows per width, with 3 seeds and paired per-window tests. The fixed-encoding best-of-1,000 baseline uses the same decodes, sampling strategies and batched decoding as ReCoDe, and removing re-encoding is the largest effect of any factor, significant at every width (Figure 1E). Counting every window, including decode failures, CT+ReCoDe-1000 is below &deepsyn at every width, significantly at K=10 and K=12 (Figure 1). It is also significantly smaller than CT+MCTS-1000 at every width, on 800 windows per width (Table 1). In a complete synthesis flow on EPFL designs, CT+ReCoDe-1000 gives the smallest or tied-smallest design on all four (Table 3).

On computational fairness, following a suggestion by Reviewer 9CdF, we also compared CT+ReCoDe against the best of N independent &deepsyn restarts at matched wall-clock time on one CPU core, and at matched hardware on 24 cores, one H100's share of its server (Section 4.2, Figure 5, Appendix D). We have since extended CT+ReCoDe to 10,000 decodes, and found it keeps improving at every width. From about 3,000 decodes onward, CT+ReCoDe is smaller at every width in both settings, and at 10,000 decodes it is significantly smaller than the best of all &deepsyn restarts at every width (sign test, p < 0.001). In the revised PDF, this round's changes are marked in green and the earlier ones in red.

We would appreciate knowing whether our response addressed your concerns. If it did, we would be grateful if you would consider updating your rating. We are happy to clarify anything further.

I appreciate the authors' detailed response and additional experimental results. The controlled ablations provide stronger evidence of the effectiveness of re-encoding, while the expanded evaluations and complete synthesis flow address most of my earlier concerns.

Nevertheless, I remain concerned about the significance of the overall contribution. Although the controlled ablations demonstrate the benefits of re-encoding, the improvements over the fixed-conditioning best-of-1000 baseline remain relatively modest, particularly for larger windows.

Furthermore, the complete synthesis flow raises additional questions regarding practical effectiveness. For example, on mem_ctrl, ReCoDe-1000 reduces the AND count from 46,656 to 46,641 compared with &deepsyn, while requiring 10.4 hours rather than 1.2 hours. Although the matched wall-clock experiments indicate that extending the runtime of &deepsyn does not substantially improve its results, it remains unclear whether such marginal gains justify the additional computational cost.

Moreover, prior work [1] reports substantially greater reductions in AIG size on the same EPFL benchmark designs. For example, a single application of ABC's compress2rs reduces mem_ctrl to approximately 43,923 AND nodes. Although these results are not directly comparable without verifying that identical initial netlists and optimization settings were used, they suggest that the complete-flow evaluation would benefit from comparisons against stronger classical synthesis flows.

Overall, while the additional results strengthen the empirical validation, they do not change my assessment of the paper's contribution.

References [1] S.-Y. Lee, Contemporary Logic Synthesis: With an Application to AQFP Circuit Optimization, Ph.D. dissertation, EPFL, 2024.

AuthorsOpenReview ↗

New complete-flow experiment with compress2rs, and clarifying the contribution

Thank you for reading the new results. We answer your remaining concerns in turn.

1. Size of the improvements. The margins of generative models over the heuristics are small in this line of work, where every circuit must stay exactly equivalent to its input. In the Circuit Transformer paper (Li et al., ICLR 2025), the leading method, CT+MCTS, is 0.5% below Resyn2. Our baseline &deepsyn is stronger, 3 to 8% below Resyn2 on our windows. Measured against &deepsyn, the Circuit Transformer with one decode is 8 to 14% larger, CT+MCTS-1000 is still 0.1 to 0.9% larger, and CT+ReCoDe-1000 is 0.6 to 2.5% smaller (Table 1). Re-encoding is what makes this difference, and its effect is significant at every width (paired 95% CI). With the same 1,000 decodes, a fixed encoding does not get below a single &deepsyn run at any width, and re-encoding does at every width (Figures 1E and 5).

2. Stronger classical flows. ABC's compress2rs restructures the whole design. On our starting netlist it gives 43,924 ANDs on mem_ctrl, in line with [1], and we will add it to Table 3. The methods in Table 3 rewrite only 8-input windows, which cover at most 12% of mem_ctrl. Since the two are complementary, we applied the same window flow after compress2rs.

mem_ctrl: #AND with compress2rs + window flows applied after

Method#ANDReduction after compress2rs
Original46,836
&deepsyn on windows (Table 3)46,656
CT+MCTS-1000 on windows (Table 3)46,643
CT+ReCoDe-1000 on windows (Table 3)46,641
compress2rs43,924
compress2rs + resyn243,87549
compress2rs + CT single decode43,83589
compress2rs + &deepsyn43,795129
compress2rs + CT+ReCoDe-100043,785139

After compress2rs, CT+ReCoDe-1000 removes a further 139 ANDs, more than every other window optimizer, and it is smaller than &deepsyn on 32 of the 503 windows and larger on none (sign test, p < 0.001).

3. Cost. On mem_ctrl, CT+ReCoDe-100 is level with &deepsyn in about the same time (1.4 GPU-hours against 1.2 CPU-hours), and CT+ReCoDe-1000 reaches the size of CT+MCTS-1000 with 55× less GPU time.

Overall contribution. We added the complete synthesis flow at your suggestion. The main purpose of the paper is not a tool that replaces classical flows. The paper belongs to an emerging line of work on generative models for logic synthesis (Li et al., ICLR 2025). Generative models are highly successful in language and vision, but under exact equivalence they are only starting to match hand-engineered heuristics. Our contribution is a more effective way to spend inference-time compute in these models: re-encoding the model's own outputs instead of searching over decoder tokens from one fixed encoding. Relative to a single decode, the baseline that inference-time compute is meant to improve, CT+ReCoDe-1000 reduces the size of the hardest windows by 18 to 22% (Figure 1).

We also ran one further experiment, on a second problem that requires exact equivalence: shortening expressions in the Halide compiler, with every output proven equivalent by Z3. Details will be in the paper's appendix.

Halide: mean expression length in characters, reduction relative to the input, and time per expression (1,855 expressions)

MethodDecodesLengthReductionTime
Input65.90
Z3 simplifier62.654.9%
Caviar55.2616.1%
Halide's own simplifier52.5820.2%
Our model, one decode163.723.3%
Fixed encoding, best of N10052.4320.4%75 ms
MCTS10052.6820.1%237 ms
ReCoDe10051.7521.5%74 ms
Fixed encoding, best of N1,00050.0524.0%198 ms
MCTS1,00050.0424.1%431 ms
ReCoDe1,00048.7826.0%195 ms
ReCoDe2,00048.0527.1%339 ms

With one decode, the model is behind all three symbolic simplifiers in the table (Z3, Caviar and Halide's own, which are built on hand-written rules). With ReCoDe-1000 it is ahead of all three, by 7% against Halide's own and 12% against Caviar, and ahead of MCTS and the fixed encoding at the same number of decodes, in less than half the time of MCTS (all significant, paired 95% CI). This illustrates one of the main points of our paper. In domains that require equivalence, exact as here or relaxed as in approximate synthesis, where neural models have so far been behind, ReCoDe is a general way to spend inference-time compute, and it lets generative models close the gap to hand-engineered heuristics.

We appreciate your noting that the ablations give stronger evidence for re-encoding and that the complete flow addresses most of your concerns. We hope these results address the remaining ones, and we would be grateful if you would reconsider your rating.

Reviewer_k2jGOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents ReCoDe, an inference-time search method for generative logic synthesis.
ReCoDe re-encodes intermediate generated circuits and continues decoding from their new representations. ReCoDe is evaluated on exact and approximate synthesis using Circuit Transformer and GTAC.

Critical strengths
  1. ReCoDe is a simple and useful inference-time method that requires no backbone modification or additional training.
  2. Functional correctness is verified exhaustively over all input patterns, with an additional ABC equivalence check for the 8-input setting.
  3. The paper presents informative mechanism analyses and clearly acknowledges when dedicated approximate synthesizers remain better.
Critical weaknesses
  1. ReCoDe combines repeated encode-decode steps with a standard population-based search using truncation selection. Iterative re-encoding, learned mutation operators, and population-based optimization are all established ideas. The main novelty is their application to constrained generative logic synthesis, rather than a new general search mechanism.

  2. The main matched-budget evidence is too small. CT+MCTS-1000 and ReCoDe-1000 are compared at the same 1000-decode budget on only five windows per bucket. The no-population re-encoding baseline is evaluated on only five hard windows. At the 100-decode budget used on the full benchmark, ReCoDe only matches MCTS at 8 inputs and performs worse on the harder 10- and 12-input windows.

  3. The mechanism comparison is not fully controlled. ReCoDe changes the conditioning, population structure, selection rule, batching behavior, and sampling procedure. An random-restart baseline that always decodes from the original encoding would better isolate the contribution of re-encoding.

Questions for authors
  1. Can the authors compare ReCoDe-1000 and MCTS-1000 on a larger matched set, then report paired results and end-to-end GPU time?
  2. Can the authors add a fixed-encoding random-restart baseline with the same sampling strategies and decode budget?
4 comments
AuthorsOpenReview ↗

Response to Reviewer k2jG

We thank the reviewer for the careful review and the concrete requests, which led to new experiments that helped strengthen the paper. All changes are in the revised PDF and marked in red.

W1. Scope of the contribution. We agree that our contribution lies in the application to generative logic synthesis rather than in a new general search mechanism. Existing search such as CT+MCTS explores token continuations from one fixed encoding of the input. ReCoDe instead searches over the encoding itself, by re-encoding equivalent intermediate circuits. This has two practical benefits. First, it scales with compute. At every time budget and width, CT+ReCoDe gives smaller circuits than CT+MCTS and keeps improving even at 3,000 decodes (Figure 5, page 9). Second, as the reviewer notes, it requires no backbone modification or retraining. It is a general inference-time framework in the generative logic synthesis domain, and works with different neural backbones in both exact and approximate synthesis, improving CT in exact synthesis, and both CT and GTAC in approximate synthesis (Figures 1 and 2, page 7).

W2 / Q1. Larger matched comparison, paired results and GPU time. We now compare on 800 windows per width, instead of five per bucket, with 3 seeds (Table 1, page 8), and are continuing to add windows for the final version.

Mean #AND per window

MethodK=8K=10K=12
CT+MCTS-10019.68 ± 0.0117.88 ± 0.0121.67 ± 0.00
CT+MCTS-100019.4417.5921.32
CT+ReCoDe-10019.61 ± 0.0217.56 ± 0.0421.41 ± 0.02
CT+ReCoDe-100018.93 ± 0.0317.33 ± 0.0221.14 ± 0.03

In a paired per-window test (95% CI), CT+ReCoDe-1000 is significantly smaller than CT+MCTS-1000 at every width. CT+MCTS-1000 has one seed here because of its cost. However, on the 200 windows of Figure 5 we ran CT+MCTS-1000 with 3 seeds, and its standard deviation is at most 0.01.

Previously, our CT+ReCoDe-100 underperformed CT+MCTS-100 at K=10 and K=12, as the reviewer pointed out. This came from windows where no decode completed. We added a decode-failure step to ReCoDe's search process for these windows. When no initial decode completes, ReCoDe continues its re-encoding search from a circuit reassembled from separately decoded logic cones (Section 3.2, Algorithm 1). After this change, CT+ReCoDe-100 produces smaller circuits than CT+MCTS-100 at every width, while using 3.4–5.3× less time. With the same splitting applied to CT+MCTS, CT+ReCoDe still produces smaller circuits with both 100 and 1,000 decodes at every width.

Time per window (s), one H100

MethodK=8K=10K=12
CT+MCTS-100179148160
CT+MCTS-1000177014861477
CT+ReCoDe-100343447
CT+ReCoDe-1000172186248

Times are end to end (Table 2, page 8). We also added a new experiment that runs every method through a complete synthesis flow on full EPFL designs (Table 3, page 10). On mem_ctrl, the largest design, optimizing all 425 windows takes 10.4 GPU-hours with CT+ReCoDe-1000, against 570.3 for CT+MCTS-1000. There CT+ReCoDe-1000 matches CT+MCTS-1000 on size and has the lowest mapped area of all methods, while taking 55× less GPU time.

W3 / Q2. Fixed-encoding random-restart baseline with the same sampling and budget. We added the requested control and moved the ablations from five hard windows to 200 windows per width with 3 seeds (Figure 1E, page 7). Each variant changes one of the factors the reviewer lists, with the same 1,000 decodes, the same sampling strategies and the same batched decoding as ReCoDe. Fixed encoding is the requested random-restart baseline. It always decodes from the original encoding and keeps the best result, removing re-encoding. Population size 1, which replaces the earlier no-population re-encoding baseline, changes the population structure, keeping only the single smallest candidate as the parent in each generation. Random selection changes the selection rule, choosing the 20 parents at random instead of the 20 smallest.

Mean #AND, 200 windows, 3 seeds

MethodK=8K=10K=12
CT+ReCoDe-100019.14 ± 0.0517.11 ± 0.0921.56 ± 0.08
CT+ReCoDe-1000, population size 119.25 ± 0.0617.16 ± 0.0821.55 ± 0.01
CT+ReCoDe-1000, random selection19.29 ± 0.0517.17 ± 0.0521.56 ± 0.03
CT, fixed encoding, best of 1,00019.77 ± 0.0117.29 ± 0.0621.68 ± 0.02

This isolates the contribution of re-encoding. Without it, the mean grows by 0.63, 0.18 and 0.12 AND per window at K=8, 10 and 12. This is significant at every width (paired 95% CI) and the largest effect of any factor. Even with population size 1, re-encoding beats fixed encoding.

We hope these additions address each of the reviewer's concerns, and we would be grateful if the reviewer would consider raising their score. We are happy to answer further questions during the discussion period.

AuthorsOpenReview ↗

Follow-up to Reviewer k2jG

As the discussion period closes on November 18 (AoE), we wanted to check in. Thank you again for your concrete suggestions. Our previous response reported both experiments you proposed.

We now compare CT+ReCoDe and CT+MCTS on 800 windows per width instead of five per bucket. CT+ReCoDe is smaller at both 100 and 1,000 decodes at every width, significantly so at 1,000 in a paired per-window test (Table 1), with end-to-end GPU times in Table 2. We moved the ablations from five hard windows to 200 windows per width with 3 seeds and added the fixed-encoding random-restart baseline, with the same 1,000 decodes, sampling strategies and batched decoding as ReCoDe. Removing re-encoding is the largest effect of any factor and significant at every width (Figure 1E).

Our response also noted that, at matched time on the same GPU, CT+ReCoDe is below CT+MCTS at every time budget and keeps improving with compute (Figure 5). We have since extended CT+ReCoDe to 10,000 decodes, and found it still improves at every width (Figure 5, Table 5). In the revised PDF, this round's changes are marked in green and the earlier ones in red.

We would appreciate knowing whether our response addressed your concerns. If it did, we would be grateful if you would consider updating your rating. We are happy to clarify anything further.

Thank you for the detailed response and the substantial additional experiments.

I still consider the methodological novelty modest and largely specific to generative logic synthesis. Although the rebuttal materially strengthens the empirical validation, it does not change my assessment of the paper's overall contribution, so I retain my rating of 2.

Thank you for the reply. To address the concern that the method is largely specific to generative logic synthesis, we applied ReCoDe in another domain, expression simplification in the Halide compiler.

Task and data. The task is expression simplification, a standard step in optimizing compilers, which is to rewrite an integer expression from the Halide compiler into a shorter equivalent one. Halide has its own rule-based simplifier for it. As in our exact synthesis setting, an output counts only if it is exactly equivalent to its input, and here Z3 proves this for every output. We trained our own 44M-parameter encoder-decoder models on synthetic expressions paired with the output of Halide's simplifier, and we test on 1,855 distinct expressions from the public data of [1], which were extracted from the Halide compiler. As in our previous experiments, the baselines are matched to ReCoDe: all methods use the same models, the same number of decodes and the same equivalence check. The baselines use the same sampling temperature as ReCoDe.

Mean expression length in characters, reduction relative to the input, and time per expression

MethodDecodesLengthReductionTime
Input65.90
Z3 simplifier62.654.9%
Caviar55.2616.1%
Halide's simplifier52.5820.2%
Our model, one decode163.723.3%
Fixed encoding, best of N10052.4320.4%75 ms
MCTS10052.6820.1%237 ms
ReCoDe10051.7521.5%74 ms
Fixed encoding, best of N1,00050.0524.0%198 ms
MCTS1,00050.0424.1%431 ms
ReCoDe1,00048.7826.0%195 ms
ReCoDe2,00048.0527.1%339 ms

ReCoDe gives the shortest expressions at every number of decodes, and it does so in less time than MCTS. It is ahead of MCTS both at equal decodes and with less time. It is also ahead of the fixed encoding, which differs from it only in re-encoding. With 1,000 decodes, ReCoDe is also significantly shorter than the symbolic simplifiers, by 7% against Halide's own simplifier and 12% against Caviar. All of these differences are statistically significant (paired 95% confidence intervals).

What this domain shares with logic synthesis. Section 3.1 explains why re-encoding helps. The training targets come from a heuristic, so a decode is not minimal, and the encoder conditions on the structure of its input, so an equivalent output induces a new distribution. Together with an exact equivalence check, these are the properties ReCoDe uses, and none is specific to generative logic synthesis. The method again gives better results than sampling or MCTS from a fixed encoding. This indicates that ReCoDe carries over to exact-equivalence problems outside circuits. We will add this experiment to the paper as an appendix, with full details.

Thank you for raising this point. It led us to test ReCoDe outside logic synthesis, and we believe the result strengthens the paper. We appreciate your acknowledgement of the substantial additional experiments, and that they materially strengthen the empirical validation. We hope this new experiment addresses your remaining concern, and we would be grateful if you would reconsider your rating.

[1] Kourta, S., Namani, A. A., Benbouzid-Si Tayeb, F., Hazelwood, K., Cummins, C., Leather, H., & Baghdadi, R. (2022, March). Caviar: an e-graph based TRS for automatic code optimization. In Proceedings of the 31st ACM SIGPLAN International Conference on Compiler Construction (pp. 54-64).

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

The authors address the minimization of And-Inverter Graphs (AIGs), a standard representation of Boolean circuits, and propose an inference-time procedure for neural circuit synthesizers built on an encoder-decoder architecture. The current state of the art searches for a smaller, functionally equivalent AIG with a Monte Carlo Tree Search (MCTS) over decoder tokens. The input graph X0X_0 is encoded once into a latent representation h(X0)h(X_0). MCTS then explores alternative token continuations of the output circuit, and every rollout is conditioned on the same fixed latent, Y∼pθ(⋅∣h(X0))Y \sim p_\theta(\cdot \mid h(X_0)).

ReCoDe makes the conditioning dynamic instead. Each decoded circuit is fed back into the encoder, so successive circuits are conditioned on the model's own intermediate outputs: Yk∼pθ(⋅∣h(Yk−1)),Y0:=X0,Y_k \sim p_\theta\big(\cdot \mid h(Y_{k-1})\big), \qquad Y_0 := X_0,which gives the chain h(X0)→h(Y1)→h(Y2)→⋯h(X_0) \to h(Y_1) \to h(Y_2) \to \cdots. This recurrence is embedded in a genetic algorithm that discards unpromising candidates at each generation.

Critical strengths

Because their solution is design to operate at inference time, ReCoDe can wrap generative encoder-decoder synthesizer whose decoded output are valid inputs to its own encoder. The authors demonstrate ReCoDe efficacy with two separately trained backbones (CT and GTAC), under exact equivalence and under an error constraint, without retraining either model.

Critical weaknesses

The weaknesses fall into two areas: the method and the results.

Method

  1. Training data. The AI-use statement says that LLMs were used to generate synthetic datasets. Which datasets does this refer to, and does it include the 15 million circuits used to retrain CT at K=10K = 10 and K=12K = 12 (Section 4.1)? If not, how were they generated? In particular, it is unclear how the input circuits XX are created, what target YY the retrained synthesizer is trained on, and which method is used to compute YY.

  2. Training procedure. Closely related, the paper describes neither the objective nor the practical aspects of retraining CT at K=10K = 10 and K=12K = 12, so these models are not reproducible without the code. Missing details include, among others, the loss function, the number of encoder and decoder layers, and the learning rate.

  3. Justification for re-encoding. It is unclear why the iterative encode–decode procedure should help: the ablation on five hard windows (Table 1B) shows that it does, but a theoretical justification is missing. If the backbone were trained to output a true minimum, $ f^\star(X) \in \arg\min_{Y \equiv X} #\mathrm{AND}(Y), $ then #AND(f⋆(f⋆(X)))=#AND(f⋆(X))\#\mathrm{AND}\big(f^\star(f^\star(X))\big) = \#\mathrm{AND}\big(f^\star(X)\big) and re-encoding would add nothing. Iteration can only help if the learned map fθf_\theta is not idempotent in this sense, e.g. because the targets YY are produced by a heuristic (Resyn2 for the 8-input CT), or because the encoding depends on circuit structure rather than only on the function (X≡X′⇏h(X)=h(X′)X \equiv X' \not\Rightarrow h(X) = h(X')). Could the authors state the targets of the retrained models and clarify which mechanism drives the gain?

Results

  1. Baselines. Zhu et al. [1] is not included among the baselines, although the paper relies on it for the definition of fanout-free windows and for the benchmark. Could the authors explain this choice?

  2. Variance. Apart from CT+ReCoDe-1000 in Figure 1 (mean ±\pm std over three seeds), no standard deviations are reported: Tables 1 to 4 report single runs, and the seeds of the stochastic baselines (&deepsyn, CT+MCTS) are not stated. Why?

  3. Runtime. Apart from CT+ReCoDe-100 against CT+MCTS-100 at K=8K = 8 (8 s against 45 s per window), no wall-clock times are reported; a full comparison across all baselines would help validate the reported gains. Was the same time limit applied to every baseline, and in particular, what limit was set for &deepsyn? Plots of graph-size reduction versus computation time would also clarify this point.

[1] X. Zhu, R. Tang, L. Chen, X. Li, X. Huang, M. Yuan, W. Sheng, and J. Xu. A database dependent framework for kk-input maximum fanout-free window rewriting. In 2023 60th ACM/IEEE Design Automation Conference (DAC), pp. 1–6. IEEE, 2023.

Questions for authors

I would appreciate, if you could address the weaknesses. I would be really happy to change my rating as a consequence.

7 comments
AuthorsOpenReview ↗

Response to Reviewer 9CdF

We thank the reviewer for the careful reading and the precise questions, which led to new experiments and a clearer description of our training setup. All changes are in the revised PDF and marked in red.

W1. Training data and use of AI. At K=8 we use the CT checkpoint released by the original CT authors (Li et al., 2025) unchanged. For K=10 and K=12 we train one 12-input CT from scratch, and use it at K=10 by adding two unused inputs to each 10-input window. The training inputs are 15M random 12-input, 2-output AIGs of 24–78 ANDs, the released 8-input size range scaled to 12 inputs. We reject any circuit whose output functions match a benchmark window.

Each target is the &deepsyn result for its input with a 1 s limit, as in the released CT training code, and we keep a pair only if simulation on all 4,096 input patterns confirms that the target computes the same function.

The submitted AI statement wrongly implied that an LLM generated our datasets, and we have corrected it. For the data, an LLM only helped edit the code of the random-circuit generator from the CT authors, which we verified and take full responsibility for. No training circuit or target was directly generated by an LLM. Details are in Section 4.1 (page 5) and Appendix B (page 14). We appreciate the reviewer's attention to these details, which made the paper more reproducible.

W2. Training procedure. The architecture matches CT: 12 encoder and 12 decoder layers, width 512, 8 heads and feed-forward width 2048. The loss is the masked token-level cross-entropy of the decoder against the target AIG. We use Adam (β1=0.9, β2=0.98, ε=1e-9) with 4,000 warm-up steps, peak learning rate 7e-4 and batch size 128, for 19 epochs on 14.1M of 15M pairs.

W3. Justification for re-encoding. We thank the reviewer for this insightful argument, which helped us formulate the rationale now in Section 3.1 (page 4). Both mechanisms the reviewer names matter, in different roles. Our retrained model's targets come from &deepsyn, a heuristic, so a decode is often not of minimum size. CT's encoder reads the gates and connections of the AIG, not its truth table, so an equivalent circuit gives a different distribution of decodes. The second is what separates re-encoding from resampling. If the encoding depended only on the function, all equivalent circuits would share one encoding, and ReCoDe would reduce to sampling from the original encoding.

The ablation agrees with this account, now on 200 windows per width instead of five, with 3 seeds. Sampling only from the original encoding, with the same 1,000 decodes and sampling strategies, is significantly worse at every width (paired 95% CI).

Mean #AND per window

MethodK=8K=10K=12
CT+ReCoDe-100019.14 ± 0.0517.11 ± 0.0921.56 ± 0.08
CT, fixed encoding, best of 1,00019.77 ± 0.0117.29 ± 0.0621.68 ± 0.02

W4. Zhu et al. We added the method of Zhu et al. (2023), MFFW Rewriting, as a baseline. We reimplemented it, ran it on every benchmark window, and report it in Figure 1 (page 7) and Section 4.1.

W5. Variance and seeds. Figure 1 (page 7), Table 1 (page 8) and the ablations now report the mean and standard deviation over 3 seeds for every stochastic method, including &deepsyn and CT+MCTS. In Table 1 the standard deviation is at most 0.04 AND per window. The one exception is CT+MCTS-1000 in Table 1, with one seed because of its cost. However, we did run CT+MCTS-1000 with 3 seeds on the 200 windows of Figure 5, with standard deviation at most 0.01. Table 1 now uses 800 windows per width, and we are adding more windows for the final version.

W6. Runtime and time limits. We added wall-clock time for &deepsyn and the neural methods to the main paper (Table 2, page 8). Neural methods run on one H100 and &deepsyn on one CPU core. &deepsyn is single-threaded, so more cores do not speed up a run.

Time per window (s)

MethodK=8K=10K=12
&deepsyn111
CT+MCTS-100179148160
CT+MCTS-1000177014861477
CT+ReCoDe-100343447
CT+ReCoDe-1000172186248

&deepsyn uses a 1 s limit. CT+MCTS and CT+ReCoDe have no time limit, and their budget is the number of decodes. As the reviewer suggested, we added plots of graph size and mapped area versus computation time (Figure 5, page 9). We also ran &deepsyn with time limits up to CT+ReCoDe-3000's time per window. Its mean size changes by less than 1%, while CT+ReCoDe keeps improving and ends up smaller at every width. On all 3,000 windows, CT+ReCoDe-1000 is significantly smaller than &deepsyn (16.97 vs 17.15 at K=10, 21.36 vs 21.49 at K=12).

We hope these additions address each of the reviewer's points, and we would be grateful if the reviewer would consider updating the score. We are happy to answer further questions during the discussion period.

Thank you for the detailed answers. They address my questions and give me a much clearer understanding of your work. After reading the revised PDF, I have one minor observation and one last question.

Minor observation (compute comparison). Table 2 compares &deepsyn on a single CPU core with the neural methods on a full H100. These hardware resources are very different, so wall-clock time alone does not show a fair comparison of compute. A short statement of this asymmetry in the paper, or a comparison in terms of equivalent resources, would make Table 2 easier to read.

Question (&deepsyn with restarts). The results are clearly better than those of existing neural methods, and the experiments show that ReCoDe uses inference-time compute more effectively than the current state of the art. However, &deepsyn uses about two orders of magnitude less time than CT+ReCoDe-1000 (1 s against 186 s at K=10K = 10 and 248 s at K=12K = 12 per window, Table 2). It still comes within about 1.0% of CT+ReCoDe-1000 at K=10K = 10 (17.15 against 16.97 AND per window) and within about 0.6% at K=12K = 12 (21.49 against 21.36 AND per window).

&deepsyn is a stochastic heuristic. With its default settings (-I 1), it runs one search from one fixed seed and does not restart. Figure 5 increases only the time limit (-T). A natural additional baseline is the best of NN independent restarts, for example &deepsyn -I N -T 1, where restart ii uses seed S+iS+i. NN can be chosen so that the total CPU time matches the time per window of CT+ReCoDe, or the restarts can run in parallel on several CPU cores to match the hardware cost of one H100. This would compare the two methods at equal time and also at more comparable physical resources.

If you think this experiment is not relevant or not applicable to your work, please mentioned it.

AuthorsOpenReview ↗

&deepsyn with restarts

Thank you for reading the revised PDF so carefully, and for these suggestions. This round's changes are marked in green.

On the minor observation, we agree that wall-clock time on one H100 and on one CPU core is not a comparison at equal resources. The caption of Table 2 now says so, notes that these times are a reference point, and points to Figure 5 and the new Appendix D, which compare the methods at equal resources.

On the restart baseline, we ran it as you described and added it to Section 4.2, Figure 5 and Appendix D. Each restart is one run of &deepsyn -T 1 with its own seed, and we keep the best of N restarts, given the time per window of CT+ReCoDe either on one CPU core (equal time) or in parallel on 24 cores, one H100's share of its server (equal hardware). Table 5 gives the numbers, mean #AND on the 200 windows per width of Figure 5:

DecodesMethodK=8K=10K=12
1,000CT+ReCoDe19.1417.1121.56
&deepsyn restarts, 1 core19.2317.1221.51
&deepsyn restarts, 24 cores19.0517.1121.48
3,000CT+ReCoDe19.0017.0021.36
&deepsyn restarts, 1 core19.1417.1221.50
&deepsyn restarts, 24 cores19.0117.1121.46
10,000CT+ReCoDe18.8816.9021.27
&deepsyn restarts, 1 core19.0717.1221.48
&deepsyn restarts, 24 cores18.9717.1021.45

We read your question as whether the advantage of CT+ReCoDe over &deepsyn only reflects its much larger compute. At 1,000 decodes, giving &deepsyn the same time and hardware closes the distance you point out, and on 24 cores restarts are slightly ahead at K=8 and K=12. But as compute grows, &deepsyn improves more slowly than CT+ReCoDe, whether through a longer time limit, more restarts or more cores, and CT+ReCoDe eventually surpasses it, as the curves in Figure 5 show. From about 3,000 decodes onward, CT+ReCoDe is smaller at every width in both settings. At 10,000 decodes it finds a smaller circuit than the best of tens of thousands of restarts on 19 to 28% of windows, and a larger one on 2 to 12% (sign test, p < 0.001 at every width). This suggests that the gap reflects how the two methods use additional compute rather than how much they get.

This also changed how we discuss the result. The CT backbone is trained on single 1 s runs of &deepsyn, so &deepsyn is its teacher. We keep the single run as the main baseline in Figure 1 to measure whether search lets the model surpass its teacher, and the restart experiment shows that with enough compute it also goes beyond the stronger variant of the teacher. We added this to the Discussion. In Future work we added the natural next steps: training the backbone on stronger targets, such as best-of-N &deepsyn, and also repeatedly fine-tuning it on ReCoDe's own outputs, in a self-improving loop that needs less search at inference time.

Thank you again for this suggestion. We would be glad to hear your thoughts on these results, and if they address your remaining question, we would be grateful if you would consider updating your rating.

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

This paper proposes a inference time method that integrates genetic algorithm with the pretrained circuit transformer model. The introduced ReCoDe dramatically reduces area especially for the hard circuit subset. This paper explores the sequential time-time scaling of generative circuit synthesis and outperforms human operators, which is a big step.

Critical strengths
  • A simple but effective inference time computation method to iteratively refine the circuits with the pretrained circuit transformer model.
  • Noticeable area optimization under the hard subset under different cut input size.
Critical weaknesses
  • The curve of the overall circuit area under the iterative refinement process is not provided to demonstrate the effectiveness of test time scaling.
  • No wall time cost is provided for different methods.
Questions for authors
  • What are the area results of CT+ReCoDe-1000 and CT+MCTS-1000 under larger input cut size? The current CT+ReCoDe-100 underperform CT+MCTS-100.
  • How does the ReCoDe scale with more computation budget?

I will raise my score if you properly address my questions.

2 comments
AuthorsOpenReview ↗

Response to Reviewer PzDA

We thank the reviewer for the positive evaluation of our work and the insightful questions, which led to new experiments that helped strengthen the paper. We have addressed all of them in the revised PDF, with changes marked in red.

W1. Circuit area under iterative refinement. We added Figure 5 (page 9). It plots circuit size (#AND, Figure 5A) and mapped area (µm², Figure 5B) against wall-clock time per window for CT+ReCoDe, CT+MCTS and &deepsyn, at each width (K=8, 10, 12). Each point is one compute budget per method. CT+MCTS is the slowest method and has the worst wall-clock time scaling: CT+MCTS-1000 takes longer per window than CT+ReCoDe-3000. At every time budget and width, CT+ReCoDe is below CT+MCTS in both size and mapped area, and ends lowest at its largest budget.

W2. Wall-clock time. We added wall-clock time for the methods to the main paper (Table 2, page 8). Times are end-to-end per window, on one H100 for the neural methods and on one CPU core for &deepsyn.

Time per window (s)

MethodK=8K=10K=12
&deepsyn111
CT+MCTS-100179148160
CT+MCTS-1000177014861477
CT+ReCoDe-100343447
CT+ReCoDe-1000172186248

At the same decode budget, CT+ReCoDe is 3.4–5.3× faster than CT+MCTS at 100 decodes and 6.0–10.3× faster at 1,000. We also measured end-to-end time on a complete design (Table 3, page 10) and found that optimizing all windows of the EPFL design mem_ctrl takes 10.4 GPU-hours with CT+ReCoDe-1000, against 570.3 GPU-hours for CT+MCTS-1000.

Q1. Larger cut sizes, and CT+ReCoDe-100 vs CT+MCTS-100. We now compare on 800 windows per width, with 3 seeds (Table 1, page 8).

Mean #AND per window

MethodK=8K=10K=12
CT+MCTS-10019.68 ± 0.0117.88 ± 0.0121.67 ± 0.00
CT+ReCoDe-10019.61 ± 0.0217.56 ± 0.0421.41 ± 0.02
CT+MCTS-100019.4417.5921.32
CT+ReCoDe-100018.93 ± 0.0317.33 ± 0.0221.14 ± 0.03

CT+ReCoDe produces smaller circuits than CT+MCTS at both budgets and every width. CT+ReCoDe-1000 has significantly smaller #ANDs than CT+MCTS-1000 in a paired per-window test (95% CI). CT+MCTS-1000 has one seed here because of its cost, and 3 seeds on the 200 windows of Figure 5 (Q2 below). CT+ReCoDe-1000 also has significantly smaller mapped areas than CT+MCTS-1000 at every width.

Width (windows)Δ Mapped area, CT+ReCoDe-1000 minus CT+MCTS-1000 (µm², mean ± 95% CI)
K=8 (500)−0.21 ± 0.11
K=10 (800)−0.21 ± 0.11
K=12 (800)−0.15 ± 0.10

Previously, our CT+ReCoDe-100 slightly underperformed CT+MCTS-100 at K=10 and K=12, as the reviewer pointed out. This was due to windows where none of the decodes completed. We added a decode-failure step to ReCoDe for these windows. When no initial decode completes, ReCoDe continues its re-encoding search from a circuit reassembled from separately decoded logic cones (Section 3.2 and Algorithm 1, line 2). After this change, CT+ReCoDe-100 produces smaller circuits than CT+MCTS-100 at every width, while using 3.4–5.3× less time. With the same splitting applied to CT+MCTS, CT+ReCoDe still produces smaller circuits with both 100 and 1,000 decodes at every width.

Q2. Scaling with more compute. We extended CT+ReCoDe to 3,000 decodes and found that it keeps improving at every width (Figure 5, page 9).

Mean #AND (time per window), 200 windows, 3 seeds

MethodK=8K=10K=12
CT+ReCoDe-100019.14 (193 s)17.11 (168 s)21.56 (228 s)
CT+ReCoDe-300019.02 (544 s)17.00 (471 s)21.36 (643 s)
CT+MCTS-100019.68 (1767 s)17.20 (1486 s)21.71 (1477 s)

CT+ReCoDe-3000 produces smaller circuits than CT+MCTS-1000 at every width while using 2.3–3.2× less time.

We hope these additions address each of the reviewer's questions, and we would be grateful if the reviewer would consider updating the score. We are happy to answer further questions during the discussion period. Thank you again for your suggestions.

AuthorsOpenReview ↗

Check-in and scaling with compute

Since our response, we extended CT+ReCoDe to 10,000 decodes, and found it keeps improving at every width (Figure 5, Table 5). CT+ReCoDe is now compared with both CT+MCTS and &deepsyn at matched time and hardware. CT+MCTS runs on the same GPU, and CT+ReCoDe is below it in both size and mapped area at every time budget (Figure 5). For &deepsyn, we added a stronger baseline suggested by Reviewer 9CdF, the best of N independent restarts given the same time per window, on one CPU core or on 24 cores, one H100's share of its server (Section 4.2, Appendix D). From about 3,000 decodes onward, CT+ReCoDe is smaller than both restart settings at every width. Since the backbone is trained on single &deepsyn runs, search lets the model go beyond even this stronger variant of its teacher.

As in our previous response, CT+ReCoDe gives smaller circuits than CT+MCTS at both 100 and 1,000 decodes at every width (Table 1), with wall-clock times in Table 2. In the revised PDF, this round's changes are marked in green and the earlier ones in red.

As the discussion period closes on November 18 (AoE), we would appreciate knowing whether our response addressed your questions. If it did, we would be grateful if you would consider updating your rating. We are happy to clarify anything further.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of the discussion and revisions

We thank the AC and all reviewers. This note summarizes the discussion and the revisions. All changes are in the revised PDF, with the first round marked in red, the second in green and the third in magenta.

What reviewers valued.

  • A simple inference-time method that needs no retraining and works with two separately trained backbones, in exact and approximate synthesis (k2jG, 9CdF, 3mgA).
  • A well-motivated alternative to fixed-encoding search (3mgA).
  • Test-time scaling (PzDA).
  • 9CdF wrote that the results are clearly better than those of existing neural methods, and that "ReCoDe uses inference-time compute more effectively than the current state of the art."

1. Larger matched comparison with CT+MCTS (PzDA, k2jG, 3mgA). The comparison grew from five windows per bucket to 800 windows per width (Table 1), with 3 seeds (one for CT+MCTS-1000, because of its cost). CT+ReCoDe-1000 is significantly smaller than CT+MCTS-1000 at every width (paired 95% CI), while using 6.0–10.3× less time. CT+ReCoDe-100 is also smaller than CT+MCTS-100 at every width, after a decode-failure step (Section 3.2), and stays smaller when CT+MCTS gets the same step.

2. Controlled ablation (k2jG, 3mgA, 9CdF). On 200 windows per width with 3 seeds, a fixed-encoding best-of-1,000 baseline, population size 1 and random selection each change one factor, with the same decodes, sampling strategies and batched decoding as ReCoDe (Figure 1E). Removing re-encoding is the largest effect and significant at every width. Section 3.1 now explains the mechanism: the training targets come from a heuristic, and the encoder reads circuit structure rather than only the function.

3. Compute, runtime and fairness (PzDA, 9CdF, 3mgA). Table 2 gives end-to-end times. On the same GPU, CT+ReCoDe is below CT+MCTS at every time budget and keeps improving up to 10,000 decodes. Following 9CdF, we compared against the best of N independent &deepsyn restarts at equal time on one CPU core and at equal hardware on 24 cores (Appendix D). At 1,000 decodes the restarts are equal or better. At 10,000 decodes CT+ReCoDe is significantly smaller than the best of all restarts at every width (sign test, p < 0.001).

4. All windows and a complete synthesis flow (3mgA). Counting every window, including decode failures, CT+ReCoDe-1000 is below &deepsyn at every width, significantly at K=10 and K=12 (Figure 1). In a complete synthesis flow on four EPFL designs, where every method rewrites the same windows, CT+ReCoDe-1000 gives the smallest or tied-smallest design on all four (Table 3). On mem_ctrl it matches CT+MCTS-1000 in size with 55× less GPU time. Following 3mgA, we ran whole-design compress2rs (43,924 ANDs on mem_ctrl) and applied the window flows after it. CT+ReCoDe-1000 removes a further 139 ANDs, more than every other window optimizer.

5. Reproducibility and clarity (9CdF). We describe the training of the 12-input CT (Section 4.1, Appendix B), corrected the AI-use statement, added MFFW Rewriting as a baseline, and report standard deviations over 3 seeds.

6. Beyond logic synthesis (k2jG). To test whether the method is specific to logic synthesis, we applied ReCoDe to a second problem that requires exact equivalence, expression simplification in the Halide compiler, with our own models and every output proven by Z3. On 1,855 public expressions extracted from the compiler, ReCoDe gives significantly shorter expressions than MCTS and than fixed-encoding sampling at 100 and 1,000 decodes (paired 95% CI), with the same sampling temperature for all methods and in less than half the time of MCTS. With 1,000 decodes it is also shorter than Halide's own simplifier, which produced its training targets. The table is in our replies to k2jG and 3mgA, and the experiment is in Appendix F.

Third-round changes (9CdF, 3mgA, k2jG). We softened two claims ("surpass its own teacher", and the 18–22% reduction, which is relative to a single decode). The paper now refers to training targets instead of a teacher and states where &deepsyn remains ahead. We added standard deviations to Table 5, corrected the sentence on mem_ctrl savings, added compress2rs and the window flows after it as Appendix E (Table 6), and added the Halide experiment as Appendix F (Table 7).

Status of the discussion. 9CdF wrote that we addressed all their requests fairly and that the ablations show re-encoding is a sound approach, and raised their rating to 3. The revised claims they asked for are in the PDF. 3mgA wrote that the ablations and the complete flow address most of their earlier concerns, and remained concerned about the size of the gains and stronger classical flows, which item 4 and our latest reply address. k2jG wrote that the rebuttal materially strengthens the empirical validation, and considered the method specific to logic synthesis, which item 6 addresses.

We thank the reviewers for suggestions that strengthened the paper.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.