# Brief: level-3 substrates (full architectures, multi-kernel)

Level-3 KernelBench problems are whole networks. Their substrate is a PIPELINE
of kernels — one `__global__` per layer — so that a mutation lands in a
specific layer and we can measure how far a fault propagates through depth.

Read `substrates/SPEC.md` first for the general contract, then the differences
below. Read `problems_batch2.py` for the CUDA style, and at least two accepted
substrates from `substrates/accepted/`.

## What changes vs a level-1/2 substrate

1. `cuda` holds SEVERAL `__global__` kernels, one per layer of the network
   (e.g. `mlp_gemm_relu_kernel`, `mlp_gemm_kernel`). Name them so the layer is
   identifiable.
2. `kernel_name` is a LIST of those symbol names, in pipeline order.
3. `launch` returns a DICT describing the sequence instead of a single tuple:

```python
def launch(inputs, torch):
    x = inputs[0]
    ...
    bufs = [torch.zeros(...), ...]        # intermediate activations
    seq = [
        # (kernel_name, grid3, block3, [tensor args in order], [(ctype, scalar), ...])
        ("layer0_kernel", (gx, gy, 1), (32, 32, 1), [x, w0, b0, bufs[0]],
         [(ctypes.c_int, M), (ctypes.c_int, K), (ctypes.c_int, N)]),
        ("layer1_kernel", ..., [bufs[0], w1, b1, out], [...]),
    ]
    return {"seq": seq, "out": out}
```

   Tensor arguments are passed as data pointers in the order listed; scalars
   follow. Allocate intermediates inside `launch`.

4. WEIGHTS: the reference `Model` owns nn.Parameters. Create them ONCE with a
   fixed seed inside the substrate module (module-level, lazily on first use),
   and have `ref` use THE SAME tensors, so reference and kernel see identical
   weights. Put them on the input's device.

5. `ref` must reproduce the KernelBench `Model.forward` exactly, using those
   same weights (e.g. `torch.nn.functional.linear(x, W0, b0).relu()` ...).

6. Suites: `T0_original` must reproduce the problem's `get_inputs()`; add 2-3
   targeted suites. Keep the legitimate-variance ceiling in mind: prefer
   same-sign large values over signed ones.

## Performance does not matter

Naive kernels are fine (one thread per output element, sequential loops). What
matters is: correct, readable, and rich in mutation sites (explicit bounds
guards, ceil-division, distinct `__syncthreads()` where relevant).

## Deliverable

`substrates/candidate_L3p<N>_<short>.py` with a `register(K, torch, ctypes)`
function exactly as in SPEC.md, plus `kernel_name` as a list and the dict-style
`launch` above. Import-safe, no GPU work at import time, do not modify other
files.