claim_minRev {SPLICE}

Minor Revisions of Outstanding Claim Payments

Description

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⁠).

Usage

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,
  ...
)

Arguments

claims

an claims object containing all the simulated quantities (other than those related to incurred loss), see claims.

prob_atP

(optional) probability that a minor revision will occur at the time of a partial payment; default value 0.5.

rfun_notatP

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.

paramfun_notatP

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.

frequency_vector

a vector of claim frequencies for all the periods (not required if the claims argument is provided); see claim_frequency.

settlement_list

list of settlement delays (not required if the claims argument is provided); see claim_closure.

no_payments_list

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.

minRev_list

nested list of minor revision histories (with non-empty revision frequencies).

payment_delay_list

(compound) list of inter partial delays (not required if the claims argument is provided); see claim_payment_delay.

majRev_list

nested list of major revision histories (with non-empty revision frequencies).

rfun

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).

paramfun_atP

parameters for rfun in claim_minRev_size() for minor revisions that occur at the time of a partial payment.

Value

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()].

Details - claim_minRev_freq (Frequency)

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.

Details - claim_minRev_time (Time)

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).

Details - claim_minRev_size (Revision Multiplier)

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.

See Also

claims

Examples

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)