Fix determinism issues in sorting, proposal seeding, and rounding

B3: argsort_by_first broke ties on the primary key nondeterministically
(std::sort is unstable). Add a secondary tie-break by original index so the
ordering is a total order. This makes the label-multiset downsample argmax and
restrict_set truncation deterministic on count ties (smaller id wins).

B4: GreedyAdditiveMulticutProposalGenerator derived its per-call seed as
seed_ + call_count_, which collided with the fusion-move driver's per-slot
seed + slot offset (different (slot, iteration) cells computed identical
proposals). Mix the packed (seed, counter) pair through a SplitMix64 finalizer
to remove the linearity.

B7: WatershedProposalGenerator::reset re-seeded the RNG but left the cached
normal-distribution deviate, so a reset generator was not identical to a fresh
one. Add noise_.reset().

flow: round_to_flat_index used std::nearbyint (FP-rounding-mode dependent,
half-to-even); switch to floor(x + 0.5) to match the half-up convention used
in affine.hxx and watershed.hxx.

Add a determinism regression test for the downsample count-tie case.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: constantinpape

include/bioimage_cpp/flow/flow_density.hxx

@@ -109,7 +109,10 @@ inline std::ptrdiff_t round_to_flat_index(
         } else if (clipped > grid.upper[axis]) {
             clipped = grid.upper[axis];
         }
-        const auto coord = static_cast<std::ptrdiff_t>(std::nearbyint(clipped));
+        // Round half up, matching the nearest-neighbor convention in
+        // transformation/affine.hxx and segmentation/watershed.hxx.
+        // std::nearbyint would honor the FP rounding mode (round-half-to-even).
+        const auto coord = static_cast<std::ptrdiff_t>(std::floor(clipped + 0.5f));
         flat += coord * grid.strides[axis];
     }
     return flat;

include/bioimage_cpp/graph/proposal_generators/greedy_additive_multicut.hxx

@@ -54,7 +54,7 @@ public:
             weight_stop_,
             node_num_stop_,
             true,
-            seed_ + static_cast<int>(call_count_),
+            mixed_seed(seed_, call_count_),
             sigma_
         );
         ++call_count_;
@@ -65,6 +65,23 @@ public:
     }
 
 private:
+    // Mix the base seed and the call counter so proposals from different
+    // (slot, iteration) cells never realign. A plain `seed_ + call_count_`
+    // collided with the per-slot `seed + slot` offset applied by the fusion-move
+    // driver (slot 0 at iteration i+1 reused the seed of slot 1 at iteration i),
+    // recomputing identical proposals and shrinking effective diversity. A
+    // SplitMix64 finalizer over the packed (seed, counter) pair removes the
+    // linearity.
+    static int mixed_seed(const int base, const std::size_t counter) {
+        std::uint64_t z =
+            (static_cast<std::uint64_t>(static_cast<std::uint32_t>(base)) << 32) |
+            static_cast<std::uint64_t>(static_cast<std::uint32_t>(counter));
+        z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9ULL;
+        z = (z ^ (z >> 27)) * 0x94D049BB133111EBULL;
+        z = z ^ (z >> 31);
+        return static_cast<int>(static_cast<std::uint32_t>(z));
+    }
+
     const UndirectedGraph &graph_;
     std::vector<double> edge_costs_;
     double sigma_;

include/bioimage_cpp/graph/proposal_generators/watershed.hxx

@@ -109,6 +109,9 @@ public:
 
     void reset() override {
         generator_.seed(static_cast<std::mt19937::result_type>(seed_));
+        // std::normal_distribution caches a second Box-Muller deviate; clear it
+        // so a reset generator is bytewise identical to a freshly constructed one.
+        noise_.reset();
     }
 
 private:

include/bioimage_cpp/label_multiset/multiset.hxx

@@ -24,12 +24,22 @@ template <class V1, class V2>
 inline void argsort_by_first(V1 &v1, V2 &v2, const bool ascending = true) {
     std::vector<std::size_t> idx(v1.size());
     std::iota(idx.begin(), idx.end(), 0);
+    // Break ties on the primary key by original index so the ordering is a
+    // total order. std::sort is unstable, so without this tie-break equal keys
+    // (e.g. equal counts when sorting label entries) would be reordered
+    // nondeterministically across runs / STL implementations.
     if (ascending) {
         std::sort(idx.begin(), idx.end(),
-                  [&v1](std::size_t a, std::size_t b) { return v1[a] < v1[b]; });
+                  [&v1](std::size_t a, std::size_t b) {
+                      if (v1[a] != v1[b]) return v1[a] < v1[b];
+                      return a < b;
+                  });
     } else {
         std::sort(idx.begin(), idx.end(),
-                  [&v1](std::size_t a, std::size_t b) { return v1[a] > v1[b]; });
+                  [&v1](std::size_t a, std::size_t b) {
+                      if (v1[a] != v1[b]) return v1[a] > v1[b];
+                      return a < b;
+                  });
     }
     reorder_inplace(v1, idx);
     reorder_inplace(v2, idx);

tests/label_multiset/test_downsample.py

@@ -123,3 +123,21 @@ def test_downsample_restrict_set_keeps_top_k():
     assert ids.tolist() == [0]
     assert counts.tolist() == [15]
     assert ms_top1.argmax.tolist() == [0]
+
+
+def test_downsample_restrict_set_count_tie_is_deterministic():
+    # Two labels with equal counts (8 each). With restrict_set=1 and a count
+    # tie, the argmax / retained entry must be deterministic: the smaller id
+    # wins (the sort breaks ties by id). Run twice to confirm stability.
+    labels = np.empty((4, 4), dtype=np.uint64)
+    labels[:2, :] = 1
+    labels[2:, :] = 2
+    ms_full = multiset_from_labels(labels, (1, 1))
+    b = Blocking([0, 0], [4, 4], [4, 4])
+    results = []
+    for _ in range(2):
+        ms_top1 = downsample_multiset(ms_full, b, restrict_set=1)
+        ids, counts = ms_top1.entry(0)
+        results.append((ms_top1.argmax.tolist(), ids.tolist(), counts.tolist()))
+    assert results[0] == results[1]
+    assert results[0] == ([1], [1], [8])