The function `MultiChainLadder`

implements multivariate methods to forecast insurance loss payments based on several cumulative claims development triangles. These methods are multivariate extensions of the chain ladder technique, which develop several correlated triangles simultaneously in a way that both contemporaneous correlations and structural relationships can be accounted for. The estimated conditional Mean Square Errors (MSE) are also produced.

1 2 3 4 5 6 | ```
MultiChainLadder(Triangles, fit.method = "SUR", delta = 1,
int = NULL, restrict.regMat = NULL, extrap = TRUE,
mse.method = "Mack", model = "MCL", ...)
MultiChainLadder2(Triangles, mse.method = "Mack", last = 3,
type = c("MCL", "MCL+int", "GMCL-int", "GMCL"), ...)
``` |

`Triangles` |
a list of cumulative claims triangles of the same dimensions. |

`fit.method` |
the method used to fit the multivariate regression in each development period. The default is |

`delta` |
parameter for controlling weights. It is used to determine the covariance structure |

`int` |
a numeric vector that indicates which development periods have intercepts specified. This only takes effect for |

`restrict.regMat` |
a list of matrix specifying parameter restriction matrix for each period. This is only used for |

`extrap` |
a logical value indicating whether to use Mack's extrapolation method for the last period to get the residual variance estimation. It only takes effect for |

`mse.method` |
method to estimate the mean square error. It can be either |

`model` |
the structure of the model to be fitted. It is either |

`last` |
an integer. The |

`type` |
the type of the model structure to be specified for the first part of the split model in |

`...` |
arguments passed to |

This function implements multivariate loss reserving models within the chain ladder framework. Two major models are included. One is the Multivariate Chain Ladder (MCL) model proposed by Prohl and Schmidt (2005). This is a direct multivariate generalization of the univariate chain ladder model in that losses from different triangles are assumed to be correlated but the mean development in one triangle only depends on its past values, not on the observed values from other triangles. In contrast, the other model, the General Multivariate Chain Ladder (GMCL) model outlined in Zhang (2010), extends the MCL model by allowing development dependencies among different triangles as well as the inclusion of regression intercepts. As a result, structurally related triangles, such as the paid and incurred loss triangles or the paid loss and case reserve triangles, can be developed together while still accounting for the potential contemporaneous correlations. While the MCL model is a special case of the GMCL model, it is programmed and listed separately because: a) it is an important model for its own sake; b) different MSE methods are only available for the MCL model; c) extrapolation of the residual variance estimation can be implemented for the MCL model, which is considerably difficult for the GMCL model.

We introduce some details of the GMCL model in the following. Assume N triangles are available. Denote *Y_{i,k}=(Y^{(1)}_{i,k}, … ,Y^{(N)}_{i,k})* as an *N \times 1* vector of cumulative losses at accident year i and development year k, where (n) refers to the n-th triangle. The GMCL model in development period k (from development year k to year k+1) is:

*Y_{i,k+1}=A_k + B_k \cdot Y_{i,k}+ε_{i,k},*

where *A_k* is a column of intercepts and *B_k* is the *N \times N* development matrix. By default, `MultiChainLadder`

sets *A_k* to be zero. This behavior can be changed by appropriately specifying the `int`

argument.
Assumptions for this model are:

*E(ε_{i,k}|Y_{i,1},…,Y_{i,I+1-k})=0.*

*cov(ε_{i,k}|Y_{i,1},…,Y_{i,I+1-k})=Σ_{ε_{i,k}}=D(Y_{i,k}^{δ/2})Σ_k D(Y_{i,k}^{δ/2}).*

*\mbox{losses of different accident years are independent}.*

*ε_{i,k} \, \mbox{are symmetrically distributed}.*

The GMCL model structure is generally over-parameterized. Parameter restrictions are usually necessary for the estimation to be feasible, which can be specified through the `restrict.regMat`

argument. We refer the users to the documentation for `systemfit`

for details and the demo of the present function for examples.

In particular, if one restricts the development matrix to be diagonal, the GMCL model will reduce to the MCL model. When non-diagonal development matrix is used and the GMCL model is applied to paid and incurred loss triangles, it can reflect the development relationship between the two triangles, as described in Quarg and Mack (2004). The full bivariate model is identical to the "double regression" model described by Mack (2003), which is argued by him to be very similar to the Munich Chain Ladder (MuCL) model. The GMCL model with intercepts can also help improve model adequacy as described in Barnett and Zehnwirth (2000).

Currently, the GMCL model only works for trapezoid data, and only implements `mse.method = "Mack"`

. The MCL model allows an additional mse estimation method that assumes independence among the estimated parameters. Further, the MCL model using `fit.method = "OLS"`

will be equivalent to running univariate chain ladders separately on each triangle. Indeed, when only one triangle is specified (as a list), the MCL model is equivalent to `MackChainLadder`

.

The GMCL model allows different model structures to be specified in each development period. This is generally achieved through the combination of the `int`

argument, which specifies the periods that have intercepts, and the `restrict.regMat`

argument, which imposes parameter restrictions on the development matrix.

In using the multivariate methods, we often specify separate univariate chain ladders for the tail periods to stabilize the estimation - there are few data points in the tail and running a multivariate model often produces extremely volatile estimates or even fails. In this case, we can use the subset operator `"["`

defined for class `triangles`

to split the input data into two parts. We can specify a multivariate model with rich structures on the first part to reflect the multivariate dependencies, and simply apply multiple univariate chain ladders on the second part. The two models are subsequently joined together using the `Join2Fits`

function. We can then invoke the `predict`

and `Mse`

methods to produce loss predictions and mean square error estimations. They can further be combined via the `JoinFitMse`

function to construct an object of class `MultiChainLadder`

. See the demo for such examples.

To facilitate such a split-and-join process for most applications, we have created the function `MultiChainLadder2`

. This function splits the data according to the `last`

argument (e.g., if `last = 3`

, the last three periods go into the second part), and fits the first part according to the structure indicated in the `type`

argument. See the 'Arguments' section for details.

`MultiChainLadder`

returns an object of class `MultiChainLadder`

with the following slots:

`model` |
the model structure used, either |

`Triangles` |
input triangles of cumulative claims that are converted to class |

`models` |
fitted models for each development period. This is the output from the call of |

`coefficients` |
estimated regression coefficients or development parameters. They are put into the matrix format for the GMCL model. |

`coefCov` |
estimated variance-covariance matrix for the regression coefficients. |

`residCov` |
estimated residual covariance matrix. |

`fit.method` |
multivariate regression estimation method |

`delta` |
the value of delta |

`mse.ay` |
mean square error matrix for each accident year |

`mse.ay.est` |
estimation error matrix for each accident year |

`mse.ay.proc` |
process error matrix for each accident year |

`mse.total` |
mean square error matrix for all accident years combined |

`mse.total.est` |
estimation error matrix for all accident years combined |

`mse.total.proc` |
process error matrix for all accident years combined |

`FullTriangles` |
the forecasted full triangles of class |

`int` |
intercept indicators |

When `MultiChainLadder`

or `MultiChainLadder2`

fails, the most possible reason is that there is little or no development in the tail periods. That is, the development factor is `1`

or almost equal to `1`

. In this case, the `systemfit`

function may fail even for `fit.method = "OLS"`

, because the residual covariance matrix *Σ_k* is singular. The simplest solution is to remove these columns using the `"["`

operator and fit the model on the remaining part.

Also, we recommend the use of `MultiChainLadder2`

over `MultiChainLadder`

. The function `MultiChainLadder2`

meets the need for most applications, is relatively easy to use and produces more stable but very similar results to `MultiChainLadder`

. Use `MultiChainLadder`

only when non-standard situation arises, e.g., when different parameter restrictions are needed for different periods. See the demo for such examples.

Wayne Zhang actuary_zhang@hotmail.com

Buchwalder M, Bühlmann H, Merz M, Wüthrich M.V (2006). The mean square error of prediction in the chain ladder reserving method (Mack and Murphy revisited), *ASTIN Bulletin*, 36(2), 521-542.

Prohl C, Schmidt K.D (2005). Multivariate chain-ladder, *Dresdner Schriften zur Versicherungsmathematik*.

Mack T (1993). Distribution-free calculation of the standard error, *ASTIN Bulletin*, 23, No.2.

Mack T (1999). The standard error of chain ladder reserve estimates: recursive calculation and inclusion of a tail factor, *ASTIN Bulletin*, 29, No.2, 361-366.

Merz M, Wüthrich M (2008). Prediction error of the multivariate chain ladder reserving method, *North American Actuarial Journal*, 12, No.2, 175-197.

Zhang Y (2010). A general multivariate chain ladder model.*Insurance: Mathematics and Economics*, 46, pp. 588-599.

Zhang Y (2010). Prediction error of the general multivariate chain ladder model.

See also `MackChainLadder`

, `MunichChainLadder`

, `triangles`

, `MultiChainLadder`

, `summary,MultiChainLadder-method`

and `plot,MultiChainLadder,missing-method`

.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | ```
# This shows that the MCL model using "OLS" is equivalent to
# the MackChainLadder when applied to one triangle
data(GenIns)
(U1 <- MackChainLadder(GenIns, est.sigma = "Mack"))
(U2 <- MultiChainLadder(list(GenIns), fit.method = "OLS"))
# show plots
parold <- par(mfrow = c(2, 2))
plot(U2, which.plot = 1:4)
plot(U2, which.plot = 5)
par(parold)
# For mse.method = "Independence", the model is equivalent
# to that in Buchwalder et al. (2006)
(B1 <- MultiChainLadder(list(GenIns), fit.method = "OLS",
mse.method = "Independence"))
# use the unbiased residual covariance estimator
# in Merz and Wuthrich (2008)
(W1 <- MultiChainLadder2(liab, mse.method = "Independence",
control = systemfit::systemfit.control(methodResidCov = "Theil")))
## Not run:
# use the iterative residual covariance estimator
for (i in 1:5){
W2 <- MultiChainLadder2(liab, mse.method = "Independence",
control = systemfit::systemfit.control(
methodResidCov = "Theil", maxiter = i))
print(format(summary(W2)@report.summary[[3]][15, 4:5],
digits = 6, big.mark = ","))
}
# The following fits an MCL model with intercepts for years 1:7
# and separate chain ladder models for the rest periods
f1 <- MultiChainLadder2(auto, type = "MCL+int")
# compare with the model without intercepts through residual plots
f0 <- MultiChainLadder2(auto, type = "MCL")
parold <- par(mfrow = c(2, 3), mar = c(3, 3, 2, 1))
mt <- list(c("Personal Paid", "Personal Incured", "Commercial Paid"))
plot(f0, which.plot = 3, main = mt)
plot(f1, which.plot = 3, main = mt)
par(parold)
## summary statistics
summary(f1, portfolio = "1+3")@report.summary[[4]]
# model for joint development of paid and incurred triangles
da <- auto[1:2]
# MCL with diagonal development
M0 <- MultiChainLadder(da)
# non-diagonal development matrix with no intercepts
M1 <- MultiChainLadder2(da, type = "GMCL-int")
# Munich Chain Ladder
M2 <- MunichChainLadder(da[[1]], da[[2]])
# compile results and compare projected paid to incurred ratios
r1 <- lapply(list(M0, M1), function(x){
ult <- summary(x)@Ultimate
ult[, 1] / ult[, 2]
})
names(r1) <- c("MCL", "GMCL")
r2 <- summary(M2)[[1]][, 6]
r2 <- c(r2, summary(M2)[[2]][2, 3])
print(do.call(cbind, c(r1, list(MuCl = r2))) * 100, digits = 4)
## End(Not run)
# To reproduce results in Zhang (2010) and see more examples, use:
## Not run:
demo(MultiChainLadder)
## End(Not run)
``` |

Questions? Problems? Suggestions? Tweet to @rdrrHQ or email at ian@mutexlabs.com.

All documentation is copyright its authors; we didn't write any of that.