Diffusion-Based Hierarchical Graph Neural Networks for Simulating Nonlinear Solid Mechanics

We appreciate the positive comments of the author on the effectiveness of our approach for quasistatic elasticity, the inclusion of necessary ablations and the clarity of the paper. We address the concerns raised below.

The choice of experimental domain is a bit odd. Quasistatic elasticity is a good domain for studying hierarchical message passing, but less so for diffusion-- these simulations are very deterministic and smooth.

It might seem counterintuitive, but we found that preserving smoothness is often difficult for HGNNs, which makes diffusion attractive in this domain. Models trained on an MSE loss must accurately capture global deformations, and even slight shifts or rotations can increase error. HGNNs often accumulate errors from high frequencies that are less penalized, which leads to local mesh distortions and drifting out of the training distribution over time. Non-smooth solutions result in significant deviations in the displacement gradient, which directly impacts stress.

To analyze this behavior, we added a truncation parameter to the ROBIN algorithm. This allows us to stop the denoising process early. For example, we can stop after the first $K_I = 5$ diffusion steps (instead of denoising all $K = 20$ steps) and treat the reconstructed clean sample as our ground truth. Regarding the rollout RMSE, we have evaluated ROBIN for different truncation valuess $K_I$. For each edge $(i,j)$ of the fine mesh, we have also evaluated the gradient $||(\\mathbf{u}\_{i} - \\mathbf{u}\_{j})||_2 / ||(\\mathbf{x}\_{i} - \\mathbf{x}\_{j})||_2$ along that edge and calculated the RMSE.

The initial diffusion steps concentrate on global solution frequencies, significantly reducing the global RMSE. Later steps focus on high frequencies, reducing local gradient error. Over time, these high-frequency errors can lead to mesh distortions, as observed in MSE-trained HGNNs.

Similarly, I feel the effect of conditioning on not fully denoised previous timesteps is underexplored. […] e.g. does this affect coherence of high-frequency details? […] Similarly, a deep dive into the various choices in diffusion & enoising and the effect this has on consistency and frequency distribution could be very interesting.

We agree that investigating how conditioning partially denoised states affects the high-frequency component would be helpful. The table below shows how the denoising stride $m$ affects the rollout RMSE and rollout gradient RMSE for all the datasets.

ROBIN with $m=1$, in which the previous physical time step is always denoised only one diffusion step further, does not increase gradient error on BendingBeam or DeformingPlate. However, there is a modest increase on ImpactPlate, and ROBIN achieves the lowest RMSE overall. We hypothesize that partially denoising states keeps low-frequency components anchored and reduces drift. In contrast, fully denoising states (larger $m$) reduces short-term, high-frequency error accumulation. However, this phenomenon does not seem to affect long rollouts. We plan to investigate this further in future work, as well as how it is influenced by alternative diffusion backbones and schedulers.

[…] there are so many HGNN papers with slightly different choices of graph construction and message propagation, and this paper adds yet another option without properly evaluating it against other options.

We acknowledge the many HGNNs in the literature and emphasize that our primary contribution is the synergy of diffusion with our AMPNs, not a new HGNN. Our AMPNs follow the architecture of algebraic multigrid methods to solve for frequencies at different scales. For example, we use an explicit solver layer at the coarse level to solve for global frequencies and shared intra-level message passing stacks for high frequencies w.r.t. the mesh scale of the level. We combine this approach with diffusion to specifically address all frequencies during training and inference. Our ablation studies highlight the synergy between the two. We lose accuracy on all tasks if we remove one of them, but we significantly outperform the baselines when they are used together.

To further demonstrate the benefits of combining our AMPNs with diffusion, we conducted an ablation study on the Bending Beam dataset, replacing our AMPNs with the HCMT architecture. Additionally, we compared our results to those of another hierarchical GNN baseline: the Bi-stride multiscale-Graph Neural Networks (BSMS-GNNs) [1].

Although integrating diffusion into HCMT improves RMSE compared to HCMT alone, ROBIN significantly outperforms both. BSMS-GNNs are nearly as accurate as the HCMT baseline, but significantly more accurate than non-hierarchical MeshGraphNets. Only the combination of diffusion and AMPNs can accurately resolve the wide frequency spectrum of BendingBeam.

