acceptodds
Under review as a conference paper at ICLR 2027

MSP-GNN: Learning First-Stage Decisions in Multistage Stochastic Programming via Subtree Permutation Invariance

Abstract

Scenario-based multistage stochastic programming (MSP) provides a principled framework for sequential decision-making under uncertainty, but the exponential growth of scenario trees with the planning horizon poses a major computational barrier to real-time optimization. Learning-based solution predictors offer a promising alternative. However, fully connected architectures that flatten scenario trees into fixed-length vectors overlook their hierarchical symmetries and require parameter counts that grow with tree size. We focus on first-stage, or here-and-now, decisions, which are operationally critical because they must be committed before future uncertainty unfolds while accounting for all subsequent recourse. Our central observation is that optimal first-stage decisions are invariant to recursive permutations of child subtrees at any node of the scenario tree. We exploit this symmetry to introduce MSP-GNN, an end-to-end graph neural network that enforces subtree permutation invariance by construction and has a parameter count independent of scenario-tree size. To characterize its expressive power, we develop a Tree-Weisfeiler-Lehman (TWL) framework tailored to MSP. We prove that TWL-indistinguishable scenario trees admit identical optimal first-stage decisions and that MSP-GNN can simulate the TWL test. Building on these results, we establish a universal approximation guarantee for the optimal first-stage decision mapping on compact domains. Experiments on multistage asset allocation and weighted stochastic linear-quadratic regulator problems demonstrate that, across balanced and asymmetric scenario trees, MSP-GNN achieves predictive accuracy comparable to or better than fully connected networks and DeepSets while using substantially fewer parameters. These findings establish subtree permutation invariance as an effective inductive bias for learning first-stage decisions in MSP.

Primary area:
optimization
Keywords:
graph neural network, stochastic programming, permutation-invariance

Reviews

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

This paper addresses the exponential growth of scenario trees with the planning horizon in scenario-based multistage stochastic programming (MSP). To tackle this issue, the authors propose MSP-GNN, a graph neural network motivated by the claimed subtree permutation invariance of scenario trees, with the aim of learning first-stage decisions accurately while achieving low prediction error.

Critical strengths
  1. The paper is easy to read and follow. The writing is clear.
Critical weaknesses
  1. The connection between the proposed symmetry motivation and the design of MSP-GNN is unclear to me. I do not see a specific architectural component or adaptation in MSP-GNN that is directly motivated by the claimed subtree permutation invariance. In particular, standard tree/GNN message passing with permutation-invariant aggregation already appears to naturally preserve this type of symmetry. The authors should clarify what additional design choice is introduced specifically because of this observation.

  2. More importantly, the current baselines, evaluation metrics, and ablation studies do not appear sufficiently complete. In Table 2, I believe Tree-GCNN, rather than FCNN, could be a strong competitor to MSP-GNN. Tree-based GNNs can also support bidirectional processing and may therefore capture information from both parent and child nodes. The authors’ argument that “we omit Tree-GNN from this experiment because its implementation assumes a balanced tree with a fixed branching factor” is not fully convincing. A balanced scenario tree is still a valid MSP setting, so the authors could construct a balanced-tree benchmark in which both Tree-GNN and MSP-GNN are applicable and provide a fair comparison. I would therefore like to see such a comparison, together with a more informative ablation study involving Tree-GNN.

For the evaluation metrics, I also suggest reporting the objective gap in the main results table. Since the ultimate goal of learning-to-optimize methods is decision quality rather than prediction accuracy alone, the objective gap would provide a more direct and meaningful measure of practical performance. And I also like to see at least one strong baseline from non-learning optimization methods to show the learning methods achieves extreme fast inference performance at the cost of minor optimal gap.

Questions for authors

No other question. expect the authors can clarify the weaknesses above.

7 comments
AuthorsOpenReview ↗

Response to Reviewer SYV5

Dear Reviewer SYV5,

Thank you for your constructive feedback.

C1. The ... observation.

Response. We believe the motivation behind our architectural design was not made sufficiently clear in the manuscript, and we would like to clarify it as follows.

The architectures in existing studies are FCNN and DeepSets, but both have limitations for MSP: FCNNs flatten the scenario tree and suffer from the curse of dimensionality, while DeepSets ignores its parent-child relationships by treating all nodes as exchangeable.

