## kernels.one_year_cdr()


Merz-Wuthrich (2008) closed-form msep of the one-year CDR.


Usage

``` python
kernels.one_year_cdr(fit)
```


Write `ratio_j = sigma_j^2 / f_j^2`, `S_j` for the volume behind `f_j` today and `S_j^{I+1} = S_j + C[i_j][j]` for the same volume once the new diagonal has arrived, where `i_j` is the single accident year joining dev step `j` next year. The leverage of that one new observation on the re-estimated factor is

    a_j = C[i_j][j] / S_j^{I+1}

and it is the whole story of the one-year view: within twelve months an accident year learns (i) its own next cell in full, and (ii) about every later factor ONLY through that single new observation. So for accident year `i` with its diagonal at dev `k = latest_dev[i]`,

    Phi_i   = ratio_k / C[i][k]
            + sum_{j>k} ratio_j * C[i_j][j] / (S_j^{I+1})^2      (process)
    Delta_i = ratio_k / S_k
            + sum_{j>k} a_j^2 * ratio_j / S_j                    (estimation)
    msep_i  = Chat[i][J]^2 * (Phi_i + Delta_i)

Compare Mack's run-off msep, `Chat^2 * sum_{j>=k} ratio_j (1/Chat[i][j] + 1/S_j)`: the one-year formula keeps the `j = k` terms in full and damps every later one by the leverage `a_j` (squared, for the estimation part). An accident year one step from ultimate therefore has one-year msep exactly equal to its run-off msep, which is the sharpest test of the formula and is asserted in `tests/test_cdr.py`.

Aggregation carries a cross term, because accident years share the factors they still have to run through. With `V_i = ratio_k/S_k + sum_{j>k} a_j * ratio_j / S_j`,

    msep_total = sum_i Chat_i^2 ratio_{k_i} / C[i][k_i]
               + sum_i sum_{i'} V_{min(i,i')} * Chat_i * Chat_{i'}

- the min picks the OLDER year of each pair, whose (shorter) list of remaining steps is the set the two share. This is the grouping of Wuthrich's own reference implementation (R ChainLadder, `CL_MSEPs`); it is algebraically the same total as the Phi/Delta split above, which `tests/test_cdr.py` pins. Note only the TOTAL is convention-free: R calls just `ratio_k/C[i][k]` process variance and lumps the rest into parameter uncertainty, where the split here follows the paper - `Phi` is the part a re-reserving simulation with `parameter_risk=False` reproduces.

Valid only for the volume-weighted (alpha = 1) chain ladder, without a tail factor, and on an annual development grain. The first two are the same restrictions R's `CDR.MackChainLadder` enforces, and both are structural here: [fit_mack](kernels.fit_mack.md#ibnr.kernels.fit_mack) estimates nothing else. The third is what makes the single development step above a year, and a fit on any other grain is refused by name.

MACK-SPECIFIC BY CONSTRUCTION, and deliberately not offered as a `generator=` option on [simulate_one_year_cdr()](kernels.simulate_one_year_cdr.md#ibnr.kernels.simulate_one_year_cdr). Every term above is `sigma_j^2 / f_j^2`: the formula is a linearization of the chain-ladder factor update *around Mack's conditional moments*, so there is no ODP bootstrap version of it and no version for any other model. The routes that do generalize are the simulated ones - [cdr_methods()](kernels.cdr_methods.md#ibnr.kernels.cdr_methods) lists them.