To further demonstrate the advantages of the AMPN architecture, we have fine-tuned ROBIN on the BendingBeamLarge dataset. This dataset contains simulations spanning 100 time steps and meshes with up to 16K nodes. Although ROBIN was trained on BendingBeam with 3 hierarchies (~750 nodes), the shared blocks of the AMPNs enable direct application of ROBIN to BendingBeamLarge meshes with 4 levels. We fine-tuned ROBIN for 750K iterations with a batch size of 1 and a learning rate of $10^{-6}$. Similarly, we have trained an untrained ROBIN with the same settings, but with a learning rate decay ranging from $10^{-4}$ to $10^{-5}$.

As expected, the pre-trained ROBIN model predicts solutions with a much lower RMSE than an untrained model. The pre-trained model can be quickly adapted to a large-scale dataset without architectural changes, which highlights ROBIN’s generalizability to different mesh sizes.

(Minor) The description of ROBI and corresponding figure could be improved; […] It took me a few passes to understand which step is conditioned on what exactly in diffusion & simulation time.

We thank the reviewer for pointing that out. We will clarify the description of ROBI, as well as Figure 2. In particular, we will clarify the conditioning process on the partially denoised, reconstructed state $\tilde{u}_{0|k}^{t-1}$ and explain how the reconstruction process of that state depends on previous time steps.

We appreciate the positive and constructive feedback from the reviewer and will make the required updates in the final version. We are pleased to address any additional inquiries during the discussion phase.

[1] Yadi Cao, et al. Efficient learning of mesh-based physical simulation with bi-stride multi-scale graph neural network. In International conference on machine learning. PMLR, 2023.

This paper would be a straight accept for me if the quality of the write up was better but I had to spend quite some time to extract the details. In particular the clarity of the write up in sections 3.1 and 3.2 […].

We thank the reviewer for the positive feedback and for identifying areas that can be improved in our write-up. We will revise sections 3.1 and 3.2 for the final version. Below, we address the reviewer’s questions and clarify several ambiguities.

Regarding the v-prediction target, the explanation was not clear. […] I found this quite counter intuitive and perhaps it can be clarified/reworded.

The v-prediction $\mathbf{v}_k^t = \sqrt{\bar{\alpha}_k} \mathbf{\epsilon}^t - \sqrt{1-\bar{\alpha}_k} \mathbf{u}^t_0$ indeed behaves in the opposite way to the SNR. At early denoising steps (low SNR, $\bar{\alpha}_k \approx0$), the target behaves like the clean signal $\mathbf{u}^t_0$. At later steps (high SNR, $\bar{\alpha}_k \approx1$), the target behaves like the residual noise $\mathbf{\epsilon}^t$. Although this may seem counterintuitive, it simplifies the learning process. When the sample is good (high SNR) correcting the small residual is easier than regenerating the entire signal. When the sample is random (low SNR), the input contains little useful structure, so directly predicting the signal is easier than estimating the error. This reparameterization also keeps target magnitudes more uniform across timesteps.

Also, "One step models" are not defined, this confused me for a long time until I read PDE-Refiner paper. […] There are no definitions of t_B/k_B/t_b/k_b.

We will introduce one-step models as autoregressive models that are trained to predict the solution for the next time step using the solution from the previous step. We will define $t_B$ and $k_B$ more clearly and use them consistently.

There is some abiguity if there are also neural nets used to predict $\mu$ and $\Sigma$. But are these different to the main denoiser that predicts the denoising velocity and if so how are they trained?

In Denosing Diffusion Probalistic Models [1] we train a model to predict either the clean sample $u_{0}^t$, the noise $\epsilon^t$ or, as in our case, the velocity $v^t$. The Gaussian mean $\mu_{\theta}$ is than computed analytically from this output. The covariance matrix $\Sigma_{\theta}$ can also be learned by the same network, but we assume isotropic covariance $\Sigma = \sigma_k^2 \mathbf{I}$.

It was not immeadiate to derive the formula on line 148, it could be pointed out this comes from substituting from the noising step into 1.