To address this problem, we (i) identify the subtree permutation invariance of MSP, (ii) construct a graph representation that preserves the scenario tree structure, (iii) design MSP-GNN with permutation-invariant message passing and a root-based readout to respect this symmetry, and (iv) establish its universal approximation capability. Thus, rather than directly applying an existing GNN, our approach follows a principled design from the structural properties of MSP to graph representation, neural architecture, and theoretical guarantees. Our gains over FCNN and DeepSets are substantial (see Table 2).

Therefore, our primary contribution is not an isolated permutation-invariant module, but rather a systematic framework that exploits subtree permutation invariance, an unexplored property in prior MSP literature. While we agree that alternative architectures respecting this symmetry (such as standard tree-based or GNN models) could be adapted for this purpose, none have yet been investigated for MSP. Our work establishes the theoretical foundation necessary to motivate and guide such future variants, serving as a first and useful step toward tree-structured neural architectures in this domain.

C2. More .... Tree-GNN.

Response. We understand that "Table 2" in the comment refers to Table 5, since Table 2 already includes Tree-GNN as an ablation. Please correct us if our understanding is inaccurate.

We conducted a comparison on a balanced tree (T=3T=3, b=5b=5, 31 nodes), where both models are applicable (mean ± SD over three seeds):

MethodObjective gap (%)
FCNN2.325 ± 0.113
DeepSets0.430 ± 0.012
Tree-GNN0.040 ± 0.004
MSP-GNN0.045 ± 0.002

Both tree-aware architectures reduce the objective gap by more than 50× relative to FCNN and about 10× relative to DeepSets. Tree-GNN achieves a slightly lower mean objective gap than MSP-GNN, which we explain below.

First, the two are comparable within seed variation: the difference is about one standard deviation of Tree-GNN.

Second, the result is consistent with the special structure of LQR: being unconstrained and quadratic, it is solved by a backward recursion in which each node passes a fixed-size summary to its parent, exactly as in the bottom-up Tree-GNN.

Third, Tree-GNN is not an existing scheme from the literature. It is an ablation of our proposed MSP-GNN. Both respect subtree permutation invariance, which drives the main gains. Bidirectional message passing is one design choice, not necessarily superior.

Ablation. To assess the effect of parent-to-child (P2C) messages, we compare MSP-GNN, its w/o P2C variant, and Tree-GNN on asset allocation (test MSE ×10⁻³, averaged over six seeds):

SettingTree-GNNMSP-GNN w/o P2CMSP-GNN
Baseline6.4556.4426.276
Scale TT6.4585.6265.579
Scale bb10.81611.39910.739
Scale AA7.2206.5456.400
Scale all20.97018.83615.131

We find that removing P2C messages increases the error of MSP-GNN in all five configurations, and that MSP-GNN is more accurate than Tree-GNN in all five. P2C messages therefore help in this problem.

C3. For ... gap.

Response. For each learning method, we fix the predicted first-stage decision and optimize subsequent decisions to compute the objective gap relative to HiGHS (zero-gap baseline). The table reports the mean gap (%) over three seeds and runtime per instance:

SettingFCNNDeepSetsTree-GNNMSP-GNNHiGHS (ms)MSP-GNN (ms)Speedup
Baseline0.0501.2980.0090.0082.480.643.9×
Scale TT0.0471.2210.0080.0053.110.754.1×
Scale bb0.0671.5030.0180.0153.040.664.6×
Scale AA0.2952.4220.0300.0282.870.664.4×
Scale all2.0922.8880.1460.0834.990.786.4×
4,681 nodes2.4122.4150.0560.028153.097.6520.0×

MSP-GNN achieves the lowest objective gap among the learning methods in all configurations (below 0.09%). On the same single-thread CPU, it is 3.9×–6.4× faster than HiGHS in the five main configurations and 20.0× faster on the 4,681-node tree (HiGHS time includes canonicalization).

We will include these clarifications and results in the revision.

Thank you for your detailed response and the additional experiments addressing my concerns. I appreciate the authors' efforts. However, I still have three concerns.

  1. Clarification of the Tree-GNN baseline.

In Section 6 of the original manuscript, the authors state:

"We evaluate MSP-GNN against FCNN, DeepSets (Zaheer et al., 2017), and a bottom-up Tree-GNN baseline (Thost & Chen, 2021)."

However, the rebuttal states:

"Tree-GNN is not an existing scheme from the literature. It is an ablation of our proposed MSP-GNN."

These two statements appear inconsistent. Could the authors clarify whether Tree-GNN is an existing method adapted from the literature or an ablation specifically constructed from MSP-GNN? This distinction is important for evaluating the methodological novelty relative to existing Tree-GNN architectures.

  1. Limited performance advantage over Tree-GNN.

The additional results show that MSP-GNN actually performs slightly worse than Tree-GNN in the reported comparison (0.045% vs. 0.040%). Moreover, the objective gaps are extremely small(even comparable to solver mip_gap in scale of many settings), making it difficult to establish any meaningful advantage of MSP-GNN over Tree-GNN.

  1. Problem scale and computational efficiency.

The latest runtime results reported in the rebuttal show that HiGHS solves the problems in just a few milliseconds, with even the largest instance taking only 153 ms. This raises concerns about whether the tested problems are sufficiently challenging. Moreover, at such small runtimes, Python and solver-interface overhead may dominate the measurements, making it difficult to assess the actual computational advantage of the proposed method.

AuthorsOpenReview ↗

Response to Reviewer SYV5: Part I

Dear Reviewer SYV5,

Thank you for your response and insightful comment. Below, we respond to each point in detail.

C1. Clarification of the Tree-GNN baseline.

Response. Thank you for the comment. We would like to clarify that Tree-GNN is not an existing scheme from the literature. It is an ablation of our proposed MSP-GNN.

Tree-GNN is obtained from MSP-GNN by replacing bidirectional message passing with sequential bottom-up updates, while keeping everything else the same, including the hidden dimension, depth, aggregation, and update functions. Its purpose is to ablate the effect of the bidirectional message-passing scheme.

We cite Thost & Chen (2021) because their work employs a similar bottom-up message-passing scheme. The citation acknowledges bottom-up message passing as an established approach for tree-structured graphs and supports its use as a reasonable ablation choice. However, our Tree-GNN is not an implementation of their method: its architecture and update functions are inherited from MSP-GNN and differ from those of DAGNN. Moreover, DAGNN was not designed for learning first-stage decisions of MSP and cannot be directly applied to this task without constructing an appropriate graph representation of the MSP inputs and adapting its prediction mechanism. The wording in Section 6 did not make this distinction clear, and we have revised it.

Our contribution is not a particular permutation-invariant architecture, but a systematic framework for learning the first-stage solution mapping of MSP. It consists of

  • (i) identifying the subtree permutation invariance of MSP,
  • (ii) formulating first-stage decision learning as a graph learning problem by constructing a graph representation from MSP inputs,
  • (iii) designing architectures that preserve the identified symmetry (with MSP-GNN as a simple and general instance, which uses sum aggregation and bidirectional message passing without restricting information flow to a single direction), and
  • (iv) establishing the universal approximation capability of MSP-GNN.

To our knowledge, none of these four contributions has been previously established in the MSP literature.

This framework provides a mathematical foundation for applying symmetry-preserving architectures to MSP. Building on the identified invariance, the graph representation, and the theoretical analysis, researchers can adapt existing tree- or graph-based models or develop new ones.

Thus, our work goes beyond comparing particular architectural modules or message-passing schemes (e.g., bidirectional versus bottom-up message passing, or with versus without attention). While such comparisons are informative, they are not our main contribution. Instead, we provide a principled framework for learning first-stage solutions of MSP by exploiting its structural symmetry, opening the door to a broader range of symmetry-preserving tree/graph-based architectures.

We have revised Sections 1, 4.2, and 6, as well as Appendix G.1.3, to clarify these points in the uploaded revised manuscript, with all changes highlighted in blue.

(Continued in the next comment.)

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

The manuscript proposes new algorithm for multistage stochastic optimization problems, MSP-GNN. Theoretically, universal approximation result is proved. Numerically, the algorithm performs reasonably well in test problems.

Critical strengths

Numerical experiments show relatively good performance. Universal approximation result (Theorem 1) is interesting and strong.

Critical weaknesses

The gain relative to the competitor tree-GNN seems minor after all.

Questions for authors

Could you elaborate on the gains of the proposed algorithm, in particular in comparison to competitors? Are there some settings in which MSP-GNN would really shine? Also, is there any intuition why standard deviations seem bit higher for MSP-GNN compared to tree-GNN? Not in all cases, but in most.

3 comments
AuthorsOpenReview ↗

Response to Reviewer kqi3

Dear Reviewer kqi3,

Thank you for your constructive feedback and for recognizing the theoretical results. We respond to each point below.

C1. The gain relative to the competitor Tree-GNN seems minor after all.

Response. Thank you for the comment. We believe the role of Tree-GNN was not made sufficiently clear in our manuscript, and we would like to clarify it as follows.

We first note that Tree-GNN is NOT an existing scheme from the literature. Rather, it is an ablation version of our proposed MSP-GNN, obtained by replacing bidirectional message passing with sequential bottom-up message passing. Its purpose is to isolate the effect of the message-passing scheme. With this ablation, we find that (i) respecting subtree permutation invariance is the main source of the gains, as both architectures substantially outperform FCNN and DeepSets; and (ii) bidirectional message passing can further improve performance in some cases, but it is not our main point/contribution.

Our contribution is (i) to identify the subtree permutation invariance of the MSP problem, and (ii) to design architectures such as MSP-GNN that respect this property by construction and to prove their universal approximation capability. Our work can thus be regarded as a first step toward designing tree-structured neural architectures for MSP, of which our own ablation Tree-GNN is one variant.

The competitors in the literature are FCNN and DeepSets, which have been used for general constrained optimization problems and two-stage stochastic programs, respectively. Our gains relative to them are substantial: MSP-GNN achieves 1.9×–4.9× lower test MSE than FCNN and 6.3×–19.7× lower than DeepSets (Table 2).

We will make these points clear in the revision.

Q1. Could you elaborate on the gains of the proposed algorithm, in particular in comparison to competitors? Are there some settings in which MSP-GNN would really shine?

Response. Thank you for the comment. As clarified in C1, Tree-GNN is not an existing scheme but an ablation of our proposed MSP-GNN. The competitors from the literature are FCNN and DeepSets. The gains of MSP-GNN relative to them are substantial in all test settings: across the five configurations of Table 2, MSP-GNN achieves 1.9×–4.9× lower test MSE than FCNN and 6.3×–19.7× lower than DeepSets.

MSP-GNN shines most on large scenario trees. On the 4,681-node tree (Table 3), it achieves 17.8× lower test MSE than FCNN with 114.5× fewer parameters, and 9.0× lower test MSE than DeepSets. From the smallest tree (7 nodes) to this largest one, the parameter count of FCNN grows by more than two orders of magnitude, whereas that of MSP-GNN less than doubles.

Q2. Is there any intuition why standard deviations seem a bit higher for MSP-GNN compared to Tree-GNN? Not in all cases, but in most.

Response. We thank the reviewer for this observation. To better understand the variability, we extended our experiments from three to six random seeds and introduced an additional ablation that removes parent-to-child messages from MSP-GNN while retaining synchronous updates. All three models were evaluated under the same six-seed protocol.

The results report test MSE (mean ± standard deviation, ×10−3\times 10^{-3}).

SettingTree-GNNMSP-GNNMSP-GNN without parent-to-child messages
Baseline6.455 ± 0.6116.276 ± 1.1086.442 ± 1.010
Scale TT6.458 ± 0.8345.579 ± 1.2185.626 ± 0.854
Scale bb10.816 ± 3.65810.739 ± 2.94811.399 ± 2.655
Scale AA7.220 ± 0.7456.400 ± 1.0586.545 ± 0.816
Scale all20.970 ± 5.18415.131 ± 1.67618.836 ± 4.379

First, the higher standard deviation is not systematic. MSP-GNN exhibits higher standard deviation than Tree-GNN in three configurations but lower standard deviation in the other two. Notably, in Scale-all, MSP-GNN achieves both substantially lower mean MSE and approximately three times lower standard deviation (1.676 vs. 5.184).

Second, bidirectional message passing affects variability, but its effect depends on the configuration. Removing parent-to-child messages reduces the standard deviation in four of the five configurations, while increasing mean MSE in all five. In Scale-all, removing these messages increases both mean MSE (15.131 to 18.836) and standard deviation (1.676 to 4.379).

These findings suggest that bidirectional message passing may increase across-seed variability in some settings, but this is not a systematic disadvantage and can accompany better predictive accuracy. Moreover, higher standard deviation does not necessarily indicate unsuccessful training: in Scale-AA, it is partly driven by an unusually accurate run (MSE 4.183 versus 6.148–7.354 for the remaining seeds). We will include these additional results in the revised manuscript.

We hope these clarifications address your concerns.

Thank you for your clarification. I am satisfied with it, and changed my rating to weak acceptance.

Dear Reviewer kqi3,

Thank you very much for your careful reading, your constructive comments, and for updating your rating. Your feedback has helped us clarify our contributions and strengthen the evaluation. We will incorporate all the clarifications and additional results discussed above into the final version of the paper.

Thank you again for your review and response.

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

This paper studies first-stage decision prediction in multistage stochastic programming. Exploiting the invariance of optimal first-stage decisions to recursive subtree permutations, the authors propose MSP-GNN, which uses bidirectional message passing on scenario trees and a root-based readout. The paper analyzes its expressive capacity through a TWL framework and demonstrates its effectiveness on asset allocation and stochastic LQR problems.

Critical strengths
  1. The motivation is clear, and the architecture is naturally aligned with the task. Scenario trees represent the information hierarchy of multistage decisions, while shared message-passing functions and a root-based readout preserve this structure and avoid the parameter growth associated with flattened inputs. The reported parameter-efficiency gains also support the practical value of this modeling choice.

  2. The paper provides a systematic theoretical analysis of its structural inductive bias. Connecting subtree permutation invariance, TWL indistinguishability, and first-stage target equivalence helps explain which input differences can be ignored and what information a tree encoder needs to preserve. This provides a useful framework for understanding the model's expressive capacity.

Critical weaknesses
  1. The central subtree permutation invariance is a natural and relatively straightforward property that standard tree message-passing models already respect. Compared with the bottom-up Tree-GNN, the main architectural change is the addition of parent-to-child messages. Although Tables 2 and 3 report improvements in several configurations, the paper does not sufficiently explain the motivation for this change or distinguish theoretical results that apply to general tree encoders from those specific to the proposed bidirectional architecture. The contribution beyond existing tree-encoding methods therefore remains unclear.

  2. The evaluation of actual decision quality remains incomplete. The asset-allocation experiments in Table 2 primarily report the MSE of first-stage decisions, but a smaller decision-vector error does not necessarily imply a smaller optimization objective gap. Although Table 5 reports objective gaps, it lacks a Tree-GNN comparison or a corresponding unidirectional ablation. This makes it difficult to assess whether bidirectional message passing improves optimization outcomes over a simpler bottom-up tree encoder.

Questions for authors
  1. Could the authors report objective gaps for the methods in Table 2? Following the evaluation in Table 5, the predicted first-stage decision could be fixed while the remaining stages are solved optimally, and the resulting objective compared with the full problem's optimum. This would clarify whether lower MSE translates into better optimization outcomes, particularly relative to Tree-GNN.

  2. With injective aggregation and updates and sufficient propagation depth, a bottom-up tree encoder can already distinguish rooted feature-labeled trees while preserving subtree permutation invariance. What specifically motivates adding parent-to-child messages in MSP-GNN, and how is this design expected to benefit first-stage decision prediction?

  3. Could Table 5 include an ablation of MSP-GNN that retains only child-to-parent message passing while keeping the rest of the architecture unchanged?

4 comments
AuthorsOpenReview ↗

Response to Reviewer VDYj

Dear Reviewer VDYj,

Thank you for your constructive feedback.

C1. "The ... unclear.

Response. Thank you for the comment. We believe the motivation and contribution of our design were not made sufficiently clear in the manuscript, and we would like to clarify them as follows.

The architectures in existing studies are FCNN and DeepSets, which have been used for general constrained optimization problems and two-stage stochastic programs, respectively. However, both have limitations for MSP: FCNN flattens the scenario tree and suffers from the curse of dimensionality, while DeepSets treats all nodes as exchangeable and discards the parent-child relationships of the tree. To the best of our knowledge, no tree-encoding method has been proposed for MSP; the bottom-up Tree-GNN in our experiments is not an existing method, but our own ablation of the proposed MSP-GNN.

To address this problem, we (i) identify the subtree permutation invariance of the MSP problem, and (ii) design an architecture, MSP-GNN, that respects this property by construction, and prove its universal approximation capability. The design choice motivated by the symmetry is thus to operate directly on the scenario tree with permutation-invariant message passing and a root-based readout. Our gains over FCNN and DeepSets are substantial (see Table 2).

