acceptodds
Under review as a conference paper at ICLR 2027

Differentiate the Solver, Not the Equation: Reverse-Sweep Adjoints for Block Implicit Simulation

Abstract

Differentiable simulation is a key component in learning, control, and inverse problems, where gradients through nonlinear implicit solvers are required. Existing approaches either rely on unrolled automatic differentiation, whose memory grows with solver depth, or on equation-level implicit differentiation, which assembles global Jacobians and solves large sparse adjoint systems, discarding the locality of the forward solver, and differentiating the converged equation rather than the finite computation that actually ran. To overcome these limitations, we propose solver-level differentiation, which differentiates the executed solver itself. Our key insight is that when a solver is composed of block implicit updates, its discrete adjoint is obtained by applying the corresponding adjoint updates in reverse order, yielding a reverse-sweep formulation whose backward pass mirrors the forward solver. From an operator perspective, the forward pass realizes an approximate inverse through ordered local solves, and the backward applies its transpose through reverse local adjoint solves, constructing no global system. We instantiate this idea on Vertex Block Descent, yielding a differentiable solver whose reverse colored Gauss-Seidel sweeps are composed entirely of local adjoint solves. The backward matches automatic differentiation through the identical executed forward to machine precision at every solver depth, where the equation-level adjoint is off by 37% after one sweep; in a controlled same-codebase, same-GPU comparison it is faster and uses less memory than unrolled automatic differentiation; and the same construction is exact on projective dynamics and extended position-based dynamics. We scale differentiable elastodynamics to contact-coupled soft bodies (8M vertices) on one GPU. Overall, this work highlights solver structure as a practical organizing principle for efficient differentiable simulation.

Primary area:
applications to robotics, autonomy, planning
Keywords:
differentiable simulation, discrete adjoint, implicit differentiation, vertex block descent, block coordinate descent, elastodynamics, physics-based simulation

Reviews

Among:
Shape:
1234this paper, Top 1%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.67 over 3 reviews, above 99% of the others.
Reviewer_XvikOpenReview ↗
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
AuthorsOpenReview ↗

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.

W1 / Q1. The basic 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?

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.

AuthorsOpenReview ↗

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.

Reviewer_QbCROpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes a solver-level differentiation methodology, which differentiates the executed solver rather than the converged equation, to obtain gradients through implicit simulation steps without the memory blowup of unrolled AD or the global adjoint solves of implicit differentiation. The authors show that for block implicit solvers like Vertex Block Descent, the adjoint is simply the forward sweep run in reverse with local solves transposed, so the backward keeps the forward’s locality and parallelism. They also identify several overlooked terms needed for the gradient to be exact when the solver is not run to convergence. Evaluation shows the gradients match autograd to machine precision at every solver depth, with 33× speedup and 69× less memory than unrolled AD, and the method scales to 8M vertices on a single GPU.

Critical strengths
  1. This paper identifies a real and under-appreciated gap: existing adjoint methods differentiate the converged equation rather than the solver that actually ran, which matters because practical solvers are run for a small fixed number of sweeps. The analysis and experiments on this point are thorough and the results in Table 1 support the motivation and method convincingly.
  2. The experimental methodology is rigorous: all baselines are compared on the same codebase and hardware with identical forward passes, and the gradient accuracy is measured against an exact reference rather than inferred from optimizer outcomes. This makes both the correctness and efficiency claims credible.
Critical weaknesses
  1. Although the backward comparison is well controlled, the unrolled AD baseline itself is weak: it uses PyTorch autograd over per-vertex operations, which is known to be extremely inefficient for this kind of fine-grained computation, whereas kernel-level AD systems (e.g., Warp’s own tape, which the authors already use as a backend, or DiffTaichi) would record at a granularity close to the proposed replay buffer. Since the 33× and 69× headline numbers are measured against this baseline, part of the reported gain may reflect the baseline choice rather than the method, and a stronger AD comparison is needed to know how much.
