Address review comments on build time docs

Author: tenpercent

include/ck/BUILD_TIME_OPTIMIZATION.md

@@ -8,6 +8,16 @@ This document describes techniques for reducing C++ template instantiation overh
 
 Composable Kernel relies heavily on C++ template metaprogramming to achieve GPU kernels with no runtime abstraction penalty. However, deep template instantiation can significantly impact build times. A single translation unit may trigger hundreds of thousands of template instantiations, with each instantiation adding to compile time.
 
+## Key Types
+
+This codebase uses compile-time types to enable zero-overhead abstractions:
+
+- `Number<N>` - compile-time integer, enables static dispatch and compile-time arithmetic
+- `Sequence<Is...>` - compile-time integer sequence, used for dimension ordering and index manipulation
+- `Tuple<Ts...>` - heterogeneous container holding different types, used for tensor descriptors and transforms
+
+These types allow the compiler to fully unroll loops, eliminate branches, and inline all operations - producing GPU kernels with no runtime abstraction cost.
+
 ## Optimization Techniques
 
 ### 1. Replace Recursive Templates with Pack Expansion
@@ -65,7 +75,7 @@ struct sequence_gen
 };
 ```
 
-Note: While `std::make_integer_sequence` is the standard C++14 way to generate integer sequences, it only produces `std::integer_sequence<T, ...>`. We use `__make_integer_seq` directly because it accepts any template as its first argument, enabling this pattern where the helper class receives the index pack directly.
+Note: This document assumes C++17 or later. While `std::make_integer_sequence` (introduced in C++14) is the standard library facility for generating integer sequences, it only produces `std::integer_sequence<T, ...>`. We use `__make_integer_seq` directly because it accepts any template as its first argument, enabling this pattern where the helper class receives the index pack directly.
 
 ### 2. Replace Lambdas with Named Functors
 
@@ -153,11 +163,18 @@ Template recursion creates N template instantiations for N iterations. A constex
 **Before** (O(N) template instantiations):
 
 ```cpp
-template <index_t Target, typename Seq, index_t Pos>
+// Simplified example - actual CK code used more complex recursive patterns
+template <index_t Target, typename Seq, index_t Pos, bool AtEnd>
 struct find_source_index_impl
 {
     static constexpr index_t value =
-        (Seq::template At<Pos>() == Target) ? Pos : find_source_index_impl<Target, Seq, Pos+1>::value;
+        (Seq::template At<Pos>() == Target) ? Pos : find_source_index_impl<Target, Seq, Pos+1, (Pos+1 == Seq::Size())>::value;
+};
+
+template <index_t Target, typename Seq, index_t Pos>
+struct find_source_index_impl<Target, Seq, Pos, true>
+{
+    static constexpr index_t value = -1; // not found
 };
 ```
 
@@ -167,10 +184,11 @@ struct find_source_index_impl
 template <index_t Target, index_t... Is>
 __host__ __device__ constexpr index_t find_source_index(Sequence<Is...>)
 {
+    // Simplified example - actual implementation handles empty sequences
     constexpr index_t values[] = {Is...};
     for(index_t i = 0; i < sizeof...(Is); ++i)
         if(values[i] == Target) return i;
-    return 0;
+    return -1; // not found
 }
 ```
 
@@ -180,14 +198,14 @@ This reduced `sequence_map_inverse` instantiations from 45 to 10 (78% reduction)
 
 Fold expressions (C++17) can replace recursive template patterns for accumulation operations.
 
-**Before** (implicit recursion through generate_tuple and container_reduce):
+**Before** (uses helper utilities that hide template recursion: `generate_tuple` recursively constructs a tuple of N elements, and `container_reduce` recursively reduces that tuple):
 
 ```cpp
 const auto element_space_size = container_reduce(
     generate_tuple([&](auto i) {
-        return (lengths[i] - I1) * strides[i];
+        return (lengths[i] - Number<1>{}) * strides[i];
     }, Number<N>{}),
-    math::plus{}, LongNumber<1>{});
+    math::plus{}, Number<1>{});
 ```
 
 **After** (single fold expression):