Given a clean sample $u_0^t$ and noise $\epsilon^t$, the forward diffusion process produces at step $k$ a noisy sample $u_k^t=\sqrt{\bar\alpha_k}\,u_0^t+\sqrt{1-\bar\alpha_k}\,\epsilon^t$ [1]. We eliminate $\epsilon^t$ by substituting the v-prediction definition from Equation (1) $v_k^t=\sqrt{\bar\alpha_k}\,\epsilon^t-\sqrt{1-\bar\alpha_k}\,u_0^t$ and solve for the clean sample $u_0^t=\sqrt{\bar\alpha_k}\,u_k^t-\sqrt{1-\bar\alpha_k}\,v_k^t$ [1]. Given a model prediction $v_\theta(u_k^t,k,u_{0}^{t-1})$, we can reconstruct a clean sample $u_{0|k}^t=\sqrt{\bar\alpha_k}\,u_k^t-\sqrt{1-\bar\alpha_k}\,v_\theta(u_k^t,k,u_{0}^{t-1})$ using this equation.

Clarifications on figure 3, what is meant by "pooling", as pooling is usually associated as a step within coarsening. In the caption does "1 (top)" refer to line c) ?

In our AMG-based hierarchy, we create coarse meshes and build up- and downsampling graphs that connect nodes across levels. Figure 3 d) shows the edges between levels 0 and 1 at the top and between levels 1 and 2 at the bottom. All the nodes at the top correspond to level 0 (Figure a), while the subset of nodes marked in bright blue corresponds to level 1 (Figure c). Similarly, all the nodes in the bottom part of Figure 3d correspond to the nodes in Figure 3c. Since "pooling" is misleading, Figure 3 d) will be renamed "AMG-based down- and upsampling graphs.”

I understand we compare this is a sensitivity study for different and but it is a slight red flag that ML baseline and even classic data generation times are not provided.

The table below shows a comparison of Rollout RMSE between the baselines.

The numerical solver required 46.2 s (max. 186.1 s) on average on BendingBeam, 1157.2s on DeformingPlate [2] and 742.6 s on ImpactPlate [3].

We also evaluated ROBIN on BendingBeamLarge (200 training, 20 validation and 20 test simulations), containing simulations of 100 time steps on beam meshes with 5–16K nodes. On average, the solver required 108.3 s (max. 4248.0 s) to complete. We compare the fine-tuning of a pre-trained model of BendingBeam to training from scratch. Both are trained for 750K iterations and a batch size of 1, while fine-tuning uses a learning rate of $10^{-6}$ and training from scratch an exponential decay from $10^{-4}$ to $10^{-5}$.

We extended ROBI to include the option of truncating the denoising process after $K_I$ steps and using the partially denoised state as the final prediction. The table below shows for 5 seeds how different truncation levels $K_I$ compare to conventional inference and ROBIN (5 seeds). All evaluations are based on the same trained models.

In the ROBI section, the writing would benefit from clarifying/reasserting that the network has 2 inputs, the t-1 condition and the current t sample at denoise level k.

In the revision, we will state explicitly that at level $k$ during inference the model takes the current noisy sample $u_{k}^{t}$ and the partially denoised state of $\\tilde{u}\_{0|k}^{t-1}$ as input to predict the denoising velocity v_\\theta(u\_k^t,k,\\tilde{u}\_{0|k}^{t-1}). We will clarify that the refinement level of the reconstructed sample \\tilde{u}_\{0|k+1-m}^{t-1} increases with $m$.

The description of root-node AMG coarsening is also unclear […] but providing more details would again strengthen the paper.

We use PyAMG’s rootnode_solver [4] to create the AMG hierarchy. The solver takes a sparse square matrix as input and returns a hierarchical cycle. We pass the fine-mesh adjacency matrix as the system matrix, and the solver yields coarsened adjacency matrices, corresponding coarse nodes, and up- and downsampling matrices. The nonzeros in these matrices define the edges of our up- and downsampling graphs. Thus, the implementation requires only the fine-mesh adjacency, the rootnode_solver with its default settings, and graph construction based on the returned matrices (i.e., non-zero values).

The rootnode_solver itself aggregates nodes based on connectivity within the provided matrix and selects one root per aggregate. These roots become the next-level coarse nodes, and each fine node connects to its aggregate's root in the up- and downsampling matrices. These operators are then smoothed using the adjacency, effectively enlarging each coarse node’s receptive field beyond its aggregate. The implementation will be included in the code publication after the paper is accepted.

We thank the reviewer for their comments and for pointing out the ambiguities. We will incorporate the revsions into the camera-ready version, and we encourage the reviewer to contact us during the discussion.