Questions for authors
  1. The unrolled AD baseline is PyTorch autograd over per-vertex operations, which is known to be inefficient for this kind of computation. Have you compared against a kernel-level AD system such as Warp’s own tape or DiffTaichi, and how much of the reported speedup and memory saving remains?
  2. Section 5 states that the per-vertex block defaults to a positive-definite approximation of the Hessian rather than the full block used in Vertex Block Descent, with the exact variant mentioned only in passing. Which block was used in the reported experiments, and do the exactness and cost results hold for the full indefinite block?
  3. The controlled comparison against the global adjoint baselines is performed only on a small mesh, while the scaling study covers the proposed method alone. Could you provide an evaluation or analysis of how the time and memory advantage over equation-level methods changes as mesh size grows?
3 comments
AuthorsOpenReview ↗

Response to Reviewer QbCR (1/2)

We thank the reviewer for the encouraging review, and are glad you found the gap we address real and under-appreciated and the experimental methodology rigorous. We address each question below.

Q1. Have you compared against a kernel-level AD system such as Warp's own tape or DiffTaichi, and how much of the reported speedup and memory saving remains?

Thank you for this valuable suggestion. We chose Warp's tape because our forward already runs in Warp, so both routes differentiate a bit-identical forward. We implemented the identical forward as Warp kernels and differentiated it with wp.Tape, in float64 with the same saturation and determinant guard (revised §6, baseline (5), and App. N.2). Because Gauss–Seidel overwrites positions after every color and a tape can only differentiate through arrays that are not overwritten, the tape keeps one position buffer per color per sweep. Its gradient matches ours to machine precision. Ours is faster and uses less memory at every size:

Vertices3,90625,662173,663
Backward, ours vs Warp tape8.1 vs 60.9 ms13.9 vs 67.4 ms53.6 vs 80.7 ms
Forward + backward16 vs 235 ms27 vs 251 ms112 vs 300 ms
Peak memory33 vs 192 MB220 MB vs 1.32 GB1.44 vs 9.04 GB

This confirms that the advantage comes from the method itself. At the 115-vertex setting of Table 3, ours is 13× faster than the tape in backward time and uses 6× less memory (Table G1). The lead comes from what has to be stored: a tape keeps the state for every color, while the reverse sweep keeps only the replay record of §4 and reconstructs each linearization point by undoing the recorded update. Each added rollout step costs 251 MB for ours against 2.22 GB for the tape, so on one 80 GB GPU ours backpropagates through 288 steps of the 173,663-vertex mesh without checkpointing, against 32 for the tape and 2 for PyTorch (Table 14). End to end, ours reaches the identical optimization result 11.6× faster than the tape (Table G2).

We have added the Warp tape to the comparison (revised §6.3, Table 4), which now reports the ratios against both baselines. The PyTorch baseline is vectorized per color class (one batched tensor operation per color rather than per vertex), which the revised §6 now states explicitly. The large-mesh timings use a pair-parallel thread layout (one thread per vertex–element pair), which performs the same arithmetic as the submission's kernels and is verified exact against them (App. N.6).

AuthorsOpenReview ↗

Response to Reviewer QbCR (2/2)

Q2. Which block was used in the reported experiments, and do the exactness and cost results hold for the full indefinite block?

Thank you for this question, which led to a stronger result that we are glad to add (revised §5 and App. N.4). All reported experiments use Hᵢ = μ‖∇Nᵢ‖² I + λ q qᵀ. For Stable Neo-Hookean on linear tetrahedra, the exact per-vertex diagonal block turns out to be μ‖∇Nᵢ‖² I + (λ + μ) q qᵀ: since J is affine in each single vertex position, the (J − α)∂²J term vanishes from every vertex block, even though it makes the 12×12 element Hessian indefinite. The exact block is therefore always positive semidefinite, and the default differs from it only in the rank-one coefficient.

We verified this on 2,000 random tetrahedra (793 inverted): the closed form matches the autodiff Hessian block to 4.7e-10, every vertex block has a positive minimum eigenvalue, while the element Hessians reach −3.9e10. Running the exact block end to end, a different solver (trajectories differ by up to 7.2e-3), our adjoint matches unrolled AD to 3.2e-15 for x₀, v₀ and 2.0e-13 for μ, λ over 18 configurations, at the same cost as the default block. The released code exposes the exact block as an option.

Q3. Could you provide an evaluation or analysis of how the time and memory advantage over equation-level methods changes as mesh size grows?

Thank you for this suggestion. Table G1 (revised Table 4 and App. N.1) compares all routes from 115 to 173,663 vertices, and the advantage grows with mesh size: from 6.9× at 115 vertices to 14.7× at 173,663 in backward time over the assembled global adjoint, and to 303× over the matrix-free one. The equation-level cost tracks the PCG iteration count, which grows with size (36 iterations at 115 vertices, 826 at 173,663) and with stiffness (5,718 at 173,663 vertices with μ = λ = 5e5, taking 3.08 s), while ours does not depend on conditioning (53.6 ms on both materials). At fixed depth the equation-level gradient also departs from the executed solver on large meshes (93% error at 173,663 vertices), so ours is both cheaper and the one that stays exact.

Thank you again for these thoughtful questions; the kernel-level comparison and the exact-block analysis have made the paper stronger. We hope these results further strengthen your confidence in our work, and we would be glad to discuss any further questions.

I appreciate the authors for the detailed response and additional experiments.

For Q1, the new results address my concern and the contribution from the method is now clear. For Q2 and Q3, I am also glad to see these supportive new experiment results and the evaluation is now much stronger.

Overall, the rebuttal has addressed my concerns. Considering my expertise, I am not confident enough to further raise my score, but I would keep positive on this work.

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

The paper proposes a reverse-sweep adjoint method for block implicit solvers and implements it using Vertex Block Descent (Chen et al., 2024a). The method computes gradients through the finite sequence of solver updates, rather than differentiating the converged solution. The paper reports accurate gradients on small systems and demonstrates several inverse problems. A controlled runtime and memory comparison, together with scaling experiments reaching approximately eight million vertices, provides evidence of the method’s efficiency and scalability.

Critical strengths
  1. Accurate gradients for the solver after a finite number of iterations, supported by comparisons with automatic differentiation.
  2. Careful treatment of numerical safeguards and analysis of their effects on gradient accuracy.
  3. Useful scaling experiments, including a demonstration with 8M vertices.
Critical weaknesses
  1. A very small setup for gradients check (up to 115 vertices with K=20, or 631 vertices with K=1)
  2. Rather narrow results in general for a very particular class of the systems covered by Vertex Block Descent algorithm.
  3. Also probably the paper lacks important demonstration of the practical benefits for downstream optimisation of a finite-depth solver instead of the converged solution.
Questions for authors

Q1. Can you extend the comparison with the alternatives to bigger systems? Q2. In which applications does differentiating a solver run for a fixed number of iterations provide a practical advantage over differentiating a sufficiently converged solution? Can you demonstrate this advantage through downstream optimization results under comparable computational budgets? Q3: In $5 you say “Pair indices carry no gradient, so the search algorithm never touches differentiability”. What happens when a small change in positions changes the selected contact pairs? Please clarify the assumptions under which the computed gradients remain valid and how transitions where contact pairs appear or disappear are handled

3 comments
AuthorsOpenReview ↗

Response to Reviewer Ttfh (1/2)

We thank the reviewer for the thoughtful review, and are glad you found our finite-depth gradients accurate, our treatment of numerical safeguards careful, and our scaling experiments useful. We address each comment below.

W1 / Q1. A very small setup for gradients check (up to 115 vertices with K=20, or 631 vertices with K=1). Can you extend the comparison with the alternatives to bigger systems?

Yes. We extended both the exactness check and the cross-method comparison to K = 20 on meshes up to 173,663 vertices, 1,500× larger than the setting of Table 3 (Table G1; revised §6.3, Table 4 and App. N.1).

Exactness holds at every size: the relative error is at most 9.1e-15, against unrolled autograd up to 25,662 vertices and against Warp's kernel-level tape at 173,663 vertices, where PyTorch autograd does not fit in 80 GB.

Ours also has the lowest time and memory at every size. At 173,663 vertices its backward is 14.7× faster than the assembled global adjoint with 5.6× less memory, and 303× faster than the matrix-free one. The gap widens with size and stiffness because the equation-level cost follows the PCG iteration count.

