Company Value with Ruin Constraint in a Discrete Model

Abstract

Optimal dividend payment under a ruin constraint is a two objective control problem which—in simple models—can be solved numerically by three essentially different methods. One is based on a modified Bellman equation and the policy improvement method (see Hipp (2003)). In this paper we use explicit formulas for running allowed ruin probabilities which avoid a complete search and speed up and simplify the computation. The second is also a policy improvement method, but without the use of a dynamic equation (see Hipp (2016)). It is based on closed formulas for first entry probabilities and discount factors for the time until first entry. Third a new, faster and more intuitive method which uses appropriately chosen barrier levels and a closed formula for the corresponding dividend value. Using the running allowed ruin probabilities, a simple test for admissibility—concerning the ruin constraint—is given. All these methods work for the discrete De Finetti model and are applied in a numerical example. The non stationary Lagrange multiplier method suggested in Hipp (2016), Section 2.2.2, also yields optimal dividend strategies which differ from those in all other methods, and Lagrange gaps are present here.

1. Introduction

Let $S\left(t\right),t=0,1,\dots$ be the time t surplus of a company and $D\left(t\right),t=0,1,\dots$ the adapted non-decreasing sequence of accumulated dividends. For a fixed discount factor $0<r<1$ the dividend value under $D\left(t\right)=d\left(1\right)+\dots +d\left(t\right)$ is given by

$$V^D\left(s\right)=E\left[\sum _0^{\infty }{r}^{t}d\left(t\right)|S\left(0\right)=s\right],$$

where $s\ge 0$ is the initial surplus. The with dividend ruin time of the company is

$${\tau }^D=inf\{t\ge 0:S\left(t\right)-D\left(t\right)<0\},$$

and ${\psi }^D\left(s\right)$ is the corresponding with dividend ruin probability

$${\psi }^D\left(s\right)=\mathbb{P}\{{\tau }^D<\infty |S\left(0\right)=s\}.$$

(1)

We assume in the following that dividends are never paid at or after ruin. The object to be investigated is

$$V(s,\alpha )=\underset{D}{sup}\{V^D\left(s\right):{\psi }^D\left(s\right)\le \alpha \},s\ge 0,$$

(2)

for a given value $\alpha .$ The quantity $V(s,1)$ is sometimes called value of the company. A lot of research has been done on this quantity, starting with the seminal work of De Finetti (1957) and Gerber (1969), Choulli et al. (2003) and Albrecher and Thonhauser (2008) as well as Schmidli (2007), Section 2.4, and Loeffen (2008), Avanzi (2009) and Feng et al. (2015) for related work. The concept leading to $V(s,\alpha )$ is a possible answer to the problem posed in Borch (1963) who wrote:

If the general manager of our insurance company wants to run the company strictly as a business enterprise, he will probably always seek out the decisions which maximize $V(s,1).$ If, however, he is concerned with the social responsibility of the company, and the security which it offers to policy holders, he may also consider ${\psi }^0\left(s\right)$ [the ruin probability without dividend payment] when making his decisions. He will probably try to balance the two elements, but it is not easy to specify how this should be done.

One approach for the computation of the value function $V(s,\alpha )$ is based on a modified Hamilton-Jacobi-Bellman equation for the corresponding stationary Markov process with a bivariate state variable (see Hipp (2003)). This approach needs a fine discretization of the values for the ruin probability, and a large number of iteration steps. In the ruin probability grid, a complete search was necessary in the old version of the policy improvement method. A second approach is the iteration method presented in Hipp (2016). Here, we have shorter but still long computation times. Again we have a complete search, but in the much smaller set of possible surplus values.

The purpose of this paper is to study the form of optimal dividend strategies and use running allowed ruin probabilities to speed up the computation of the first method. This enables a big number of iterations for this first method even for fine discretizations. Compared with the iteration method, the second approach, we obtained slightly higher company values caused by the larger number of iterations. Finally, we show that optimal dividend strategies are of barrier type, and we present analytic formulas for the dividend value of these barrier type strategies. In a numerical example we show how appropriate barrier levels can be found.

The quantity company value under a ruin constraint should later serve as an objective function for finding optimal reinsurance or investment strategies. For this we need simple algorithms for the computation of $V(s,\alpha )$ with a possible chance to use them also in the corresponding control problem. We restrict ourselves to the following very simple space and time discrete model in which such algorithms can be more easily found.

We consider a simple random walk $S\left(t\right),t=0,1,\dots ,$ on the integers starting at s and going up or down by 1 with probability p or $q=1-p$, respectively. This is the classical De Finetti model which is skip free (upwards and downwards). In the insurance framework, t labels periods in which premia of size 1 come in and claims of size 2 go out. In this discrete model, each dividend payment can be assumed to be integral (see Schmidli (2007), Lemma 1.9). In Hipp (2016) it is shown that for

