- Rating
- 4(+1)
- Confidence
- 3(−1)
- Informativeness
- 2
- Presentation
- 3
- Soundness
- 3
Read review
Paper summary
This paper proposes an efficient backward method for block implicit simulation. Unrolled automatic differentiation (AD) requires storing a large computational graph, while equation-level implicit differentiation typically involves solving a global adjoint system and does not capture the gradients of a solver stopped after a finite number of iterations.
To address these limitations, the authors propose Reverse-Sweep Adjoint, which computes gradients by applying local adjoint updates in reverse order. The method is developed for Vertex Block Descent (VBD), using local 3×3 linear solves and gradient propagation without assembling a global adjoint matrix. It also accounts for the Hessian tangent and derivatives of numerical safeguards to obtain accurate gradients at finite solver depth.
The experiments show that the resulting gradients match unrolled autograd to nearly machine precision across different iteration counts. In a controlled comparison, the backward pass is about 33× faster and uses 69× less memory than unrolled autograd. The authors also demonstrate the method on material identification, physical control, real-to-sim fitting, and large-scale simulation involving one million soft bodies.
Critical strengths
1. Accurate gradients while preserving the solver's local structure. The paper derives a local adjoint formulation for block implicit solvers with a finite number of iterations, avoiding the global adjoint system required by equation-level implicit differentiation. The authors also account for terms that are easy to overlook, such as the Hessian tangent and update saturation, and use ablation studies to show why these terms matter. The close agreement with unrolled autograd across different solver depths provides good evidence that the gradients are implemented correctly.
2. Large efficiency gains and useful application results. The method substantially reduces backward time and memory usage compared with unrolled autograd under the same hardware and forward simulation settings. The authors also test the gradients on several inverse problems, including material identification, initial-state optimization, contact-related control, and fitting simulations to real videos. The large-scale GPU experiment further demonstrates the scalability of the implementation. These results make a good case for the practical usefulness of the method.
Critical weaknesses
1. The novelty of the core mathematical idea is somewhat limited. The main idea is to treat a finite sequence of block updates as a composition of functions and compute local vector-Jacobian products in reverse order. This follows directly from standard reverse-mode differentiation and discrete adjoint methods. While the authors provide a detailed derivation and an efficient implementation for VBD, the paper does not clearly establish what is fundamentally new compared with existing analytic adjoints, differentiation of local constraint projections, and custom VJP implementations. The main novelty appears to lie in the solver-specific adjoint construction and its efficient implementation, rather than in a fundamentally new differentiation principle.
2. The experiments do not fully establish the advantages in more complex simulation settings. The main cross-method performance comparison uses a relatively small VBD mesh, while the larger-scale experiments do not provide matched comparisons with alternative differentiation methods. The XPBD and Projective Dynamics results are also limited to small-scale implementations. The million-body experiment uses a simplified center-of-mass contact penalty, which does not fully represent complex geometric contact between deformable bodies.
Also, while the paper demonstrates accurate gradients and substantial computational savings, it does not compare different differentiation methods on the same inverse problems in terms of end-to-end optimization time and final results. It is therefore unclear how much of the reported advantage translates into practical gains in more demanding optimization tasks.
Questions for authors
1. The basic Reverse-Sweep Adjoint formulation appears to follow from standard reverse-mode differentiation and the local implicit function theorem. Could the authors clarify the main algorithmic contributions beyond the VBD-specific implementation, particularly compared with existing discrete adjoint methods, DiffXPBD, and other analytic approaches to differentiating local updates?
2. Could the authors compare different differentiation methods on the same inverse problems, including both total optimization time and final results? Also, do the reported performance gains hold for larger meshes and scenes involving more complex geometric contact?
3 comments
Response to Reviewer Xvik (2/2)
W2 / Q2. Could the authors compare different differentiation methods on the same inverse problems, including both total optimization time and final results? Also, do the reported performance gains hold for larger meshes and scenes involving more complex geometric contact?
Thank you for these valuable suggestions, which led to some of the most informative experiments in the revision. We optimized the same inverse problem with every route (Tables G2 and G3; revised §6.5 and App. N.3). With the K = 5 solver used in practice, ours reaches the result in 3.2 s; the Warp tape and PyTorch reach the identical result in 37 s and 452 s, while the equation-level adjoint stalls within 2.3× of its start. On a stiffer, finer mesh with a fixed 300 s budget, ours completes 17,000 iterations against 2,100 for the tape, 180 for PyTorch and 220 for the equation-level adjoint, whose loss rises.
For larger meshes, all five routes now run up to 173,663 vertices on one GPU (Table G1), and ours has the lowest time and memory throughout, with the advantage over equation-level methods growing with size and stiffness. Exactness in Theorem 1 does not depend on problem size, which Table G1 confirms up to 173,663 vertices, and App. B verifies the same exactness on extended position-based dynamics and projective dynamics, including a global solve.
On contact, the IPC barrier between deformable bodies is differentiated through the same local solve with no contact-specific adjoint. Cover the Spot (§6.5, App. I) optimizes three soft disks through disk–disk and disk–floor IPC contact, and the new exactness check covers active contact with damping (error at most 2.7e-13). In the million-body scene, the center-of-mass penalty is what makes contact among 10⁶ bodies affordable, and the revised §6.7 now states this choice.
Thank you again for your insightful and detailed feedback, which helped us sharpen both the statement of our contributions and the experiments. We hope these clarifications and new results further strengthen your confidence in the paper, and we would welcome any further discussion.
Thank you for your detailed responses and additional experiments, which have largely addressed my concerns and strengthened the paper.
I find the experimental results very impressive, and I am glad to see that there is still significant potential for improvement in differentiable simulation. This makes the final scoring decision particularly difficult for me. However, I still have some reservations about the novelty of the core mathematical ideas. In computer graphics, using adjoint-based methods as an alternative to unrolled automatic differentiation is a fairly natural direction. The reverse-sweep formulation and its memory efficiency also appear to build largely on established principles of reverse-mode differentiation and discrete adjoint methods. Nevertheless, I recognize the value of the solver-specific construction, the accurate gradients at finite solver depth, and the substantial practical improvements demonstrated in the experiments.
Overall, my assessment is close to 3.5, between Weak Acceptance and Acceptance. Since this score is not available, I have decided to raise my rating to 4 (Clear acceptance) while lowering my confidence to 3, reflecting my remaining uncertainty in weighing the paper's novelty against its strong practical contributions.
Response to Reviewer Xvik (1/2)
We thank the reviewer for the detailed and insightful review, and are glad you found the gradients accurate and the efficiency gains large, with useful applications. We address each comment below.
Thank you for this insightful question, which helps us state our contribution more precisely. Indeed, our method builds on the standard principle of reverse-mode differentiation of a finite composition; our contribution is making it exact and efficient for block implicit solvers. To the best of our knowledge, ours is the first adjoint of a block-coordinate implicit solver that is exact for the executed finite sweep and forms no global linear-algebra object (App. D). The new experiments help quantify three aspects of this.
First, the reverse sweep needs very little storage. Undoing each recorded update in reverse color order reconstructs every linearization point exactly, so a nine-double replay record per vertex per sweep suffices (§4). Against Warp's kernel-level tape of the same solver this gives 6.3× less memory at 173,663 vertices and a 9× longer rollout on one GPU (288 against 32 steps); against PyTorch autograd, 64× less memory at 25,662 vertices, with autograd out of memory at 173,663.
Second, exactness at finite depth depends on terms that analytic adjoints of local updates easily overlook, as the reviewer also noted: the Hessian tangent, the saturation Jacobian and the mirroring of validity gates. Each omission is invisible at convergence and grows under refinement, reaching 26% at 631 vertices (Table 2).
Third, the two routes differentiate different functions. At K = 20 the equation-level gradient is off by 3.3% at 25,662 vertices and by 93% at 173,663, and in end-to-end optimization it stalls within 2.3× of its starting loss while ours lowers the loss by up to 5,300× (Table G2).
We are also glad to clarify the relation to the works the reviewer mentions. Existing discrete adjoint methods for implicit integration differentiate the converged per-step equation, while ours differentiates the sweep that was executed; Table G1 compares the two routes side by side. DiffXPBD derives analytic gradients of local constraint projections, and its backward then solves a sparse adjoint system with CG at each step (App. D), whereas our reverse sweep keeps the backward local, like the forward. Our backward also fits naturally into a custom VJP; what it contributes is the content of that VJP, a reverse sweep of 3×3 solves that never assembles a global object, which is what Table G1 measures. We hope this clarifies the contribution, and we would be glad to elaborate on any of these points.