Thanks a lot for your involvement in the discussion!
**Regarding W1**, we are happy to hear that you find the experiment promising. We plan to extend this experiment in the revised version as follows: consider the diverse graphs generated based on different graph distances (in our case - Portrait-Div, NetLSD, GCD). Then, we can evaluate various algorithms from the CLRS benchmark on these diverse sets. We expect that diverse sets are more challenging compared to the standard test sets (as shown above for Portrait-Div), but it would also be interesting to see which graph distance leads to more challenging graphs for a particular algorithm. This will give us more insights into graph distances and provide more challenging diverse sets for particular algorithms.
**Regarding W3**, we agree that it is an important issue, so let us elaborate on this challenge (and we will add this discussion to the revised version).
When scaling to significantly larger graphs, there are two aspects that one should consider: the computation cost of the chosen graph distance and the speed of convergence of the algorithm.
Regarding graph distances, their computation cost may vary significantly. For instance, there are simple graph distances based on node degrees which can be easily computed but are less expressive, while some more advanced ones are based on optimal node matching which becomes infeasible even for moderate-size graphs. Among the distances we consider in the paper, the NetLSD implementation turns out to be the fastest. Importantly, most graph distances first compute descriptors of graphs and then measure the distance (e.g., Euclidean) between these descriptors. For better scalability, we suggest using graph distances of this type since in this case we can compute the descriptor for each graph only once and then use it for all distance measurements which significantly reduces the costs.
Regarding the convergence of the algorithm (in terms of the number of graphs we are allowed to try), this issue is more tricky: the number of possible graph structures grows extremely fast with the number of nodes and thus one cannot hope to explore the whole space via simple bruteforce. Thus, the ability to scale significantly depends on the particular algorithm used.
Let us revisit the algorithms considered in the paper and discuss their potential ability to scale.
- **Greedy**. This algorithm is scalable: assuming that we pre-computed all graph descriptors, the complexity of this algorithm does not depend on the sizes of graphs. Moreover, it is easily parallelizable. However, the success of Greedy critically relies on the initial set. In the paper, we apply this algorithm to a set of graphs generated by diverse generators with different parameters. While this requires a hand-crafted list of models, the solution is very scalable: most random graph generators easily scale to large graphs. If we have a diverse set of graph generators, the greedy algorithm is a very promising model to consider.
- **Local optimization**. This approach is not scalable: it operates with small graph modifications and thus cannot effectively explore the space of all graphs. We find this algorithm suitable for the final tuning of graphs if they are already diverse. A possible way to improve the scalability of LocalOpt is to also allow larger graph modifications, especially in the early steps of the algorithm (e.g., replacing a subgraph instead of changing only one edge).
- **Genetic**. We find this algorithm promising for exploring the space of graphs since its operations (crossovers and mutations) often lead to graphs that significantly differ from the parent graphs. Additionally, we suggest incorporating stochasticity into this algorithm by sampling pairs for fitness calculations instead of evaluating all pairs. This approach could accelerate convergence by allowing more steps within the same timeframe. Finally, in our preliminary experiments on larger graphs, we noticed that Genetic works significantly better when starting with a sufficiently diverse set of graphs.
- **IGGM**. The efficiency of IGGM significantly depends on the efficiency of the underlying generative model. Thus, scaling IGGM to large graphs depends on the future development of efficient GGMs, which lies beyond the scope of this paper. But if we assume that the generative model is sufficiently cheap, IGGM is expected to scale to large graphs, similarly to the greedy algorithm discussed above.
Overall, we are working on these strategies to enhance the scalability of our framework and appreciate the reviewer's insights on this matter.
Additionally, we’ve launched more experiments with graphs on 1000 nodes to analyze how scalable are some of the approaches. Due to the limited discussion period, we don't consider larger graphs, but $n = 1000$ is already significantly larger than $n = 16$ used in most of our experiments. We plan to add the results before the end of the discussion period.