test(cuda): pin scaledProdExp bit-identity to composed exp((c·x)·y)

`Buffer.scaledProdExp x y c` is a single fused device kernel for
`exp((c·x)·y)`. Add a CUDA kernel-coverage test asserting it is
bit-identical — compared by `Float.toBits`, not a tolerance — to the
composed form built from the `full` / `mul` / `exp` elementwise kernels,
over signed/zero fixtures and a range of scalars. A fast-math `__expf`,
a reassociated product, or a dropped float32 cast would fail it. Runs on
the CPU stub (`lake build`) and on the GPU (`-K cuda`) alike; wired into
the CUDA suite.

Author: NicolasRouquette

NN/Tests/Runtime/Cuda/ScaledProdExp.lean

@@ -0,0 +1,64 @@
+/-
+Copyright (c) 2026 TorchLean
+Released under MIT license as described in the file LICENSE.
+Authors: TorchLean Team
+-/
+
+module
+
+public import NN.Runtime.Autograd.Engine.Cuda.Buffer
+public import Std
+
+/-!
+# CUDA Kernel Coverage: scaledProdExp (fused scaled product exponential)
+
+`Buffer.scaledProdExp x y c` computes `exp((c · x) · y)` in a single fused device kernel. This test
+pins its defining property: element for element it must be **bit-identical** to the composed form built
+from the elementwise `full` / `mul` / `exp` kernels — `exp(((full c) · x) · y)`, the same
+left-association and the same `expf`. A silent divergence (a fast-math `__expf`, a reassociated
+product, a lost float32 cast) is a regression this catches.
+
+Like the rest of this suite it runs on the CPU stub (`lake build`) and on the GPU (`-K cuda`) alike.
+-/
+
+@[expose] public section
+
+namespace Tests
+namespace Cuda
+namespace ScaledProdExp
+
+open Runtime.Autograd.Cuda
+
+def run : IO Unit := do
+  IO.println "=== CUDA kernel coverage: scaledProdExp (fused vs composed) ==="
+  -- Varied, signed, finite fixtures, kept in a range where `exp` stays finite.
+  let xs : FloatArray := FloatArray.mk #[0.10, -0.20, 0.35, -0.50, 0.75, -0.90, 0.00, 1.00, -1.00, 0.42]
+  let ys : FloatArray := FloatArray.mk #[0.90, -0.75, 0.50, -0.30, 0.15, -0.05, 1.00, -1.00, 0.25, -0.60]
+  let n : UInt32 := xs.size.toUInt32
+  let x := Buffer.ofFloatArray xs
+  let y := Buffer.ofFloatArray ys
+  -- Scalars spanning sign and magnitude, including the identity `c = 0`.
+  for c in ([-2.0, 0.5, 3.25, -0.125, 1.0, 0.0] : List Float) do
+    let fused    := Buffer.scaledProdExp x y c
+    let composed := Buffer.exp (Buffer.mul (Buffer.mul (Buffer.full n c) x) y)
+    let af := Buffer.toFloatArray fused
+    let ac := Buffer.toFloatArray composed
+    if af.size != ac.size then
+      throw <| IO.userError s!"scaledProdExp c={c}: size mismatch ({af.size} vs {ac.size})"
+    let mut mism : Nat := 0
+    let mut maxDiff : Float := 0.0
+    for i in [:af.size] do
+      let vf := af.get! i
+      let vc := ac.get! i
+      -- Bit-level comparison: `toBits` distinguishes results that `==` would call equal.
+      if vf.toBits != vc.toBits then mism := mism + 1
+      let d := Float.abs (vf - vc)
+      if d > maxDiff then maxDiff := d
+    if mism != 0 then
+      throw <| IO.userError
+        s!"scaledProdExp c={c}: {mism}/{af.size} elements differ from composed exp((c·x)·y) (max |Δ|={maxDiff})"
+  IO.println "  fused scaledProdExp bit-identical to composed exp((c·x)·y) over all fixtures ✓"
+
+end ScaledProdExp
+end Cuda
+end Tests

NN/Tests/Runtime/Cuda/Suite.lean

@@ -21,6 +21,7 @@ public import NN.Tests.Runtime.Cuda.MatmulBmm
 public import NN.Tests.Runtime.Cuda.Fft
 public import NN.Tests.Runtime.Cuda.ViewsBroadcastReduce
 public import NN.Tests.Runtime.Cuda.LinearMseConcatSliceGather
+public import NN.Tests.Runtime.Cuda.ScaledProdExp
 public import NN.Tests.Runtime.Cuda.Stress
 
 /-!
@@ -56,6 +57,7 @@ def run : IO Unit := do
   Fft.run
   ViewsBroadcastReduce.run
   LinearMseConcatSliceGather.run
+  ScaledProdExp.run
   Stress.run
   IO.println "=== CUDA kernel coverage suite completed ==="