A suite of functions that works together to simulate, in order, the (1) frequency, (2) time, and (3) size of minor revisions of outstanding claim payments, for each of the claims occurring in each of the periods.
We separate the case of minor revisions that occur simultaneously with a
partial payment (denoted _atP), and the ones that do not coincide with a
payment (denoted _notatP).
claim_minRev_freq(
claims,
prob_atP = 0.5,
rfun_notatP,
paramfun_notatP,
frequency_vector = claims$frequency_vector,
settlement_list = claims$settlement_list,
no_payments_list = claims$no_payments_list,
...
)claim_minRev_time(
claims,
minRev_list,
rfun_notatP,
paramfun_notatP,
settlement_list = claims$settlement_list,
payment_delay_list = claims$payment_delay_list,
...
)
claim_minRev_size(
claims,
majRev_list,
minRev_list,
rfun,
paramfun_atP,
paramfun_notatP,
settlement_list = claims$settlement_list,
...
)
A nested list structure such that the jth component of the ith sub-list is a list of information on minor revisions of the jth claim of occurrence period i. The "unit list" (i.e. the smallest, innermost sub-list) contains the following components:
minRev_atP | A vector of indicators showing whether there is a minor
revision at each partial payment [claim_minRev_freq()]. |
minRev_freq_atP | Number of minor revisions that occur simultaneously with
a partial payment, numerically equals to the sum of minRev_atP
[claim_minRev_freq()]. |
minRev_freq_notatP | Number of minor revisions that do not occur with a
partial payment [claim_minRev_freq()]. |
minRev_time_atP | Time of minor revisions that occur simultaneously with
a partial payment (time measured from claim notification)
[claim_minRev_time()]. |
minRev_time_notatP | Time of minor revisions that do not occur
simultaneously with a partial payment (time measured from claim notification)
[claim_minRev_time()]. |
minRev_factor_atP | Minor revision multipliers of outstanding claim
payments for revisions at partial payments [claim_minRev_size()]. |
minRev_factor_notatP | Minor revision multipliers of outstanding claim
payments for revisions at any other times [claim_minRev_size()]. |
an claims object containing all the simulated quantities
(other than those related to incurred loss), see
claims.
(optional) probability that a minor revision will occur at the time of a partial payment; default value 0.5.
optional alternative random sampling function for:
claim_minRev_freq: the number of minor revisions that occur at an epoch
other than those of partial payments;
claim_minRev_time: the epochs of such minor revisions measured from claim
notification;
claim_minRev_size: the sizes of the minor revision multipliers (common for
_atP and _notatP, hence simply termed rfun in this case).
See Details for default.
parameters for the above random sampling function,
as a function of other claim characteristics (e.g. lambda as a function of
claim_size for an rpois simulation); see Examples.
a vector of claim frequencies for all the periods
(not required if the claims argument is provided); see
claim_frequency.
list of settlement delays (not required if the
claims argument is provided); see claim_closure.
list of number of partial payments (not required if
the claims argument is provided); see
claim_payment_no.
other arguments/parameters to be passed onto paramfun.
nested list of minor revision histories (with non-empty revision frequencies).
(compound) list of inter partial delays (not
required if the claims argument is provided); see
claim_payment_delay.
nested list of major revision histories (with non-empty revision frequencies).
optional alternative random sampling function for the sizes of
the minor revision multipliers (common for _atP and _notatP, hence simply
termed rfun in this case).
parameters for rfun in claim_minRev_size() for minor
revisions that occur at the time of a partial payment.
Minor revisions may occur simultaneously with a partial payment, or at any other time.
For the former case, we sample the occurrence of minor revisions as Bernoulli
random variables with default probability parameter prob_atP \(= 1/2\).
For the latter case, by default we sample the number of (non payment simultaneous) minor revisions from a geometric distribution with mean = \(min(3, setldel / 4)\).
One can modify the above sampling distributions by plugging in their own
prob_atP parameter and rfun_notatP function, where the former dictates
the probability of incurring a minor revision at the time of a payment, and
the latter simulates and returns the number of minor revisions at any other
points in time, with possible dependence on the settlement delay of the claim
and/or other claim characteristics.
For minor revisions that occur simultaneously with a partial payment, the revision times simply coincide with the epochs of the relevant partial payments.
For minor revisions that occur at a different time, by default the revision
times are sampled from a uniform distribution with parameters min \(=
settlement_delay / 6\) and max \(= settlement_delay\).
One can modify the above sampling distribution by plugging in their own
rfun_notatP and paramfun_notatP in claim_minRev_time(), which together
simulate the epochs of minor revisions that do not coincide with a payment,
with possible dependence on the settlement delay of the claim and/or other
claim characteristics (see Examples).
The sampling
distribution for minor revision multipliers is the same for both revisions
that occur with and without a partial payment. In the default setting, we
incorporate sampling dependence on the delay from notification to settlement
(setldel), the delay from notification to the subject minor revisions
(minRev_time), and the history of major revisions (in particular, the time
of the second major revision).
Let \(\tau\) denote the delay from notification to the epoch of the minor revision, and \(w\) the settlement delay. Then
For \(\tau \le w / 3\), the revision multiplier is sampled from a
lognormal distribution with parameters meanlog \(= 0.15\) and sdlog
\(= 0.05\) if preceded by a 2nd major revision, sdlog \(= 0.1\)
otherwise;
For \(w / 3 < \tau \le 2w / 3\), the revision multiplier is sampled
from a lognormal distribution with parameters meanlog \(= 0\) and sdlog
\(= 0.05\) if preceded by a 2nd major revision, sdlog \(= 0.1\)
otherwise;
For \(\tau > 2w / 3\), the revision multiplier is sampled from a
lognormal distribution with parameters meanlog \(= -0.1\) and sdlog
\(= 0.05\) if preceded by a 2nd major revision, sdlog \(= 0.1\)
otherwise.
Note that minor revisions tend to be upward in the early part of a claim’s life, and downward in the latter part.
The revision multipliers are subject to further constraints to ensure that
the revised incurred estimate never falls below what has already been paid.
This is dicussed in claim_history.
Important note: Unlike the major revision multipliers which apply to the incurred loss estimates, the minor revision multipliers apply to the case estimate of outstanding claim payments i.e. a revision multiplier of 2.54 means that at the time of the minor revision the outstanding claims payment increases by a factor of 2.54.
claims
set.seed(1)
test_claims <- SynthETIC::test_claims_object
# generate major revisions (required for the simulation of minor revisions)
major <- claim_majRev_freq(test_claims)
major <- claim_majRev_time(test_claims, major)
major <- claim_majRev_size(major)
# generate frequency of minor revisions
minor <- claim_minRev_freq(test_claims)
minor[[1]][[1]] # the "unit list" for the first claim
# update the timing information
minor <- claim_minRev_time(test_claims, minor)
# observe how this has changed
minor[[1]][[1]]
# with an alternative sampling distribution e.g. triangular
minRev_time_notatP <- function(n, setldel) {
sort(rtri(n, min = setldel/6, max = setldel, mode = setldel))
}
minor_2 <- claim_minRev_time(test_claims, minor, minRev_time_notatP)
# update the revision multipliers (need to generate "major" first)
minor <- claim_minRev_size(test_claims, major, minor)
Run the code above in your browser using DataLab