Regarding the two specific points raised by the reviewer: (i) the theoretical results are not specific to the bidirectional architecture. Proposition 1 and Lemma 1 concern the MSP solution mapping and are independent of the architecture, and the argument of Theorem 1 extends to tree encoders with injective aggregation and sufficient depth; we will state this in a remark. (ii) We adopt bidirectional message passing for generality and simplicity, as it is the standard form of message passing on graphs. It is one implementation choice, not a requirement imposed by the symmetry, and its empirical benefit depends on the problem setting.

Therefore, our primary contribution is not an isolated permutation-invariant module, but rather a systematic framework that exploits subtree permutation invariance, an unexplored property in prior MSP literature. While we agree that alternative architectures respecting this symmetry (such as standard tree-based or GNN models) could be adapted for this purpose, none have yet been investigated for MSP. Our work establishes the theoretical foundation necessary to motivate and guide such future variants, serving as a first and useful step toward tree-structured neural architectures in this domain.

C2. "The ... incomplete ...

Response. Thank you for the comment. We computed the objective gap for all four methods from the original checkpoints, and will add it to Table 2.

SettingFCNN (%)DeepSets (%)Tree-GNN (%)MSP-GNN (%)
Baseline0.050 ± 0.0011.298 ± 0.0490.009 ± 0.0010.008 ± 0.001
Scale TT0.047 ± 0.0011.221 ± 0.0250.008 ± 0.0010.005 ± 0.003
Scale bb0.067 ± 0.0041.503 ± 0.0270.018 ± 0.0070.015 ± 0.002
Scale AA0.295 ± 0.0282.422 ± 0.0610.030 ± 0.0040.028 ± 0.003
Scale all2.092 ± 0.2382.888 ± 0.0290.146 ± 0.0230.083 ± 0.012
4,681 nodes2.412 ± 0.0092.415 ± 0.0310.056 ± 0.0030.028 ± 0.003

Both tree-aware architectures stay within 0.15% of optimal, and MSP-GNN attains a 4.6×–85.3× lower gap than FCNN. Its mean gap is also lower than that of Tree-GNN in all configurations, most clearly on the larger trees (about 43% lower in Scale-all and 50% on the 4,681-node tree).

C3. ... Table 5 ... comparison ...

Response. Our Tree-GNN implementation assumes a fixed branching factor and does not apply to the unbalanced tree of Table 5. We therefore added a balanced-tree LQR experiment (T=3T=3, b=5b=5, 31 nodes) with Tree-GNN and the requested ablation, MSP-GNN without parent-to-child messages (w/o P2C). Results are mean ± SD over three seeds:

MethodObjective gap (%)
FCNN2.325 ± 0.113
DeepSets0.430 ± 0.012
Tree-GNN0.040 ± 0.004
MSP-GNN w/o P2C0.036 ± 0.003
MSP-GNN0.045 ± 0.002

The tree-aware models reduce the objective gap by more than 50× relative to FCNN and about 10× relative to DeepSets. Removing parent-to-child messages gives the lowest gap. This is consistent with the special structure of LQR: being unconstrained and quadratic, it is solved by a backward recursion in which each node passes a fixed-size summary to its parent, exactly as in a bottom-up encoder. In contrast, the same ablation on asset allocation increases the mean test MSE in all five configurations.

Q1. Could ... gaps ...?

Response. Please see C2.

Q2. ... What ... MSP-GNN ...?

Response. Please see C1.

Q3. Could Table 5 ...?

Response. Please refer to C3.

We hope these clarifications and additional results address your concerns.

Dear Reviewer VDYj,

Thank you again for taking the time to provide a detailed and constructive review.

As the author discussion period approaches its end, we would appreciate knowing whether our rebuttal and additional experiments have addressed your main concerns.

We would be happy to clarify any remaining questions or concerns before the discussion closes.

Thank you for the clarifications and additional experiments. The objective-gap results substantially address my concern about decision quality and demonstrate the value of tree-aware models, particularly on larger instances. I have raised my score.

Dear Reviewer VDYj,

Thank you for your response, your comments, and for updating the rating. We are happy that our response has addressed your concerns. We will incorporate all the clarifications and additional results discussed above into the final version of the paper.

Thank you again for your review and response.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.