Restore §3.3.3 truncation cases in the divisibility check

The strong divisibility check from the previous commit fixes the
wrong-answer composition from #3177, but rejects the paper's §3.3.3
"apparent violation" cases that produce well-defined results, e.g.

    A = (4,2,8):(3,12,97), B = 3:3   ->   3:9

After the public composition() coalesces A to (8,8):(3,97), the
strong check sees `8 % 3 != 0` and refuses to compile, even though
A(0)=0, A(3)=9, A(6)=18 is well-defined.

Add a third disjunct that accepts the safe-truncation pattern: when
B's entire image fits inside the current LHS mode, higher modes are
unreachable and cannot perturb the result. This is the §3.3.3
distinction between "apparent" and "real" divisibility violations.

Predicate now accepts iff at least one of:
  (a) (rest_stride % curr_shape) == 0   -- skip mode entirely
  (b) (curr_shape % rest_stride) == 0   -- partial traversal
  (c) (rest_shape - 1) * rest_stride < curr_shape
                                        -- safe truncation: B's image
                                           stays within the current mode

Verification matrix:

  Case                                  Pre-coalesce LHS         Decision
  ----------------------------------    ---------------------    --------
  paper §3.3.3 ok (returns 3:9)         (8,8):(3,97) o 3:3       accept
  paper §3.3.3 fail-left                (8,8):(3,97) o 4:3       reject
  paper §3.3.3 fail-right               (4,2,8):(3,15,97) o 3:3  reject
  wrong-answer bug #3177                (4,6,8):(2,3,5) o 6:3    reject
  CuTe test (8,8):(8,1) o 2:3           (8,8):(8,1) o 2:3        accept
  CuTe test (8,8):(8,1) o 3:3           (8,8):(8,1) o 3:3        accept
  CuTe test (8,8):(8,1) o 4:3           (8,8):(8,1) o 4:3        reject

Reference: arXiv:2603.02298 §3.3.3.

Author: jduprat

include/cute/layout.hpp