The two gradients also differ more as the mesh is refined. At K = 20, where Table 1 shows all routes agreeing on the small mesh, the equation-level error rises from 9.7e-10 at 115 vertices to 3.3% at 25,662 and 93% at 173,663. A fixed number of sweeps converges less on finer meshes, while the equation-level route assumes convergence; ours differentiates what was executed and remains exact.

W3 / Q2. In which applications does differentiating a solver run for a fixed number of iterations provide a practical advantage over differentiating a sufficiently converged solution? Can you demonstrate this advantage through downstream optimization results under comparable computational budgets?

Thank you for suggesting this experiment, which makes the paper's case more concrete. The advantage arises wherever a block solver is run for a small, fixed number of sweeps per step, which is where VBD and related solvers get their speed: large-scale scenes such as our million-body run (K = 5, §6.7), and inverse problems solved at the deployed solver depth, such as the task below (K = 5). In that regime, differentiating the solver gives the exact gradient of the function that is actually executed. A sufficiently converged solve is also costly to reach: on the 25,662-vertex stiff mesh even K = 100 sweeps do not converge, and there ours lowers the loss by 15,000× to 88,000× while the equation-level adjoint does not reduce it (App. N.3).

We solved the same inverse problem with every route (Table G2; revised §6.5 and App. N.3). Ours reaches the result in 3.2 s; the Warp tape and PyTorch reach the identical result in 37 s and 452 s. The equation-level adjoint stalls within 2.3× of its starting loss after 68 s (assembled) and 879 s (matrix-free). Under a comparable budget on a stiffer, finer mesh (Table G3, 300 s per run), ours completes 17,000 iterations and lowers the loss by 720,000× to 2,300,000×, against 2,100 iterations for the tape, 180 for PyTorch, and 220 for the equation-level adjoint, whose loss rises. Running the solver deeper (K = 100) on the stiff material, ours is 3.2× faster per iteration than the assembled adjoint on 3,906 vertices and 4.9× on 25,662, with a lower final loss on every seed (App. N.3, Table 17).

AuthorsOpenReview ↗

Response to Reviewer Ttfh (2/2)

Q3. What happens when a small change in positions changes the selected contact pairs? Please clarify the assumptions under which the computed gradients remain valid and how transitions where contact pairs appear or disappear are handled.

Thank you for this question. The revised §5 (Contact) and App. N.5 now give the full argument. The broad phase only selects which terms are evaluated, and the gradient stays valid across pair changes because every contact term vanishes smoothly at its activation boundary.

  • The IPC barrier b(d) = −κ(d − d̂)² log(d/d̂) has b, b′ and b″ all equal to zero at d = d̂. A pair entering or leaving the active set changes neither gᵢ nor Hᵢ, so the executed update is C² across the transition.
  • The center-of-mass penalty ½κ·ReLU(2r − d)² has a continuous force at d = 2r.

Our gradient is therefore the exact derivative of the executed program wherever the active set is locally constant, which is almost everywhere. We verified exactness with active floor contact and damping (error at most 2.7e-13 over 36 configurations). We also checked the million-body run directly: across all 61 stored frames, no grid cell ever held more than half of the broad-phase candidate cap, so no overlapping pair was dropped (0 of 1.23 million).

W2. Rather narrow results in general for a very particular class of the systems covered by Vertex Block Descent algorithm.

Thank you for this comment. The result applies well beyond Vertex Block Descent: Theorem 1 requires only a finite composition of block implicit updates with invertible local Jacobians, and App. B verifies exactness on extended position-based dynamics and projective dynamics, including a global solve (error at most 1.1e-14). The revised Scope paragraph in §1 now states this generality explicitly.

Thank you again for your constructive suggestions, which have improved the paper in a concrete way. We hope these new results further strengthen your confidence in our work, and we would be glad to discuss any further questions during the discussion period.

Reviewer_TtfhOpenReview ↗

Grade increased

Considering the significant increase in paper quality I update both soundness and overall grades. Thanks to the authors for their work and the additional experiments.

Comments on the paper

3 comments
AuthorsOpenReview ↗

Summary for the area chair

We thank the area chair for handling our submission, and the reviewers for their constructive comments, which led directly to the new results below. In every comparison the reviewers suggested, our method remains exact and compares favorably. For convenience, we summarize the main points here.

Reviewer suggestionWhere addressedResult
Comparison at larger scale (Ttfh, QbCR, Xvik)Table G1; §6.3, App. N.1Exact (≤ 9.1e-15) with the lowest time and memory at every size up to 173,663 vertices: 14.7× faster than the assembled global adjoint (57× on a stiff material) and 303× faster than the matrix-free one
Comparison with a kernel-level AD system (QbCR)Response to QbCR; App. N.2Faster than Warp's kernel-level tape at every size with 6.3× less memory; backpropagates through 288 steps on one GPU without checkpointing, compared with 32
Downstream benefit under a matched budget (Ttfh, Xvik)Tables G2–G3; §6.5, App. N.3Same result 11.6× faster than the tape and 143× faster than PyTorch, while the equation-level adjoint plateaus early; 17,000 iterations in 300 s, compared with 2,100
Finite depth vs. a converged solve (Ttfh)Response to Ttfh; App. N.3Even at K = 100 the stiff solve does not converge; ours lowers the loss by 15,000–88,000×, whereas the equation-level adjoint does not reduce it
Full vertex block (QbCR)App. N.4The exact block is always positive semidefinite, and our adjoint stays exact through it (3.2e-15) at no extra cost
Contact-pair changes (Ttfh)App. N.5Exact through contact (≤ 2.7e-13); 0 of 1.23 million pairs dropped in the million-body run
Relation to discrete adjoints, DiffXPBD and custom VJPs (Xvik)Response to XvikTo our knowledge, the first adjoint of a block implicit solver that is exact for the executed sweep and forms no global system
Applicability beyond VBD (Ttfh, Xvik)§1, App. BEqually exact on extended position-based dynamics and projective dynamics (≤ 1.1e-14)

Thank you again for your time and feedback. We would be happy to address any further questions during the discussion period.

AuthorsOpenReview ↗

General Response (2/2)

Table G2. Recovering the 11,718-dimensional initial velocity of a 3,906-vertex body from its state after 10 steps (μ = λ = 5e4, K = 5, Adam, 300 iterations, 3 seeds).

Backward routeFinal loss (3 seeds)Wall time
Ours4.8e-8 / 4.8e-8 / 4.5e-73.2 s
Warp tape4.8e-8 / 4.8e-8 / 4.5e-736.7 s
Unrolled AD (PyTorch)4.8e-8 / 4.8e-8 / 4.5e-7452 s
Global adjoint (assembled)1.0e-4 / 1.5e-4 / 2.4e-468.2 s
Global adjoint (matrix-free)1.0e-4 / 1.5e-4 / 2.4e-4879 s

The three exact routes follow the same loss curve and lower the loss by 870× to 5,300×. The equation-level adjoint lowers it for 60 to 80 iterations and then raises it, because it follows the gradient of a converged solve rather than of the K = 5 solver that is executed.

Table G3. Same task on 25,662 vertices with a stiff material (μ = λ = 5e5), fixed budget of 300 s per run, 3 seeds.

Backward routeIterations in 300 sLoss reduction
Ours17,000720,000–2,300,000×
Warp tape2,10046,000–150,000×
Unrolled AD (PyTorch)180570–3,800×
Global adjoint (assembled)220loss rises 64–140×

The revised PDF contains the following changes (in blue; page numbers refer to the revised PDF).

  1. §6.3, Table 4 and paragraph "Larger meshes" (p. 8); App. N.1, Tables 12–13 (pp. 24–25): all five routes up to 173,663 vertices, soft and stiff. [Ttfh, QbCR, Xvik]
  2. §6, baseline (5) (p. 7); App. N.2, Table 14 (pp. 24–25): kernel-level AD, and the rollout length that fits without checkpointing. [QbCR]
  3. §6.5, paragraph "End-to-end comparison" (p. 9); App. N.3, Tables 15–17 (pp. 25–26): the shared inverse problem, the fixed-budget run, and a deeper solver (K = 100). [Ttfh, Xvik]
  4. §5 (p. 6); App. N.4 (p. 26): the exact vertex block and its positive semidefiniteness. [QbCR]
  5. §5, Contact (p. 6); App. N.5 (p. 26): contact-pair transitions and the broad-phase check. [Ttfh]
  6. §1 (p. 2) and §6.7 (p. 9): the kernel-level baseline in the contributions, App. B's error bound (at most 1.1e-14) in the Scope paragraph, and the role of the center-of-mass penalty at 10⁶ bodies. [QbCR, Ttfh, Xvik]
  7. §6.4, App. D and App. K (pp. 8, 15, 22): the memory constant stated per executed sweep (about 80 bytes per vertex). App. N.6 documents the thread layout used for the new timings.

We thank the reviewers again for their constructive feedback, which has substantially strengthened the paper. We respond to each reviewer individually below and are happy to discuss any remaining questions.

AuthorsOpenReview ↗

General Response (1/2)

We thank all reviewers for their careful reading and helpful comments. We are encouraged that the reviewers found the problem real and under-appreciated (QbCR), the gradients accurate at finite depth (Ttfh, Xvik), the experimental comparison rigorous (QbCR), and the efficiency gains large (Xvik).

Following the reviewers' suggestions, we ran the experiments below and uploaded a revised PDF with all changes in blue. Every new comparison runs all routes on the same NVIDIA H100 (80 GB).

  1. We compared all five backward routes from 115 to 173,663 vertices (Table G1). Ours stays exact (relative error ≤ 9.1e-15) and has the lowest time and memory at every size. At 173,663 vertices its backward is 14.7× faster than the assembled global adjoint (57× on a stiff material) and uses 5.6× less memory. [Ttfh, QbCR, Xvik]
  2. We added Warp's own tape over the identical forward as a kernel-level AD baseline. Ours is faster at every size and uses 6.3× less memory, so on one GPU it backpropagates through 288 steps of the 173,663-vertex mesh without checkpointing, against 32 for the tape. [QbCR]
  3. We solved the same inverse problem with every route (Table G2). Ours reaches the result of the other exact routes 11.6× faster than the Warp tape and 143× faster than PyTorch, while the equation-level adjoint stalls within 2.3× of its starting loss. On a stiffer, finer mesh with a fixed 300 s budget, ours completes 17,000 iterations against 2,100 (tape), 180 (PyTorch) and 220 (global adjoint) (Table G3). [Ttfh, Xvik]
  4. We derived the exact Stable Neo-Hookean vertex block. It is always positive semidefinite, and our adjoint stays exact through it at the same cost. [QbCR]
  5. We checked contact-pair transitions on the million-body run: the broad phase never dropped a candidate pair (0 of 1.23 million). [Ttfh]

Table G1. Backward time / peak memory, K = 20, backpropagation through 4 steps, μ = λ = 5e3. Last column: relative gradient error of the equation-level route (metric of Table 1).

VerticesOursWarp tapeUnrolled AD (PyTorch)Global adj. (assembled)Global adj. (matrix-free)Global err
1154.08 ms / 1.0 MB53.9 ms / 6.1 MB1.23 s / 112 MB27.9 ms / 68 MB154 ms / 65 MB9.7e-10
3,9068.1 ms / 33 MB60.9 ms / 192 MB1.46 s / 1.95 GB53.8 ms / 236 MB545 ms / 132 MB9.7e-7
25,66213.9 ms / 220 MB67.4 ms / 1.32 GB1.62 s / 13.8 GB138 ms / 1.21 GB1.56 s / 525 MB3.3e-2
173,66353.6 ms / 1.44 GB80.7 ms / 9.04 GBout of memory790 ms / 8.04 GB16.2 s / 3.18 GB0.93
173,663, stiff (5e5)53.6 ms / 1.44 GB80.7 ms / 9.04 GBout of memory3.08 s / 8.04 GB111 s / 3.18 GB34

Our error is at most 9.1e-15 in every configuration. The 115-vertex row reproduces the equation-level error of Table 1. On the stiff material the assembled route needs 5,718 PCG iterations at 173,663 vertices, while our time does not change. Full grid: App. N.1, Tables 12–13.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.