Next Article in Journal
Exact Permutation and Bootstrap Distribution of Generalized Pairwise Comparisons Statistics
Next Article in Special Issue
On Parsing Programming Languages with Turing-Complete Parser
Previous Article in Journal
How Does the Competitiveness Index Promote Foreign Direct Investment at the Provincial Level in Vietnam? An Integrated Grey Delphi–DEA Model Approach
Previous Article in Special Issue
Modeling Languages for Internet of Things (IoT) Applications: A Comparative Analysis Study
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

On the Devylder–Goovaerts Conjecture in Ruin Theory

Laboratoire de Sciences Actuarielle et Financière, Institut de Science Financière et d’Assurances, Université Claude Bernard Lyon 1, Univ Lyon, 50 Avenue Tony Garnier, F-69007 Lyon, France
*
Author to whom correspondence should be addressed.
Mathematics 2023, 11(6), 1501; https://doi.org/10.3390/math11061501
Submission received: 16 January 2023 / Revised: 11 March 2023 / Accepted: 14 March 2023 / Published: 20 March 2023
(This article belongs to the Special Issue Mathematics: 10th Anniversary)

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.

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 n = 3 . They also acknowledged that for a fixed n 4 , 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 T > 0 : an insurer has initial surplus u 0 , receives premium continuously at rate c > 0 , and pays for claims. The aggregate claim amount up to time t is represented by a compound Poisson process ( S t ) t 0 ,
S t = k = 1 N t X k ,
where the Poisson process ( N t ) 0 represents the number of claims up to time t and X k , k 1 , corresponds to the kth claim amount. In the classical model, the X k ’s, k 1 , are independent and identically distributed, and independent from ( N t ) t 0 . The finite-time ruin probability in the continuous time classical model is defined as
ψ ( u , T ) = P t T , u + c t S t < 0 .
In the equalized model, each claim amount is replaced with the average claim amount on the period [ 0 , T ] . The aggregate claim amount becomes
S e q ( t ) = N t X 1 + + X N T N T
when N T > 0 and zero otherwise. The finite-time ruin probability when claim amounts are equalized is defined as
ψ e q ( u , T ) = P t T , u + c t S t e q < 0 .
The Devylder–Goovaerts conjecture states that for all u 0 ,
ψ e q ( u , T ) ψ ( u , T ) .
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 M 1 , we have S 0 = 0 , and the surplus process at time 1 i M is defined as u + c i S ( i ) , where
S ( i ) = Y 1 + + Y i
is the aggregated claim amount up to time i and Y j is the aggregated claim amount on period j i . The Y j ’s are independent and identically distributed. The discrete-time ruin probability is
ψ d ( u , M ) = P 1 i M , u + c i S ( i ) < 0 .
When aggregate claim amounts are equalized, the aggregate claim amount up to time i 1 becomes
S e q ( i ) = i Y 1 + + Y M M ,
and the ruin probability is then defined as
ψ d e q ( u , M ) = P 1 i M , u + c i S e q ( i ) < 0 .
Proposition 1.
A weak version of the Devylder–Goovaerts conjecture holds true in the discrete-time risk model described above: for u 0 and M 1 , we have
ψ d e q ( u , M ) ψ d ( u , M ) .
Proof. 
Consider the discrete-time model described above. Note that
1 ψ d e q ( u , M ) = P S ( M ) M u + c , , M S ( M ) M u + c M .
We have
1 ψ d e q ( u , M ) = P S ( M ) u M + c M , , S ( M ) u + c M = P S ( M ) u + c M .
As
1 ψ d ( u , M ) = P S ( 1 ) u + c , , S ( M ) u + c M ,
we therefore have
1 ψ d e q ( u , M ) 1 ψ d ( u , M )
and
ψ d e q ( u , M ) ψ d ( u , M )
for u 0 .    □

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 X 1 is often larger than ( X 1 + + X N T ) / N T , 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 [ 0 , T ] . Therefore, if we want to favor early ruin (to take advantage of the superadditivity of the value at risk for Pareto distributions with α 1 ), 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 u = 0 .

4. The Counterexamples