@@ -1075,12 +1075,26 @@ composition_impl(LShape const& lhs_shape, [[maybe_unused]] LStride const& lhs_st
                    //   (b) a divisor of the mode's shape   ((curr_shape % rest_stride) == 0), so the mode is partially traversed by an integral number of strides.
                    //CUTE_STATIC_ASSERT_V(((rest_stride % curr_shape) == Int<0>{}) or ((curr_shape % rest_stride) == Int<0>{}), "Stride Divisibility Condition");
 
-                   // Weak divisibility condition -- verify the divisibility condition whenever possible
-                   if constexpr (is_static<decltype(curr_shape)>::value and is_static<decltype(rest_stride)>::value) {
-                     CUTE_STATIC_ASSERT_V(((rest_stride % curr_shape) == Int<0>{}) or ((curr_shape % rest_stride) == Int<0>{}), "Stride Divisibility Condition");
+                   // Composition C = A o B is well defined for the current mode iff at least one of:
+                   //   (a) rest_stride is a multiple of curr_shape  ((rest_stride % curr_shape) == 0):
+                   //         the mode is skipped entirely.
+                   //   (b) curr_shape is a multiple of rest_stride  ((curr_shape % rest_stride) == 0):
+                   //         the mode is partially traversed by an integral number of strides.
+                   //   (c) every point in B's image stays inside the current mode:
+                   //         (rest_shape - 1) * rest_stride < curr_shape.
+                   //         Higher modes are unreachable and cannot perturb the result;
+                   //         this is the §3.3.3 "apparent violation" pattern resolved by truncation.
+                   if constexpr (is_static<decltype(curr_shape)>::value and
+                                 is_static<decltype(rest_stride)>::value and
+                                 is_static<decltype(rest_shape)>::value) {
+                     CUTE_STATIC_ASSERT_V(((rest_stride % curr_shape) == Int<0>{}) or
+                                          ((curr_shape % rest_stride) == Int<0>{}) or
+                                          (((rest_shape - Int<1>{}) * rest_stride) < curr_shape),
+                                          "Stride Divisibility Condition");
                    } else {
                      // DEBUG assert can cause extra registers and inappropriate compile-time/run-time failure
-                     //assert((((rest_stride % curr_shape) == 0) or ((curr_shape % rest_stride) == 0)) && "Stride Divisibility Condition");
+                     //assert((((rest_stride % curr_shape) == 0) or ((curr_shape % rest_stride) == 0) or
+                     //       (((rest_shape - 1) * rest_stride) < curr_shape)) and "Stride Divisibility Condition");
                    }
 
                    // next_shape:  ceil(exclusive_prefix_product<r>(lhs_shape) / rhs_stride)

test/unit/cute/core/composition.cpp

@@ -456,25 +456,56 @@ TEST(CuTe_core, Composition)
     test_composition(a, b);
   }
 
-  // Should fail the strong stride-divisibility condition: rhs stride 3 neither
-  // divides nor is divided by lhs mode-0 shape 8.  The previous "weak" check
-  // (rest_stride < curr_shape) accepted these cases; for these particular
-  // rhs sizes they happen to produce the right answer because the rhs
-  // coordinates never reach the mode boundary, but the same algorithm produces
-  // wrong answers for compositions that do cross it (see NVIDIA/cutlass#3177).
+  // Safe truncation: rhs stride 3 neither divides nor is divided by lhs
+  // mode-0 shape 8, but the rhs image stays inside that mode so higher modes
+  // are unreachable.  Accepted via the safe-truncation disjunct
+  // ((rest_shape - 1) * rest_stride < curr_shape).
+  {
+    auto a = make_layout(Shape<_8,_8>{}, Stride<_8,_1>{});
+    auto b = make_layout(_2{}, _3{});
+    test_composition(a, b);
+  }
+  {
+    auto a = make_layout(Shape<_8,_8>{}, Stride<_8,_1>{});
+    auto b = make_layout(_3{}, _3{});
+    test_composition(a, b);
+  }
+
+  // Paper §3.3.3 "apparent violation": (4,2,8):(3,12,97) coalesces to
+  // (8,8):(3,97), then o 3:3 truncates safely to 3:9.
+  // arXiv:2603.02298 §3.3.3.
+  {
+    auto a = make_layout(Shape<_4,_2,_8>{}, Stride<_3,_12,Int<97>>{});
+    auto b = make_layout(_3{}, _3{});
+    test_composition(a, b);
+  }
+
+  // Should fail the divisibility condition: rhs image crosses the mode
+  // boundary (every disjunct of the predicate fails).
   // {
   //   auto a = make_layout(Shape<_8,_8>{}, Stride<_8,_1>{});
-  //   auto b = make_layout(_2{}, _3{});
+  //   auto b = make_layout(_4{}, _3{});
   //   test_composition(a, b);
   // }
+  // Paper §3.3.3 fail-left: same A as above but B=4:3 doesn't truncate
+  // (after coalesce, (4-1)*3 = 9 >= 8).
   // {
-  //   auto a = make_layout(Shape<_8,_8>{}, Stride<_8,_1>{});
+  //   auto a = make_layout(Shape<_4,_2,_8>{}, Stride<_3,_12,Int<97>>{});
+  //   auto b = make_layout(_4{}, _3{});
+  //   test_composition(a, b);
+  // }
+  // Paper §3.3.3 fail-right: A's middle stride 15 prevents the coalesce
+  // that would otherwise expose a safe truncation.
+  // {
+  //   auto a = make_layout(Shape<_4,_2,_8>{}, Stride<_3,Int<15>,Int<97>>{});
   //   auto b = make_layout(_3{}, _3{});
   //   test_composition(a, b);
   // }
+  // Wrong-answer case from #3177: the previous weak check accepted this and
+  // returned (_2,_3):(_6,_3), but C(2) = 3 != A(B(2)) = 7.
   // {
-  //   auto a = make_layout(Shape<_8,_8>{}, Stride<_8,_1>{});
-  //   auto b = make_layout(_4{}, _3{});
+  //   auto a = make_layout(Shape<_4,_6,_8>{}, Stride<_2,_3,_5>{});
+  //   auto b = make_layout(_6{}, _3{});
   //   test_composition(a, b);
   // }