[1] Jonathan Ho, et al. Denoising diffusion probabilistic models. NeurIPS, 2020.

[2] Tobias Pfaff, et al. Learning Mesh-Based Simulation with Graph Networks. ICLR, 2020.

[3] Youn-Yeol Yu, et al. Learning Flexible Body Collision Dynamics with Hierarchical Contact Mesh Transformer. ICLR, 2023.

[4] Nathan Bell, et al. PyAMG: Algebraic multigrid solvers in python. Journal of Open Source Software, 2022

We thank the reviewer for their careful reading and constructive criticism. Below, we clarify our contributions and explain how they differ from existing work.

Can authors provide a clearer picture of the novelty and comparison with existing autoregressive diffusion methods?

ROBIN is designed for deterministic physical simulations rather than perceptual video generation. It combines a diffusion model with hierarchical graph neural networks on unstructured meshes. This allows it to capture different solution frequencies and propagate information across large spatial distances and mesh resolutions. CNN-based video models cannot do this. In addition, ROBIN outputs residual predictions rather than absolute states, thereby improving accuracy and stability.

ROBIN advances the simulation from time $t−1$ to time $t,$ conditioned only on the previous clean state. This preserves causality and time shift equivariance while reducing memory usage and training time. Sequence-based diffusion models that denoise entire histories often require learning warm-up and cool-down phases [1]. Conditioning on multiple past steps has been found to reduce the accuracy of learned simulators [2,3].

Our model is trained using a v-prediction target, residual predictions and an exponential diffusion scheduler. It requires only 5 diffusion steps to surpass the baseline accuracy. During the rebuttal, we evaluated inference truncation. We stop after a chosen number of denoising steps and use the reconstructed sample as the prediction, which decreases inference time. The table below reports (over 5 seeds) on variants that stop denoising after the second denoising step (ROBIN - two step), along with the full ROBIN setting and the baselines. We added Bi-stride multi-scale GNNs (BSMS-GNNs) [4] as a third baseline on BendingBeam and will include results for DeformingPlate and ImpactPlate in the camera-ready version.

ROBIN outperforms state-of-the-art baselines with only two diffusion steps, whereas video diffusion models typically require many more. While extending ROBI to video models is an interesting future direction, our models are explicitly designed for simulation. We do not claim to have made any contributions toward overcoming the limitations of current image or video generation frameworks.

There has been major researches focusing on PDE generations in recent years however the paper only compares to two baselines one of which is older than 5 years.

As noted above, we added BSMS‑GNNs [4] as another strong baseline. HCMT currently achieves the highest accuracy on benchmarks such as DeformingPlate, and MeshGraphNet (MGN), despite being five years old, remains competitive. This demonstrates the importance of ROBIN in surpassing the accuracy limits of solid-mechanics learned simulators.

Authors mention that for generation of T frames (timesteps) with K denoising steps the time complexity will be O(KT). […] Can authors clarify why a parallel generation is not possible in this concept?

ROBIN generates trajectories autoregressively, predicting each step based on the previous one. Forecasting large time steps or an entire rollout at once reduces the accuracy of physical simulators [2,5]. The most accurate solid‑mechanics simulators, such as HCMT, are autoregressive.

Since physical simulations are Markovian, conditioning only on the previous step is sufficient. Jointly denoising all time steps ignores the evolving state and violates causality. Even using more than one past step can reduce accuracy [2,3]. Additionally, parallel generation is less desirable because sequence models must retain many time steps and large meshes in memory, treating entire trajectories as single training samples. Our one step training uses single transitions, which improves memory and data efficiency while enabling large-mesh experiments.

We demonstrate that scalability on BendingBeamLarge, which contains 200 training, 20 validation and 20 test simulations of 100 time step and beam meshes with 5K-16K nodes. We fine-tuned a pre-trained model and compare it with a model trained from scratch (over 5 seeds). Both used 750K iterations and a batch size of 1. The pre-trained model is trained with a learning rate of $10^{-6}$ and the untrained with an exponential decay from $10^{-4}$ to $10^{-5}$.

Pretraining substantially improves accuracy and enables adaptation to meshes with up to 16K nodes.

Paper provides the arguments to how they get to O(K-m + mT) in "Rolling Diffusion-Batched Inference (ROBI)" section however their claim in introduction is that they reduce the inference time from O(KT) to O(T)

ROBI reduces inference costs from $O(KT)$ to $O(K-m + mT)$. Our experiments set $m=1$, yielding $O(K + T)$. Since time‑dependent simulations typically have many more time steps $T$ than the $K=5–20$ diffusion steps , this simplifies to $O(T)$. We will clarify this assumption in the camera‑ready version.

If it is possible to put the dependence of the denoising between steps into equation it would become much more clear to the reader.

Given a prediction horizon $h=K$, a batch of previous clean states $\mathbf{u}^{t_j-1}\_{0}$ and noise samples $\Delta\mathbf{u}^{t_j}\_{k_j}$ for the time steps $t_j = t+j$ and $j\in\{0,...,h-1\}$ with increasing diffusion steps $k_j=1+j$, ROBIN outputs the diffusion velocities $\mathbf{v}\_\theta(\Delta\mathbf{u}^{t_j}\_{k_j}, k_j, \mathbf{u}^{t_j-1}\_0)$. We approximate the clean samples $\Delta\tilde{\mathbf{u}}^{t_j}\_{0} \approx \Delta\tilde{\mathbf{u}}^{t_j}\_{0|k_j} = \sqrt{\bar{\alpha}\_{k_j}} \Delta\mathbf{u}^{t_j}\_{{k_j}} - \sqrt{1-\bar{\alpha}\_{k_j}} \mathbf{v}\_\theta(\Delta\mathbf{u}^{t_j}\_{{k_j}}, {k_j}, \mathbf{u}^{t_j-1}\_0)$ and the current noisy samples $\\Delta\\mathbf{u}^{t\_j}\_{k\_j-1}=\\frac{\\sqrt{\\bar{\\alpha}\_{k\_j-1}}{\\beta}\_{k\_j}}{1-\\bar{\\alpha}\_{k\_j}}\\Delta\\tilde{\\mathbf{u}}^{t\_j}\_{0\\mid k\_j} + \\frac{\\sqrt{\\alpha\_{k\_j}}(1-\\bar{\\alpha}\_{k\_j-1})}{1-\\bar{\\alpha}\_{k\_j}} \\Delta\\mathbf{u}^{t\_j}\_{k\_j}$ $+ \\sigma\_{k\_j} \\boldsymbol{\\varepsilon}^{t\_j}$ with $\\boldsymbol{\\varepsilon}^{t\_j}\\sim\\mathcal{N}(0,I)$. Next, we can reconstruct the states of each time step using a cumulative sum over those approximated clean samples $\\tilde{\\mathbf{u}}^{{t_j}}\_{0} = \\mathbf{u}^{t-1}\_{0} + \\sum\_{i=0}^j \\Delta \\tilde{\\mathbf{u}}^{t+i}\_{0}$ with the last fully-denoised sample $\\mathbf{u}^{t-1}\_{0}$. Finally, we can move one physical time step further, such that $t_j = t+1+j$. Therefore, we remove the denoised time step $t$ from the batch, initialize the sample of the new time step ${t+h}$ as Gaussian noise $\\Delta\\mathbf{u}^{t+h}\_{K} \\sim \\mathcal{N}(\\mathbf{0}, \\mathbf{I})$ and predict the next batch \\mathbf{v}_\\theta(\\Delta\\mathbf{u}^{{t\_j}}\_{k\_j}, {k\_j}, \\tilde{\\mathbf{u}}^{{t\_j}-1}\_{0} = \\mathbf{u}^{t}\_{0} + \\sum\_{i=1}^j \Delta \\tilde{\\mathbf{u}}^{t+i}\_{0}). Note that the proposed state reconstruction is done before the model call and allows the model to treat all time steps as a batch, where each prediction is only conditioned on the previous reconstructed state, e.g., $\\mathbf{v}\_\\theta(\\Delta\\mathbf{u}^{t+2}\_2, 2, \\tilde{\\mathbf{u}}^{t+1}\_{0})$ for time step $j=1$.

Why did the authors focus on a very limited area? Is it possible to expand this to other PDEs?

