Remove all determinism statements from the change

The changelog fragments now state only the speedup and the
floating-point tolerance of the result shift; the gather docstring and
candidate-sort docstring describe the mechanics without claiming any
reproducibility property; test wording is neutral. The behavior itself
(fixed consumption order, no output atomics) is unchanged and remains
pinned by the order-permutation and repeated-step tests.

Author: AnkaChan

changelog/4141.changed.1.md

@@ -1 +1 @@
-Sort soft-contact candidate pairs by shape on every device. With sufficient contact capacity this keeps the same contacts in a different order, so CPU and deterministic results can shift within floating-point tolerance (when capacity overflows, the retained subset can differ too). Faster on scenes with many shapes or worlds; a little slower on small dense-contact scenes.
+Sort soft-contact candidate pairs by shape on every device. Results can shift within floating-point tolerance, and when contact capacity overflows the retained subset can differ. Faster on scenes with many shapes or worlds; a little slower on small dense-contact scenes.

changelog/4141.changed.md

@@ -1 +1 @@
-Speed up `SolverVBD` rigid-soft contact and deformable elasticity on CUDA, most in scenes with many contacts or worlds. Contact forces now use one per-particle gather on every device and determinism mode, with no accumulation atomics: for a given set of detected contacts the sums are deterministic, and exact values can shift within floating-point tolerance relative to earlier releases.
+Speed up `SolverVBD` rigid-soft contact and deformable elasticity on CUDA, most in scenes with many contacts or worlds. Exact values can shift within floating-point tolerance relative to earlier releases.

newton/_src/sim/collide.py

@@ -945,7 +945,7 @@ def _world_compatible_pairs(
 
     Pairs are stably sorted by shape index so consecutive candidates process the same shape: on CUDA
     a warp then reads one shape's transform/scale/SDF data and takes one type-dispatch branch. The
-    order is deterministic on every device; each contact record stores its candidate tid, so
+    sort runs on the host at construction; each contact record stores its candidate tid, so
     downstream mapping does not depend on candidate order.
 
     Worlds are immutable after :meth:`~newton.ModelBuilder.finalize`, so this filtering is safe to

newton/_src/solvers/vbd/particle_vbd_kernels.py

@@ -2406,14 +2406,10 @@ def gather_particle_body_contact_force_and_hessian(
 ):
     """Gather all body-contact contributions for one colored particle without output atomics.
 
-    Contacts are consumed in increasing node order rather than linked-list order. Node ids are
-    positions in the contact buffer, so for a given set of detected contact records the
-    floating-point sum is deterministic on every device and determinism mode, with no output
-    atomics. (End-to-end run-to-run reproducibility additionally requires the collision pipeline
-    to emit records at reproducible slot indices; soft-contact slots are claimed with an atomic
-    counter during generation.) Selection scans the list once per consumed node
-    (O(k^2) link reads for k contacts on one particle); k is small in practice and the scan cost is
-    trivial next to one contact evaluation.
+    Contacts are consumed in increasing node order rather than linked-list order, so the
+    summation order follows the contact buffer instead of the lists' insertion order. Selection
+    scans the list once per consumed node (O(k^2) link reads for k contacts on one particle);
+    k is small in practice and the scan cost is trivial next to one contact evaluation.
     """
     particle_index = particle_ids_in_color[wp.tid()]
     force = wp.vec3(0.0)

newton/tests/test_solver_vbd.py

@@ -2119,7 +2119,7 @@ def _launch_particle_contact_gather(data, contact_count, contact_head, contact_n
 
 
 def _particle_contact_gather_order_pinned(test, device):
-    """Produce bitwise-identical gather sums for any chain permutation with the same membership.
+    """Produce identical gather sums for any chain permutation with the same membership.
 
     The adjacency build's atomic insertions make chain order scheduling-dependent; the gather's
     ascending-node-id consumption must erase that. Reversing every per-particle chain is one such
@@ -2326,7 +2326,7 @@ def _particle_contact_gather_capture_replays_device_count(test, device):
 
 
 def _particle_contact_gather_solver_step_dispatch_and_capture(test, device):
-    """Exercise production gather dispatch, capture replay, and deterministic-mode reproducibility."""
+    """Exercise production gather dispatch, capture replay, and repeated-step consistency."""
     with wp.ScopedDevice(device):
         model, _vertices = _build_edge_over_post(device)
         pipeline = newton.CollisionPipeline(
@@ -2376,8 +2376,7 @@ def _particle_contact_gather_solver_step_dispatch_and_capture(test, device):
                     test.assertTrue(np.any(head >= 0))
                 test.assertTrue(np.all(np.isfinite(state_out.particle_q.numpy())))
 
-        # The gather is the only contact-force path; in deterministic mode its canonical
-        # node-order consumption must make repeated identical steps bitwise reproducible.
+        # Repeated identical steps on the same contact buffer must produce identical results.
         deterministic_solver = newton.solvers.SolverVBD(
             model,
             iterations=1,