Abstract
The Devylder–Goovaerts conjecture is probably the oldest conjecture in actuarial mathematics and has received a lot of attention in recent years. It claims that ruin with equalized claim amounts is always less likely than in the classical model. Investigating the validity of this conjecture is important both from a theoretical aspect and a practical point of view, as it suggests that one always underestimates the risk of insolvency by replacing claim amounts with the average claim amount a posteriori. We first state a simplified version of the conjecture in the discrete-time risk model when one equalizes aggregate claim amounts and prove that it holds. We then use properties of the Pareto distribution in risk theory and other ideas to target candidate counterexamples and provide several counterexamples to the original Devylder–Goovaerts conjecture.
Keywords:
ruin theory; Devylder–Goovaerts conjecture; equalized claim amounts; applied probability; insurance MSC:
91G05
1. Introduction
The Devylder–Goovaerts conjecture is probably the oldest conjecture in actuarial science. In the classical ruin model in finite time, three sources of uncertainty may be considered: uncertainty on the number of claims, on the average claim amount, as well as on the heterogeneity between claim amounts. Sometimes, one claim might dominate the others, while in other times all claim amounts may be close to the average. It seems natural to think that adverse events, such as ruin, become less likely when one source of uncertainty is removed. Concerned with the third source of uncertainty, Devylder and Goovaerts [1] stated that ruin is always less or equally likely than in the classical risk model when claim amounts are equalized.
Their conjecture has recently received some attention in the literature. Using stop-loss order and Schur convexity, Robert [2] proved a kind of weaker version of the conjecture: the integral of the ruin probability (when the initial reserve belongs to a right-unbounded interval) is reduced when claim amounts are equalized. Kazi-Tani et al. [3] showed that the conjecture held asymptotically when the number of claims tended to infinity using a diffusion approximation of both risk models. They proved that the corresponding renormalized processes converged in distribution to Gaussian processes satisfying quite simple SDEs. Kim et al. [4] provided a stronger version of the Devylder–Goovaerts conjecture and showed that the conjecture held when the number of claims was equal to three. Actually, the authors established sufficient conditions for the conjecture to be true for a given finite number of claims n, and proved the case . They also acknowledged that for a fixed , the proof would be hard and difficult to make by hand. However, they announced they intended to try it with the help of a symbolic computation supported by computer programming.
In this paper, we first note that a simplified version of the conjecture holds true in discrete time (when the uncertainty about claim occurrence times is neutralized). We then use the properties of the Pareto distribution in risk theory to select the area where one should look first for a counterexample. We identify a counterexample when the claim amounts are Pareto distributed. We also show that it is possible to find counterexamples when claim amounts are light-tailed or with bounded support, as well as with positive safety loading.
The paper is organized as follows: In Section 2, we describe the model with equalized claim amounts and show that the conjecture holds true in discrete time. In Section 3, we explain how to look for counterexamples. In Section 4, we provide one first counterexample and explain how to find other ones. The code of our program is provided in Appendix A.
2. The Model with Equalized Claim Amounts
Let us consider the classical risk model with a finite time horizon : an insurer has initial surplus , receives premium continuously at rate , and pays for claims. The aggregate claim amount up to time t is represented by a compound Poisson process ,
where the Poisson process represents the number of claims up to time t and , , corresponds to the kth claim amount. In the classical model, the ’s, , are independent and identically distributed, and independent from . The finite-time ruin probability in the continuous time classical model is defined as
In the equalized model, each claim amount is replaced with the average claim amount on the period . The aggregate claim amount becomes
when and zero otherwise. The finite-time ruin probability when claim amounts are equalized is defined as
The Devylder–Goovaerts conjecture states that for all ,
Before looking at counterexamples (in the original, continuous-time setting used by Devylder and Goovaerts), let us note that a simplified version of the conjecture holds in the discrete-time risk model when one equalizes the aggregate claim amounts.
In the discrete-time classical risk model with finite time horizon , we have , and the surplus process at time is defined as , where
is the aggregated claim amount up to time i and is the aggregated claim amount on period . The ’s are independent and identically distributed. The discrete-time ruin probability is
When aggregate claim amounts are equalized, the aggregate claim amount up to time becomes
and the ruin probability is then defined as
Proposition 1.
A weak version of the Devylder–Goovaerts conjecture holds true in the discrete-time risk model described above: for and , we have
Proof.
Consider the discrete-time model described above. Note that
We have
As
we therefore have
and
for . □
3. Identifying Counterexamples in the Continuous-Time Risk Model
Coming back to the original (continuous-time) conjecture, there are several reasons to doubt its validity. The first one is that many results about stochastic orderings hold for convex orderings but not at the first order. This probably pushed Robert [2] to look for a proof of another result, involving the integral of the ruin probability.
Moreover, the value at risk is not subadditive and is known to be superadditive for Pareto distributions with parameter less than 1 and quantile levels close to 1. This implies that for such claim size distributions, we can hope that the first claim is often larger than , and that ruin after the first claim is more likely in the classical model than when claim amounts are equalized (with stochastic occurrence times, as we have seen that the conjecture is true in the discrete-time model).
Furthermore, we know that if u goes to infinity and c is fixed, in the classical model with Pareto distributed claim amounts, given that ruin occurs, everything asymptotically behaves as if ruin is caused by one large claim, whose time of occurrence is uniformly distributed on the time interval . Therefore, if we want to favor early ruin (to take advantage of the superadditivity of the value at risk for Pareto distributions with ), we should keep u relatively small and take c large enough to escape from zero fast (and therefore favor early ruin) and to make the asymptotic regime valid fast enough. Note that u needs to be positive as both ruin probabilities are equal when .
4. The Counterexamples
After several attempts, a counterexample was obtained for , , , , , and . Note that the cumulative distribution function of the Pareto distribution at point considered here is given by
Using a computer with 192 cores and simulations, we obtained in approximately 640 min that , , with an asymptotic confidence interval (95%) equal to . We repeated the experience with different seeds 10 times. Here are the results obtained:
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
- , , with an asymptotic confidence interval equal to .
Our code is given in the Appendix A for reproducibility purposes and is available at the bottom of the following webpage: https://sites.google.com/view/stephaneloisel/recherche/papiers (accessed on 13 March 2023). We checked that we could reproduce the results of Devylder and Goovaerts [1] with our program.
As expected, the ruin probabilities and were very close to each other (sharing the same first digits). However, for each of the 11 seeds considered here (See Table 1), the estimated equalized ruin probability was larger than the 95% confidence interval upper bound of the classical ruin probability. We could therefore conclude that the conjecture appeared to be false for the set of parameters used for these computations.
Table 1.
Results obtained for 11 different seeds.
Note that we could have replaced the Pareto distribution with a distribution where the probability mass of the interval was transferred to point without changing anything to the results. This would have provided a counterexample with a distribution with finite support (and finite mean), as only the part of distribution related to matters. In a similar way, one could have replaced the Pareto tail after with an equivalent exponential tail without altering results.
Regarding the heart of the claim size distribution, as both the ruin probability and the ruin probability with equalized claim amounts are continuous with respect to the claim size distribution, it is possible to find a counterexample with mixed-Erlang distributed claim amounts, as the class of mixture of Erlang distributions is dense in the class of continuous and positive distributions (see Tijms [5]).
It is also possible to find infinitely many counterexamples by slightly varying the parameters of the model. For instance, alternative counterexamples were obtained for the following sets of values:
- , , , , , .
- , , , , , .
- , , , , , .
- , , , , , .
These first counterexamples have one common point: the net profit condition is not satisfied as , which implies that claim amounts have infinite mean. However, as mentioned above, there is a priori no reason why counterexamples would only occur for a negative safety loading, as the infinite mean can be replaced by a finite-mean model without altering the computations. Using our previous numerical analysis, we were eventually able to identify a counterexample to the conjecture for a model with a positive safety loading. The parameters were , , , , , and . For this model, we had and the safety loading was therefore close to .
5. Conclusions
In this paper, we showed that the original Devylder–Goovaerts conjecture did not hold. In addition to the theoretical interest of the identified counterexamples, this study also brought new practical implications: ignoring one source of uncertainty did not always reduce risk when it was measured by the finite-time ruin probability. However, it was not easy to identify counterexamples, as the finite-time ruin probability with equalized claim amounts was very often smaller than the classical finite-time ruin probability. Moreover, we showed that a simplified version of the conjecture held in a discrete-time framework (with the limit that only aggregated claim amounts were equalized, which did not exactly correspond to the discrete-time version of the original conjecture). It would therefore be interesting to identify additional assumptions that make the revised conjecture valid. We showed in this paper that it was not enough to restrict the conjecture to a positive safety loading. We leave this problem for further research.
Author Contributions
Conceptualization, S.L.; Software, C.M. All authors have read and agreed to the published version of the manuscript.
Funding
Research chair “Actuariat Durable et Risques Climatiques” funded by Milliman Paris.
Data Availability Statement
Not applicable.
Acknowledgments
This paper was realized within the framework of the Research Chair Actuariat Durable et Risques Climatiques, supported by Milliman Paris, as well as the research chair DAMI/NINA, sponsored by BNP Paribas Cardif. The authors thank Philippe Picard and Claude Lefèvre for numerous discussions related to this conjecture, as well as Alexis Bienvenue for his help with programming.
Conflicts of Interest
The authors declare no conflict of interest.
Appendix A. Script of the Program
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include <cuda.h>
#include <cuda_runtime.h>
#include <curand_kernel.h>
#include <time.h>
#include <stdexcept>
#include <helper_cuda.h>
#define U 0.001 \\ value which should be modified
#define T 1 \\ value which should be modified
#define lambda 1 \\ value which should be modified
#define theta 0.01 \\ value which should be modified
#define alpha 0.01 \\ value which should be modified
#define c 100000 \\ value which should be modified
#define MU 1/lambda
#define NTMAX 1000000
#define N_SIMUL 1000000000000000
_ _global_ _ void initRNG(curandState *const rngStates,
const unsigned int seed)
{
// Determine thread ID
unsigned int tid = blockIdx.x * blockDim.x + threadIdx.x;
// Initialise the RNG
curand_init(seed, tid, 0, &rngStates[tid]);
}
_ _device_ _ inline double ran_exponential(curandState &state, double mu)
{
return( -mu*log(curand_uniform_double(&state)) );
}
_ _device_ _ inline double ran_pareto(curandState &state,
double a, double b)
{
return( b * ( pow (curand_uniform_double(&state), -1 / a) -1) );
}
_ _global_ _ void monte_carlo(curandState *const rngStates,
long long int *d_results,
long long int n_simul) {
unsigned int tid = blockIdx.x * blockDim.x + threadIdx.x;
double temps;
double entrees,cmoy_seuil0, cmoy_seuil;
int n;
double cc;
double ccc;
int r_eq;
int r_base;
for(long long int i_simul=0; i_simul<n_simul; i_simul++) {
temps=0;
n=0;
cc=0;
ccc = 0;
r_eq=0;
r_base=0;
cmoy_seuil = 0;
do {
// random time step
temps += ran_exponential(rngStates[tid], MU);
if(temps<T) {
if(n >= NTMAX) {
printf("Taille insuffisante pour le vecteur des dates...\n");
// exit(1);
}
// simulates and adds an amount of a claim
cc += ran_pareto(rngStates[tid], alpha, theta);
// checks if there is a ruin
entrees = U + temps * c;
if(entrees < cc) {
r_base=1;
}
n++;
// updates the threshold for the equalized process so as to
// determine a case of ruin
cmoy_seuil0 = entrees / n;
if(n == 1 || cmoy_seuil0 < cmoy_seuil) {
cmoy_seuil = cmoy_seuil0;
}
}
} while(temps<T);
if(n>0) {
// computes the average of the amounts of the claims
ccc = cc/n;
if(ccc > cmoy_seuil) {
r_eq = 1;
}
}
// updates the counts of ruin for each of the 4 cases
if(r_eq > 0) {
if(r_base > 0) {
d_results[4*tid+2]++; // both process ruined
} else {
d_results[4*tid]++; // only the classical process is ruined
}
} else {
if(r_base>0) {
d_results[4*tid+1]++; // only the equalized process is ruined
} else {
d_results[4*tid+3]++; // neither is ruined
}
}
}
}
int main(int argc,const char **argv) {
using std::runtime_error;
using std::invalid_argument;
time_t debut = time(NULL);
char *value = 0;
unsigned int seed = 1234;
int n_blocks = 1024;
int n_threads_per_block = 1;
int deviceCount = 0;
cudaError_t cudaResult = cudaSuccess;
// by default specify GPU Device == 0
int device = 0;
// Get number of available devices
cudaResult = cudaGetDeviceCount(&deviceCount);
if (cudaResult != cudaSuccess) {
printf("could not get device count.\n");
throw runtime_error("cudaGetDeviceCount");
}
// --device n
if (getCmdLineArgumentString(argc, argv, "device", &value)) {
device = (int)atoi(value);
if (device >= deviceCount) {
printf("invalid target device specified on command line
(device %d does not exist).\n", device);
throw invalid_argument("device");
}
} else {
device = gpuGetMaxGflopsDeviceId();
}
printf("Device : %d\n", device);
// --seed n
if (getCmdLineArgumentString(argc, argv, "seed", &value)) {
// Check requested seed is valid
seed = (unsigned int)atoi(value);
if (seed == 0) {
printf("specified seed (%d) is invalid, must be non-zero.\n", seed);
throw invalid_argument("seed");
}
}
printf("Seed : %u\n", seed);
// sets number of blocks and threads from the device properties
cudaDeviceProp deviceProperties;
cudaResult = cudaGetDeviceProperties(&deviceProperties, device);
if (cudaResult != cudaSuccess) {
printf("cound not get device properties for device %d.\n", device);
throw runtime_error("cudaGetDeviceProperties");
}
n_threads_per_block =
static_cast<unsigned int>(deviceProperties.maxThreadsPerBlock);
n_blocks = 10 * deviceProperties.multiProcessorCount;
printf("Blocs : %d\n", n_blocks);
printf("Threads par bloc : %d\n", n_threads_per_block);
int n_threads=n_blocks*n_threads_per_block;
long long int n_simul=N_SIMUL;
// --sims n
if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
n_simul = atoll(value);
if(n_simul<100) {
// if it is smaller than 100, we take the power of 10
long long int x=1;
for(int i=0; i<n_simul; i++) x*=10;
n_simul=x;
}
}
long long int n_simul_par_thread = n_simul/n_threads;
n_simul = n_simul_par_thread * n_threads;
printf("Simulations: %lld\n", n_simul);
// ----------------------------------------------------------------
// select device
cudaResult = cudaSetDevice(device);
if (cudaResult != cudaSuccess) {
printf("cound not select device %d.\n", device);
throw runtime_error("cudaSetDevice");
}
// init RNGs
curandState *d_rngStates = 0;
cudaResult = cudaMalloc((void **)&d_rngStates,
n_threads * sizeof(curandState));
if (cudaResult != cudaSuccess) {
printf("cound not allocate RNG state memory for device %d.\n", device);
throw runtime_error("cudaAllocate");
}
initRNG<<<n_blocks, n_threads_per_block>>>(d_rngStates, seed);
// allocate results memory
long long int *d_results;
cudaResult = cudaMalloc((void**)&d_results,
sizeof(long long int) * 4 * n_threads);
if (cudaResult != cudaSuccess) {
printf("cound not allocate results memory for device %d.\n", device);
throw runtime_error("cudaAllocate");
}
// call Monte Carlo simulations
monte_carlo<<<n_blocks, n_threads_per_block>>>(d_rngStates, d_results,
n_simul_par_thread);
// get back results
long long int *results = (long long *)malloc(sizeof(long long int) * 4
* n_threads);
cudaResult = cudaMemcpy(results, d_results,
sizeof(long long int) * 4 * n_threads, cudaMemcpyDeviceToHost);
if (cudaResult != cudaSuccess) {
printf("cound not get back results for device %d.\n", device);
throw runtime_error("cudaMemcpy");
}
// sum results up
for(int n=1; n<n_threads; n++) {
for(int i=0; i<4; i++) {
results[i] += results[i+n*4];
}
}
// output stats
printf("EQ + BASE + DEUX + AUCUN = %lld + %lld + %lld + %lld\n",
results[0], results[1], results[2], results[3]);
printf("P(ruine_base) = %g\n", ((double)(results[1]+results[2]))/n_simul );
printf("P(ruine_eq) = %g\n", ((double)(results[0]+results[2]))/n_simul );
printf("E(ruine_eq - ruine_base) = %g\n",
((double)(results[0]-results[1]))/n_simul);
double esp=((double)(results[0]-results[1]))/n_simul; \\ confidence interval
double esp2=((double)(results[0]+results[1]))/n_simul; \\ confidence interval
printf("E(ruine_eq - ruine_base) = %g +/- %g\n",
esp, 1.96 * sqrt((esp2-esp*esp)/n_simul)); \\ confidence interval
printf("Secondes ecoulees : %d\n", time(NULL)-debut);
}
References
- De Vylder, F.; Goovaerts, M. Homogeneous risk models with equalized claim amounts. Insur. Math. Econ. 2000, 26, 223–238. [Google Scholar] [CrossRef]
- Robert, C. On the de Vylder and Goovaerts conjecture about ruin for equalized claims. J. Appl. Probab. 2014, 51, 874–879. [Google Scholar] [CrossRef]
- Ankirchner, S.; Blanchet-Scalliet, C.; Kazi-Tani, N. The De Vylder-Goovaerts conjecture holds true within the diffusion limit. J. Appl. Probab. 2019, 56, 546–557. [Google Scholar] [CrossRef]
- Kim, B.; Kim, J.; Kim, J. De Vylder and Goovaerts’ conjecture on homogeneous risk models with equalized claim amounts. Insur. Math. Econ. 2021, 101, 186–201. [Google Scholar] [CrossRef]
- Tijms, H. Stochastic Models: An Algorithmic Approach; John Wiley & Sons: New York, NY, USA, 1994. [Google Scholar]
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2023 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https://creativecommons.org/licenses/by/4.0/).