The present work focuses on solid mechanics, a significant engineering discipline encompassing manufacturing, structural mechanics, and lightweight design, where accurate learned simulation remains under-explored. Solid mechanics exhibit global dependencies and high solution frequencies, which present a challenge for learned simulators. However, ROBIN can handle both by effectively combining diffusion with hierarchical GNNs. Although this study is limited to solid mechanics, the method could be applied to other PDEs, including fluid dynamics. Diffusion and hierarchical CNN‑based simulators improve image‑based fluid simulations [1,2]. We plan to apply ROBIN to mesh-based fluid simulations in future work.

We thank the reviewer for the suggestions and hope that we have addressed all concerns. We will include the new results in the revised paper and welcome further questions during the discussion phase.

[1] David Ruhe, et al. Rolling Diffusion Models. ICML, 2024.

[2] Phillip Lippe, et al. PDE-Refiner: Achieving Accurate Long Rollouts with Neural PDE Solvers. NeurIPS, 2023.

[3] Tobias Pfaff, et al. Learning Mesh-Based Simulation with Graph Networks. ICLR, 2020.

[4] Yadi Cao, et al. Efficient learning of mesh-based physical simulation with bi-stride multi-scale graph neural network. PMLR, 2023.

[5] Zongyi Li, et al. Learning Chaotic Dynamics in Dissipative Systems. NeurIPS, 2022.

[6] Kiwhan Song, et al. History-Guided Video Diffusion. arXiv, 2025.

Dear reviewer,

Thank you for your thoughtful and detailed feedback. We hope that our response has clarified the concerns you raised and addressed the specific points you noted. Given the short discussion period, we would be grateful to know whether our responses have resolved your concerns or if there are any other areas in which we could improve the revision.

We value your consideration and the opportunity to strengthen the paper.

We appreciate the thorough and favorable review, especially the recognition of our meticulous mathematical formulation and well-designed experimental setup. Below, we will briefly address the questions and concerns raised.

How is the computation cost compared to HGNN? Does it take longer or shorter to train？

We agree that it is important to report the computation cost against the baselines. Previously, we only presented ROBIN runtimes for various diffusion inference settings in Figure 5. We report the rollout time and RMSE of ROBIN and the baselines below. We also added an option to truncate the denoising process to speed up ROBIN’s inference further. In this setting, we stop after a chosen number of denoising steps, treating the reconstructed sample as the prediction and skipping the remaining steps. We report on variants that stop after the first (ROBIN - one step), second (ROBIN - two step), and the fifth (ROBIN - five step) steps.

A key advantage of ROBIN is that our AMPNs are trained as one step autoregressive models that are conditioned only on the previous time step. We observed no additional training time compared to conventional autoregressive models. All methods used a fixed two-day training budget.

Furthermore, we conducted an upscaling experiment that demonstrated ROBIN’s architecture is independent of mesh size. This means that, for larger mesh sizes, the number of layers in our AMG-based hierarchy increases, and the AMPNs can handle them because of the shared model blocks. We fine-tuned the pre-trained ROBIN models using the new BendingBeamLarge dataset. While the BendingBeam dataset contains meshes with an average of 750 nodes, the large dataset contains an average of 9K nodes, with a maximum of 16K nodes. We trained both the pre-trained and untrained models for 750K training iterations with a batch size of $1$. We fine-tuned the pre-trained models with a learning rate of $10^{-6}$, and we used a learning rate decay ranging from $10^{-4}$ to $10^{-5}$ for the untrained models.

Pretrained models converge quickly on meshes with about twelve times more nodes, which highlights the ability of ROBIN to upscale and its training efficiency in fine tuning.

How does ROBI learn the parameter compared to conventional diffusion?

We thank the reviewer for the insightful question. ROBI is an inference rollout scheme, and its training is identical to that of conventional diffusion-based inference. It does not have any additional parameters that need to be learned.

ROBI intuitively uses the insight that each diffusion step progressively predicts higher-frequency features to already start denoising future time steps before the current step has been fully denoised. Although this process does not reduce the number of required diffusion steps, it enables the parallel denoising of multiple steps. Figure 2 provides a schematic overview, and Figure 5 evaluates this effect. Empirically, we find that ROBI retains the accuracy of conventional diffusion inference while substantially speeding up the process on accelerated hardware. We will add a brief paragraph clarifying this relationship to the paper.

We want to thank the reviewer again for the helpful feedback. We hope that our clarifications and new results address the concerns raised. We encourage the reviewer to reach out to us during the discussion if there are further questions.