$$rp>1/2$$

(3)

and for fixed $s\ge 0$ the function $\alpha \to V(s,\alpha )$ is continuous (notice that the continuity statement in Hipp (2003), Lemma 2e, is not correct, and its proof has a gap; a correct proof can be found in Hipp (2016), Lemma 2). This shows that a purely discrete model can lead to a situation with a continuous parameter $\alpha .$ To avoid technical problems we will assume in the following that (3) holds. The function $\alpha \to V(s,\alpha )$ is strictly increasing on ${\psi }^0\left(s\right)\le \alpha \le 1,$ and $V(s,\alpha )=0$ for $\alpha \le {\psi }^0\left(s\right).$ In the De Finetti model the survival probability $1-{\psi }^0\left(s\right)$ satisfies the following difference equation for functions $f\left(s\right),s\ge -1,$ with $f(-1)=0:$

$$f\left(s\right)=pf(s+1)+qf(s-1),s\ge 0.$$

(4)

This equation is homogeneous, and the set of solutions is one-dimensional. If $0\le s<B$ then the probability $p(s,B)$ that $S\left(t\right)$ reaches B from s before ruin satisfies (4), and $p(B,B)=1$ leads to

$$p(s,B)=(1-{\psi }^0\left(s\right))/(1-{\psi }^0\left(B\right)).$$

The company value $V(s,1)$ satisfies a similar difference equation for functions $f\left(s\right),s\ge -1,$ satisfying $f(-1)=0:$

$$f\left(s\right)=r\left(pf\right(s+1)+qf(s-1\left)\right),s\ge 0,$$

(5)

which holds in the range without dividend payment: let $W\left(s\right)$ be the unique solution of (5) with $W\left(1\right)=1.$ Find $M\ge 0$ for which $W(M+1)-W\left(M\right)\le W(s+1)-W\left(s\right)$ for all $s\ge 0.$ Then

$$V(s,1)=W\left(s\right)/\left(W\right(M+1)-W(M\left)\right),s\le M,$$

where M is the barrier for dividend payment: $V(s,1)=V(M,1)+s-M$ for $s\ge M.$ Also equation (5) is homogeneous, and the set of solutions has dimension 1. So, for the waiting time $\tau (s,B)$ to reach B from s before ruin, the expected discount factor $W(s,B)=E\left[r^{\tau (s,B)}\right]$ is a solution of (5), and $W(s,B)$ is proportional to the function $W\left(s\right):$

$$E\left[r^{\tau (s,B)}\right]=W\left(s\right)/W\left(B\right).$$

2. Methods

2.1. A Modified Bellman Equation

Our first numerical method for the company value with ruin constraint is based on a modified Bellman equation. We use the following dynamic equations for $V(s,\alpha )$ (see Hipp (2003), formula (4)):

$$\begin{array}{ccc}\hfill V(s,\alpha )& =& max\left\{V\right(s-1,\alpha )+1,G(s,\alpha \left)\right\},\hfill \end{array}$$

(6)

$$\begin{array}{ccc}\hfill G(s,\alpha )& =& \underset{A(s,\alpha )}{sup}\{rpV(s+1,{\beta }_1)+rqV(s-1,{\beta }_2)\}\hfill \end{array}$$

(7)

$$\begin{array}{ccc}\hfill A(s,\alpha )& =& \{({\beta }_1,{\beta }_2)\in B(s,\alpha ):p{\beta }_1+q{\beta }_2=\alpha \}\hfill \end{array}$$

(8)

$$\begin{array}{ccc}\hfill B(s,\alpha )& =& \{({\beta }_1,{\beta }_2):{\psi }^0(s+1)\le {\beta }_1\le 1,{\psi }^0(s-1)\le {\beta }_2\le 1\}.\hfill \end{array}$$

(9)

These equations hold in the range $s=0,1,2,\dots$ and ${\psi }^0\left(s\right)\le \alpha \le 1,$ and we use the values $V(-1,\alpha )=0$ and ${\psi }^0(-1)=1.$ The dynamic equations define the optimal dividend strategy in feedback form: Equation (6) tells us when a dividend of size 1 is paid. Equation (7) gives the value function when no dividend is paid, depending on the next period in which the surplus can go up with probability p or down with probability $q.$ The number $\alpha$ is the running allowed ruin probability, which changes to ${\beta }_1$ or ${\beta }_2$ in the next period depending on an up- or down-move of the surplus. Equation (8) implies that the process of running allowed ruin probabilities is a martingale with mean $\alpha .$ Computation is based on an iteration which is the well known policy improvement procedure (see Hipp (2003)): we start from $V_0(s,\alpha )=0,$ and when $V_n(s,\alpha )$ is given for all s and $\alpha ,$ we compute $V_{n+1}(s,\alpha )$ from Equations (6)–(9) where we use the functions $V_n$ on the right hand side of (7) and obtain $V_{n+1}$ on the left hand side of (6):