After several attempts, a counterexample was obtained for u = 0.001 , λ = 1 , T = 0.1 , c = 10 , 000 , α = 0.95 , and β = 10 . Note that the cumulative distribution function of the Pareto ( α , β ) distribution at point x > 0 considered here is given by
F ( x ) = 1 β x + β α .
Using a computer with 192 cores and n = 10 14 simulations, we obtained in approximately 640 min that ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.46014 × 10 8 < 0 with an asymptotic confidence interval (95%) equal to 2.66903 × 10 9 . We repeated the experience with different seeds 10 times. Here are the results obtained:
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.11128 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66906 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.3067 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66907 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.29491 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66908 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.0385 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66907 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.19286 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66906 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.18805 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66906 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.165 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66905 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.04824 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66905 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.23203 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66904 × 10 9 .
  • ψ ( u ) = 0.00518464 , ψ e q ( u ) = 0.00518466 , ψ ( u ) ψ e q ( u ) = 2.31037 × 10 8 < 0 with an asymptotic confidence interval equal to 2.66903 × 10 9 .
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 ψ ( u ) and ψ e q ( u ) 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.
Note that we could have replaced the Pareto distribution with a distribution where the probability mass of the interval ( u + c T , + ) was transferred to point u + c T + 1 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 [ 0 , u + c T ] matters. In a similar way, one could have replaced the Pareto tail after u + c T 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:
  • u = 0.001 , λ = 1 , T = 1 , c = 100 , 000 , α = 0.01 , β = 0.01 .
  • u = 0.01 , λ = 1 , T = 1 , c = 100 , 000 , α = 0.01 , β = 0.1 .
  • u = 0.001 , λ = 1 , T = 1 , c = 10 , 000 , α = 1 , β = 10 .
  • u = 0.1 , λ = 1 , T = 1 , c = 10 , 000 , α = 0.1 , β = 10 .
These first counterexamples have one common point: the net profit condition is not satisfied as α 1 , 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 u = 0.001 , λ = 1 , T = 1 , c = 10 000 , α = 1.0011 , and β = 10 . For this model, we had E ( X 1 ) = 10 / ( 1.0011 1 ) = 9090.91 and the safety loading was therefore close to 10 % .

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

  1. De Vylder, F.; Goovaerts, M. Homogeneous risk models with equalized claim amounts. Insur. Math. Econ. 2000, 26, 223–238. [Google Scholar] [CrossRef]
  2. Robert, C. On the de Vylder and Goovaerts conjecture about ruin for equalized claims. J. Appl. Probab. 2014, 51, 874–879. [Google Scholar] [CrossRef]
  3. 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] [Green Version]
  4. 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]
  5. Tijms, H. Stochastic Models: An Algorithmic Approach; John Wiley & Sons: New York, NY, USA, 1994. [Google Scholar]
Table 1. Results obtained for 11 different seeds.
Table 1. Results obtained for 11 different seeds.
ψ ( u ) ψ eq ( u ) ψ ( u ) ψ eq ( u ) Asymptotic Confidence Interval
0.00518464 0.00518466 2.46014 × 10 8 2.66903 × 10 9
0.00518464 0.00518466 2.11128 × 10 8 2.66906 × 10 9
0.00518464 0.00518466 2.3067 × 10 8 2.66907 × 10 9
0.00518464 0.00518466 2.29491 × 10 8 2.66908 × 10 9
0.00518464 0.00518466 2.0385 × 10 8 2.66907 × 10 9
0.00518464 0.00518466 2.19286 × 10 8 2.66906 × 10 9
0.00518464 0.00518466 2.18805 × 10 8 2.66906 × 10 9
0.00518464 0.00518466 2.165 × 10 8 2.66905 × 10 9
0.00518464 0.00518466 2.04824 × 10 8 2.66905 × 10 9
0.00518464 0.00518466 2.23203 × 10 8 2.66904 × 10 9
0.00518464 0.00518466 2.31037 × 10 8 2.66903 × 10 9
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.

Share and Cite

MDPI and ACS Style

Loisel, S.; Minier, C. On the Devylder–Goovaerts Conjecture in Ruin Theory. Mathematics 2023, 11, 1501. https://doi.org/10.3390/math11061501

AMA Style

Loisel S, Minier C. On the Devylder–Goovaerts Conjecture in Ruin Theory. Mathematics. 2023; 11(6):1501. https://doi.org/10.3390/math11061501

Chicago/Turabian Style

Loisel, Stéphane, and Charles Minier. 2023. "On the Devylder–Goovaerts Conjecture in Ruin Theory" Mathematics 11, no. 6: 1501. https://doi.org/10.3390/math11061501

APA Style

Loisel, S., & Minier, C. (2023). On the Devylder–Goovaerts Conjecture in Ruin Theory. Mathematics, 11(6), 1501. https://doi.org/10.3390/math11061501

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop