We appreciate the reviewer's valuable review and constructive comments, and we would like you to know that your questions provide considerably helpful guidance to improve the quality of our paper.

We will try our best to address each of the concerns and questions raised by the reviewer below:

1. [Re: The bottom-left positioning of the B*-tree root (Fig. 1) lacks clear justification. What justifies this over central placement or placement at other positions? Could you provide further discussion on the positioning of the B*-tree root? ]

B*-tree is an ordered binary tree, where the root node must be placed first and is defined using a bottom-left positioning scheme. Newly added modules are inserted as left or right children, causing the overall tree to grow toward the right and upward.

We follow the original definition of the B*-tree, as stated in the literature: “A B-tree is an ordered binary tree whose root corresponds to the module on the bottom-left corner.”

[1]. B*-Trees: A New Representation for Non-Slicing Floorplans

2. [Re: Could you explain why not use methods based on orthogonal constraint graph and shortest path spanning tree?]

We choose the B-tree representation* for three main reasons:

1. Efficient evaluation and update. Since the floorplanner is embedded as the environment of an MDP, each state–action transition must be evaluated quickly. Unlike other representations, the B*-tree does not require the construction of horizontal/vertical constraint graphs or shortest-path computations to evaluate performance, which significantly reduces computational overhead. Moreover, it supports incremental evaluation, making it well-suited for sequential decision-making settings.
2. Consise search space. A B*-tree encodes fewer permutations compared to most alternative representations, resulting in a more concise search space that facilitates efficient exploration and learning.
3. Modifiable open-source infrastructure. Effective heuristics such as SA have already been developed for B*-trees, and robust open-source implementations are readily available, making it easier to integrate and extend.

We opt for the B*-tree representation, but our approach is not tied to it. Any other encoding could be substituted, since our work concentrates on the higher-level framework; the core contribution is the development of a cooperative optimization scheme.

3. [Re: The authors provide inadequate coverage of related works, particularly regarding EA+RL approaches such as [1][2] and [3]. Additionally, there is a lack of comparative analysis between the proposed method and classic EA+RL techniques. [1] Moriarty D E, Schultz A C, Grefenstette J J. Evolutionary algorithms for reinforcement learning[J]. Journal of Artificial Intelligence Research, 1999, 11: 241-276. Khadka S, Majumdar S, Nassar T, et al. Collaborative evolutionary reinforcement learning[C]//International conference on machine learning. PMLR, 2019: 3341-3350. Bai H, Cheng R, Jin Y. Evolutionary reinforcement learning: A survey[J]. Intelligent Computing, 2023, 2: 0025.]

We sincerely thank the reviewer for the insightful comment. The algorithms highlighted by the reviewer primarily focus on optimizing policy parameters using EA or RL. In contrast, CORE adopts a direct solution-space optimization approach via EA, which operates in a significantly smaller and more tractable search space. This design choice enhances optimization efficiency compared to methods that rely on parameter-space exploration.

To address the reviewer’s concern, we additionally implemented a parameter-centric ERL framework. It is important to note that such frameworks typically rely on off-policy algorithms, such as TD3 or SAC, which face inherent challenges when applied to discrete action spaces. To ensure a fair and consistent comparison, we adapt the baseline methods to use B* tree-based PPO, which is better suited for discrete structural representations. The corresponding experimental results are presented below:

We observe that CORE consistently outperforms the ERL-based methods across all cases. To enhance the completeness of the manuscript, we will include this additional discussion in the revised version. If we have overlooked any relevant work, we would greatly appreciate it if the reviewer could kindly point it out.

4. [Re: No convergence guarantees for EA-RL collaboration. I noticed the authors mentioned other methods may be "trapped in local optima". How do the proposed CORE avoid local optima?]

EA excels at global exploration and is capable of rapidly identifying promising solutions, but it often struggles with fine-tuning due to its inherent randomness. In contrast, RL is well-suited for local refinement and policy improvement. To avoid suboptimal solutions and fully leverage the strengths of both paradigms, we design a collaborative mechanism: EA guides RL by providing high-quality samples that help shape its learning direction, while RL in turn injects refined policies into the EA population to steer evolution more effectively. This bidirectional synergy enables efficient cooperation between the two components.

We present the results of our ablation study below, which clearly demonstrate that the integration of both mechanisms leads to improved performance.

The original B*-tree paper [1] provides theoretical justifications and empirical results demonstrating several advantages over other tree-based representations:

1. Fixed binary structure enables fast operations. Due to its fixed binary nature, insertion and lookup require only simple pointer manipulations in O(1) to O(log n) time, making it significantly lighter than representations like the O-tree, which involve variable branching. This allows for O(n) evaluation per layout, making B*-tree well-suited for high-frequency calls in search or reinforcement learning environments.
2. No need for constraint graph construction. Unlike sequence pair or constraint-graph-based methods, the B*-tree allows direct area computation without constructing horizontal or vertical constraint graphs, thus avoiding shortest-path computations and reducing overhead.
3. Efficient incremental updates. After module swaps, only the affected nodes along the DFS traversal path require local incremental updates, keeping computational costs low.

These advantages have been empirically validated on MCNC benchmarks, where B*-tree implementations demonstrate faster runtime, lower memory usage, and superior solution quality.

6. [Re: No comparison with commercial tools (e.g., Cadence Innovus) or macro-placement methods.]

We thank the reviewer for the suggestion. Cadence Innovus relies on human expert intervention, while DREAMPlace is a macro placement algorithm that typically struggles to produce high-quality results on floorplanning problems. In our work, we provide comparisons with two state-of-the-art macro placement algorithms.

We can observe that CORE significantly outperforms both MaskPlace and ChipFormer, further demonstrating the effectiveness of methods specifically designed for floorplanning.

7. [Re: While App. B addresses scalability concerns, could you provide further discussion on the algorithm's scalability and complexity? ]

CORE introduces RL, which results in additional time overhead compared to heuristic methods. Thus we design a parallel architecture to improve efficiency. Unfortunately, existing learning-based methods for floorplanning have not released open-source implementations. Therefore, we compare the runtime and achieved HPWL with the available baselines.

CORE achieves better HPWL compared to baselines, and requires more time than EA. However, it outperforms other learning-based method MaskPlace.

Furthermore, CORE can be further accelerated by switching to a statically compiled framework such as JAX. That said, we acknowledge that CORE still has limitations in terms of runtime efficiency. Nevertheless, we believe that learning-based methods represent a promising direction with the potential to deliver competitive solutions.

We hope our replies have addressed the concerns the reviewer posed and shown the improved quality of the paper. We are always willing to answer any of the reviewer's concerns about our work and we are looking forward to more inspiring discussions.

I am pleased that the authors have addressed most of my concerns in their rebuttal. The additional experiments are impressive, leading me to elevate my overall assessment to a score of 4 (Borderline accept). I maintain openness to score improvement pending further manuscript revisions.

We appreciate the reviewer's valuable review and constructive comments, and we would like you to know that your questions provide considerably helpful guidance to improve the quality of our paper.

We will try our best to address each of the concerns and questions raised by the reviewer below:

1. [Re: For two RL baselines, the Area Utilization was an assumption taken from the literature, not a direct measurement, which slightly weakens the comparison on that metric. ]

Consequently, for several metrics that were not reported in the original papers, we provide results under idealized assumptions. To mitigate these issues and ensure reproducibility and fair benchmarking, we will release our algorithm along with a Python-based floorplanning platform.

2. [Re: You run each algorithm five times and reporting the best convergence performance achieved. I am not sure if it is a convention in this area. Why not report the mean and standard deviation?]

We follow the prior works by reporting the best results, as this highlights the algorithm’s peak performance. For completeness, we also provide the mean and standard deviation in the appendix, as shown in the table below.

We can observe that CORE still consistently outperforms the best performance of other baselines.

3. [Re: A key challenge in industrial floorplanning is satisfying a variety of specific hardware design rules, such as boundary alignment or grouping constraints. How might the CORE framework, particularly its B*-Tree representation, be adapted to handle such constraints? Would this require new mutation operators for the EA and a modified reward/MDP formulation for the RL component?]

Adding constraints typically does not require changes to the algorithm itself. Instead, we can incorporate the constraints into the reward or fitness function. For example, by embedding grouping constraints as part of the evaluation objective—both in the fitness function for EA and the reward function for RL. we can handle such constraints within the existing optimization framework. In addition, some adjustments based on the specific optimization objectives may also be necessary. For example, constructing subtrees on top of the B* tree can be an effective way to address grouping constraints.

4. [Re: converting a complete B*-Tree from the EA archive into a state-action sequence for the RL agent to imitate. or does it require a specific traversal (e.g., pre-order)? How does this choice of conversion affect the stability and effectiveness of the imitation learning? ]

Before answering this question, it is important to outline the optimization process of the B*-tree. After each module is inserted, the B*-tree adjusts the entire layout to ensure seamless placement of modules. This adjustment is performed in a depth-first traversal of the tree, during which each node is updated sequentially, and the adjustment order is recorded.

Consequently, when converting a layout back into a decision sequence, we must model it according to this recorded order. The reason is that any deviation from the original traversal order can lead to inconsistencies between the reconstructed and original layouts. For example, adjusting the left or right child first may result in entirely different outcomes. This process is inherently tied to the structure of the B*-tree, which relies on depth-first traversal for both module placement and reordering. Therefore, reconstructing the sequence must also follow the same depth-first traversal logic.

5. [Re: Do the roles of the EA and RL shift over the course of training? For example, one might hypothesize that the EA's guidance is more critical in the early stages to help the RL agent find promising regions of the search space, while the RL agent's injections are more impactful later for fine-tuning the population. Do your observations support this, or is the collaborative balance relatively stable?]

We observe a three-phase phenomenon: (1) Initial Phase: RL) dominates. (2) Middle Phase: The effect of EA gradually becomes more prominent, while the impact of RL diminishes. (3) Final Phase: RL regains influence and starts contributing effectively again.

The reason behind Phase 1 is that, in our experiments, layouts generated by randomly initialized policy networks often outperform those constructed by random layout initialization by EA. As a result, the RL injection success rate reaches nearly 100% in the early stages.

As EA proceeds through several iterations, it begins to discover solutions that outperform those generated by RL, leading to a drop in the RL injection success rate.

After a period of training, we observe that the quality of EA-generated solutions relative to RL begins to decline, and the RL injection success rate starts to rise again.

Except for the first phase, our findings are consistent with the reviewer’s observations in the second and third phases. The first phase is a notable exception, which we attribute to the fundamental difference between the two paradigms: EA focuses on solution optimization, whereas RL optimizes the policy. This structural difference leads to a performance gap in initial solution quality.

6. [Re: Did you consider other compact representations like Sequence-Pair or Corner Block Lists? What are the specific advantages of B*-Tree for this hybrid EA+RL framework that made it the preferred choice?]

We choose the B-tree representation* for three main reasons:

1. Efficient evaluation and update. Since the floorplanner is embedded as the environment of an MDP, each state–action transition must be evaluated quickly. Unlike other representations, the B*-tree does not require the construction of horizontal/vertical constraint graphs or shortest-path computations to evaluate performance, which significantly reduces computational overhead. Moreover, it supports incremental evaluation, making it well-suited for sequential decision-making settings.
2. Consise search space. A B*-tree encodes fewer permutations compared to most alternative representations, resulting in a more concise search space that facilitates efficient exploration and learning.
3. Modifiable open-source infrastructure. Effective heuristics such as SA have already been developed for B*-trees, and robust open-source implementations are readily available, making it easier to integrate and extend.

We opt for the B*-tree representation, but our approach is not tied to it. Any other encoding could be substituted, since our work concentrates on the higher-level framework; the core contribution is the development of a cooperative optimization scheme.

7. [Re: Limitations]

We thank the reviewer for the valuable suggestion. Below, we provide a discussion of some limitations of CORE.

1. Time overhead: Learning-based methods typically incur additional training costs. Although we mitigate this through a parallel framework or potential framework modifications to reduce training time, the process remains relatively time-consuming.
2. Theoretical support: Our method currently lacks theoretical guarantees and relies more on empirical validation.

We hope our replies have addressed the concerns the reviewer posed and shown the improved quality of the paper. We are always willing to answer any of the reviewer's concerns about our work and we are looking forward to more inspiring discussions.

We appreciate the reviewer's valuable review and constructive comments, and we would like you to know that your questions provide considerably helpful guidance to improve the quality of our paper.

We will try our best to address each of the concerns and questions raised by the reviewer below:

1. [Re: The authors do not include their algorithm pseudocode in the main text of the paper.]

We thank the reviewer for the valuable suggestion. We will incorporate the pseudocode into the main text to improve readability in the revised version.

2. [Re: the authors repeatedly refer to their approach as an evolutionary algorithm, but it's unclear if it has a crossover function. The concept of selecting parents is mentioned once, but it seems this may only have been meant in terms of which members of a population are mutated.]

We thank the reviewer for the valuable suggestion. We would like to clarify that our algorithm does not employ crossover operations. The primary reason is that crossover is difficult to apply to tree-based representations. For instance, in two parent trees, each node corresponds to a different module. Directly exchanging subtrees may lead to module duplication.

3. [Re: I'm unclear why EAs are referred to as black box optimization methods when their process is transparent. Clarity around these points would be appreciated.]

A black-box optimization algorithm refers to an approach that only requires access to the objective function (fitness function), without needing any explicit gradients, constraint formulations, or internal structural information. EAs fall under this category: although their optimization process is transparent, they rely solely on the evaluation of solution scores f(x), without analytically exploiting the structure of f(x) to guide the optimization of x. For this reason, EAs are commonly referred to as black-box optimization methods.

4. [Re: I have one major concern which is that the authors appear to have potentially reinvented MAP-Elites. The authors make use of quality and diversity search based on binning solutions, which is very close to MAP-Elites. Despite this, the authors do not mention MAP-Elites or even directly identify their work as falling within the Quality-Diversity (QD) paradigm.]

We thank the reviewer for pointing out this omission. MAP-Elites typically requires the explicit construction of an archive to store the best-performing solutions across different behavioral descriptors. In contrast, our method employs clustering to identify diverse and high-quality solutions, thereby mitigating the risk of convergence to suboptimal regions.

Our results confirm that incorporating quality diversity leads to more efficient optimization and yields higher-quality solutions compared to a standard EA baseline. (See the table below for details.)

Thank you for the valuable suggestions. We will include this discussion about MAP-Elites in the revised version. We would greatly appreciate it if the reviewer could point out any relevant references we may have overlooked.

We hope our replies have addressed the concerns the reviewer posed and shown the improved quality of the paper. We are always willing to answer any of the reviewer's concerns about our work and we are looking forward to more inspiring discussions.

We appreciate the reviewer's valuable review and constructive comments, and we would like you to know that your questions provide considerably helpful guidance to improve the quality of our paper.

We will try our best to address each of the concerns and questions raised by the reviewer below:

1. [Re: The integration of multiple complex components (EA, RL, B*-Tree) may introduce runtime overhead, which could affect scalability or deployment in real-world settings.]

Learning-based methods typically need additional runtime overhead, primarily due to the cost of sampling and training. To address this issue, we design a parallel architecture that significantly reduces the runtime burden (details in Appendix B).

Moreover, the framework can be further accelerated by adopting the statically compiled JAX backend instead of PyTorch, which often yields a speedup of approximately 300%.

In practical industrial floorplanning tasks, the number of modules is typically below 50, and cases exceeding this scale are extremely rare. This makes learning-based approaches particularly competitive.

Furthermore, compared to the current state-of-the-art macro placement algorithm, our method achieves comparable runtime while delivering superior performance.

2. [Re: More extensive ablation experiments to isolate and validate the contribution of each key component in the framework.]

We thank the reviewers for their valuable suggestions. In response, we provide the following ablations:

Coordination Mechanism: The ablation results are presented below. As shown, integrating both of our proposed coordination mechanisms leads to the best overall performance.

CDES: We compare our proposed CDES with a vanilla EA that does not incorporate the clustering method. The results show that CDES achieves significantly better optimization performance than the vanilla EA.

3. [Re: How does the runtime efficiency of the proposed method compare to other baseline approaches?]
CORE introduces RL, which results in additional time overhead compared to heuristic methods. Thus we design a parallel architecture to improve efficiency. We compare the runtime and achieved HPWL with available baselines:

CORE achieves better HPWL compared to baselines, and requires more time than EA. However, it outperforms other learning-based method MaskPlace.

We hope our replies have addressed the concerns the reviewer posed and shown the improved quality of the paper. We are always willing to answer any of the reviewer's concerns about our work and we are looking forward to more inspiring discussions.