$$\begin{array}{ccc}\hfill G_n(s,\alpha )& =& \underset{A(s,\alpha )}{sup}\{rp{V}_n(s+1,{\beta }_1)+rq{V}_n(s-1,{\beta }_2)\}\hfill \end{array}$$

(10)

$$\begin{array}{ccc}\hfill V_{n+1}(s,\alpha )& =& max\{V_{n+1}(s-1,\alpha )+1,G_n(s,\alpha )\}.\hfill \end{array}$$

(11)

One can show that the sequence of functions $V_n(s,\alpha )$ is non-decreasing and bounded, and its limit is a solution of the dynamic equations above (see Hipp (2003), Lemma 2a). The classical verification argument yields that the limit is the value function of our control problem, and a solution to the dynamic Equations (6)–(9), see also Hipp (2003), Lemma 2b–d. By continuity of $\alpha \to V(s,\alpha ),$ the supremum in (7) is attained at some $({\beta }_1,{\beta }_2)\in A(s,\alpha ).$ Let $\alpha \left(t\right)$ be the process of allowed ruin probabilities defined by $\alpha (t+1)=\alpha \left(t\right)$ when a dividend of size 1 is paid at $t,$ and otherwise $\alpha (t+1)={\beta }_1$ or $\alpha (t+1)={\beta }_2$ when $S\left(t\right)$ goes up or down, respectively. Notice that for all $t\ge 0$ we have

$$\psi \left(S\right(t\left)\right)\le \alpha \left(t\right)\le 1.$$

(12)

Using the bivariate process $\left(S\right(t),\alpha (t\left)\right)$ we can define the optimal dividend strategy in feedback form: in state $(s,\alpha )$ we pay a dividend of size 1 whenever the maximum in (6) is at $V(s-1,\alpha )+1.$ The second component $\alpha \left(t\right)$ makes the optimal dividend strategy path dependent. Each payment of size 1 does not change the state, so during dividend payment we stay in the same state until the next claim (downward jump). This implies that there exists a function $M\left(\alpha \right)$ such that dividends are paid above $M\left(\alpha \right)$ when the allowed ruin probability equals $\alpha .$ The function $M\left(\alpha \right)$ is a non-increasing step function. Below, we study the running allowed ruin probabilities $\alpha \left(t\right)$ in more detail. In the above computation based on the modified Bellman equation we first used a complete search for the maximizer ${\beta }_1,{\beta }_2.$ Here we replaced each complete search by an easy computation of running allowed ruin probabilities which speeds up a lot.

2.2. Iteration Method

The iteration method is based on the observation that, starting at initial surplus $s,$ we either pay dividends immediately, or we wait until we arrive at some larger surplus $B.$ If at B the ruin probability $a\left(B\right)$ is allowed, then we continue with a dividend strategy producing a dividend value (close to) $V(B,a(B\left)\right).$ If we start with an initial function $V_0(s,\alpha )$ (e.g., $V_0(s,\alpha )=0)$, and if $V_{n-1}(s,\alpha )$ is given, then our iteration reads

$$\begin{array}{ccc}\hfill V_n(s,\alpha )& =& \underset{B\ge s}{max}\left\{W(s,B)V(s,a\left(B\right))\right\}\hfill \end{array}$$

(13)

$$\begin{array}{ccc}\hfill V_n(s,\alpha )& \ge & V_n(s-1,\alpha )+1\mathrm{if}\psi (s-1)\le \alpha ,\hfill \end{array}$$

(14)

$$\begin{array}{ccc}\hfill \alpha & =& p(s,B)+(1-p(s,B\left)\right)a\left(B\right).\hfill \end{array}$$

(15)

Here, $p(s,B)$ is the probability that the without dividend process $S\left(t\right)$ falls below zero before reaching $B,$ and $W(s,B)$ is the discounting factor $E\left[r^{\tau (s,B)}\right)]$ for $\tau (s,B)$ the waiting time to reach B from s before ruin. This device produces a monotone sequence of functions $V_n$ which might converge to the value function $V(s,\alpha ).$ The first Equation (13) covers the case in which no dividends are paid before reaching $B,$ while Equation (14) allows for immediate dividend payment at surplus $s.$ The numerical results verify that the optimal dividend strategies are of barrier type.

2.3. Running Allowed Ruin Probabilities

The running allowed ruin probabilities are ruin probabilities for optimal dividend strategies: if D is the optimal dividend strategy with initial surplus s and allowed ruin probability $\alpha ,$ then the ruin probability of the with dividend process $S\left(u\right)-D\left(u\right),u\ge 0,$ equals $\alpha .$ At time t the dividend strategy $D_t\left(u\right)=D(t+u)$ is the optimal strategy for $\left(S\right(t),a(t\left)\right),$ and so $a\left(t\right)$ is the ruin probability for the with dividend process $S(t+u)-D_t\left(u\right),u\ge 0.$ Let $B_0\ge s_0$ be the surplus above which dividends are paid first, i.e., dividends of size 1 are paid at state $B_0+1$ which produces a constant value $B_0$ for the with dividend process until the next claim (downward jump). Since no dividends are paid when $s_0\le S\left(t\right)\le B_0,$ we can write $a\left(t\right)=a_0\left(S\left(t\right)\right),$ where $a_0\left(s\right)$ satisfies (4) with $a_0(-1)=1.$ This implies that for $0\le s\le B_0$ we have $a_0\left(s\right)=1-{\gamma }_0+{\gamma }_0{\psi }^0\left(s\right)$ for some $0<{\gamma }_0\le 1,$ and ${\gamma }_0$ can be computed from $a_0\left(s_0\right)={\alpha }_0.$ During dividend payment, $a\left(t\right)$ stays on the level ${\alpha }_0=a_0\left(B_0\right),$ it leaves this level at the first claim. Let $B_1\ge B_0$ be the level above which we first pay dividends after leaving $B_0.$ Repeating the above reasoning with $B_1$ instead of $B_0$ and $B_0-1$ instead of $s_0,$ we obtain a function $a_1\left(s\right),s\le B_1,$ which is the ruin probability of the with dividend process for the initial pair $(B_0,{\alpha }_0).$ Since the transition from $B_0$ to $B_0-1$ is certain, we get $a_1(B_0-1)={\alpha }_0.$ This value determines ${\gamma }_1$ in the representation $a_1\left(s\right)=1-{\gamma }_1+{\gamma }_1\psi \left(s\right).$ Proceeding in this way, for a non-decreasing sequence of barriers $B_i,i\ge 0,$ we obtain a non-decreasing sequence of numbers ${\gamma }_i,i\ge 0$ satisfying the recursion

$${\gamma }_{i+1}={\gamma }_i\frac{1-{\psi }^0\left(B_i\right)}{1-{\psi }^0(B_i-1)}.$$

(16)

The dividend strategy D which pays dividends at the levels $B_i$ satisfies the ruin constraint ${\psi }^D\left(s_0\right)\le a_0$ provided

$$\underset{i}{sup}\left\{{\gamma }_i\right\}\le 1.$$

(17)

If we stop the sequence $B_i$ at some finite number $n,$ this means that after visiting n barrier levels we stop paying dividends for ever, i.e., ${\gamma }_i=1$ for $i>n.$

2.4. The Barrier Method

The barrier method does not use iterations or discretizations, it is more interactive and simpler. We start with a (finite) sequence of barrier levels $B\left(i\right),i=1,\dots ,n$ and compute the dividend value with an analytic formula in which all dividends which are paid on one of these levels are appropriately discounted and added. The value of dividend payments on the level $B_i,$ discounted to the time when we reach $B_i+1$ after leaving $B_{i-1}-1,$ does not depend on i and equals

$$A=\sum _{k=0}^{\infty }{p}^n{r}^n=1/(1-rp).$$

So the dividend value consists of the sum of all these payments, discounted over the times elapsed between s and $B_0+1$ (for the payments at level $B_0$), then over this time plus the time elapsed between $B_0-1$ and $B_1+1$ plus the time spent on level $B_0$ (for the payments at level $B_1$), and so on. The discount factor for the time spent on level $B_i$ is again independent of $i,$ it equals

$$C=\sum _{k=1}^{\infty }q{p}^{n-1}{r}^n=qr/(1-rp).$$

The present value for payments on level $B_0$ is

$$A\frac{W\left(s\right)}{W(B_0+1)},$$

for level $B_1$ we obtain the present value

$$A\frac{W\left(s\right)}{W(B_0+1)}C\frac{W(B_0-1)}{W(B_1+1)}$$

and so on. A closed formula for the total dividend value of the dividend strategy D is

$$V^D\left(s\right)=A\frac{W\left(s\right)}{W(B_0+1)}\sum _{k=0}^{\infty }{C}^k\prod _{i=1}^k\frac{W(B_{i-1}-1)}{W(B_i+1)}.$$

(18)

One method to find barrier levels uses the function $M\left(\alpha \right),$ which might come from the computation with one of the above numerical methods:

$$M\left(\alpha \right)=min\{s:V(s+1,\alpha )=V(s,\alpha )+1\}.$$

Notice that for all $s\ge M\left(\alpha \right)$ we have $V(s+1,\alpha )=V(s,\alpha )+1,$ since the running allowed ruin probability equal $\alpha$ for $s\ge M\left(\alpha \right)$ (use $\alpha =p{\beta }_1+q{\beta }_2$ which holds for ${\beta }_2=\alpha$ only if ${\beta }_1=\alpha$). The function $M\left(\alpha \right)$ (see Figure 1 left below) is combined with the running ruin probabilities $a_i\left(s\right)$ defined sequentially as follows: $a_0\left(s\right)$ is computed from the initial data $(s_0,{\alpha }_0).$ The intersection of $a_0\left(s\right)$ with $M\left(\alpha \right)$, plotted in the same diagram, is barrier $B_0.$ From the data $(B_0,a_0\left(B_0\right))$ we compute $a_1\left(s\right),$ and so on: the intersection points of $a_i\left(s\right)$ with $M\left(\alpha \right)$ are the barriers $B_i.$ Figure 1 right above shows the functions $a_i\left(s\right),i=0,\dots ,15$ intersecting $M\left(\alpha \right)$ at level $s=4$ or $s=5.$

Another, more precise method is an (almost) complete search in the vectors of non-decreasing $n-$ tuples of numbers $k,k+1,\dots ,K$, where k is the barrier in the unconstrained problem and K a suitable limit of the state space for $s.$ Search for a smallest – in pointwise order – vector for which the maximal ${\gamma }_i$ is smaller than 1. Finally we apply formula (18) to this smallest vector. The computation of the ${\gamma }^{\prime }s$ is very simple, and the test checks for an appropriate with dividend ruin probability. A numerical example is given below. Following our intuition we searched for a barrier sequence only in the set of all non decreasing sequences. That intuition does not fail in this situation can be seen with the following argument. The functions $a_i\left(s\right)$ are defined by $a_i(-1)=1,$ Equation (4) for $0\le s\le B_i-1,$ and some value for $a_i\left(s_0\right)$ with $0\le s_0\le B_i.$ The functions are concatenated by the value in which the with dividend surplus jumps after leaving the barrier level $B_i.$ For $B_{i+1}\ge B_i-1$ this produces the recursion (16), but for $B_{i+1}<B_i-1$ after a jump to $B_i-1$ we pay out dividends immediately which leads us to $B_{i+1}.$ In this case the recursion reads

$${\gamma }_{i+1}={\gamma }_i\frac{1-{\psi }^0\left(B_i\right)}{1-{\psi }^0\left(B_{i+1}\right)}.$$

With a next barrier $B_{i+2}\ge B_{i+1}-1$ we obtain

$${\gamma }_{i+2}={\gamma }_i\frac{1-{\psi }^0\left(B_i\right)}{1-{\psi }^0(B_{i+1}-1)}$$

(19)

If we replace $B_i$ by ${\widehat{B}}_i=B_{i+1}+1<B_i$ we obtain for the barriers ${\widehat{B}}_i,B_{i+1},B_{i+2}$ a parameter

$${\widehat{\gamma }}_{i+2}={\gamma }_i\frac{1-{\psi }^0\left({\widehat{B}}_i\right)}{1-{\psi }^0(B_{i+1}-1)}\le {\gamma }_{i+2},$$

and the same value appears for the non decreasing threetuple $B_{i+1},{\widehat{B}}_i,B_{i+2}.$ The dividend value for these barriers is larger than before, since we pay dividends earlier. Repeating this argument step by step, we can replace an arbitrary admissible sequence of barriers by an admissible non decreasing one which leads to a higher dividend value.

2.5. The Lagrange Multiplier Approach

For the Lagrange multiplier method we choose a constant $L>0$ and maximize the company value minus the weighted corresponding ruin probability:

$$V(s,L)=\underset{D}{sup}\{V^D\left(s\right)-L{\psi }^D\left(s\right)\},s\ge 0.$$

(20)

We used a non-stationary approach and computed the quantities for time t

$$\begin{array}{ccc}\hfill V(s,L,t)& =& \underset{D}{sup}\{V^D(s,t)-L{\psi }^D(s,t)\},s\ge 0,\hfill \\ \hfill V^D(s,t)& =& E\left[\sum _t^{\infty }{r}^{u}d\left(u\right)|S\left(t\right)=s\right],\hfill \\ \hfill {\psi }^D(s,t)& =& \mathbb{P}\left\{S\right(u)-D(u)<0\mathrm{for}\mathrm{some}u\ge t|S\left(t\right)=s\}\hfill \end{array}$$

via the recursion

$$V(s,L,t-1)=max\{V(s-1,L,t-1)+r^{t-1},pV(s+1,L,t)+qV(s-1,L,t)\}$$

(21)

with $V(-1,L,t)=-L.$ The resulting optimal dividend strategy is a time dependent barrier strategy $M\left(t\right)$ with which dividends are paid at t when the with dividend surplus is above $M\left(t\right).$ Using the barrier function $M\left(t\right)$ one can compute the ruin probability for the optimal dividend strategy via the recursion

$$\psi (s,t-1)=max\left(p\psi \right(s+1,t)+q\psi (s-1,t),\psi (M(t-1),t).$$

The value $V(s,L)=V(s,L,0)$ can efficiently be approximated via a backward recursion starting at $V(s,L,T)=-L\psi \left(s\right)$ and $\psi (s,T)={\psi }^0\left(s\right)$ for some large $T,$ a computation which turned out to be easy. Numerical experiments indicate that the approach produces dividend strategies which differ from the ones computed with the other methods: The resulting optimal dividend strategies for $V(s,L)$ are state and time dependent, but not path dependent.

The proposed policy improvement method without dynamic equation works also for more general models which are skip-free upwards and have independent stationary increments, e.g., classical Lundberg models with arbitrary claim size distribution or Brownian motions with drift. For these models the fist entrance probabilities and the discount factors for first entry waiting times are available. For Lundberg models the policy improvement method based on a modified Bellman equation can probably be applied, in particular with the explicit form of running allowed ruin probabilities. For the barrier method a continuous state space might cause problems: after discretization the resulting grid will be too large for an easy selection of optimal barriers.

3. Numerical Example

All computations in this section are done with MatLab (modified Bellman, policy improvement, and Lagrange) or with Maple (Barrier method). We consider the case with parameters $p=0.7,$$r=1/1.03,s_0=4$ and $a_0=0.2.$ We have

$$\begin{array}{ccc}\hfill {\psi }^0\left(s\right)& =& {(q/p)}^{s+1},s\ge 0,\hfill \\ \hfill W\left(s\right)& =& K{z}_1^s+(1-K)z_2^s,s\ge 0,\hfill \\ \hfill z_1& =& 1.07142857142857142,\hfill \\ \hfill z_2& =& 0.4,\hfill \\ \hfill K& =& 1.5957446808510638298,\hfill \\ \hfill A& =& 103/33,\hfill \\ \hfill C& =& 10/11,\hfill \\ \hfill {\gamma }_0& =& 0.804988026.\hfill \end{array}$$

We used the iteration method with 150 repetitions and a step size $1/100,000$ for $\alpha$ and obtained

$$V(4,0.2)=12.8162.$$

The unconstrained company value is

$$V(4,1)=13.1004.$$

This shows that a ruin constraint is rather cheap. The method using the modified Bellman equation described in Hipp (2003) is done—slightly modified—with the same step size $1/100,000$ for $\alpha ,$ which results with 800 iterations and interpolation in a somewhat larger value:

$$V(4,0.2)=12.817618.$$

The modification, which speeds up a lot and allows for a small step size and a large number of iterations, is the specification of the maximizers ${\beta }_1$ and ${\beta }_2$ when s and $\alpha$ are given. We use again the running ruin probabilities for states without dividend payment $a\left(x\right)=1-\gamma +\gamma {\psi }^0\left(x\right)$ with $\gamma$ derived from $a\left(s\right)=\alpha$ and set

$${\beta }_1=a(s+1),{\beta }_2=a(s-1).$$

(22)

The larger value obtained with the old method indicates that the iteration method was used with an insufficient number of repetitions. Furthermore, interpolation reduces the effect of a discretization. Since the iteration method uses a complete search over the possible surplus values (reducing the search to one over a small region leads to wrong results), larger numbers of iterations are not acceptable even for a patient user. Finally, for the iteration method we do not have a proof for convergence to the value function. Of course the best results can be obtained using the barrier method which is based on exact formulas. We computed $V(4,0.2)$ from given barrier levels $B_0,\dots ,B_{100}.$ Stopping dividend payment after visiting 100 not necessarily different barriers produces a numerical result below the true value, but the small size of this error can be seen in the (worst) case $\alpha =1:V(4,1)=13.1003845,$ while with 100 steps we obtain $13.1003469.$ We used the barriers

$$\begin{array}{ccc}\hfill B_i& =& 4,0\le i\le 6,\hfill \\ \hfill B_i& =& 5,7\le i\le 14,\hfill \\ \hfill B_i& =& 8,15\le i\le 19,\hfill \\ \hfill B_i& =& 12,20\le i\le 30,\hfill \\ \hfill B_i& =& 15,31\le i\le 40,\hfill \\ \hfill B_i& =& 18,41\le i\le 50,\hfill \\ \hfill B_i& =& 24,51\le i\le 100.\hfill \end{array}$$

All corresponding ${\gamma }_i$ are smaller than 1. With these we obtained the value

$$V(4,0.2)=12.9099.$$

The barriers are found in an interactive procedure: we started with three regions $[0,\dots ,6],$ $[7,\dots ,13], [14,\dots ,19]$ in which all barriers have the same value $a,b,c,$ respectively. We took $a=4$ which is the barrier in the unconstrained problem, $b=6$ and $b=7.$ All other barriers are $K.$ To avoid ${\gamma }_i>1$ we increased step by step to $c=8.$ Then we reduced the size of barriers in the remaining groups. We are close to the optimal value when ${\gamma }_K<1$ is very close to one. The difference between the dividend values $12.817618$ and $12.9099$ for $V(4,0.2)$ is caused by the discretization of $\alpha ;$ even a step size of $1/100,000$ results in a rather big error due to the large number of calculations.

For the Lagrange multiplier method we wanted to use the above numerical methods with a factor L for which the ruin probability equals $0.2.$ This $L,$ however, does not exist, there is a Lagrange gap at this point. These gaps always exist in De Finetti models, see Hipp (2017). We computed with $L=2.94$ the values $\alpha =0.1998175$ and $V(4,\alpha )=V(4,L)+\alpha L=12.84498,$ and for $L=2.93$ the values are $\alpha =0.20149665$ and $V(4,\alpha )=12.84499.$ These numbers are close to the numbers obtained with other numerical methods, but still there is an essential difference: the corresponding dividend strategies are of barrier type which are state and time dependent but not path dependent. The time dependent barrier $M\left(t\right)$ is a non decreasing step function, see Figure 2 below.

We include the source code of five programs which are used for the problems above. Three MatLab codes are titled Policy improvement with Bellman, Policy improvement without dynamic equation, and Lagrange method. The code DeFinettiModel is used in all these three mentioned MatLab codes and specifies the parameters of the problem and the method. In addition we give the code of a MAPLE program which is used for the Barrier method.

DeFinettiModel
 
ds=1;
S0=300; S=0:ds:S0; KS=length(S);
W=zeros(1,KS); V1=W; V2=W; V0=W;
p=0.7; q=1-p;
r=1/1.03;
a1=1.0714285;
a2=0.4;
b2=-.5957446812;
b1=1-b2;
for k=1:KS
    W(k)=b1*a1^(k-1)+b2*a2^(k-1);
end
kk=6;
C=1/(W(kk)-W(kk-1));
for k=1:kk
    V0(k)=W(k)*C;
end
g=(1-p)/p;
Psi=g.^(1:1:KS);
for i=(kk+1):KS
    V0(i)=V0(i-1)+1;
end
Policy improvement with Bellman, with new
formulas for beta1 and beta2 and interpolation
 
DeFinettiModel;
da=1/100000;
Alpha=da:da:1; KA=length(Alpha);
V1=zeros(KS,KA); V2=V1;
for L=1:400
    M=zeros(1,KA);
    al0=ceil(Psi(1)/da);
    for al=al0:KA
        alpha=al*da;
        y1=(alpha-q)/p/da;
        u1=floor(y1);
        z1=(y1-u1);
        if u1==0
            v1=z1*V1(2,u1+1);
        else
            v1=V1(2,u1)+z1*(V1(2,u1+1)-V1(2,u1));
        end
        V2(1,al)=r*p*v1;
    end
    for s=2:KS-1
        for al=1:KA
            alpha=al*da;
            if Psi(s)>=alpha
                V2(s,al)=0;
            else
                ga=(1-alpha)/(1-Psi(s));
                y1=(1-ga+ga*Psi(s+1))/da;
                y2=(1-ga+ga*Psi(s-1))/da;
                u1=floor(y1);
                u2=floor(y2);
                z1=(y1-u1);
                z2=(y2-u2);
                if u1==0
                    v1=z1*V1(s+1,u1+1);
                else
                    v1=V1(s+1,u1)+z1*(V1(s+1,u1+1)-V1(s+1,u1));
                end
                if u2==0
                    v2=z2*V1(s-1,u2+1);
                else
                    v2=V1(s-1,u2)+z2*(V1(s-1,u2+1)-V1(s-1,u2));
                end
                x=r*p*v1+r*q*v2;
                if Psi(s-1)<alpha & x<V2(s-1,al)+1
                    if M(al)==0
                        M(al)=s;
                    end
                    x=V2(s-1,al)+1;
                end
                V2(s,al)=max(V1(s,al),x);
            end
        end
    end
    V1=V2;
    V1(:,KA)=V0;
    [L V1(5,round(0.2/da)) V0(5)]’
end
 
 
Policy improvement without dynamic equation
 
clear;
DeFinettiModel;
da=1/100000; Alpha=da:da:1; KA=length(Alpha);
V1=zeros(KS,KA); V2=V1;
V1(:,KA)=V0;
M0=round(0.2/da);
for L=1:150
    M=zeros(1,KA);
    for s=1:KS
        for al=max(round(Psi(s)/da),1):KA-1
            Feld=zeros(1,KS);
            alpha=al*da;
            if M(al)>0 && s>M(al) && Psi(s-1)<al
                V1(s,al)=V1(s-1,al)+1;
            end
            for B=s+1:KS
                x1=(Psi(s)-Psi(B))/(1-Psi(B));
                x2=1-x1;
                y=(alpha-x1)/x2*KA;
                aB=floor(y);
                z=y-aB;
                if aB==0
                    VF=z*V1(B,aB+1);
                end
                if aB>0
                    VF=V1(B,aB)+z*(V1(B,aB+1)-V1(aB));
                end
                Feld(B-s)=W(s)/W(B)*VF;
            end
            x=max(Feld);
            if s>1
                y=V2(s-1,al)+ds;
                if (Psi(s-1)<al*da) & (x<y)
                    V2(s,al)=max(V1(s,al),y);
                    if M(al)==0
                        M(al)=s;
                    end
                else
                    V2(s,al)=max(V1(s,al),x);
                end;
            end
        end
        V2(s,KA)=V0(s);
    end
    V1=V2;
end
 
Lagrange method
 
DeFinettiModel;
T0=2000; T=0:T0; KT=length(T);
V=zeros(KS,KT); W=V;
M=zeros(1,KT);
L=2.93;
s0=5; a0=0.2; p=0.7; r=1/1.03;
% computation of value function
V(:,T0)=-L*Psi;
for k=1:T0-1
    t=T0-k;
    rt=r^(t-1);
    V(1,t)=p*V(2,t+1)-q*L;
    for i=2:KS-1
        V(i,t)=max(p*V(i+1,t+1)+q*V(i-1,t+1),V(i-1,t)+rt);
        if p*V(i+1,t+1)+q*V(i-1,t+1)<V(i-1,t)+rt
            if M(t+1)==0
                M(t+1)=i-1;
            end
        end
    end
end
% computation of corresponding ruin probability
W(:,T0)=Psi;
for k=1:T0-1
    t=T0-k;
    W(1,t)=p*W(2,t+1)+q;
    for i=2:KS-1
        W(i,t)=p*W(i+1,t+1)+q*W(i-1,t+1);
        if i>M(t+1)
            W(i,t)=W(M(t+1),t);
        end
    end
end
[V(5,1) W(5,1) V(5,1)+L*W(5,1)]’
And finally the MAPLE code for the barrier method:
Barrier.mw
 
restart; Digits := 25;
p := .7; q := 1-p; r := 1/1.03;
Ps := s->(q/p)^(s+1);
z := solve(r*(p*x^2+q) = x, x);
B0 := solve((1-B)*z[2]+B*z[1] = 0, B);
W := s->(1-B0)*z[1]^s+B0*z[2]^s;
s0 := 4; a0 := .2;
for i from 0 to 6 do B[i] := 4 end do;
for i from 7 to 14 do B[i] := 5 end do;
for i from 15 to 19 do B[i] := 8 end do;
for i from 20 to 30 do B[i] := 12 end do;
for i from 31 to 40 do B[i] := 15 end do;
for i from 41 to 50 do B[i] := 18 end do;
for i from 51 to 101 do B[i] := 24 end do;
g[0] := (1-a0)/(1-Ps(s0));
a[0] := 1-g[0]+g[0]*Ps(B[0]);
for i from 0 to 100 do a[i] := 1-g[i]+g[i]*Ps(B[i]);
g[i+1] := (1-a[i])/(1-Ps(B[i]-1)) end do;
g[100];
A1 := (103/33)*W(s0)/W(B[0]+1); C := 10/11;
U[1] := 1; for i from 2 to 100 do U[i] := U[i-1]*C*W(B[i-1]-1)/W(B[i]+1) end do;
F := evalf(A1*(sum(U[k], k = 1 .. 100)));