Hafta 5 — Poliçe Koşulları, Toplam Hasar ve Prim Prensipleri

IST5109 İleri Aktüerya Teknikleri · Sigorta Verileriyle İstatistiksel Programlama

Bu haftanın amacı

Hafta 3’te hasar tutarlarına dağılım uydurduk ve Danish dosyasının bir seçilim eşiği olduğunu gördük: 1 mDKK’nın altındaki hasarlar dosyaya hiç girmemişti ve eşiği yok sayan üç model de olasılığının bir bölümünü bu gözlemsiz bölgeye koyuyordu. Bu hafta eşik bir poliçe koşulu olarak geri geliyor: muafiyet, kaybın bir tutara kadar olan kısmını ödemenin dışında bırakır ve sigortacının gördüğü ödemeleri tam da böyle bir eşikten başlatır.

Bir kaybın tutarı ile sigortacının ödediği tutar aynı değildir. Hafta bu farkı adım adım kurar ve her adım bir öncekinin sonucunu kullanır:

  1. Tek bir kayıpta ödeme (Kayıptan ödemeye, Küçük çalışılmış örnek): muafiyet, limit ve koasürans bir kaybı sigortacının ödediği ve sigortalının kendi ödediği iki parçaya ayırır; bunu yapan küçük bir R işlevi yazarız, policy_payment().
  2. Beklenen ödeme (Sınırlı beklenen değer): kayıp henüz gerçekleşmemişken ödemenin ortalaması; her kayıp dağılımında geçerli genel bir tarif.
  3. Gerçekçi bir dağılımda sayı (Pareto kayıplarında beklenen ödeme): tarifi Hafta 3’ün Pareto II dağılımına uygulayıp sonucu actuar paketiyle doğrularız.
  4. Yıllık toplam ödeme (Bileşik toplam hasar): kayıp sayısını ödemeyle birleştirip toplamın ortalamasını ve varyansını kurarız.
  5. Prim (Basit prim prensipleri): bu iki momentten iki basit prim hesaplarız.

Öğrenme çıktıları

Oturum sonunda öğrenci:

  1. kaybı, sigortacının ödediği tutar ile sigortalının kendi ödediği tutara ayırır;
  2. muafiyet, limit ve koasüransın ödemeyi nasıl değiştirdiğini açıklar;
  3. küçük ve test edilebilir bir policy_payment() fonksiyonu yazar;
  4. sınırlı beklenen değerle beklenen poliçe ödemesini ve ödemenin ikinci momentini hesaplar;
  5. açık formül ile actuar::levpareto() sonucunu karşılaştırır;
  6. bileşik toplam hasarın beklenen değerini ve varyansını kurar;
  7. beklenen değer ve standart sapma prim prensiplerini yorumlar.

Üç saatlik akış

Süre Etkinlik
0–45 dk Kayıptan ödemeye: poliçe koşulları, policy_payment() ve sınır testleri
45–75 dk Beklenen ödeme: sınırlı beklenen değer, fark özdeşliği ve \(E[Y^2]\); Pareto kayıplarında açık formül ve actuar ile kontrol
75–85 dk Ara
85–155 dk Bileşik toplam hasar, prim prensipleri ve R laboratuvarı
155–175 dk Alıştırmalar: prim prensiplerinin ve model varsayımlarının sınırları
175–180 dk Haftanın özeti ve açık sorular

1 Kayıptan ödemeye

\(X\ge 0\) gerçekleşen kayıp, yani sigortalının uğradığı zararın tamamı olsun. Bu zararın bir kısmını sigorta şirketi, yani sigortacı, öder; sigortacının ödediği tutara (tazminata) \(Y\) diyeceğiz. Zararın geri kalanını, \(X-Y\)’yi, sigortalı kendisi öder; iki tutarın toplamı her zaman kaybın kendisidir. Kaybın nasıl paylaşılacağını üç poliçe koşulu belirler:

  • \(d\): muafiyet (deductible); kaybın ilk \(d\) TL’sini sigortalı kendisi öder.
  • \(L\): muafiyet sonrası ödeme limiti (policy limit); kaybın \(d\)’yi aşan kısmından en çok \(L\) TL’si hesaba girer.
  • \(c\): koasürans (coinsurance) oranı, \(0<c\le1\); sigortacı hesaba giren tutarın \(c\) katını öder, kalan \(1-c\) payını sigortalı öder.

Bu derste kullanacağımız ödeme tanımı:

\[ \begin{aligned} Y&=c\min\{(X-d)_+,L\},\\ (X-d)_+&=\max(X-d,\,0). \end{aligned} \]

Formül içten dışa okunur ve her katman bir koşulu uygular: \((X-d)_+\) kaybın \(d\)’yi aşan kısmıdır, kayıp \(d\)’nin altındaysa sıfırdır; \(\min\{\cdot,L\}\) bu kısmı \(L\)’de keser; \(c\) kalanın sigortacıya düşen payını alır. Limit koasüranstan önce uygulanır; sıra değişirse ödeme de değişir (Alıştırma 5).

Alt simgedeki \(+\) işareti, parantezin içindeki fark negatifse sonucu sıfıra çeker; pozitifse farkı olduğu gibi bırakır. Sayfada başka farklarda da aynı anlamda kullanılır: örneğin \((X-d-L)_+\), kaybın \(d+L\)’yi aşan kısmıdır ve kayıp \(d+L\)’nin altındaysa sıfırdır.

Formülü kaybın \(d\) ile \(d+L\)’ye göre durduğu üç bölgede ayrı ayrı uygulayınca ödeme üç parçalı bir işlev olur:

\[ Y=\begin{cases} 0, & X\le d,\\ c(X-d), & d<X<d+L,\\ cL, & X\ge d+L. \end{cases} \]

Parçalar birleştikleri iki noktada aynı değeri verir: \(X=d\)’de komşu iki parça da 0, \(X=d+L\)’de ikisi de \(cL\)’dir. Ödeme bu yüzden sıçramaz; sınır noktasının hangi parçaya yazıldığı sonucu değiştirmez.

Türetmeler, varsayılanı kapalı Türetmeyi göster kutularındadır; metin yalnız sonuçları ve ne anlama geldiklerini verir.

Üç parça. Formülün üç katmanı içten dışa uygulanır. Kaybın bölgesi ilk iki katmanda iki sayıdan hangisinin seçileceğini belirler, üçüncü katman seçilen tutarı \(c\) ile çarpar:

Bölge \((X-d)_+\) \(\min\{(X-d)_+,L\}\) \(Y\)
\(X\le d\) \(0\) \(0\) \(0\)
\(d<X<d+L\) \(X-d\) \(X-d\) \(c(X-d)\)
\(X\ge d+L\) \(X-d\) \(L\) \(cL\)

Satırlar sırasıyla:

  1. \(X\le d\) ise \(X-d\le0\) ve \(\max(X-d,0)\) sıfırı seçer; limit pozitif olduğu için \(\min\{0,L\}=0\) ve \(c\cdot0=0\).
  2. \(d<X<d+L\) ise \(0<X-d<L\): \(\max\) pozitif olan \(X-d\)’yi, \(\min\) küçük olan \(X-d\)’yi seçer; \(c\) ile çarpılınca \(c(X-d)\) olur.
  3. \(X\ge d+L\) ise \(X-d\ge L>0\): \(\max\) yine \(X-d\)’yi, \(\min\) bu kez küçük olan \(L\)’yi seçer; \(c\) ile çarpılınca \(cL\) olur.

Birleşme noktaları. Her noktada komşu iki parçanın değerini ayrı ayrı hesaplıyoruz:

\[ \begin{aligned} &X=d:\\ &\quad\text{1. parça: }0,\\ &\quad\text{2. parça: }c(d-d)=0;\\ &X=d+L:\\ &\quad\text{2. parça: }c(d+L-d)=cL,\\ &\quad\text{3. parça: }cL. \end{aligned} \]

İki noktada da komşu parçalar aynı değeri verir.

Uyarı

“Limit” farklı sözleşmelerde muafiyet sonrası ödeme limiti veya toplam kayıp limiti olarak tanımlanabilir. Bu derste \(L\) muafiyet sonrası ödeme limitidir ve yukarıdaki formül bu okumayla yazılmıştır. Toplam kayıp limitinde üst sınır \(u\) kaybın kendisine konur ve ödeme \[ Y=c\,\bigl(\min(X,u)-d\bigr)_+ \] olur. \(u=d+L\) alınırsa iki formül aynı ödemeyi verir: \(X\le d\) iken ikisi de sıfırdır, \(X>d\) iken \(\min(X,d+L)-d\) \(=\min(X-d,L)\)’dir. Aynı sayı iki okumada ise farklı ödeme doğurur. \(d=1.000\), \(c=0{,}80\) ve “10.000 limit” ile 12.000 TL’lik bir kayıpta birinci okuma \(0{,}80\times\min\{11.000,\;10.000\}=8.000\) TL, ikincisi \(0{,}80\times(10.000-1.000)=7.200\) TL öder. Formül yazmadan yalnızca “10.000 limit” demek bu yüzden yeterli değildir.

2 Küçük çalışılmış örnek

Poliçe koşulları \(d=1.000\) TL, \(L=10.000\) TL ve \(c=0{,}80\) olsun. Kayıptan ödemeye bölümündeki üç parçalı biçimin sınırları bu koşullarda \(d=1.000\) ve \(d+L=11.000\) TL’dir. Üçüncü parçanın tutarı \(cL=0{,}80\times10.000=8.000\) TL’dir: kayıp ne kadar büyük olursa olsun sigortacı en çok 8.000 TL öder.

Beş kaybı her parçaya en az biri düşecek biçimde seçiyoruz: 500 TL birinci, 1.500 ve 5.000 TL ikinci, 12.000 ve 30.000 TL üçüncü parçadadır.

Kaybı kim öder? Her kayıpta önce hangi bölgede olduğuna bakılır, sonra o bölgenin parçası uygulanır; bu, sigorta şirketinin ödediği \(Y\)’dir. Kaybın şirketin ödemediği kısmını, \(X-Y\)’yi, sigortalı kendisi öder. Bu yüzden her satırda iki tutarın toplamı kaybın kendisidir. Örneğin 12.000 TL’lik bir kayıpta şirket 8.000 TL öder, kalan 4.000 TL’yi sigortalı öder.

Kayıp \(X\) Bölge ve uygulanan parça Şirket öder
\(Y\)
Sigortalı öder
\(X-Y\)
500 \(X\le d\): \(Y=0\) 0 500
1.500 \(d<X<d+L\): \(Y=c(X-d)\) \(=0{,}80\times(1.500-1.000)\) 400 1.100
5.000 \(d<X<d+L\): \(Y=c(X-d)\) \(=0{,}80\times(5.000-1.000)\) 3.200 1.800
12.000 \(X\ge d+L\): \(Y=cL\) \(=0{,}80\times10.000\) 8.000 4.000
30.000 \(X\ge d+L\): \(Y=cL\) \(=0{,}80\times10.000\) 8.000 22.000

Aynı tutarı Kayıptan ödemeye bölümündeki ödeme formülü katman katman da verir; formül içten dışa okunur. 12.000 TL’lik kayıpta önce muafiyet düşülür, \((X-d)_+=12.000-1.000=11.000\); sonra limit uygulanır, \(\min\{11.000;\,10.000\}=10.000\); en son \(c\) ile çarpılır, \(Y=0{,}80\times10.000=8.000\) TL. Bu, üçüncü parçanın verdiği tutardır. Aşağıdaki R kodu bu yolu izler.

Sigortalının ödediği tutar nereden gelir? Kayıp üç kısma ayrılır: ilk \(d\) TL, \(d\) ile \(d+L\) arasındaki kısım ve \(d+L\)’yi aşan kısım. Sigorta şirketi yalnız ortadaki kısmın \(c\) katını öder; geri kalan her şeyi sigortalı öder:

\[ \begin{aligned} X-Y={}&\min(X,d)\\ &+(1-c)\min\{(X-d)_+,L\}\\ &+(X-d-L)_+. \end{aligned} \]

Üç terim sırasıyla muafiyet, ortadaki kısmın \(1-c\) koasürans payı ve limit üstüdür. Aşağıdaki tabloda her biri ayrı bir sütundur.

Kaybın üç kısmı. Ortadaki kısım ödeme formülünün limit sonrası tutarıdır; kısaca \(W=\min\{(X-d)_+,L\}\) diyelim. Her bölgede üç kısmı ayrı ayrı yazıp topluyoruz:

Bölge \(\min(X,d)\) \(W\) \((X-d-L)_+\) Toplam
\(X\le d\) \(X\) \(0\) \(0\) \(X\)
\(d<X<d+L\) \(d\) \(X-d\) \(0\) \(X\)
\(X\ge d+L\) \(d\) \(L\) \(X-d-L\) \(X\)

Üç bölgede de toplam \(X\)’tir:

\[ \begin{aligned} X={}&\min(X,d)\\ &+\min\{(X-d)_+,L\}\\ &+(X-d-L)_+. \end{aligned} \]

Ortadaki terim, ödeme formülünde \(c\) ile çarpılan tutardır: \(Y=c\min\{(X-d)_+,L\}\). \(X\)’ten \(Y\) çıkarılınca ortadaki terimin \(1-c\) katı kalır, öbür iki terim olduğu gibi durur; sonuç yukarıdaki formüldür.

Kayıp \(X\) Muafiyet Koasürans
payı
Limit
üstü
Sigortalı öder
\(X-Y\)
500 500 0 0 500
1.500 1.000 100 0 1.100
5.000 1.000 800 0 1.800
12.000 1.000 2.000 1.000 4.000
30.000 1.000 2.000 19.000 22.000

Örneğin 30.000 TL’lik kayıpta sigortalı muafiyet olarak 1.000 TL, koasürans payı olarak \(0{,}20\times10.000=2.000\) TL ve limit üstü olarak \(30.000-11.000=19.000\) TL öder; toplam 22.000 TL. Sigorta şirketinin ödediği 8.000 TL ile birlikte kaybın tamamı karşılanır: \(22.000+8.000=30.000\).

Açık R ifadesi

Bu haftada kullanılan grafik paketlerini en başta yüklüyoruz. actuar yüklenmez; işlevleri Hafta 3’teki gibi actuar:: önekiyle çağrılır.

Kodu göster / gizle
library(ggplot2)
library(scales)

Birinci tablonun \(Y\) sütununu ödeme formülünün katmanlarıyla, dört adımda yeniden üretiyoruz. Önce kayıpları ve poliçe koşullarını tanımlıyoruz:

Kodu göster / gizle
x <- c(500, 1500, 5000, 12000, 30000)
d <- 1000
L <- 10000
c <- 0.80
c
#> [1] 0.8

Son satır koasürans oranını yazdırır. c adını formüldeki \(c\) ile aynı olsun diye seçtik, ama bu ad temel R’nin vektör kuran c() işlevinin de adıdır. R bir adı çağrı olarak, c(500, 1500) biçiminde, ararken işlev olmayan nesneleri atlar; bu yüzden c() bu sayfada da çalışır. Ad bir değer olarak geçtiğinde, örneğin bir işlevi argüman olarak alan do.call(c, list(1, 2)) çağrısında, R 0,80’i bulur ve çağrı “‘what’ must be a function or character string” hatasıyla durur.

İkinci adımda her kayıptan muafiyeti düşüyoruz:

Kodu göster / gizle
muafiyet_sonrasi <- pmax(x - d, 0)
muafiyet_sonrasi
#> [1]     0   500  4000 11000 29000

Çıktı formülün en iç katmanıdır, \((X-d)_+\): 0; 500; 4.000; 11.000 ve 29.000 TL.

  • pmax(x - d, 0) — Hafta 2’de gördüğümüz pmax(); formüldeki \((X-d)_+\) işlemini yapar. Yalnızca x - d yazılsaydı muafiyet altındaki kayıplar negatif çıkardı; max() ise hata vermeden tek bir sayı döndürürdü: bütün farkların en büyüğü, 29.000.

Üçüncü adımda bu tutarı ödeme limitiyle kısıtlıyoruz. Yeni nesne limit_sonrasi, koasürans uygulanmadan önce sigortacıya düşen tutardır:

Kodu göster / gizle
limit_sonrasi <- pmin(muafiyet_sonrasi, L)
limit_sonrasi
#> [1]     0   500  4000 10000 10000

Çıktı ikinci katmandır, \(\min\{(X-d)_+,L\}\): küçük kayıplarda muafiyet_sonrasi ile aynı kalır, büyük kayıplarda \(L\) değerinde durur.

Dördüncü adımda koasürans çarpanını uyguluyoruz; y sigortacının fiilen ödediği tutardır:

Kodu göster / gizle
y <- c * limit_sonrasi
y
#> [1]    0  400 3200 8000 8000

Çıktı birinci tablonun \(Y\) sütunudur: 0; 400; 3.200; 8.000 ve 8.000 TL.

Sigortalının kendi ödediği tutar, kayıptan sigortacının ödediğinin çıkarılmasıdır.

Kodu göster / gizle
sigortalinin_odedigi <- x - y
sigortalinin_odedigi
#> [1]   500  1100  1800  4000 22000

Çıktı 500; 1.100; 1.800; 4.000 ve 22.000 TL olmalıdır.

policy_payment() fonksiyonu

Dört adımı tek bir işlevde topluyoruz. İşlevin son satırı formülün kendisidir, \(Y=c\min\{(X-d)_+,L\}\); ondan önceki stopifnot() girdileri denetler.

Kodu göster / gizle
policy_payment <- function(loss, deductible = 0,
                           limit = Inf, coinsurance = 1) {
  stopifnot(
    is.numeric(loss), all(loss >= 0),
    deductible >= 0, limit > 0,
    coinsurance > 0, coinsurance <= 1
  )
  coinsurance * pmin(pmax(loss - deductible, 0), limit)
}

policy_payment(c(500, 1500, 30000), deductible = 1000, limit = 10000, coinsurance = 0.80)
#> [1]    0  400 8000

Yukarıdaki üç kayıp küçük çalışılmış örnekteki muafiyet altı, ara ve limit üstü durumlardır; sonuç sırasıyla 0, 400 ve 8.000 TL olmalıdır.

Argümanların varsayılan değerleri koşulu kapatır: deductible = 0 muafiyet yok, limit = Inf (R’de sonsuz) limit yok, coinsurance = 1 kesinti yok demektir. Üçü de yazılmazsa policy_payment(x) kaybın kendisini döndürür. stopifnot() geçersiz girdide işlevi durdurur: koasürans yüzde olarak, 80, yazılırsa çağrı “coinsurance <= 1 is not TRUE” hatasıyla durur; denetim olmasaydı 30.000 TL’lik kayıp 8.000 yerine 800.000 TL ödeme verirdi.

Bu küçük ve öğretici policy_payment() fonksiyonunu derste siz yazacaksınız; yukarıdaki sürüm, kendi yazdığınızı karşılaştırmanız içindir. Dağılım altyapısını ve güvenilir rastgele sayı üretimini ise yeniden yazmıyoruz: onlar paketten gelir.

Sınır testleri

Önce üç parçanın her birinden bir kaybı tek tek sınıyor, sonra sonuçlarını adlandırılmış bir vektörde topluyoruz:

Kodu göster / gizle
stopifnot(policy_payment(500, 1000, 10000, 0.8) == 0)
stopifnot(policy_payment(1500, 1000, 10000, 0.8) == 400)
stopifnot(policy_payment(30000, 1000, 10000, 0.8) == 8000)

sinir_testleri <- c(
  muafiyet_alti = policy_payment(500, 1000, 10000, 0.8),
  ara = policy_payment(1500, 1000, 10000, 0.8),
  limit_ustu = policy_payment(30000, 1000, 10000, 0.8)
)
sinir_testleri
#> muafiyet_alti           ara    limit_ustu 
#>             0           400          8000

Vektörün üç öğesi sırasıyla muafiyet altı, muafiyet–limit arası ve limit üstü kaybın ödemesidir.

Bloğun ilk üç satırındaki == karşılaştırması tutar, çünkü \(0{,}8\times500\) ve \(0{,}8\times10.000\) bilgisayarda tam 400 ve 8.000’e yuvarlanır. Her çarpım böyle değildir: koasürans 0,70 ve kayıp 1.700 TL iken ödeme ekranda 490 görünür, ama saklanan değer 489,99999999999994’tür ve == 490 FALSE verir; Hafta 1’deki 0.1 + 0.2 == 0.3 örneğiyle aynı durum. Aşağıdaki karşılaştırma bu yüzden all.equal() kullanır.

Aynı üç değeri şimdi tek bir karşılaştırmada beklenen değerlerle, Hafta 1’deki isTRUE(all.equal(...)) ve stopifnot() kalıbıyla sınıyoruz; sinir_kontrol bu karşılaştırmanın bayrağıdır:

Kodu göster / gizle
sinir_kontrol <- isTRUE(all.equal(unname(sinir_testleri), c(0, 400, 8000)))
stopifnot(sinir_kontrol)
list(sonuclar = sinir_testleri, uyumlu = sinir_kontrol)
#> $sonuclar
#> muafiyet_alti           ara    limit_ustu 
#>             0           400          8000 
#> 
#> $uyumlu
#> [1] TRUE

Bu testler muafiyet altı, muafiyet–limit arası ve limit üstü üç parçayı kapsar; uyumlu değerinin TRUE çıkması üçünün de beklenen 0, 400 ve 8.000 TL’yi verdiğini doğrular.

Parçaların birleştiği 1.000 ve 11.000 TL’yi ayrıca sınamıyoruz: orada komşu iki parça aynı ödemeyi verir (Kayıptan ödemeye), yani bu iki nokta yeni bir durum oluşturmaz.

Ödeme eğrisi

Sınır testleri ödemeyi üç kayıpta sınadı. Bütün kayıplar boyunca nasıl değiştiğini görmek için ödemeyi kayba karşı çiziyoruz.

Ödemenin kayıpla nasıl değiştiğini çizmek için önce bir kayıp ızgarası kuruyoruz; kayip_izgara grafiğin yatay eksenindeki noktaların kendisidir:

Kodu göster / gizle
kayip_izgara <- seq(0, 15000, by = 25)
head(kayip_izgara)
#> [1]   0  25  50  75 100 125
  • seq(0, 15000, by = 25) — 0’dan 15.000’e 25 TL’lik adımlarla ilerler. Ödeme parçalı doğrusal olduğu için çizginin doğru çıkması adımın küçüklüğüne değil, kırılma noktalarının, 1.000 ve 11.000’in, ızgarada bulunmasına bağlıdır; 25 ikisini de tam böler.

Şimdi çizim tablosunu kuruyoruz. transfer_veri aynı ızgarayı iki kez taşır: bir kez sigortacı ödemesi, bir kez de referans olarak ham kayıp tutarı olarak.

Kodu göster / gizle
transfer_veri <- data.frame(
  kayip = rep(kayip_izgara, 2),
  seri = factor(
    rep(c("Sigortacı ödemesi", "Kayıp tutarı (referans)"),
        each = length(kayip_izgara)),
    levels = c("Sigortacı ödemesi", "Kayıp tutarı (referans)")
  ),
  tutar = c(policy_payment(kayip_izgara, d, L, c), kayip_izgara)
)
head(transfer_veri)
#>   kayip              seri tutar
#> 1     0 Sigortacı ödemesi     0
#> 2    25 Sigortacı ödemesi     0
#> 3    50 Sigortacı ödemesi     0
#> 4    75 Sigortacı ödemesi     0
#> 5   100 Sigortacı ödemesi     0
#> 6   125 Sigortacı ödemesi     0

rep() ile factor(..., levels = ...)’i Hafta 3’ün çizim tablosunda görmüştük: ızgara iki seri için uç uca iki kez yazılır, seri adları da renk eşlemesinin ve göstergenin sırasını belirleyen sabit bir sıraya bağlanır.

Çizim bloğu yalnızca bu tabloyu okur:

Kodu göster / gizle
ggplot(transfer_veri,
       aes(x = kayip, y = tutar, colour = seri, linetype = seri)) +
  geom_vline(xintercept = c(d, d + L), colour = "#2E75B6",
             linetype = "dotted", linewidth = 0.5) +
  geom_line(linewidth = 1) +
  scale_colour_manual(
    values = c("Sigortacı ödemesi" = "#1F4E79",
               "Kayıp tutarı (referans)" = "#C8A45C")
  ) +
  scale_linetype_manual(
    values = c("Sigortacı ödemesi" = "solid",
               "Kayıp tutarı (referans)" = "dashed")
  ) +
  scale_x_continuous(
    breaks = c(0, d, 5000, d + L, 15000),
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  scale_y_continuous(
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  labs(x = "Ham kayıp tutarı X (TL)", y = "Tutar (TL)",
       colour = NULL, linetype = NULL) +
  theme_minimal(base_size = 12) +
  theme(legend.position = "bottom")

Lacivert düz çizgi 1.000 TL'ye kadar sıfırda yataydır, sonra 0,80 sabit eğimle yükselir, 11.000 TL'lik kayıpta 8.000 TL'ye ulaşır ve sağa doğru yatay kalır. Altın kesikli y = x referans çizgisi her yerde üstte kalır; iki çizgi arasındaki dikey açıklık sigortalının kendi ödediği tutardır ve kayıp büyüdükçe genişler.

Muafiyet, koasürans ve limit birlikte kaybı ödemeye çevirir: ödeme 1.000 TL’ye kadar sıfır, 11.000 TL’ye kadar kaybın 1.000 TL’yi aşan kısmının %80’i, sonrasında sabit 8.000 TL’dir.

Eğrinin eğimi, kayıp 1 TL arttığında ödemenin ne kadar arttığıdır: muafiyetin altında 0, iki sınır arasında \(c=0{,}80\), limitin üstünde yine 0. Kesikli çizgiyle aradaki dikey açıklık sigortalının kendi ödediği \(X-Y\)’dir ve hiç daralmaz, çünkü her ek liranın muafiyet altında ve limit üstünde tamamını, arada %20’sini sigortalı öder. 15.000 TL’lik kayıpta açıklık \(15.000-8.000=7.000\) TL’dir.

Bu grafik iki aşamada kurulur; ikinci aşamanın eklediği tek şey iki kılavuz çizgidir, ama okumayı değiştiren de odur.

Aşama 1 — iki seri. Sigortacı ödemesi ile referans olarak ham kayıp tutarı:

Kodu göster / gizle
ggplot(transfer_veri,
       aes(x = kayip, y = tutar, colour = seri, linetype = seri)) +
  geom_line(linewidth = 1) +
  scale_colour_manual(
    values = c("Sigortacı ödemesi" = "#1F4E79",
               "Kayıp tutarı (referans)" = "#C8A45C")
  ) +
  scale_linetype_manual(
    values = c("Sigortacı ödemesi" = "solid",
               "Kayıp tutarı (referans)" = "dashed")
  ) +
  scale_x_continuous(
    breaks = c(0, d, 5000, d + L, 15000),
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  scale_y_continuous(
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  labs(x = "Ham kayıp tutarı X (TL)", y = "Tutar (TL)",
       colour = NULL, linetype = NULL) +
  theme_minimal(base_size = 12) +
  theme(legend.position = "bottom")

Lacivert düz çizgi 1.000 TL'ye kadar sıfırda yataydır, sonra sabit eğimle yükselir, 11.000 TL'de 8.000 TL'ye ulaşır ve sağa doğru yatay kalır. Altın kesikli y = x referans çizgisi her yerde onun üzerindedir. Yatay eksende 1.000 ve 11.000 işaretleri ve bunların açık gri ızgara çizgileri vardır; kırılmaları öne çıkaran ayrı bir çizgi yoktur.

Ödeme eğrisi ile y = x kayıp referansı; kırılmaların tam olarak nerede olduğu eksenden okunmak zorundadır.

Bu aşamanın argümanları:

  • linewidth = 1 — iki serinin de çizgi kalınlığı.
  • colour ve linetype aynı sütuna (seri) bağlanır: renk ve çizgi tipi birlikte değişir, böylece grafik siyah beyaz basıldığında da okunur.
  • breaks = c(0, d, 5000, d + L, 15000) — eksende işaret konacak değerler. İkisi seçilmiş sayı değil, modelin kendi eşikleridir: muafiyet d ve muafiyet artı limit d + L. Verilmezse: ggplot2 düzgün aralıklı yuvarlak sayılar seçer ve tam da kırılmaların olduğu yerde işaret bulunmaz.
  • scale_colour_manual() ile scale_linetype_manual() — iki serinin rengini ve çizgi tipini adla eşler: ödeme lacivert ve düz, kayıp referansı altın ve kesikli.
  • labels = label_number(...) sayıları Türkçe biçime, base_size = 12 bütün yazıları birden ayarlar.
  • theme(legend.position = "bottom") — theme() temanın tek tek öğelerini değiştirir; burada göstergeyi grafiğin altına alır.

Aşama 2 — kırılma noktalarını işaretleme. Tek eklenen katman geom_vline()’dır. Bu aşama yukarıdaki asıl bloğun tamamıdır.

Kodu göster / gizle
ggplot(transfer_veri,
       aes(x = kayip, y = tutar, colour = seri, linetype = seri)) +
  geom_vline(xintercept = c(d, d + L), colour = "#2E75B6",
             linetype = "dotted", linewidth = 0.5) +
  geom_line(linewidth = 1) +
  scale_colour_manual(
    values = c("Sigortacı ödemesi" = "#1F4E79",
               "Kayıp tutarı (referans)" = "#C8A45C")
  ) +
  scale_linetype_manual(
    values = c("Sigortacı ödemesi" = "solid",
               "Kayıp tutarı (referans)" = "dashed")
  ) +
  scale_x_continuous(
    breaks = c(0, d, 5000, d + L, 15000),
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  scale_y_continuous(
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  labs(x = "Ham kayıp tutarı X (TL)", y = "Tutar (TL)",
       colour = NULL, linetype = NULL) +
  theme_minimal(base_size = 12) +
  theme(legend.position = "bottom")

Önceki grafiğe iki mavi noktalı dikey çizgi eklenmiştir. Birincisi ödemenin sıfırdan ayrıldığı kayıp değerinde, ikincisi ödemenin sabitlendiği kayıp değerinde durur; böylece eğimin değiştiği iki nokta açık gri ızgaranın içinde ayırt edilir hâle gelir.

Aynı grafiğe muafiyet ve muafiyet artı limit değerlerinde iki noktalı dikey çizgi eklenir; asıl bloğun tamamı budur.
  • xintercept = c(d, d + L) — çizgilerin yeri veriden değil, sözleşmenin parametrelerinden gelir. Bu yüzden d ya da L değiştiğinde grafik kendiliğinden doğru kalır.
  • linewidth = 0.5 ve linetype = "dotted" — kılavuz çizgiler bilerek ince ve noktalıdır: bir sonuç değil, bir referans gösterirler.
  • colour = "#2E75B6" — çelik mavisi, iki serinin renklerinden de ayrıdır, böylece göstergeyle karışmaz.

İki aşamayı karşılaştırınca görülen şey şudur: eğri her iki aşamada da aynıdır, değişen yalnızca nereye bakacağınızın söylenmiş olmasıdır. Bir grafiğin okunabilirliği çoğu zaman veriden değil, bu tür kılavuzlardan gelir.

3 Sınırlı beklenen değer

Kayıptan ödemeye bölümündeki ödeme formülü tek bir kayıpta ödenen tutarı verir: kayıp gerçekleşmiştir, \(X\) bir sayıdır ve \(Y\) o kayba özgüdür. Küçük çalışılmış örnekte 12.000 TL’lik kayıpta ödeme 8.000 TL, 1.500 TL’lik kayıpta 400 TL’dir. Prim ise kayıp gerçekleşmeden belirlenir; bunun için olası bütün kayıplar üzerinden ortalama ödeme, yani beklenen ödeme \(E[Y]\) gerekir. Bu bölümden başlayarak \(X\), bir dağılımı olan rastgele bir değişkendir ve \(E[Y]\) tek bir sayıdır: kayıptan kayba değişmez.

Beklenen ödemeyi ödeme formülünün en sade hâlinden kuruyoruz. Formülde muafiyeti kaldırır (\(d=0\)), koasüransı kaldırır (\(c=1\)) ve limite \(u\) dersek, \(X\ge0\) olduğu için \((X-0)_+=X\) olur ve ödeme

\[ \begin{aligned} Y&=1\cdot\min\{(X-0)_+,u\}\\ &=\min(X,u) \end{aligned} \]

olur: kayıp \(u\)’da kesilir, \(u\)’dan büyük her kayıp \(u\) sayılır. Bu kesilmiş kaybın beklenen değerine sınırlı beklenen değer (limited expected value, LEV) denir. Muafiyetsiz, koasüranssız ve yalnız \(u\) limitli bir poliçenin beklenen ödemesi budur:

\[ \begin{aligned} LEV_X(u)&=E[\min(X,u)]\\ &=\int_0^u P(X>x)\,dx. \end{aligned} \]

Gösterimi okurken iki parçayı ayırmak gerekir. Alt simgedeki \(X\), beklenen değeri alınan rastgele kayıptır; parantezdeki \(u\) ise kaybın kesildiği sabit üst sınırdır. Bu yüzden \(LEV_X(11.000)\) «11.000’in beklenen değeri» değildir; öyle olsaydı 11.000 olurdu. Kaybın 11.000’de kesilmiş hâlinin, \(\min(X,\,11.000)\)’in beklenen değeridir. \(\min(X,\,11.000)\) hiçbir zaman 11.000’i aşmadığı ve kayıp 11.000’in altında kaldığında ondan küçük olduğu için bu değer 11.000’den küçüktür.

İntegral, negatif olmayan her kayıp için geçerli olan \(E[X]=\int_0^\infty S(t)\,dt\) formülünün \(\min(X,u)\)’ya uygulanmasıdır. Formülü Hafta 3’te Pareto II’nin ortalamasını bulurken türettik, ama hiçbir dağılıma özgü değildir: \(LEV\) her kayıp dağılımında aynı integraldir, dağılım yalnızca integralin içindeki \(P(X>x)\)’i belirler. Üst sınır \(u\)’dur, çünkü \(\min(X,u)\) hiçbir zaman \(u\)’yu aşmaz: \(u\)’dan sonra aşma olasılığı sıfırdır.

\[ \begin{aligned} &LEV_X(u)\\ &=E[\min(X,u)]\\ &=\int_0^\infty P(\min(X,u)>x)\,dx\\ &=\int_0^u P(\min(X,u)>x)\,dx\\ &\quad+\int_u^\infty P(\min(X,u)>x)\,dx\\ &=\int_0^u P(X>x)\,dx+0. \end{aligned} \]

Eşitlikler sırasıyla:

  1. tanım;
  2. Hafta 3’teki formül, \(X\) yerine \(\min(X,u)\) ile;
  3. integral \(u\)’da ikiye bölündü;
  4. \(x<u\) iken \(\min(X,u)>x\) ancak \(X>x\) ise olur; \(x\ge u\) iken \(\min(X,u)\le u\le x\) olduğu için olanaksızdır.

\(LEV\)’deki \(u\) ile ödeme formülündeki \(L\) aynı şey değildir. \(u\) kaybın kendisine konan üst sınırdır; \(L\) ise muafiyetten sonra kalan tutara konur. \(d=0\) iken ikisi çakışır. Muafiyet varken \(L\)’nin kayıp ölçeğindeki karşılığı \(u=d+L\)’dir: ödeme, kayıp \(d+L\)’ye ulaşınca durur. Uyarı kutusundaki iki “limit” okumasının farkı da budur.

\(LEV\)’e ayrı bir ad verilmesinin nedeni, gerçek poliçenin, yani muafiyetli, limitli ve koasüranslı poliçenin beklenen ödemesinin iki \(LEV\)’in farkıyla yazılabilmesidir. Pareto gibi dağılımlarda \(LEV\) kapalı bir formülle ya da bir paket işleviyle doğrudan hesaplanır; böylece her poliçe için yeni bir integral almak gerekmez.

Koasüransı bir yana bırakıp limit sonrası tutara \(W=\min\{(X-d)_+,L\}\) diyelim; \(Y=cW\)’dir. \(W\)’nin beklentisi iki \(LEV\) farkıdır, çünkü her \(x\ge0\) için şu özdeşlik geçer:

\[ \begin{aligned} &\min\{(x-d)_+,L\}\\ &\quad=\min(x,d+L)-\min(x,d). \end{aligned} \]

Sağ taraf, kaybın \(d\) ile \(d+L\) arasına düşen parçasıdır; poliçenin hesaba kattığı da bu parçadır.

Kaybın üç durumunda iki tarafı ayrı ayrı hesaplıyoruz:

Durum Sol taraf Sağ taraf
\(x\le d\) \(0\) \(x-x=0\)
\(d<x<d+L\) \(x-d\) \(x-d\)
\(x\ge d+L\) \(L\) \((d+L)-d=L\)

Üç satırda da iki taraf aynıdır; özdeşlik bu yüzden her kayıpta geçer.

Özdeşlik her kayıpta geçtiği için beklentide de geçer; \(Y=cW\) olduğundan:

\[ \begin{aligned} E[Y]&=c\bigl(LEV_X(d+L)-LEV_X(d)\bigr)\\ &=c\int_d^{d+L}P(X>x)\,dx. \end{aligned} \]

Beklenen ödeme, aşma olasılığı eğrisinin \(d\) ile \(d+L\) arasındaki alanının \(c\) katıdır. Bu aralıktaki her lira ancak kayıp onu aşarsa ödenir ve bunun olasılığı \(P(X>x)\)’tir.

\(Y=cW\) ve \(c\) sabit olduğu için \(E[Y]=c\,E[W]\)’dir. \(E[W]\):

\[ \begin{aligned} &E[W]\\ &=E[\min(X,d+L)-\min(X,d)]\\ &=E[\min(X,d+L)]-E[\min(X,d)]\\ &=LEV_X(d+L)-LEV_X(d)\\ &=\int_0^{d+L}P(X>x)\,dx\\ &\quad-\int_0^{d}P(X>x)\,dx\\ &=\int_d^{d+L}P(X>x)\,dx. \end{aligned} \]

Eşitlikler sırasıyla:

  1. \(W\) yerine özdeşliğin sağ tarafı;
  2. farkın beklentisi beklentilerin farkıdır;
  3. \(LEV\)’in tanımı, \(u=d+L\) ve \(u=d\) ile;
  4. her \(LEV\) yerine integrali yazıldı;
  5. iki integralin ortak \([0,d]\) parçası sadeleşti.

Bu fark, uyarı kutusundaki birinci okumayla, yani muafiyet sonrası ödeme limitiyle kurulmuştur: ödeme \(d\)’de başlar ve \(d+L\)’de durur. Limit toplam kayıp limiti \(u\) olarak okunsaydı özdeşlik \(d+L\) yerine \(u\) ile kurulur ve \(E[Y]=c\bigl(LEV_X(u)-LEV_X(d)\bigr)\) verirdi.

Özdeşliği küçük çalışılmış örneğin beş kaybında elle görelim. Her kayıp için iki kesilmiş tutarı yazıyoruz: kaybın \(d+L=11.000\)’de kesilmiş hâli \(\min(X,\,11.000)\) ve \(d=1.000\)’de kesilmiş hâli \(\min(X,\,1.000)\). Sonra ikisinin farkını alıp ödeme formülündeki limit sonrası tutarla, \(W=\min\{(X-d)_+,L\}\) ile karşılaştırıyoruz. Başlıklardaki adlar, aşağıdaki kodun aynı sütunlara verdiği adlardır.

Kayıp \(X\) ust
\(\min(X,\,11.000)\)
alt
\(\min(X,\,1.000)\)
fark limit_sonrasi
\(W\)
500 500 500 0 0
1.500 1.500 1.000 500 500
5.000 5.000 1.000 4.000 4.000
12.000 11.000 1.000 10.000 10.000
30.000 11.000 1.000 10.000 10.000

Satırlar özdeşliğin üç durumunu gösterir. 500 TL’lik kayıp muafiyetin altındadır: iki kesme de kaybın kendisini verir ve fark sıfırdır. 1.500 ve 5.000 TL’lik kayıplar iki sınırın arasındadır: üst kesme kaybı, alt kesme muafiyeti verir ve fark \(X-d\)’dir. 12.000 ve 30.000 TL’lik kayıplar limitin üstündedir: fark \(11.000-1.000=10.000\), yani \(L\)’dir. Her satırda fark son sütuna eşittir.

Aynı tabloyu kodla kuralım. lev_ozdeslik bu beş sütunu taşır:

Kodu göster / gizle
lev_ozdeslik <- data.frame(
  kayip = x,
  ust = pmin(x, d + L),
  alt = pmin(x, d),
  fark = pmin(x, d + L) - pmin(x, d),
  limit_sonrasi = limit_sonrasi
)
lev_ozdeslik
#>   kayip   ust  alt  fark limit_sonrasi
#> 1   500   500  500     0             0
#> 2  1500  1500 1000   500           500
#> 3  5000  5000 1000  4000          4000
#> 4 12000 11000 1000 10000         10000
#> 5 30000 11000 1000 10000         10000

Çıktı yukarıdaki elle kurduğumuz tablonun aynısıdır: ust sütunu \(\min(x,d+L)\), alt sütunu \(\min(x,d)\) ve fark her satırda limit_sonrasi’na eşittir.

Tablonun her satırı tek bir kayıptır ve ödeme formülü her satıra ayrı bir tutar verir. Beklenen değer ise satırların değil sütunların özetidir. Beş kaybı her biri 1/5 olasılıklı bir dağılım sayarsak bir sütunun beklenen değeri o sütunun ortalamasıdır:

Kodu göster / gizle
lev_ortalamalari <- colMeans(lev_ozdeslik)
lev_ortalamalari
#>         kayip           ust           alt          fark limit_sonrasi 
#>          9800          5800           900          4900          4900
  • colMeans(lev_ozdeslik) — tablonun her sütununun ortalamasını alır ve sütun adlarını taşıyan bir vektör döndürür.

ust sütunu \(\min(x,\,11.000)\)’dir: beş tutarın toplamı 29.000 TL, ortalaması 5.800 TL. Beş kayıp eşit olasılıklı olduğu için bu ortalama, kaybın 11.000’de kesilmiş hâlinin beklenen değeridir: \(LEV_X(11.000)\) \(=E[\min(X,\,11.000)]\) \(=5.800\) TL.

alt sütunu \(\min(x,\,1.000)\)’dir: toplamı 4.500 TL, ortalaması \(LEV_X(1.000)\) \(=E[\min(X,\,1.000)]\) \(=900\) TL. fark ile limit_sonrasi sütunlarının ortalaması ikisinin farkıdır: 4.900 TL.

Koasürans bu farkı \(c=0{,}80\) ile çarpar: \(0{,}80\times4.900=3.920\) TL. Bu, beş kayıplık dağılımın beklenen ödemesidir; y’nin beş değerinin ortalaması da aynıdır, \((0+400+3.200+8.000+8.000)/5\) \(=3.920\). Tek tek kayıpların ödemeleri 0 ile 8.000 TL arasında değişir; beklenen ödeme ise tek bir sayıdır.

Ödemenin ikinci momenti. Beklenen ödeme, ödemelerin ortalamasıdır; ödemelerin bu ortalamanın çevresinde ne kadar dağıldığını söylemez. Beş kayıplık örnekte beklenen ödeme 3.920 TL’dir, ama tek tek ödemeler 0 ile 8.000 TL arasında değişir. Bu dağılmayı varyans ölçer ve varyansı ödemenin ikinci momenti \(E[Y^2]\) verir:

\[ \operatorname{Var}(Y)=E[Y^2]-(E[Y])^2. \]

İkinci moment ileride iki yerde gerekecek. Bileşik toplam hasar bölümünde bir yıldaki bütün ödemelerin toplamının varyansını, Basit prim prensipleri bölümünde de bu varyansa dayanan standart sapma primini kuracağız; ikisi de \(E[Y^2]\)’yi kullanır. \(E[Y]\)’yi iki \(LEV\)’den kurduğumuz gibi, \(E[Y^2]\)’yi de aynı özdeşlikle kesilmiş kayıpların ikinci momentlerinden kurarız:

\[ \begin{aligned} E[Y^2]=c^2\Bigl[&E[\min(X,d+L)^2]-E[\min(X,d)^2]\\ &{}-2d\bigl(LEV_X(d+L)-LEV_X(d)\bigr)\Bigr]. \end{aligned} \]

Köşeli parantezin ilk iki terimi, \(E[Y]\)’deki iki \(LEV\)’in ikinci moment karşılığıdır. Son terim, ödeme sıfırdan değil \(d\)’den başladığı için gelir: kesilmiş kayıpların farkı \(W\)’yi verir, ama karelerinin farkı \(W^2\)’yi vermez. Kayıp muafiyeti aştığında \(\min(X,d+L)=d+W\) olduğu için \((d+W)^2-d^2=W^2+2dW\)’dir; fazladan \(2dW\)’yi \(-2d\,E[W]\) terimi geri çıkarır.

Kayıp muafiyeti aşıyorsa \(\min(X,d)=d\) ve özdeşlik \(\min(X,d+L)=d+W\) verir:

\[ \begin{aligned} &\min(X,d+L)^2-\min(X,d)^2\\ &=(d+W)^2-d^2\\ &=d^2+2dW+W^2-d^2\\ &=W^2+2dW. \end{aligned} \]

\(X\le d\) iken \(W=0\) ve iki minimum da \(X\)’tir; iki taraf sıfırdır. Eşitlik her kayıpta geçtiği için \(W^2\) yalnız bırakılıp beklenti alınır ve \(Y^2=c^2W^2\) olduğu için \(c^2\) ile çarpılır:

\[ \begin{aligned} E[Y^2]&=c^2E[W^2]\\ &=c^2\Bigl(E[\min(X,d+L)^2]\\ &\quad-E[\min(X,d)^2]\\ &\quad-2d\,E[W]\Bigr). \end{aligned} \]

\(E[W]\) yerine iki \(LEV\)’in farkı yazılınca yukarıdaki formül çıkar.

Formülü beş kayıplık dağılımda terim terim uygulayalım. Köşeli parantezin ilk iki terimi kesilmiş kayıpların karelerinin ortalamasıdır, bu yüzden lev_ozdeslik’in ust ve alt sütunlarının karelerini alıyoruz. Son sütun karşılaştırma içindir: limit_sonrasi, yani \(W\); karesinin ortalaması köşeli parantezin vermesi gereken sayıdır.

Kayıp \(X\) ust\(^2\) alt\(^2\) limit_sonrasi\(^2\)
500 250.000 250.000 0
1.500 2.250.000 1.000.000 250.000
5.000 25.000.000 1.000.000 16.000.000
12.000 121.000.000 1.000.000 100.000.000
30.000 121.000.000 1.000.000 100.000.000
ortalama 53.900.000 850.000 43.250.000

Böylece \(E[\min(X,\,11.000)^2]=53.900.000\) ve \(E[\min(X,\,1.000)^2]=850.000\)’dir. Üçüncü terim \(2d\) ile iki \(LEV\)’in farkının çarpımıdır: \(2\times1.000\times(5.800-900)\) \(=9.800.000\). Köşeli parantezin içi:

\[ \begin{aligned} &53.900.000-850.000-9.800.000\\ &=43.250.000. \end{aligned} \]

Sonuç, 43.250.000, tablonun son sütununun ortalamasıyla aynıdır: köşeli parantez \(W\)’nin ikinci momentini, \(E[W^2]\)’yi verir. Son terim unutulsaydı \(53.900.000-850.000=53.050.000\) çıkardı; fazlalık tam olarak \(2d\,E[W]=9.800.000\)’dir.

Ödemenin ikinci momenti bunun \(c^2\) katıdır: \(E[Y^2]=0{,}64\times43.250.000\) \(=27.680.000\). Varyans \(\operatorname{Var}(Y)=27.680.000-3.920^2\) \(=12.313.600\), standart sapma yaklaşık 3.509 TL’dir: beş kayıplık dağılımda ödemenin oynaklığı neredeyse ortalaması kadar büyüktür.

Formüldeki \(E[\min(X,u)^2]\) sınırlı beklenen değerin ikinci moment karşılığıdır: Hafta 3’teki \(E[X^2]=\int_0^\infty 2t\,S(t)\,dt\) formülü \(\min(X,u)\)’ya uygulanınca \(\int_0^u 2t\,P(X>t)\,dt\) olur. Pareto için onu da actuar hesaplar; Pareto kayıplarında beklenen ödeme bölümü formülü Pareto poliçesine uygular.

4 Pareto kayıplarında beklenen ödeme: açık formül ve paket kontrolü

Sınırlı beklenen değer bölümü beklenen ödemenin genel tarifini verdi: \(E[Y]=c\bigl(LEV_X(d+L)-LEV_X(d)\bigr)\). Tarif her kayıp dağılımında geçerlidir, ama bir sayı vermesi için kaybın aşma olasılığı \(P(X>x)\) bilinmelidir. Orada tarifi yalnızca beş eşit olasılıklı kayıpla sınadık ve beklenen ödeme 3.920 TL çıktı. Bu bölümde kayıplar gerçekçi bir dağılımdan gelir; poliçe ise küçük çalışılmış örnekteki poliçenin aynısıdır: \(d=1.000\), \(L=10.000\), \(c=0{,}80\).

Kayıp dağılımı, Hafta 3’ün Sıfır başlangıçlı Pareto / Pareto II bölümündeki dağılımdır: hasar büyüklüğü için orada aday olan, uzun kuyruklu bir dağılım. actuar paketi onu dpareto() adıyla verir. Aşma olasılığını, yoğunluğunu ve ortalamasını orada türettik:

\[ P(X>x)=\left(\frac{\theta}{\theta+x}\right)^\alpha. \]

Neden Pareto? Beklenen ödemenin tarifi dağılıma bağlı değildir; lognormal ya da Gamma kayıplarla da aynen işler. Pareto II’yi üç nedenle seçiyoruz:

  • \(LEV\)’i elle alınır. Aşma olasılığı basit bir kuvvettir, integrali de düz cebirdir; aşağıdaki kapalı formül bu yüzden elle izlenebilir. Lognormalin \(LEV\)’i standart normal dağılım fonksiyonunu, Gamma’nınki eksik gamma fonksiyonunu içerir: actuar ikisini de hesaplar, ama elle izlenemezler.
  • Hafta 3’ten tanıdığımız dağılımdır. Danish verisinde üç aday da kuyruğu küçük tahmin etmişti; en yakın kalan Pareto II’ydi (Hafta 3’ün Kuyruk: Q–Q grafiği ve yüksek kuantiller bölümü).
  • Kuvvet kuyruğu öbür ikisinin gösteremediği bir durumu gösterir. Pareto II’nin momentleri yalnız \(\alpha\)’dan küçük derecelerde vardır, yani ortalaması bile sonsuz olabilir (aşağıdaki \(\alpha=0{,}5\) örneği). Lognormal ve Gamma’nın bütün momentleri sonludur.

Seçimin sonucu ne kadar değiştirdiğini bölümün sonunda, Başka bir kayıp dağılımı seçilseydi alt bölümünde ölçeceğiz.

Burada gereken sınırlı beklenen değerdir. Bu aşma olasılığı Sınırlı beklenen değer bölümündeki integrale konur. İntegral, Hafta 3’te ortalamayı veren integralle aynı yoldan alınır; yalnız üst sınır \(\infty\) değil \(u\)’dur:

\[ \begin{aligned} &LEV_X(u)\\ &=\frac{\theta}{\alpha-1}\left[1-\left(\frac{\theta}{\theta+u}\right)^{\alpha-1}\right]. \end{aligned} \]

\[ \begin{aligned} &LEV_X(u)\\ &=\int_0^u\theta^{\alpha}(\theta+x)^{-\alpha}\,dx\\ &=\theta^{\alpha}\left[\frac{(\theta+x)^{1-\alpha}}{1-\alpha}\right]_0^u\\ &=\theta^{\alpha}\,\frac{(\theta+u)^{1-\alpha}-\theta^{1-\alpha}}{1-\alpha}\\ &=\frac{\theta^{\alpha}}{\alpha-1}\Bigl[\theta^{1-\alpha}-(\theta+u)^{1-\alpha}\Bigr]\\ &=\frac{\theta^{\alpha}\,\theta^{1-\alpha}}{\alpha-1} \Bigl[1-\Bigl(\frac{\theta+u}{\theta}\Bigr)^{1-\alpha}\Bigr]\\ &=\frac{\theta}{\alpha-1} \Bigl[1-\Bigl(\frac{\theta+u}{\theta}\Bigr)^{1-\alpha}\Bigr]\\ &=\frac{\theta}{\alpha-1} \Bigl[1-\Bigl(\frac{\theta}{\theta+u}\Bigr)^{\alpha-1}\Bigr]. \end{aligned} \]

Eşitlikler sırasıyla:

  1. aşma olasılığı \(\theta^{\alpha}(\theta+x)^{-\alpha}\) biçiminde kondu;
  2. \(\theta^{\alpha}\) dışarı alındı ve ilkel kuvvet kuralıyla yazıldı (\(1-\alpha\)’ya bölmek \(\alpha\ne1\) ister);
  3. sınırlar konup fark alındı;
  4. pay ve payda \(-1\) ile çarpıldı;
  5. köşeli parantezden \(\theta^{1-\alpha}\) ortak çarpan olarak çıktı;
  6. üsler toplandı: \(\theta^{\alpha}\,\theta^{1-\alpha}=\theta\);
  7. taban ters çevrildi, üssün işareti değişti: \(\bigl((\theta+u)/\theta\bigr)^{1-\alpha}=\bigl(\theta/(\theta+u)\bigr)^{\alpha-1}\).

\(\alpha>1\) ise köşeli parantezdeki \(\bigl(\theta/(\theta+u)\bigr)^{\alpha-1}\), tabanı 1’den küçük ve üssü pozitif olduğu için \(u\) büyüdükçe sıfıra gider ve \(LEV_X(u)\) Hafta 3’teki \(E[X]=\theta/(\alpha-1)\)’e yaklaşır; her kayıpta \(\min(X,u)\le X\) olduğu için onu hiçbir \(u\)’da aşmaz. Sonlu bir \(u\)’da ise integral her \(\alpha\) için sonludur ve formül \(\alpha\ne1\) olduğu sürece geçerlidir (\(\alpha=1\)’de payda sıfırdır; actuar::levpareto() orada NaN döndürür).

Elle. Parametreleri öğretim için \(\alpha=2{,}8\) ve \(\theta=6.000\) seçiyoruz. \(\theta/(\alpha-1)=6.000/1{,}8=3.333{,}33\)’tür. \(\theta/(\theta+u)\) oranı \(u=1.000\)’de \(6.000/7.000=6/7\), \(u=11.000\)’de \(6.000/17.000=6/17\)’dir; \((6/7)^{1{,}8}=0{,}757697\) ve \((6/17)^{1{,}8}=0{,}153414\) olduğundan

\[ \begin{aligned} LEV_X(1.000)&=3.333{,}33\,(1-0{,}757697)=807{,}68,\\ LEV_X(11.000)&=3.333{,}33\,(1-0{,}153414)=2.821{,}95, \end{aligned} \]

\[ E[Y]=0{,}80\,(2.821{,}95-807{,}68)=0{,}80\times 2.014{,}27=1.611{,}42\ \text{TL}. \]

Aynı poliçe beş kayıplık dağılımda 3.920 TL bekliyordu. Fark poliçeden değil, kayıp dağılımından gelir, ve iki yönden. Birincisi kayıpların büyüklüğüdür: beş kaybın ortalaması 9.800 TL, bu Pareto dağılımınınki 3.333,33 TL’dir.

İkincisi muafiyetin altında kalan, yani hiç ödeme doğurmayan kayıpların payıdır. Pareto’da bu pay aşma olasılığının tümleyenidir: \(P(X\le1.000)=1-(6/7)^{2{,}8}\) \(=1-0{,}649455\) \(=0{,}350545\); kayıpların yaklaşık %35’i 1.000 TL’nin altında kalır. Beş kayıplık dağılımda muafiyetin altında kalan tek kayıp 500 TL’liktir, yani bu pay 1/5, %20’dir.

Bu formülü kodlayalım.

Kodu göster / gizle
limited_mean_pareto_manual <- function(u, shape, scale) {
  scale / (shape - 1) *
    (1 - (scale / (scale + u))^(shape - 1))
}

limited_mean_pareto_manual(u = c(1000, 6000, 11000), shape = 2.8, scale = 6000)
#> [1]  807.6754 2376.0847 2821.9543

Üç örnek \(u\) değeri için sınırlı beklenen değer sırasıyla yaklaşık 807,68; 2.376,08 ve 2.821,95’tir; \(u\) büyüdükçe artış yavaşlar, çünkü \(LEV_X\)’in eğimi, yani integralin üst sınırına göre türevi, \(P(X>u)\)’dur ve bu olasılık \(u\) büyüdükçe küçülür. Eğri hiçbir zaman \(E[X]=3.333{,}33\)’ü aşmaz.

Şimdi açık formülü paketle karşılaştıralım. Bu bölüm kendi başına okunabilsin diye ders parametrelerini yeniden yazıyoruz; shape Pareto’nun \(\alpha\)’sı, scale ise \(\theta\)’sıdır:

Kodu göster / gizle
shape <- 2.8
scale <- 6000
d <- 1000
L <- 10000
shape
#> [1] 2.8

Koasürans oranı ayrı bir satırda kalır; değeri yukarıdaki bölümdekiyle aynıdır:

Kodu göster / gizle
c <- 0.80
c
#> [1] 0.8

Beklenen ödemeyi önce kendi yazdığımız kapalı formülle hesaplıyoruz:

Kodu göster / gizle
beklenen_acik <- c * (
  limited_mean_pareto_manual(d + L, shape, scale) -
    limited_mean_pareto_manual(d, shape, scale)
)
beklenen_acik
#> [1] 1611.423

Çıktı, iki sınırlı beklenen değerin farkının koasüransla çarpılmış hâlidir ve elle bulduğumuz 1.611,42 TL’yi vermelidir.

Aynı büyüklüğü şimdi paketten alıyoruz. beklenen_paket bağımsız bir hesaplamadır, çünkü kendi yazdığımız limited_mean_pareto_manual() fonksiyonuna hiç dokunmaz:

Kodu göster / gizle
beklenen_paket <- c * (
  actuar::levpareto(d + L, shape = shape, scale = scale) -
    actuar::levpareto(d, shape = shape, scale = scale)
)
beklenen_paket
#> [1] 1611.423
  • actuar::levpareto(u, shape = , scale = ) — sıfır başlangıçlı Pareto dağılımının \(u\) noktasındaki sınırlı beklenen değerini verir; :: yazımı fonksiyonun hangi paketten geldiğini görünür tutar.

İki değeri ayrı bir kod bloğunda karşılaştırıyoruz:

Kodu göster / gizle
lev_kontrol <- isTRUE(all.equal(beklenen_acik, beklenen_paket))
stopifnot(lev_kontrol)
list(sonuclar = c(elle = beklenen_acik, paket = beklenen_paket), uyumlu = lev_kontrol)
#> $sonuclar
#>     elle    paket 
#> 1611.423 1611.423 
#> 
#> $uyumlu
#> [1] TRUE

uyumlu alanının TRUE olması gerekir: kapalı formül ile actuar::levpareto() aynı beklenen ödemeyi verir; biri farklı olsaydı stopifnot() çalıştırmayı burada durdururdu.

Bu eşleşme özellikle önemlidir: Pareto adını kullanan kaynaklar farklı parametreleştirmeler kullanabilir. Bağımsız formül kontrolü, yanlış shape veya scale yorumunu erken yakalar. Alıştırma 9 bunun bedelini ölçer: aynı simgeleri eşik parametreli klasik Pareto olarak okumak beklenen ödemeyi hata vermeden 3,6 katına çıkarır.

Sigorta diliyle: ortalama kaybın \(E[X]=\theta/(\alpha-1)=3.333{,}33\) TL olduğu bu portföyde, verilen poliçe koşulları kayıp başına ortalama 1.611,42 TL’yi, yani beklenen kaybın yaklaşık %48,3’ünü (\(1.611{,}42/3.333{,}33=0{,}483\)) sigortacıya aktarır; kalanı muafiyet, limit üstü kısım ve koasürans payı olarak sigortalı kendisi öder.

Bu 1.611,42 TL kayıp başına (per loss) bir ortalamadır: muafiyetin altında kalıp hiç ödeme doğurmayan kayıplar da sıfır olarak içindedir. Sigortacının dosyasında ise yalnızca ödeme doğuran kayıplar görünür; onların ortalaması ödeme başına (per payment) ortalamadır, \(E[Y\mid X>d]\). İkisini bağlayan, ödemenin \(X\le d\) iken sıfır olmasıdır: \(E[Y]\)’ye yalnızca muafiyeti aşan kayıplar katkı yapar ve onların payı \(P(X>d)\)’dir:

\[ E[Y]=P(X>d)\,E[Y\mid X>d]. \]

Kayıplar muafiyetin altında ve üstünde kalanlar diye iki gruba ayrılır. Hafta 3’ün Fazla sıfır ve uzun kuyruk nereden gelir? bölümündeki gibi beklenen değer, grupların koşullu beklenen değerlerinin paylarla ağırlıklı toplamıdır:

\[ \begin{aligned} &E[Y]\\ &=P(X\le d)\,E[Y\mid X\le d]\\ &\quad+P(X>d)\,E[Y\mid X>d]\\ &=P(X\le d)\cdot0\\ &\quad+P(X>d)\,E[Y\mid X>d]\\ &=P(X>d)\,E[Y\mid X>d]. \end{aligned} \]

İkinci eşitlikte \(X\le d\) iken \(Y=0\) olduğu için o grubun koşullu beklenen değeri sıfırdır.

Ödeme başına ortalama bu yüzden kayıp başına ortalamanın aşma olasılığına bölünmesidir. Ders sayılarıyla \(P(X>1.000)=(6/7)^{2{,}8}\) \(=0{,}649455\) ve \(E[Y\mid X>d]\) \(=1.611{,}42/0{,}649455\) \(\approx2.481{,}19\) TL.

Aynı bölmeyi kodda yapalım. Aşma olasılığını, Hafta 3’teki gibi lower.tail = FALSE ile, actuar::ppareto() verir.

Kodu göster / gizle
odeme_basina_beklenen <- beklenen_paket /
  actuar::ppareto(d, shape = shape, scale = scale, lower.tail = FALSE)
odeme_basina_beklenen
#> [1] 2481.193

Çıktı 2.481,19 TL olmalıdır. Hafta 3’teki Danish dosyası da yalnızca ödeme doğuran hasarları taşıyan böyle bir dosyaydı: 1 mDKK’nın altındaki hasarlar hiç kaydedilmemişti.

Ödemenin ikinci momenti

Yıllık toplam hasarın varyansı ve standart sapma primi ödemenin ikinci momentini ister; ikisini Bileşik toplam hasar ve Basit prim prensipleri bölümleri kuracak. Formülü Sınırlı beklenen değer bölümünde kurduk ve beş kayıplık dağılımda terim terim uyguladık:

\[ \begin{aligned} &E[Y^2]=c^2\Bigl[E[\min(X,d+L)^2]\\ &\quad{}-E[\min(X,d)^2]\\ &\quad{}-2d\bigl(LEV_X(d+L)-LEV_X(d)\bigr)\Bigr]. \end{aligned} \]

Pareto kayıplarında \(E[\min(X,u)^2]\)’yi de actuar::levpareto() verir; tek fark order = 2 argümanıdır. ikinci_moment_kapali formülün değeridir. Yazdırılan vektörün ikinci öğesi, terimsiz, aynı formülün \(-2d\) terimi olmadan verdiği sayıdır; terimin neden gerektiğini beş kayıplık örnekte gördük.

Kodu göster / gizle
ikinci_moment_kapali <- c^2 * (
  actuar::levpareto(d + L, shape = shape, scale = scale, order = 2) -
    actuar::levpareto(d, shape = shape, scale = scale, order = 2) -
    2 * d * (actuar::levpareto(d + L, shape = shape, scale = scale) -
               actuar::levpareto(d, shape = shape, scale = scale))
)
c(kapali = ikinci_moment_kapali,
  terimsiz = c^2 * (actuar::levpareto(d + L, shape = shape, scale = scale, order = 2) -
                      actuar::levpareto(d, shape = shape, scale = scale, order = 2)))
#>   kapali terimsiz 
#>  7832206 10410483

Çıktı yaklaşık 7.832.206 ve 10.410.483 olmalıdır.

  • order = 2 — actuar::levpareto()’nun moment derecesidir: levpareto(u, ..., order = 2) \(E[\min(X,u)^2]\)’yi verir. Verilmezse: order = 1 kullanılır ve fonksiyon sınırlı beklenen değerin kendisini döndürür; formül hata vermeden ikinci moment yerine birinci momentle kurulur.

Terimsiz formül doğru değerden %33 büyüktür. Fazlalık atlanan terimin kendisidir: \(c^2\cdot2d\) ile iki \(LEV\)’in farkının çarpımı. \(c\) ile o farkın çarpımı \(E[Y]\) olduğundan terim \(2dc\,E[Y]\)’dir: \(2\times1.000\times0{,}80\times1.611{,}42\) \(\approx2{,}58\) milyon. Muafiyet yoksa (\(d=0\)) terim sıfırdır ve terimsiz formül doğrudur; hata yalnız muafiyetli poliçede ortaya çıkar.

Ödemenin standart sapması, varyansın tanımı \(\operatorname{Var}(Y)=E[Y^2]-(E[Y])^2\) ile, yaklaşık 2.288 TL’dir. Bu, beklenen ödemenin, 1.611,42 TL’nin, 1,42 katıdır: tek bir kaybın ödemesi ortalamasının çevresinde ortalamanın kendisinden daha geniş dağılır.

Kuyruk parametresi \(\alpha\) ne değiştirir?

\(\alpha\), Pareto’nun kuyruk parametresidir. Küçüldükçe aşma olasılığı \((\theta/(\theta+x))^\alpha\) büyük tutarlarda daha yavaş sıfıra iner, yani çok büyük kayıplar daha olası olur. Şimdiye kadar \(\alpha=2{,}8\) kullandık. Aynı \(\theta=6.000\) ve aynı poliçeyle \(\alpha=0{,}5\)’i deneyelim: bu kuyruk o kadar ağırdır ki ortalama kayıp sonsuzdur.

Ortalama sonsuz olsa da limitli ödemenin beklentisi sonludur, çünkü \(\min(X,u)\) hiçbir zaman \(u\)’yu aşmaz. Beklenen ödeme için yine iki \(LEV\) gerekir, muafiyet noktasında ve tavanda; ikisini \(\alpha=2{,}8\)’deki Elle hesabıyla aynı adımlarla bulalım. \(\theta/(\alpha-1)=6.000/(-0{,}5)=-12.000\)’dir. Oranlar yine \(6/7\) ve \(6/17\)’dir, ama üs bu kez \(\alpha-1=-0{,}5\) olduğu için \((6/7)^{-0{,}5}=1{,}080123\) ve \((6/17)^{-0{,}5}=1{,}683251\)’dir. Üs negatif olduğundan köşeli parantez de negatiftir ve \(-12.000\) ile çarpımı pozitif çıkar:

\[ \begin{aligned} &LEV_X(1.000)\\ &=-12.000\,(1-1{,}080123)\\ &=961{,}48,\\ &LEV_X(11.000)\\ &=-12.000\,(1-1{,}683251)\\ &=8.199{,}01. \end{aligned} \]

Beklenen ödeme, \(\alpha=2{,}8\)’de olduğu gibi iki \(LEV\)’in farkının \(c\) katıdır:

\[ \begin{aligned} E[Y]&=0{,}80\,(8.199{,}01-961{,}48)\\ &=0{,}80\times7.237{,}53\\ &=5.790{,}02\ \text{TL}. \end{aligned} \]

\(\alpha=2{,}8\)’de aynı poliçe 1.611,42 TL bekliyordu; kuyruk ağırlaşınca beklenen ödeme 5.790,02 TL’ye çıkar. Bu farkın nereden geldiğini aşağıdaki karşılaştırma gösteriyor.

İki portföyü aynı ölçülerle yan yana koyalım. Ortanca kayıp, aşma olasılığını 1/2 yapan tutardır: \((\theta/(\theta+m))^\alpha=1/2\) denkleminden \(m=\theta(2^{1/\alpha}-1)\). \(\alpha=0{,}5\)’te \(6.000\times(2^2-1)=18.000\) TL, \(\alpha=2{,}8\)’de \(6.000\times(2^{1/2{,}8}-1)\) \(=6.000\times0{,}280887\) \(=1.685{,}32\) TL’dir.

Kodu göster / gizle
alfa_karsilastirma <- data.frame(
  alfa = c(2.8, 0.5),
  ortanca = actuar::qpareto(0.5, shape = c(2.8, 0.5), scale = scale),
  muafiyet_alti = actuar::ppareto(d, shape = c(2.8, 0.5), scale = scale),
  limit_ustu = actuar::ppareto(d + L, shape = c(2.8, 0.5), scale = scale,
                               lower.tail = FALSE),
  beklenen_odeme = c * (actuar::levpareto(d + L, shape = c(2.8, 0.5), scale = scale) -
                          actuar::levpareto(d, shape = c(2.8, 0.5), scale = scale))
)
alfa_karsilastirma
#>   alfa  ortanca muafiyet_alti limit_ustu beklenen_odeme
#> 1  2.8  1685.32     0.3505451 0.05414602       1611.423
#> 2  0.5 18000.00     0.0741799 0.59408853       5790.023
  • shape = c(2.8, 0.5) — actuar’ın işlevleri bir vektör alır ve her öğe için ayrı bir sonuç döndürür; tablonun her satırı bir portföydür.
  • actuar::qpareto(0.5, ...) — Pareto’nun kuantil fonksiyonudur: 0,5 olasılığını alır, kayıpların yarısının altında kaldığı tutarı, ortancayı verir.
  • limit_ustu — kaybın \(d+L=11.000\) TL’yi aşma olasılığıdır, yani ödemenin tavana dayandığı kayıpların payı.

\(\alpha=2{,}8\)’de kayıpların yarısı 1.685 TL’nin altındadır ve yalnızca %5,4’ü limiti aşar; kayıp başına beklenen ödeme 1.611,42 TL’dir.

\(\alpha=0{,}5\)’te ortanca kayıp 18.000 TL’dir, yani tipik bir kayıp limitin bile üstündedir: kayıpların %59,4’ü 11.000 TL’yi aşar ve beklenen ödeme 5.790,02 TL’ye çıkar.

Sigorta açısından asıl fark, ödemenin nereden geldiğindedir. Limiti aşan her kayıpta sigortacı tavanı, \(cL=8.000\) TL’yi öder. \(\alpha=0{,}5\)’te bu kayıplar beklenen ödemenin \(8.000\times0{,}594089\) \(=4.752{,}71\) TL’sini, yani %82’sini oluşturur; \(\alpha=2{,}8\)’de \(8.000\times0{,}054146\) \(=433{,}17\) TL’sini, %27’sini.

Limitsiz bir poliçede \(\alpha=0{,}5\) portföyünün beklenen ödemesi sonsuz olurdu ve beklenen ödemeye dayanan hiçbir prim hesaplanamazdı. Limit böyle bir riski sigortalanabilir kılar: sigortacının beklenen maliyeti kaybın sonsuz ortalamasıyla değil limitle belirlenir ve kayıp başına en çok \(cL=8.000\) TL’dir. Kuyruğun geri kalanını, limit üstü kısmı, sigortalı kendisi öder; \(\alpha=0{,}5\)’te bu kısmın beklentisi sonsuzdur. Kuyruk ağırlaştıkça, yani \(\alpha\) küçüldükçe, limitin seçimi primi belirleyen asıl karar olur.

Başka bir kayıp dağılımı seçilseydi

Pareto bir öğretim seçimidir. Seçimin beklenen ödemeyi ne kadar değiştirdiğini görmek için aynı poliçeyi, ortalaması ve varyansı Pareto’nunkine eşit bir lognormal ve bir Gamma dağılımıyla hesaplıyoruz. İlk iki momenti eşitlemek, karşılaştırmayı adil kılar: üç dağılımın farkı yalnızca biçimlerinden, özellikle kuyruklarından gelir.

Önce Pareto’nun iki momenti. Varyans, Hafta 3’teki \(E[X^2]=2\theta^2/((\alpha-1)(\alpha-2))\)’den gelir:

Kodu göster / gizle
pareto_momentleri <- c(
  ortalama = scale / (shape - 1),
  varyans = 2 * scale^2 / ((shape - 1) * (shape - 2)) - (scale / (shape - 1))^2
)
pareto_momentleri
#>     ortalama      varyans 
#>     3333.333 38888888.889

Ortalama 3.333,33 TL, varyans 38.888.889’dur; standart sapma yaklaşık 6.236 TL.

Lognormalin ortalaması \(e^{\mu+\sigma^2/2}\)’dir ve varyansı ortalamanın karesinin \(e^{\sigma^2}-1\) katıdır; Gamma’nın ortalaması şekil çarpı ölçek, varyansı şekil çarpı ölçeğin karesidir. Bu denklemler parametreler için çözülünce:

\[ \begin{aligned} \sigma^2&=\log\bigl(1+\operatorname{Var}(X)/E[X]^2\bigr),\\ \mu&=\log E[X]-\sigma^2/2,\\ \text{şekil}&=E[X]^2/\operatorname{Var}(X),\\ \text{ölçek}&=\operatorname{Var}(X)/E[X]. \end{aligned} \]

İlk satır \(\operatorname{Var}(X)/E[X]^2=e^{\sigma^2}-1\) eşitliğinin logaritmasıdır, ikincisi ortalama formülünün \(\mu\) için çözümüdür; Gamma’nın iki satırı varyansın ortalamaya ve ortalamanın karesinin varyansa bölünmesinden gelir.

Kodu göster / gizle
es_parametreler <- with(as.list(pareto_momentleri), c(
  lognormal_mu = log(ortalama) - log(1 + varyans / ortalama^2) / 2,
  lognormal_sigma = sqrt(log(1 + varyans / ortalama^2)),
  gamma_sekil = ortalama^2 / varyans,
  gamma_olcek = varyans / ortalama
))
round(es_parametreler, 4)
#>    lognormal_mu lognormal_sigma     gamma_sekil     gamma_olcek 
#>          7.3597          1.2264          0.2857      11666.6667
  • with(as.list(pareto_momentleri), ...) — as.list() adlı vektörü bir listeye çevirir; with() listenin adlarını, ortalama ile varyans’ı, ifadenin içinde doğrudan kullandırır.

Lognormalin parametreleri \(\mu=7{,}3597\) ve \(\sigma=1{,}2264\), Gamma’nınki şekil 0,2857 ve ölçek 11.666,67’dir.

Üç dağılımı aynı ölçülerle bir tabloda karşılaştırıyoruz. lev_uc_dagilim() bir \(u\) için üç dağılımın \(LEV\)’ini sırayla verir; beklenen ödeme yine \(c\bigl(LEV_X(d+L)-LEV_X(d)\bigr)\)’dir, yalnızca \(LEV\) dağılıma göre değişir.

Kodu göster / gizle
lev_uc_dagilim <- function(u) {
  c(actuar::levpareto(u, shape = shape, scale = scale),
    actuar::levlnorm(u, meanlog = es_parametreler[["lognormal_mu"]],
                     sdlog = es_parametreler[["lognormal_sigma"]]),
    actuar::levgamma(u, shape = es_parametreler[["gamma_sekil"]],
                     scale = es_parametreler[["gamma_olcek"]]))
}

dagilim_karsilastirma <- data.frame(
  dagilim = c("Pareto II", "Lognormal", "Gamma"),
  beklenen_odeme = c * (lev_uc_dagilim(d + L) - lev_uc_dagilim(d)),
  muafiyet_alti = c(
    actuar::ppareto(d, shape = shape, scale = scale),
    plnorm(d, es_parametreler[["lognormal_mu"]], es_parametreler[["lognormal_sigma"]]),
    pgamma(d, es_parametreler[["gamma_sekil"]], scale = es_parametreler[["gamma_olcek"]])
  ),
  limit_ustu = pareto_momentleri[["ortalama"]] - lev_uc_dagilim(d + L),
  kuantil_999 = c(
    actuar::qpareto(0.999, shape = shape, scale = scale),
    qlnorm(0.999, es_parametreler[["lognormal_mu"]], es_parametreler[["lognormal_sigma"]]),
    qgamma(0.999, es_parametreler[["gamma_sekil"]], scale = es_parametreler[["gamma_olcek"]])
  )
)
dagilim_karsilastirma
#>     dagilim beklenen_odeme muafiyet_alti limit_ustu kuantil_999
#> 1 Pareto II       1611.423     0.3505451   511.3791    64726.12
#> 2 Lognormal       1541.206     0.3562494   578.5217    69534.34
#> 3     Gamma       1601.583     0.5406109   755.2836    53109.71
  • actuar::levlnorm(u, meanlog = , sdlog = ) ve actuar::levgamma(u, shape = , scale = ) — levpareto()’nun lognormal ve Gamma karşılıklarıdır: \(u\) noktasındaki sınırlı beklenen değeri verirler.
  • limit_ustu — kaybın \(d+L\)’yi aşan kısmının beklentisidir, \(E[X]-LEV_X(d+L)\); üç dağılımın ortalaması aynı olduğu için tek bir ortalamadan çıkarılır. Bu kısmı sigortalı kendisi öder.
  • kuantil_999 — kayıpların binde birinin aştığı tutardır. actuar::qpareto(), qlnorm() ve qgamma() üç dağılımın kuantil fonksiyonlarıdır: olasılığı alır, o olasılığın altında kalan tutarı verir.

Beklenen ödeme az değişir: Pareto II 1.611,42 TL, lognormal 1.541,21 TL, Gamma 1.601,58 TL verir. Sebep limittir: kaybın 11.000 TL’yi aşan kısmını sigortacı ödemez ve dağılımların en çok ayrıldığı yer tam orasıdır. Pareto’ya göre lognormal %4,4, Gamma %0,6 daha düşük beklenen ödeme verir.

Fark, sigortalının ödediği limit üstü kısımda görünür: 511,38; 578,52 ve 755,28 TL. Muafiyetin altında kalan kayıpların payı da ayrışır: Pareto II’de ve lognormalde %35 dolayında, Gamma’da %54.

Pareto II’nin kuyruğu bu aralıkta en ağır değildir: binde bir kuantil Pareto II’de 64.726, lognormalde 69.534, Gamma’da 53.110 TL’dir.

İlk iki moment eşit tutulunca Pareto’nun kuvvet kuyruğu çok daha uzakta ağırlaşır: \(\alpha=2{,}8\)’de üçüncü momenti sonsuzdur, öbür ikisininki sonludur. Yöntem dağılımdan bağımsızdır; dağılım seçimi yalnızca \(LEV\)’in nasıl hesaplandığını değiştirir.

5 Bileşik toplam hasar

Buraya kadar hep bir kayıp gerçekleştiğinde sigortacının ne ödediğine baktık: önce tek tek kayıplarda, sonra olası bütün kayıpların ortalamasında. Pareto kayıplarında beklenen ödeme bölümündeki 1.611,42 TL de böyle bir ortalamadır: kayıp başına beklenen ödeme, yani bir kayıp olduğunda sigortacının ortalama ne ödeyeceği.

Bir yıl içinde ise portföyde birden çok kayıp olur ve kaç tane olacağı da rastgeledir. Sigortacının yıllık toplam ödemesi bu yüzden hem kayıp sayısına hem de her kaybın ödemesine bağlıdır; bu bölüm ikisini birleştirir.

Hafta 3’ün Toplam hasar: hasar sayısı ve hasar büyüklüğü bölümündeki toplamı bu kez sigortacının ödemeleriyle yazıyoruz. \(N\) dönemdeki kayıp sayısı, \(Y_1,Y_2,\ldots\) bu kayıpların poliçe ödemeleri olsun. Toplam ödeme

\[ S=\sum_{i=1}^{N}Y_i \]

olur; \(N=0\) ise \(S=0\)’dır. Terim sayısının kendisi de rastgele olan böyle bir toplama bileşik toplam denir. Hafta 3’teki hasar tutarları pozitifti; buradaki terimler ise ödemedir ve muafiyetin altında kalan kayıplarda sıfırdır. Üç varsayım yapıyoruz: ödemeler birbirinden bağımsızdır, aynı dağılımlıdır ve \(N\) ödemelerden bağımsızdır.

Ortalama ve varyans. Toplam ödemenin ortalaması ve varyansı, kayıp sayısının ve ödemenin ilk iki momentinden kurulur:

\[ \begin{aligned} E[S]&=E[N]\,E[Y],\\ \operatorname{Var}(S)&=E[N]\operatorname{Var}(Y)\\ &\quad+\operatorname{Var}(N)\,(E[Y])^{2}. \end{aligned} \]

Bu, Hafta 3’ün Fazla sıfır ve uzun kuyruk nereden gelir? bölümünde karışıma uyguladığımız iki kuralın, koşullu ortalamanın ortalamasının ve toplam varyans kuralının, \(S\)’ye uygulanmasıdır; orada koşul \(\lambda\) idi, burada \(N\)’dir. Varyansın birinci terimi ödemelerin oynaklığıdır (oradaki grup içi parça): kayıp sayısı bilinse bile ödemeler oynar. İkincisi kayıp sayısının oynaklığıdır (gruplar arası parça): ödemeler sabit olsa bile sayı oynar.

Önce \(N\)’nin değerini bildiğimizi varsayalım: \(N=n\). \(N\) ödemelerden bağımsız olduğu için bu bilgi ödemelerin dağılımını değiştirmez: \(S\), her birinin ortalaması \(E[Y]\) ve varyansı \(\operatorname{Var}(Y)\) olan \(n\) bağımsız terimin toplamıdır. Toplamın beklentisi beklentilerin toplamıdır; bağımsız terimlerin kovaryansı sıfır olduğu için varyanslar da toplanır:

\[ \begin{aligned} E[S\mid N=n]&=n\,E[Y],\\ \operatorname{Var}(S\mid N=n)&=n\operatorname{Var}(Y). \end{aligned} \]

\(n\) yerine rastgele \(N\) yazılınca koşullu momentler de rastgele olur: \(E[S\mid N]=N\,E[Y]\) ve \(\operatorname{Var}(S\mid N)=N\operatorname{Var}(Y)\).

Ortalama. Koşullu ortalamanın ortalaması alınır:

\[ \begin{aligned} E[S]&=E\bigl[E[S\mid N]\bigr]\\ &=E\bigl[N\,E[Y]\bigr]\\ &=E[N]\,E[Y]. \end{aligned} \]

İkinci eşitlikte koşullu ortalama yazıldı; üçüncüde sabit \(E[Y]\) beklentinin dışına olduğu gibi çıktı.

Varyans. Toplam varyans kuralı uygulanır:

\[ \begin{aligned} \operatorname{Var}(S)&=E\bigl[\operatorname{Var}(S\mid N)\bigr]\\ &\quad+\operatorname{Var}\bigl(E[S\mid N]\bigr)\\ &=E\bigl[N\operatorname{Var}(Y)\bigr]\\ &\quad+\operatorname{Var}\bigl(N\,E[Y]\bigr)\\ &=E[N]\operatorname{Var}(Y)\\ &\quad+\operatorname{Var}(N)\,(E[Y])^{2}. \end{aligned} \]

Eşitlikler sırasıyla:

  1. toplam varyans kuralı, koşul \(N\) ile;
  2. iki koşullu moment yerine yazıldı;
  3. iki sabit dışarı çıktı: \(\operatorname{Var}(Y)\) beklentinin dışına olduğu gibi, \(E[Y]\) varyansın dışına karesiyle, çünkü \(\operatorname{Var}(aN)=a^{2}\operatorname{Var}(N)\)’dir.

\(N\sim\text{Poisson}(\lambda)\) ise \(E[N]=\operatorname{Var}(N)=\lambda\)’dır (Hafta 3) ve varyans ödemenin tek bir momentine, ham ikinci moment \(E[Y^{2}]\)’ye sadeleşir:

\[ E[S]=\lambda E[Y],\qquad\operatorname{Var}(S)=\lambda E[Y^{2}]. \]

Bu durumda \(S\)’ye bileşik Poisson (compound Poisson) toplamı denir.

Genel formülde \(E[N]\) ve \(\operatorname{Var}(N)\) yerine \(\lambda\) yazılır:

\[ \begin{aligned} \operatorname{Var}(S)&=\lambda\operatorname{Var}(Y)+\lambda(E[Y])^{2}\\ &=\lambda\bigl(\operatorname{Var}(Y)+(E[Y])^{2}\bigr)\\ &=\lambda E[Y^{2}]. \end{aligned} \]

İkinci eşitlikte ortak çarpan \(\lambda\) dışarı alındı. Üçüncüde parantezin içi ham ikinci momenttir, çünkü varyansın tanımı \(\operatorname{Var}(Y)=E[Y^{2}]-(E[Y])^{2}\)’dir.

\(E[Y]\) kayıp başına bir ortalama olduğu için \(N\) de kayıp sayısıdır, sıfır ödeme doğuran kayıplar dahil. Ödeme başına ortalamayla çalışılsaydı \(N\)’nin yerine ödeme sayısı gelirdi.

Kayıp sayısı \(\text{Poisson}(\lambda)\) ise ödeme sayısı da Poisson dağılır:

\[ \text{ödeme sayısı}\sim\text{Poisson}\bigl(\lambda P(X>d)\bigr). \]

Beklenen değeri, yani ödeme sıklığı (payment frequency), \(\lambda P(X>d)\)’dir: muafiyet kayıp sayısını değil, ödemeye dönüşen kayıpların sayısını değiştirir. Bu, Hafta 3’ün Hasar sayısı için modeller: Poisson ve alternatifleri bölümündeki \(r\) parçalı türetmenin, parça başına \(\lambda/r\) yerine \(\lambda P(X>d)/r\) olasılığıyla yinelenmesidir.

Yılı Hafta 3’teki gibi \(r\) kısa parçaya bölelim. Bir parçada ödeme olması için o parçada bir kayıp olmalı ve o kayıp muafiyeti aşmalıdır. Ödemeler kayıp sayısından bağımsız olduğu için (bölümün başındaki varsayım) iki olay bağımsızdır ve olasılıkları çarpılır:

\[ \begin{aligned} &P(\text{parçada ödeme})\\ &=P(\text{parçada kayıp})\cdot P(X>d)\\ &=\frac{\lambda}{r}\,P(X>d). \end{aligned} \]

Hafta 3’ün üç varsayımı ödemeler için de tutar (bir parçada en çok bir kayıp, dolayısıyla en çok bir ödeme olur), bu yüzden türetmenin geri kalanı oradakinin aynısıdır: \(r\) büyürken ödeme sayısının binom dağılımı, \(\lambda\)’nın yerinde \(\lambda P(X>d)\) duran Poisson’a yaklaşır.

Kayıp başına ortalamayı kayıp sayısıyla, ödeme başına ortalamayı ödeme sıklığıyla çarpmak aynı \(E[S]\)’yi verir, çünkü bir önceki bölümde gördüğümüz gibi \(P(X>d)\,E[Y\mid X>d]=E[Y]\); ders sayılarıyla \(0{,}649455\times2.481{,}19\) \(=1.611{,}42\) TL.

Bağımsızlık ve aynı dağılım varsayımları mevsimsellik, enflasyon, kümelenmiş afet hasarları veya heterojen poliçelerde bozulabilir. Alıştırma 11, bir afetin bütün ödemeleri aynı yöne ittiği uç durumda varyansın ne kadar büyüdüğünü ölçer.

Küçük bir portföyde beklenen değer ve varyans

Formülleri elle izlenebilecek bir portföyde çalışalım. Pareto poliçesinin ödemesi sürekli bir dağılımdır ve ikinci momenti için actuar gerekir; ödemenin yalnızca dört değer aldığı küçük bir dağılımda ise her adım elle izlenir. Pareto poliçesinin ikinci momentini Pareto kayıplarında beklenen ödeme bölümünde bulduk; iki primini laboratuvarın Görev C’si hesaplar. Yıllık kayıp sayısı \(N\sim\text{Poisson}(25)\) olsun; poliçe koşulları uygulandıktan sonra her kaybın ödemesi \(Y\) yalnızca dört değer alsın:

Ödeme \(y\) (TL) \(P(Y=y)\)
0 0,40
1.000 0,30
4.000 0,20
10.000 0,10

Sıfır ödemeli satır muafiyetin altında kalan kayıplardır; \(N\) kayıp sayısı olduğu için onlar da dağılımın içindedir.

Elle. İki moment ağırlıklı toplamlardır; \(E[Y^2]\)’de sıfır ödemenin terimi sıfır olduğu için yazılmamıştır:

\[ \begin{aligned} E[Y]&=0\times0{,}40+1.000\times0{,}30+4.000\times0{,}20+10.000\times0{,}10\\ &=2.100\ \text{TL}, \end{aligned} \]

\[ \begin{aligned} E[Y^2]&=1.000^2\times0{,}30+4.000^2\times0{,}20+10.000^2\times0{,}10\\ &=300.000+3.200.000+10.000.000=13.500.000. \end{aligned} \]

Kayıp sayısı Poisson olduğu için \(E[N]=\operatorname{Var}(N)=25\)’tir; bileşik Poisson formülleriyle:

\[ \begin{aligned} E[S]&=25\times2.100=52.500\ \text{TL},\\ \operatorname{Var}(S)&=25\times13.500.000=337.500.000,\\ \sqrt{\operatorname{Var}(S)}&\approx18.371{,}17\ \text{TL}. \end{aligned} \]

Aynı hesabı R’de adım adım yapalım. odeme_dagilimi tablonun kendisidir: her satırda bir ödeme değeri ve onun olasılığı.

Kodu göster / gizle
odeme_dagilimi <- data.frame(
  odeme = c(0, 1000, 4000, 10000),
  olasilik = c(0.40, 0.30, 0.20, 0.10)
)
odeme_dagilimi
#>   odeme olasilik
#> 1     0      0.4
#> 2  1000      0.3
#> 3  4000      0.2
#> 4 10000      0.1

İki momenti bu tablodan hesaplıyoruz. odeme_momentleri’nin ilk öğesi \(E[Y]\), ikincisi \(E[Y^2]\)’dir.

Kodu göster / gizle
odeme_momentleri <- c(
  birinci = sum(odeme_dagilimi$odeme * odeme_dagilimi$olasilik),
  ikinci = sum(odeme_dagilimi$odeme^2 * odeme_dagilimi$olasilik)
)
odeme_momentleri
#>  birinci   ikinci 
#>     2100 13500000

Çıktı elle bulduğumuz 2.100 ve 13.500.000 olmalıdır.

  • odeme_dagilimi$odeme * odeme_dagilimi$olasilik — iki sütunu eleman eleman çarpar; sum() çarpımları toplayınca ağırlıklı toplam, yani \(E[Y]\) çıkar. ^2 yalnızca ödemeyi kareler, olasılığı değil.

Toplam hasarın iki momentini Poisson formülleriyle kuruyoruz. lambda_ornek beklenen kayıp sayısıdır; toplam_hasar_ornek üç sayıyı adlarıyla taşır.

Kodu göster / gizle
lambda_ornek <- 25
toplam_hasar_ornek <- c(
  beklenen = lambda_ornek * odeme_momentleri[["birinci"]],
  varyans = lambda_ornek * odeme_momentleri[["ikinci"]],
  standart_sapma = sqrt(lambda_ornek * odeme_momentleri[["ikinci"]])
)
toplam_hasar_ornek
#>       beklenen        varyans standart_sapma 
#>       52500.00   337500000.00       18371.17

Üç sayı 52.500; 337.500.000 ve 18.371,17 olmalıdır.

Aynı varyansı bölümün başındaki genel formülden, \(E[N]\operatorname{Var}(Y)+\operatorname{Var}(N)(E[Y])^2\)’den de kuralım. Genel formül ham ikinci momenti değil ödemenin varyansını ister; odeme_varyansi onu ortalamadan sapmaların karelerinden hesaplar.

Kodu göster / gizle
odeme_varyansi <- sum(
  (odeme_dagilimi$odeme - odeme_momentleri[["birinci"]])^2 * odeme_dagilimi$olasilik
)
odeme_varyansi
#> [1] 9090000

Çıktı \(\operatorname{Var}(Y)=13.500.000-2.100^2\) \(=13.500.000-4.410.000\) \(=9.090.000\) olmalıdır.

Poisson’da genel formülün iki teriminde de \(\lambda\) kullanılır. varyans_genel_formul bu iki terimin toplamıdır.

Kodu göster / gizle
varyans_genel_formul <- lambda_ornek * odeme_varyansi +
  lambda_ornek * odeme_momentleri[["birinci"]]^2
varyans_genel_formul
#> [1] 337500000

Çıktı yine 337.500.000 olmalıdır: birinci terim \(25\times9.090.000\) \(=227.250.000\), ikinci terim \(25\times2.100^2\) \(=110.250.000\)’dir.

İki yolu ayrı bir blokta karşılaştırıyoruz.

Kodu göster / gizle
varyans_kontrol <- isTRUE(all.equal(varyans_genel_formul, toplam_hasar_ornek[["varyans"]]))
stopifnot(varyans_kontrol)
list(sonuclar = c(genel = varyans_genel_formul, poisson = toplam_hasar_ornek[["varyans"]]),
     uyumlu = varyans_kontrol)
#> $sonuclar
#>     genel   poisson 
#> 337500000 337500000 
#> 
#> $uyumlu
#> [1] TRUE

uyumlu alanının TRUE olması gerekir. İki yol farklı büyüklüklerden gider: biri ortalamadan sapmaların karesinden (9.090.000), öbürü ham kareden (13.500.000). Yalnızca \(\operatorname{Var}(Y)+(E[Y])^2=E[Y^2]\) eşitliği ve Poisson’un \(E[N]=\operatorname{Var}(N)\) özelliği sayesinde buluşurlar. Genel formülün ikinci terimi unutulup \(\operatorname{Var}(S)=\lambda\operatorname{Var}(Y)\) yazılsaydı sonuç 227.250.000 çıkardı: kayıp sayısının kendi oynaklığı hesaptan düşerdi ve stopifnot() çalıştırmayı burada durdururdu. Tablodaki olasılıklardan biri yanlış yazılıp toplam 1’den ayrılsaydı da eşitlik bozulur ve denetim yine dururdu.

Sigorta diliyle: bu portföyde yılda ortalama 52.500 TL ödenir. Kayıpların %40’ı sıfır ödeme doğurduğu için ödeme sıklığı \(25\times0{,}60=15\)’tir ve ödeme başına ortalama \(2.100/0{,}60=3.500\) TL’dir; \(15\times3.500\) yine 52.500 TL eder.

6 Basit prim prensipleri

Önceki bölüm yıllık toplam ödemenin, \(S\)’nin, ortalamasını ve varyansını verdi. Sigortacı bu ödemeyi yıl başında topladığı primle karşılar. Aşağıdaki iki prensip primi bu iki momentten kurar; ikisini de önceki bölümün küçük portföyüne uygulayacağız.

Beklenen değer prensibi

\[ P=(1+\rho)E[S],\qquad \rho>0. \]

\(\rho\) güvenlik yüklemesidir (safety loading): primin beklenen toplam hasarı aştığı oran. \(\rho=0{,}20\), primin \(E[S]\)’nin %20 üstünde olması demektir. Prim yalnızca \(E[S]\) olsaydı sigortacı ortalamada başabaş kalırdı, ama \(S\)’nin \(E[S]\)’yi aştığı her yıl zarar ederdi. Yükleme bu belirsizliği, giderleri ve hedef getiriyi tek bir orana toplar. Basittir, fakat dağılımdan yalnızca \(E[S]\)’yi kullanır: ortalaması aynı, oynaklığı farklı iki portföye aynı primi verir (Alıştırma 10).

Standart sapma prensibi

\[ P=E[S]+k\sqrt{\operatorname{Var}(S)},\qquad k>0. \]

Yükleme bu kez toplam hasarın standart sapmasıyla orantılıdır: \(k\), prime kaç standart sapma ekleneceğini söyleyen birimsiz bir katsayıdır. Ortalaması aynı ama daha oynak bir portföy daha yüksek prim öder; beklenen değer prensibinin görmediği fark budur. Ancak bu prensip de dağılımdan yalnızca ilk iki momenti alır ve aynı ortalama ile standart sapmaya sahip çok farklı kuyrukları ayırt edemez. Bölümün sonundaki ikinci örnek bunu gösteriyor.

İki prim küçük portföyde

Önceki bölümün portföyünde iki prensibi, öğretim için seçtiğimiz \(\rho=0{,}20\) ve \(k=0{,}30\) ile uygulayalım. Elle:

\[ \begin{aligned} P_{\text{BD}}&=(1+0{,}20)\times52.500=63.000\ \text{TL},\\ P_{\text{SS}}&=52.500+0{,}30\times18.371{,}17\approx58.011{,}35\ \text{TL}. \end{aligned} \]

Kodda iki prim tek bir adlı vektörde durur; ikisi de toplam_hasar_ornek’in sayılarını kullanır.

Kodu göster / gizle
primler_ornek <- c(
  beklenen_deger = (1 + 0.20) * toplam_hasar_ornek[["beklenen"]],
  standart_sapma = toplam_hasar_ornek[["beklenen"]] +
    0.30 * toplam_hasar_ornek[["standart_sapma"]]
)
round(primler_ornek, 2)
#> beklenen_deger standart_sapma 
#>       63000.00       58011.35

Çıktı 63.000 ve 58.011,35 TL olmalıdır. Bu katsayılarla beklenen değer primi 4.988,65 TL daha büyüktür.

İki prim de \(E[S]\)’den başlar; ayrılan yalnızca yüklemeleridir:

\[ \begin{aligned} \rho E[S]&=0{,}20\times52.500=10.500,\\ k\sqrt{\operatorname{Var}(S)}&=0{,}30\times18.371{,}17\\ &=5.511{,}35. \end{aligned} \]

İki yüklemenin farkı, \(10.500-5.511{,}35\) \(=4.988{,}65\) TL, primlerin farkının kendisidir. Hangi primin büyük olduğunu bu yüzden yüklemeler belirler: \(\rho E[S]>k\sqrt{\operatorname{Var}(S)}\) ise beklenen değer primi büyüktür. Bunun başka portföylerde ve başka katsayılarla da korunup korunmadığını laboratuvarın Görev C’si soruyor.

Aynı ilk iki moment, farklı kuyruk

Bileşik Poisson’da iki prim de ödeme dağılımından yalnızca iki sayı alır, \(E[Y]\) ile \(E[Y^2]\)’yi: biri \(E[S]=\lambda E[Y]\)’ye, öbürü \(\operatorname{Var}(S)=\lambda E[Y^2]\)’ye girer. İlk iki momenti aynı olan başka bir ödeme dağılımı bu yüzden, aynı \(\lambda\) ile ve kuyruğu ne kadar farklı olursa olsun, aynı iki primi verir.

Bunu iki portföyle görelim. İkisinde de yıllık kayıp sayısı \(N\sim\text{Poisson}(25)\)’tir; ayrıldıkları tek şey kayıp başına ödemenin dağılımıdır. Portföylere ve ödeme dağılımlarına aynı harfleri veriyoruz:

  • A portföyü, Küçük bir portföyde beklenen değer ve varyans bölümünde iki primini hesapladığımız portföydür. Ödemesi dört değer alır; R’deki adı odeme_dagilimi’dır.
  • B portföyü bu bölüm için kurduğumuz yeni bir portföydür. Ödemesi üç değer alır ve en büyük ödemesi A’nınkinin üstündedir; R’deki adı odeme_dagilimi_b’dir.

İki ödeme dağılımı yan yana şöyledir; bir portföyün hiç almadığı ödemenin olasılığı 0 yazılmıştır:

Ödeme \(y\) (TL) A portföyü
\(P(Y=y)\)
B portföyü
\(P(Y=y)\)
0 0,40 0,46
1.000 0,30 0
3.000 0 0,50
4.000 0,20 0
10.000 0,10 0
15.000 0 0,04
Toplam 1 1

A portföyünün iki momentini o bölümde bulduk: \(E[Y]=2.100\) TL ve \(E[Y^2]=13.500.000\). B portföyünün momentleri, elle: \(E[Y]=3.000\times0{,}50+15.000\times0{,}04\) \(=1.500+600\) \(=2.100\) TL ve \(E[Y^2]=3.000^2\times0{,}50+15.000^2\times0{,}04\) \(=4.500.000+9.000.000\) \(=13.500.000\); ikisi de A’nınkiyle aynıdır.

B’nin olasılıkları bu iki eşitlikten çıkar. Değerleri biz seçtik: en büyük ödemeyi A’nınkinin üstüne, 15.000 TL’ye koyduk ki B’nin kuyruğu daha uzun olsun, araya da 3.000 TL’yi. Bu iki değerin olasılıkları \(p_1\) ve \(p_2\) olsun; tutarlar bin TL cinsinden yazılınca iki moment koşulu şudur:

\[ \begin{aligned} 3p_1+15p_2&=2{,}1,\\ 9p_1+225p_2&=13{,}5. \end{aligned} \]

Bu doğrusal sistemin çözümü \(p_1=0{,}5\) ve \(p_2=0{,}04\)’tür; kalan \(1-0{,}5-0{,}04=0{,}46\) sıfır ödemenin olasılığıdır. Başka değerler de seçilebilirdi; tek koşul, hiçbir olasılığın negatif çıkmamasıdır.

Birinci koşuldan \(p_1\)’i yalnız bırakıp ikinciye koyuyoruz:

\[ \begin{aligned} &p_1=0{,}7-5p_2,\\ &9(0{,}7-5p_2)+225p_2=13{,}5,\\ &6{,}3-45p_2+225p_2=13{,}5,\\ &6{,}3+180p_2=13{,}5,\\ &180p_2=7{,}2,\\ &p_2=0{,}04,\\ &p_1=0{,}7-5\times0{,}04=0{,}5. \end{aligned} \]

Satırlar sırasıyla:

  1. birinci koşulun iki tarafı 3’e bölündü (\(2{,}1/3=0{,}7\), \(15/3=5\)) ve \(5p_2\) karşıya geçti;
  2. bu \(p_1\) ikinci koşulda yerine kondu;
  3. parantez açıldı: \(9\times0{,}7=6{,}3\) ve \(9\times5=45\);
  4. \(p_2\)’li terimler toplandı: \(225-45=180\);
  5. iki taraftan 6,3 çıkarıldı: \(13{,}5-6{,}3=7{,}2\);
  6. iki taraf 180’e bölündü: \(7{,}2/180=0{,}04\);
  7. bulunan \(p_2\) birinci satırda yerine kondu.

B portföyünün ödeme dağılımını da A’nınki gibi bir tabloya yazıyoruz.

Kodu göster / gizle
odeme_dagilimi_b <- data.frame(
  odeme = c(0, 3000, 15000),
  olasilik = c(0.46, 0.50, 0.04)
)
odeme_dagilimi_b
#>   odeme olasilik
#> 1     0     0.46
#> 2  3000     0.50
#> 3 15000     0.04

İki dağılımı aynı ölçülerle yan yana koyan küçük bir işlev yazıyoruz. İlk iki ölçü primlerin kullandığı momentlerdir; son üçü kuyruğu anlatır.

Kodu göster / gizle
dagilim_olculeri <- function(dagilim) {
  c(birinci_moment = sum(dagilim$odeme * dagilim$olasilik),
    ikinci_moment = sum(dagilim$odeme^2 * dagilim$olasilik),
    en_buyuk_odeme = max(dagilim$odeme),
    p_10000_ustu = sum(dagilim$olasilik[dagilim$odeme > 10000]),
    ucuncu_moment = sum(dagilim$odeme^3 * dagilim$olasilik))
}

iki_dagilim <- rbind(A = dagilim_olculeri(odeme_dagilimi),
                     B = dagilim_olculeri(odeme_dagilimi_b))
iki_dagilim
#>   birinci_moment ikinci_moment en_buyuk_odeme p_10000_ustu ucuncu_moment
#> A           2100      13500000          10000         0.00     1.131e+11
#> B           2100      13500000          15000         0.04     1.485e+11

İki satırın ilk iki sütunu aynıdır, son üç sütunu ayrışır. A’da en büyük ödeme 10.000 TL’dir ve 10.000 TL’yi aşan ödeme yoktur; B’de ödemelerin %4’ü 15.000 TL’dir, yani 25 kayıplık bir yılda ortalama bir ödeme 10.000 TL’nin üstüne çıkar.

Üçüncü moment de B’de %31 büyüktür: \(1{,}485\cdot10^{11}\) karşısında \(1{,}131\cdot10^{11}\). Ödemeleri küpleriyle ağırlıklandırdığı için en büyük ödemeye ilk iki momentten çok daha duyarlıdır; Hafta 3’teki çarpıklık da bu momente dayanır.

  • dagilim$olasilik[dagilim$odeme > 10000] — köşeli parantezdeki mantıksal vektör yalnızca 10.000 TL’yi aşan ödemelerin olasılıklarını seçer. A’da böyle bir ödeme yoktur; seçim boş kalır ve sum() boş bir vektörü 0 sayar.
  • rbind(A = ..., B = ...) — iki ölçü vektörünü satır satır üst üste koyar; argüman adları satır adı olur.

İlk iki momentin gerçekten aynı olduğunu ayrı bir blokta sınıyoruz. ilk_iki karşılaştırılacak iki sütunun adıdır.

Kodu göster / gizle
ilk_iki <- c("birinci_moment", "ikinci_moment")
moment_kontrol <- isTRUE(all.equal(iki_dagilim["A", ilk_iki], iki_dagilim["B", ilk_iki]))
stopifnot(moment_kontrol)
list(A = iki_dagilim["A", ilk_iki], B = iki_dagilim["B", ilk_iki], uyumlu = moment_kontrol)
#> $A
#> birinci_moment  ikinci_moment 
#>           2100       13500000 
#> 
#> $B
#> birinci_moment  ikinci_moment 
#>           2100       13500000 
#> 
#> $uyumlu
#> [1] TRUE

uyumlu alanının TRUE olması gerekir; momentlerden biri farklı olsaydı stopifnot() burada dururdu. İlk iki moment aynı olduğu için B portföyünde de \(E[S]=52.500\) TL, \(\sqrt{\operatorname{Var}(S)}=18.371{,}17\) TL, beklenen değer primi 63.000 TL ve standart sapma primi 58.011,35 TL’dir. Oysa iki portföy aynı riski taşımaz: B’nin ödemesi 15.000 TL’ye çıkabilir, A’nınki 10.000 TL’de durur. Standart sapma prensibi belirsizliği primin içine alır, ama ilk iki momentin ötesindeki farkı göremez; iki formül de üçüncü momente ya da en büyük ödemeye bakmaz.

Not

Bu hesaplar öğretim amaçlıdır. Vergi, gider, reasürans, sermaye, düzenleme, rekabet ve davranışsal etkileri içeren gerçek tarife sürecinin yerine geçmez.

7 R Laboratuvarı

İndirilebilir R laboratuvarı

Gövdede poliçe koşulları hep aynı kaldı: muafiyet 1.000, limit 10.000, koasürans 0,80. Laboratuvar gövdenin sormadığı üç soruyu sorar; her birinin yanıtı bir karara bağlanır:

Görev Soru Hangi karar için
A Üç koşulun her biri hangi kayıplarda ödemeyi değiştirir? Bir koşulu değiştirmenin hangi hasarları etkileyeceği
B Muafiyet büyüdükçe beklenen ödeme ne kadar ve hangi hızla düşer? Yüksek muafiyete verilecek prim indirimi
C Hangi prim prensibi daha büyük prim verir; sıralama portföye bağlı mı? Prim prensibinin ve katsayısının seçimi

Görevler gövdenin policy_payment() işlevini, shape, scale, d, L ve c parametrelerini, beklenen_paket ve ikinci_moment_kapali nesnelerini hazır kullanır; indirilebilir betik bunları # Gorev A satırından önce kendisi kurar, sonrası bu sayfadaki bloklarla aynıdır.

Görev A — Poliçenin parçalarını tek tek kapatın

Görevin sorusu şudur: üç koşuldan her biri hangi kayıplarda ödemeyi değiştirir, ne kadar? Bunu altı kayıpta okuyacağız: gövdenin küçük örneğindeki beş kayıp ve sıfır. İkisi muafiyetin altında (0 ve 500), ikisi muafiyet ile limit arasında (1.500 ve 5.000), ikisi limitin üstündedir (12.000 ve 30.000). Sıfır, muafiyet kalksa bile ödemenin sıfır kaldığı tek kayıptır.

Kodu göster / gizle
kayiplar <- c(0, 500, 1500, 5000, 12000, 30000)
kayiplar
#> [1]     0   500  1500  5000 12000 30000

Şimdi aynı altı kayba dört poliçe uygulayıp yan yana koyuyoruz. temel sütunu gövdenin poliçesidir; sonraki üç sütunun her birinde tek bir koşul değişir.

Kodu göster / gizle
gorev_a <- data.frame(
  kayip       = kayiplar,
  temel       = policy_payment(kayiplar, d, L, c),
  koasurans_1 = policy_payment(kayiplar, d, L, 1),
  limitsiz    = policy_payment(kayiplar, d, Inf, c),
  muafiyetsiz = policy_payment(kayiplar, 0, L, c)
)
gorev_a
#>   kayip temel koasurans_1 limitsiz muafiyetsiz
#> 1     0     0           0        0           0
#> 2   500     0           0        0         400
#> 3  1500   400         500      400        1200
#> 4  5000  3200        4000     3200        4000
#> 5 12000  8000       10000     8800        8000
#> 6 30000  8000       10000    23200        8000

Çıktıda temel sütunu 0; 0; 400; 3.200; 8.000 ve 8.000 olmalıdır. Öbür üç sütunun bundan ayrıldığı satırlar, her koşulun hangi kayıpları değiştirdiğini gösterir; nedeni gövdedeki \(Y=c\min\{(X-d)_+,L\}\) formülünden okunur:

  • policy_payment(kayiplar, d, L, 1) — koasüransı 1 yapar: sigortacı muafiyeti aşan tutarın limite kadar tamamını öder. Pozitif her ödeme temel’in \(1/0{,}80=1{,}25\) katıdır. Koasürans yalnızca ölçekler: \(c\) formülde \(\min\)’in dışında durur, ödemenin başladığı \(d\) ve sabitlendiği \(d+L\) noktaları \(c\)’yi içermez; kırılma noktaları yerinden oynamaz.
  • policy_payment(kayiplar, d, Inf, c) — limiti kaldırır. Inf R’de sonsuz sayıdır ve pmin(..., Inf) her zaman ilk argümanı döndürür, yani üst kesme ortadan kalkar. Fark yalnız \(X\ge d+L=11.000\) olan iki satırdadır: temel poliçe orada \(cL=8.000\) TL’de durur, limitsiz poliçe muafiyeti aşan tutarın %80’ini öder: 8.800 ve 23.200 TL.
  • policy_payment(kayiplar, 0, L, c) — muafiyeti kaldırır. Ödemedeki artış kaybın bulunduğu bölgeye göre değişir. Muafiyetin altında \(cX\)’tir (500 TL’de 400); muafiyet ile \(L=10.000\) arasında sabit \(cd=800\) TL’dir (1.500 ve 5.000 TL’de); \(L\) ile \(d+L=11.000\) arasında daralır, çünkü muafiyetsiz poliçe limite \(X=L\)’de, temel poliçe \(X=d+L\)’de dayanır. 12.000 ve 30.000 TL’de ikisi de \(cL=8.000\) TL öder ve fark kapanır.

Üç koşul aynı kaybı farklı yerinden değiştirir ve etki alanları aynı büyüklükte değildir: koasürans her pozitif ödemeyi ölçekler, limit yalnız üst ucu keser, muafiyet ise 1.000 ile 10.000 TL arasındaki her kayıpta ödemeyi aynı 800 TL düşürür. Muafiyetin “yalnızca küçük hasarları ilgilendirdiğini” sanmak bu yüzden yanlıştır.

Son sınama fonksiyonun durması gereken durumdur: negatif bir kayıp. Hatanın kendisi sonucun bir parçasıdır. Yakalanmayan bir hata sayfayı durdururdu; bu yüzden onu Hafta 1’deki gibi tryCatch() ile yakalayıp conditionMessage() ile yazdırıyoruz.

Kodu göster / gizle
gorev_a_hata <- tryCatch(
  policy_payment(-1, d, L, c),
  error = function(e) conditionMessage(e)
)
gorev_a_hata
#> [1] "all(loss >= 0) is not TRUE"

Çıktıda "all(loss >= 0) is not TRUE" görmelisiniz: mesaj, policy_payment() gövdesindeki stopifnot() satırının hangi koşulda kırıldığını adıyla söyler. Negatif kayıp bir veri hatasıdır; fonksiyon onu sıfır ödemeye çevirip sessizce devam etmek yerine durur.

Görev A’nın yanıtı koşulların yukarıdaki etki alanlarıdır. Bir koşulun beklenen ödemeyi ne kadar değiştirdiği ise değiştirdiği kayıpların ne kadar olası olduğuna bağlıdır; Görev B bu olasılığı muafiyet için hesaba katar.

Görev B — Muafiyet beklenen ödemeyi nereye kadar ucuzlatır?

Sigortacı daha yüksek muafiyet seçen sigortalıya primde indirim yapar; indirimin dayanağı, muafiyet yükselince beklenen ödemenin ne kadar düştüğüdür. Gövde beklenen ödemeyi tek bir muafiyette, 1.000 TL’de hesapladı. Burada soru şudur: muafiyet büyüdükçe beklenen ödeme ne kadar ve hangi hızla düşer? Limit ve koasürans sabit kalıyor.

Kodu göster / gizle
muafiyetler <- c(0, 1000, 5000)
muafiyetler
#> [1]    0 1000 5000

Her muafiyet için beklenen ödemeyi Sınırlı beklenen değer bölümündeki \(E[Y]=c\bigl(LEV_X(d+L)-LEV_X(d)\bigr)\) formülüyle, actuar::levpareto() ile hesaplıyoruz.

Kodu göster / gizle
gorev_b <- data.frame(
  muafiyet = muafiyetler,
  beklenen_odeme = c * (
    actuar::levpareto(muafiyetler + L, shape = shape, scale = scale) -
      actuar::levpareto(muafiyetler, shape = shape, scale = scale)
  )
)
gorev_b
#>   muafiyet beklenen_odeme
#> 1        0      2210.3934
#> 2     1000      1611.4231
#> 3     5000       615.9711

Üç muafiyet için beklenen ödeme sırasıyla yaklaşık 2.210,39; 1.611,42 ve 615,97 TL olmalıdır; ortadaki değer gövdenin beklenen_paket değeriyle aynıdır, çünkü gövde tam olarak bu muafiyeti kullanıyordu.

  • actuar::levpareto(muafiyetler + L, ...) — işlev vektörleştirilmiştir (vectorized): üç muafiyetin sınırlı beklenen değerini tek çağrıda, öğe öğe döndürür; döngü gerekmez.

Prim indirimi genellikle yüzde olarak söylenir; muafiyetin etkisini de muafiyetsiz poliçeye göre yüzde düşüş olarak yazalım.

Kodu göster / gizle
gorev_b_dusus <- round(
  100 * (gorev_b$beklenen_odeme / gorev_b$beklenen_odeme[1] - 1), 1
)
gorev_b_dusus
#> [1]   0.0 -27.1 -72.1

Çıktı 0,0; −27,1 ve −72,1 olmalıdır.

Düşüş muafiyetle doğru orantılı değildir: ilk 1.000 TL beklenen ödemeyi %27,1 düşürür; dört bin lira daha eklemek toplam düşüşü ancak %72,1’e çıkarır, yani ek her bin lira ilkinden çok daha az keser. Yüksek bir muafiyetin prim indirimi bu yüzden muafiyetle orantılı büyütülemez.

Her ek bin liranın daha az tasarruf sağlamasının nedeni, beklenen ödemenin bir alan olmasıdır. Sınırlı beklenen değer bölümündeki integralle iki \(LEV\)’in farkı, aşma olasılığı eğrisinin \(d\) ile \(d+L\) arasındaki alanıdır. Muafiyet 1 TL artınca bu pencere 1 TL sağa kayar: solda yüksekliği \(P(X>d)\) olan bir şerit çıkar, sağda yüksekliği \(P(X>d+L)\) olan bir şerit girer. Beklenen ödemeyi muafiyetin işlevi olarak \(g(d)\) diye yazarsak:

\[ \begin{aligned} g(d)&=c\int_d^{d+L}P(X>x)\,dx,\\ g'(d)&=-c\,\big[P(X>d)\\ &\qquad-P(X>d+L)\big]. \end{aligned} \]

Köşeli parantez, kaybın \(d\) ile \(d+L\) arasına düşme olasılığıdır. Muafiyetin her ek lirası yalnız bu kayıplardan \(c\) TL keser: \(d\)’nin altındakiler zaten ödenmiyordu, \(d+L\)’nin üstündekiler ise yine \(cL\) alır, çünkü bu derste limit muafiyetten sonra uygulanır (uyarı kutusundaki birinci okuma). Pareto yoğunluğu her yerde azaldığı için pencere sağa kaydıkça içine düşen olasılık küçülür ve her ek lira daha az tasarruf sağlar. Bu tasarrufu üç muafiyette hesaplayalım; aşma olasılıklarını Hafta 3’teki gibi lower.tail = FALSE ile alıyoruz.

Kodu göster / gizle
gorev_b_egim <- c * (
  actuar::ppareto(muafiyetler, shape = shape, scale = scale,
                  lower.tail = FALSE) -
    actuar::ppareto(muafiyetler + L, shape = shape, scale = scale,
                    lower.tail = FALSE)
)
round(gorev_b_egim, 3)
#> [1] 0.749 0.476 0.123

Muafiyet 0; 1.000 ve 5.000 TL iken her ek lira beklenen ödemeyi sırasıyla 0,749; 0,476 ve yalnız 0,123 TL düşürür. Üçü de \(c=0{,}80\)’in altındadır: muafiyetin bir lirası en çok \(c\) TL kesebilir, o da yalnız bütün kayıplar \(d\) ile \(d+L\) arasına düşseydi olurdu.

Üç nokta düşüşün yönünü gösterir, biçimini göstermez. Aynı hesabı 0’dan 10.000 TL’ye, 50 TL aralıklı bir muafiyet ızgarasında yapalım.

Kodu göster / gizle
muafiyet_izgara <- seq(0, 10000, by = 50)
head(muafiyet_izgara)
#> [1]   0  50 100 150 200 250

Her muafiyet değeri için beklenen ödemeyi hesaplayıp bir tabloya yazıyoruz; beklenen_odeme_egrisi grafiğin eğrisini çizdiği tablodur.

Kodu göster / gizle
beklenen_odeme_egrisi <- data.frame(
  muafiyet = muafiyet_izgara,
  beklenen_odeme = c * (
    actuar::levpareto(muafiyet_izgara + L, shape = shape, scale = scale) -
      actuar::levpareto(muafiyet_izgara, shape = shape, scale = scale)
  )
)
head(beklenen_odeme_egrisi)
#>   muafiyet beklenen_odeme
#> 1        0       2210.393
#> 2       50       2173.411
#> 3      100       2137.310
#> 4      150       2102.064
#> 5      200       2067.646
#> 6      250       2034.031

Ardışık iki satırın farkı, 50 TL’lik ek muafiyetin beklenen ödemeden kestiği tutardır; eğrinin her noktadaki eğimi bu yüzden yukarıdaki \(g'(d)\)’dir ve gorev_b_egim’in değerleri eğrinin o üç noktadaki eğimidir.

Çizim bloğu eğriyi bu tablodan, altın noktayı gövdenin d ve beklenen_paket değerlerinden alır.

Kodu göster / gizle
ggplot(beklenen_odeme_egrisi, aes(x = muafiyet, y = beklenen_odeme)) +
  geom_line(colour = "#1F4E79", linewidth = 1) +
  geom_point(
    data = data.frame(muafiyet = d, beklenen_odeme = beklenen_paket),
    colour = "#C8A45C", size = 3
  ) +
  annotate("text", x = d, y = beklenen_paket,
           label = "Derste kullanılan d = 1.000 TL",
           hjust = -0.08, vjust = -1.1, colour = "#C8A45C", size = 3.4) +
  scale_x_continuous(
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  scale_y_continuous(
    limits = c(0, NA),
    labels = label_number(big.mark = ".", decimal.mark = ",")
  ) +
  labs(x = "Muafiyet d (TL)",
       y = "Beklenen sigortacı ödemesi E[Y] (TL)") +
  theme_minimal(base_size = 12)

Dışbükey azalan bir eğri 2.210 TL'den başlar, ilk birkaç bin lirada dik iner, sonra yavaşlayarak 10.000 TL muafiyette 266 TL'ye ulaşır; sıfıra inmez, çünkü Pareto'da her muafiyetin üstünde bir kayıp olasılığı vardır. Altın nokta derste kullanılan 1.000 TL muafiyetteki 1.611 TL'lik beklenen ödemeyi işaretler.

Muafiyet 0’dan 10.000 TL’ye çıkarıldığında beklenen ödeme 2.210 TL’den 266 TL’ye iner; ilk 2.000 TL’lik muafiyet tek başına 991 TL tasarruf sağlarken kalan 8.000 TL’lik artış beklenen ödemeyi yalnızca 954 TL daha düşürür.
  • annotate("text", x = , y = , label = ) — veri çerçevesinden gelmeyen, tek bir elle yazılmış öğeyi grafiğe ekler. geom_text()’ten farkı budur: geom_text() bir sütundaki her satır için bir etiket çizer, annotate() ise verdiğiniz tek etiketi verdiğiniz tek noktaya koyar.
  • hjust / vjust — etiketin kendi noktasına göre yatay ve düşey hizalamasıdır; buradaki -0.08 ve -1.1 değerleri yazıyı noktanın sağına ve biraz yukarısına kaydırır, böylece etiket altın noktanın üstüne binmez.
  • limits = c(0, NA) — düşey ekseni sıfırdan başlatır; NA üst sınırı veriye bırakır. Verilmezse: eksen verinin en küçük değerinin yakınından, yaklaşık 170 TL’den başlar ve eğri olduğundan dik görünür.

Görev B’nin yanıtı şudur: muafiyet beklenen ödemeyi her düzeyde düşürür, ama her ek lira bir öncekinden daha az. Eğri 10.000 TL’lik muafiyette bile sıfıra inmez (266 TL), çünkü her muafiyetin üstünde bir kayıp olasılığı vardır. Beklenen ödemeye dayanan bir indirim tablosunda eşit aralıklı her muafiyet basamağının indirimi bu yüzden bir öncekinden küçüktür.

Görev C — Hangi prim büyük, ve bu sıralama evrensel mi?

Gövde iki primi dört değerli küçük bir ödeme dağılımında hesapladı; o örnekte beklenen değer primi daha büyük çıktı. Bu bir kural mıdır, yoksa portföye mi bağlıdır? Prim prensibini ve katsayısını seçerken bunu bilmek gerekir. Aynı iki katsayıyı ders poliçesinin Pareto ödemelerine uygulayıp sıralamanın neye bağlı olduğunu bulacağız.

Önce bileşik toplamın iki momentine ihtiyacımız var. Yıllık kayıp sayısını Poisson dağılımıyla ve \(\lambda=120\) ile alıyoruz. Bu, gövdenin küçük portföyündeki 25’ten büyük, örnek olarak seçilmiş bir değerdir; sıralamanın \(\lambda\)’ya nasıl bağlı olduğunu görevin sonunda ölçeceğiz.

Kodu göster / gizle
lambda <- 120
lambda
#> [1] 120

Beklenen toplam hasar, Bileşik toplam hasar bölümündeki \(E[S]=\lambda E[Y]\) ile gövdedeki beklenen ödemenin \(\lambda\) katıdır.

Kodu göster / gizle
beklenen_toplam <- lambda * beklenen_paket
beklenen_toplam
#> [1] 193370.8

Çıktı yaklaşık 193.370,8 olmalıdır.

Varyans, aynı bölümün Poisson formülüyle \(\operatorname{Var}(S)=\lambda E[Y^2]\)’dir. \(E[Y^2]\)’yi Pareto kayıplarında beklenen ödeme bölümünün Ödemenin ikinci momenti alt bölümünde kapalı biçimde bulduk: ikinci_moment_kapali.

Kodu göster / gizle
toplam_sd <- sqrt(lambda * ikinci_moment_kapali)
toplam_sd
#> [1] 30657.21

Çıktı yaklaşık 30.657 TL olmalıdır.

Şimdi iki primi gövdedeki iki prensiple hesaplıyoruz: beklenen değer prensibi \((1+\rho)\,E[S]\), standart sapma prensibi \(E[S]+k\sqrt{\operatorname{Var}(S)}\). Katsayılar gövdedeki örnektekilerle aynıdır: \(\rho=0{,}20\) ve \(k=0{,}30\).

Kodu göster / gizle
gorev_c <- c(
  beklenen_deger_primi = (1 + 0.20) * beklenen_toplam,
  standart_sapma_primi = beklenen_toplam + 0.30 * toplam_sd
)
round(gorev_c, 2)
#> beklenen_deger_primi standart_sapma_primi 
#>             232044.9             202567.9

Beklenen değer primi yaklaşık 232.045 TL, standart sapma primi yaklaşık 202.568 TL çıkmalıdır; beklenen toplam hasarın kendisi 193.371 TL’dir.

Bu iki katsayıyla beklenen değer primi daha büyük. Ama bu seçilen katsayılardan mı geliyor, yoksa evrensel bir kural mı? Basit prim prensipleri bölümünde gördüğümüz gibi hangi primin büyük olduğunu yüklemeler belirler: \(\rho\,E[S]>k\sqrt{\operatorname{Var}(S)}\) ise beklenen değer primi büyüktür. İki yüklemeyi eşitleyen \(k\) değeri bu yüzden yanıtı verir:

\[ k^{*}=\frac{\rho\,E[S]}{\sqrt{\operatorname{Var}(S)}}=\frac{\rho}{\mathrm{CV}}. \]

Buradaki \(\mathrm{CV}=\sqrt{\operatorname{Var}(S)}/E[S]\), toplam hasarın değişim katsayısıdır (coefficient of variation): standart sapmanın ortalamaya oranı. \(k\), \(k^{*}\)’ın altındaysa beklenen değer primi, üstündeyse standart sapma primi büyüktür.

Kodu göster / gizle
gorev_c_esitlik <- c(
  degisim_katsayisi = toplam_sd / beklenen_toplam,
  esitleyen_k       = 0.20 * beklenen_toplam / toplam_sd
)
round(gorev_c_esitlik, 4)
#> degisim_katsayisi       esitleyen_k 
#>            0.1585            1.2615

Değişim katsayısı yaklaşık 0,1585, eşitleyen \(k\) ise yaklaşık 1,2615 çıkmalıdır. Kullandığımız \(k=0{,}30\) bunun çok altında; standart sapma priminin öne geçmesi için \(k\)’nın dört katından fazla büyümesi gerekirdi.

Değişim katsayısı neden bu kadar küçük? Bileşik Poisson’da \(E[S]=\lambda E[Y]\) ve \(\operatorname{Var}(S)=\lambda E[Y^2]\) olduğundan

\[ \begin{aligned} \mathrm{CV}&=\frac{\sqrt{\lambda E[Y^2]}}{\lambda E[Y]}\\ &=\frac{1}{\sqrt{\lambda}}\cdot\frac{\sqrt{E[Y^2]}}{E[Y]}. \end{aligned} \]

İkinci çarpan yalnız tek bir ödemenin dağılımına bağlıdır; birinci çarpan portföy büyüdükçe küçülür: kayıp sayısı dört katına çıkınca değişim katsayısı yarıya iner. 120 kaybın toplamı tek bir kayba göre bu yüzden çok daha az oynaktır. \(k^{*}=\rho/\mathrm{CV}\) ise \(\sqrt{\lambda}\) ile büyür ve \(k^{*}=k\) koşulu iki primi eşitleyen portföy büyüklüğünü verir:

\[ \begin{aligned} \rho\sqrt{\lambda}\,\frac{E[Y]}{\sqrt{E[Y^2]}}&=k,\\ \lambda^{*}&=\Big(\frac{k}{\rho}\Big)^{2}\frac{E[Y^2]}{(E[Y])^{2}}. \end{aligned} \]

Bu eşiği ders poliçesinin kapalı momentleriyle hesaplayalım: ikinci_moment_kapali \(E[Y^2]\)’nin, beklenen_paket \(E[Y]\)’nin kapalı değeridir.

Kodu göster / gizle
gorev_c_lambda_esigi <- (0.30 / 0.20)^2 * ikinci_moment_kapali / beklenen_paket^2
gorev_c_lambda_esigi
#> [1] 6.786525

Çıktı yaklaşık 6,79 olmalıdır.

Bu katsayılarla standart sapma primi ancak yılda yediden az kayıp beklenen bir portföyde öne geçer. Gövdenin A portföyünde aynı eşik, o portföyün ödeme dağılımının momentleriyle, 6,89 kayıptır; \(\lambda=25\) bunun üstünde olduğu için orada da beklenen değer primi büyük çıktı.

Sıralama bu yüzden evrensel değildir: \(k\) ile \(\rho/\mathrm{CV}\) karşılaştırmasıdır ve değişim katsayısı portföy büyüdükçe \(1/\sqrt{\lambda}\) ile küçülür. Aynı katsayılarla \(\lambda=120\)’lik bu portföyde beklenen değer primi, birkaç kayıplık bir portföyde standart sapma primi büyük çıkar. Doğru cevap “beklenen değer primi daha büyüktür” değil, “bu portföyde ve bu katsayılarla daha büyüktür”.

İki prensibin asıl farkı da buradadır. Beklenen değer prensibi her portföye beklenen hasarın aynı %20’sini yükler; standart sapma prensibinin yüklemesi beklenen hasarın \(k\cdot\mathrm{CV}\) katıdır (bu portföyde %4,8) ve portföy küçülüp oynaklaştıkça büyür. Prensip seçimi bu yüzden bir fiyat politikası seçimidir: yükleme portföyün oynaklığını izlesin mi, izlemesin mi?

Alıştırmalar

Aşağıdaki alıştırmalar bu haftanın kayıptan ödemeye dönüşümünü, sınırlı beklenen değeri, bileşik toplam hasarı ve prim prensiplerini pekiştirir. Önce kendi çözümünüzü yazın, ardından her kutudaki Çözümü göster düğmesiyle karşılaştırın. Bir alıştırma gövdedeki ya da laboratuvardaki bir tabloya veya sonuca dayanıyorsa, o bilgi alıştırmanın içinde yeniden verilmiştir; geri dönüp aramanız gerekmez. Çözümler bir formülü yeniden türetmez, türetildiği bölümü adıyla anar.

Alıştırma 1 (Ödeme tablosunu elle kurun). Bir poliçede muafiyet \(d=2.000\) TL, muafiyet sonrası ödeme limiti \(L=8.000\) TL ve koasürans oranı \(c=0{,}75\)’tir. Yıl içinde gerçekleşen beş kayıp aşağıdadır:

Kayıp \(X\) (TL) Sigortacı ödemesi \(Y\) (TL)
800 ?
2.000 ?
5.000 ?
9.500 ?
25.000 ?
  1. Her kayıp için \(Y=c\min\{(X-d)_+,L\}\) değerini hesaplayın.
  2. Sigortacının ödediği toplam tutarı ve sigortalının kendi ödediği toplam tutarı bulun; kalan tutarı muafiyet, limit üstü ve koasürans payına ayırın.
  3. Her kaybın parçalı tanımın hangi parçasına düştüğünü belirtin.

(a) \(Y=c\min\{(X-d)_+,L\}\) içten dışa okunur (Kayıptan ödemeye): önce muafiyet düşülür, sonra limit uygulanır, en son koasürans oranıyla çarpılır.

Kayıp \(X\) \((X-d)_+\) \(\min\{(X-d)_+,L\}\) \(Y=c\cdot\) önceki
800 0 0 0
2.000 0 0 0
5.000 3.000 3.000 2.250
9.500 7.500 7.500 5.625
25.000 23.000 8.000 6.000

Örneğin 9.500 TL’lik kayıpta \[Y=0{,}75\times\min\{9.500-2.000,\;8.000\}=0{,}75\times 7.500=5.625\ \text{TL}.\]

(b) Toplam ödeme \[0+0+2.250+5.625+6.000=13.875\ \text{TL}.\] Toplam kayıp \(800+2.000+5.000+9.500+25.000\) \(=42.300\) TL olduğundan sigortalının kendi ödediği tutar \(42.300-13.875=28.425\) TL’dir. Sigortacı toplam kaybın \(13.875/42.300=0{,}328\)’ini, yani üçte birine yakınını üstlenmiştir.

Sigortalının ödediği 28.425 TL üç parçadan oluşur:

Sigortalının ödediği Hesap Tutar (TL)
muafiyet \(800+4\times2.000\) 8.800
limit üstü \(25.000-10.000\) 15.000
koasürans payı \(0{,}25\times18.500\) 4.625
toplam 28.425

Muafiyet payı her kayıpta \(\min(X,d)\)’dir: 800 TL’lik kayıpta 800 TL, öbür dördünde 2.000 TL. Limit üstü pay yalnız 25.000 TL’lik kayıpta vardır: kaybın \(d+L=10.000\) TL’yi aşan kısmı. Koasürans payındaki 18.500 TL, (a) tablosunun üçüncü sütununun toplamıdır (\(3.000+7.500+8.000\)), yani muafiyet ile limit arasında kalan tutarlar; sigortalı bunun %25’ini taşır. Sigortalının payının yarısından fazlasını tek bir büyük kaybın limit üstü kısmı oluşturur.

(c) \(X\le d\) parçasında 800 ve 2.000 TL vardır; 2.000 TL tam sınırdadır ve ödeme yine sıfırdır. \(d<X<d+L=10.000\) parçasında 5.000 ve 9.500 TL bulunur; burada ödeme kaybın muafiyeti aşan kısmının \(0{,}75\) katıdır. \(X\ge d+L\) parçasına yalnızca 25.000 TL düşer; ödeme \(cL=0{,}75\times 8.000=6.000\) TL’de sabitlenir ve kayıp büyüse de artmaz.

Alıştırma 2 (Muafiyet, ödeme sıklığı ve olasılık). Bir portföyde yıllık ham kayıp sayısı \(N\sim\text{Poisson}(80)\)’dir ve her kayıp sıfır başlangıçlı Pareto dağılımlıdır: \[P(X>x)=\left(\frac{6.000}{6.000+x}\right)^{2},\] yani \(\alpha=2\), \(\theta=6.000\). Poliçe muafiyeti \(d=2.000\) TL’dir.

  1. Bir kaybın muafiyeti aşma olasılığı \(P(X>2.000)\) kaçtır?
  2. Yılda beklenen ödeme sıklığı, yani ödeme doğuran olay sayısı kaçtır?
  3. Muafiyet 4.000 TL’ye çıkarılırsa ham kayıp sıklığı ve ödeme sıklığı nasıl değişir?
  4. Bir yönetici “%56,25, bir poliçenin hasar yapma olasılığıdır” diyor. Bu yorumu düzeltin.

(a) Sağkalım fonksiyonunu doğrudan kullanırız: \[P(X>2.000)=\left(\frac{6.000}{6.000+2.000}\right)^{2} =\left(\frac{3}{4}\right)^{2}=0{,}5625.\] actuar::ppareto(2000, shape = 2, scale = 6000, lower.tail = FALSE) aynı 0,5625 değerini verir.

(b) Ödeme sayısı, her kayıp için “muafiyeti aştı mı” göstergesinin, yani 1 ya da 0 değerinin \(N\) kayıp üzerinden toplamıdır. Göstergeler kayıplar gibi birbirinden bağımsız ve aynı dağılımlıdır, ortalamaları \(P(X>d)\)’dir. Bileşik toplam hasar bölümündeki \(E[S]=E[N]E[Y]\) formülü \(Y\) yerine bu göstergeyle uygulanınca: \[ \begin{aligned} E[\text{ödeme sayısı}]&=80\times 0{,}5625\\ &=45\ \text{ödeme/yıl}. \end{aligned} \]

(c) Muafiyet kaybın oluşmasını engellemez; ham kayıp sıklığı 80’de kalır. Yalnızca aşma olasılığı değişir: \[ \begin{aligned} P(X>4.000)&=\left(\frac{6.000}{10.000}\right)^{2}\\ &=0{,}36,\\ 80\times 0{,}36&=28{,}8\ \text{ödeme/yıl}. \end{aligned} \]

Ödeme sıklığı 45’ten 28,8’e, \(0{,}36/0{,}5625=0{,}64\) katına iner. Bu oran, 2.000 TL’yi aşan bir kaybın 4.000 TL’yi de aşma olasılığıdır. Gözlenen sıklıkta bunun ne anlama geldiğini Alıştırma 6 tartışır.

(d) 0,5625 bir poliçenin hasar yapma olasılığı değildir; bir kayıp gerçekleştiğinde o kaybın muafiyeti aşma olasılığıdır, yani koşullu bir olasılıktır. Bir poliçenin hasar yapma olasılığı için poliçe başına kayıp sayısının dağılımı gerekir; buradaki \(\text{Poisson}(80)\) portföyün toplam kayıp sayısıdır ve kayıpların kaç poliçeye dağıldığını söylemez. Ayrıca (b) ile (c)’deki 45 ve 28,8 olasılık değil beklenen sayıdır; 1’i rahatlıkla aşarlar. Doğru cümle şudur: “Bir kayıp gerçekleştiğinde, bu kayıp %56,25 olasılıkla muafiyeti aşar ve ödeme doğurur.”

Alıştırma 3 (Sınırlı beklenen değerle beklenen ödeme). Alıştırma 2’deki kayıp dağılımını sürdürün: \(X\sim\text{Pareto}(\alpha=2,\ \theta=6.000)\). Poliçe koşulları \(d=2.000\) TL, \(L=8.000\) TL ve \(c=0{,}75\)’tir.

  1. \(\alpha=2\) için \(LEV_X(u)\) formülünü sadeleştirin; \(LEV_X(2.000)\) ve \(LEV_X(10.000)\) değerlerini bulun.
  2. Beklenen sigortacı ödemesi \(E[Y]\)’yi hesaplayın.
  3. Poliçe koşulları uygulanmamış beklenen kayıp \(E[X]\) ile karşılaştırın: beklenen kaybın yüzde kaçı sigortacıya geçer, kalan pay muafiyet, limit üstü kısım ve koasürans arasında nasıl bölünür?

(a) Pareto II’nin \(LEV\) formülü Sıfır başlangıçlı Pareto için açık formül ve paket kontrolü bölümünde verildi. \(\alpha=2\) iken üs \(\alpha-1=1\) olur ve önündeki çarpan \(\theta/(\alpha-1)=6.000\)’dir. Köşeli parantezin içi de tek bir kesre iner, \(1-\frac{6.000}{6.000+u}=\frac{u}{6.000+u}\): \[ \begin{aligned} &LEV_X(u)\\ &\quad=6.000\left[1-\frac{6.000}{6.000+u}\right]\\ &\quad=\frac{6.000\,u}{6.000+u}. \end{aligned} \] Buradan \[\begin{aligned} LEV_X(2.000)&=\frac{6.000\times 2.000}{8.000}=1.500,\\[3pt] LEV_X(10.000)&=\frac{6.000\times 10.000}{16.000}=3.750.\end{aligned}\] actuar::levpareto(10000, shape = 2, scale = 6000) de 3.750 verir; elle bulunan formül ile paket örtüşür.

(b) Muafiyet sonrası limitli ödemenin beklenen değeri iki \(LEV\) farkıdır (Sınırlı beklenen değer): \[\begin{aligned} E[Y]&=c\bigl(LEV_X(d+L)-LEV_X(d)\bigr) =0{,}75\,(3.750-1.500)\\ &=0{,}75\times 2.250=1.687{,}50\ \text{TL}.\end{aligned}\]

(c) \(u\) sınırsız büyüdükçe \(\min(X,u)\) kaybın kendisine, \(LEV_X(u)\) de \(E[X]\)’e yaklaşır: (a)’daki \(6.000\,u/(6.000+u)\) 6.000’e gider. Bu, Hafta 3’te türetilen Pareto II ortalamasıdır, \(E[X]=\theta/(\alpha-1)=6.000\) TL. Oran \[\frac{1.687{,}50}{6.000}=0{,}28125,\] yani beklenen kaybın yalnızca yaklaşık %28,1’i sigortacıya geçer.

Kalan %71,9’un üç parçası (a)’daki iki \(LEV\) değerinden okunur:

Sigortalının ödediği Beklenen tutar (TL) \(E[X]\)’e oranı
muafiyet, \(LEV_X(2.000)\) 1.500 %25,0
limit üstü, \(E[X]-LEV_X(10.000)\) 2.250 %37,5
koasürans payı, \(0{,}25\,(3.750-1.500)\) 562,50 %9,4
toplam 4.312,50 %71,9

Limit üstü kısım \(E[X]-E[\min(X,10.000)]\), yani kaybın 10.000 TL’yi aşan kısmının beklenen değeridir. Alıştırma 1(b)’deki gibi sigortalının payının en büyük parçası yine limit üstüdür. 1.687,50 TL bir prim değil, yalnızca beklenen ödeme düzeyidir.

Alıştırma 4 (Bileşik toplam hasar ve iki prim). Gövdedekinden daha küçük bir portföyde yıllık kayıp sayısı \(N\sim\text{Poisson}(10)\)’dur. Her kayıp için sigortacı ödemesi \(Y\) (poliçe koşulları uygulandıktan sonra, ayrıklaştırılmış biçimde) şu dağılıma sahiptir:

Ödeme \(y\) (TL) \(P(Y=y)\)
0 0,85
10.000 0,10
40.000 0,05

Gövdedeki portföyde (\(\lambda=25\), A dağılımı) \(E[S]=52.500\) TL ve \(\sqrt{\operatorname{Var}(S)}=18.371{,}17\) TL idi.

  1. \(E[Y]\) ve \(E[Y^2]\) değerlerini hesaplayın.
  2. \(E[S]\), \(\operatorname{Var}(S)\) ve \(\sqrt{\operatorname{Var}(S)}\) değerlerini bulun.
  3. Gövdedeki katsayılarla, \(\rho=0{,}20\) ile beklenen değer primini ve \(k=0{,}30\) ile standart sapma primini hesaplayın. Hangisi büyüktür; gövdedeki örnekte hangisi büyüktü?
  4. İki primi eşitleyen \(k\) değerini bulun ve “beklenen değer primi her zaman daha büyüktür” iddiasını değerlendirin.

(a) Ağırlıklı toplamlar: \[\begin{aligned} E[Y]&=0\times 0{,}85+10.000\times 0{,}10+40.000\times 0{,}05\\ &=0+1.000+2.000=3.000\ \text{TL},\end{aligned}\] \[\begin{aligned} E[Y^2]&=10.000^2\times 0{,}10+40.000^2\times 0{,}05\\ &=10.000.000+80.000.000=90.000.000.\end{aligned}\] İkinci momentin %89’u (\(80.000.000/90.000.000\) \(=0{,}89\)) olasılığı yalnızca 0,05 olan 40.000 TL’lik ödemeden gelir; varyansı bu tek büyük değer belirler.

(b) Poisson kayıp sayısı için \(E[N]=\operatorname{Var}(N)=\lambda=10\) olduğundan Bileşik toplam hasar bölümünün iki formülü kullanılır: \[E[S]=\lambda E[Y]=10\times 3.000=30.000\ \text{TL},\] \[\operatorname{Var}(S)=\lambda E[Y^2]=10\times 90.000.000=900.000.000,\] \[\sqrt{\operatorname{Var}(S)}=\sqrt{900.000.000}=30.000\ \text{TL}.\] Standart sapma beklenen değere eşittir; gövdedeki portföyde ise beklenen değerin yalnızca %35’i kadardı.

(c) Beklenen değer prensibi: \[P_{\text{BD}}=(1+0{,}20)\times 30.000=36.000\ \text{TL}.\] Standart sapma prensibi: \[P_{\text{SS}}=30.000+0{,}30\times 30.000=39.000\ \text{TL}.\] Bu portföyde standart sapma primi 3.000 TL daha büyüktür. Gövdedeki örnekte sıralama tersti: beklenen değer primi 63.000 TL, standart sapma primi 58.011,35 TL. Katsayılar aynı olduğuna göre sıralamayı değiştiren portföydür.

(d) İki prim, yüklemeleri eşit olduğunda çakışır: \(\rho\,E[S]=k\sqrt{\operatorname{Var}(S)}\). Buradan \[ \begin{aligned} 0{,}20\times 30.000&=k\times 30.000,\\ k&=\frac{6.000}{30.000}=0{,}20. \end{aligned} \]

Bu, Görev C’deki \(k^{*}=\rho/\mathrm{CV}\) eşitliğinin kendisidir: değişim katsayısı \(30.000/30.000=1\) olduğu için \(k^{*}=\rho=0{,}20\)’dir. Kullanılan \(k=0{,}30\) bunun üstünde kaldığından standart sapma primi öne geçer. Gövdedeki örnekte eşik \(0{,}20\times52.500/18.371{,}17\) \(\approx0{,}5715\) idi ve \(k=0{,}30\) onun altında kalıyordu.

Değişim katsayısını neyin büyüttüğü bileşik Poisson’da açıkça görülür: \[ \begin{aligned} \mathrm{CV}&=\frac{\sqrt{\lambda E[Y^2]}}{\lambda E[Y]}\\ &=\frac{1}{\sqrt{\lambda}}\cdot\frac{\sqrt{E[Y^2]}}{E[Y]}. \end{aligned} \]

Portföy \(\lambda\) \(1/\sqrt{\lambda}\) \(\sqrt{E[Y^2]}/E[Y]\) CV
bu alıştırma 10 0,316 3,16 1,00
gövdedeki 25 0,200 1,75 0,35

Bu portföyün değişim katsayısı gövdedekinin \(1/0{,}35=2{,}86\) katıdır ve iki kaynaktan gelir: kayıp sayısı 2,5 kat az olduğu için \(\sqrt{2{,}5}=1{,}58\) kat, ödeme dağılımının kuyruğu daha ağır olduğu için \(3{,}16/1{,}75=1{,}81\) kat; \(1{,}58\times1{,}81=2{,}86\).

İddia bu yüzden yanlıştır: sıralama \(k\) ile \(\rho/\mathrm{CV}\)’nin karşılaştırmasıdır. Kayıp sayısı az ve ödemelerin kuyruğu ağır bir portföyde CV büyür, \(k^{*}\) küçülür ve standart sapma primi öne geçer.

Alıştırma 5 (İşlem sırası ve sözleşme dili). İki öğrenci ödeme fonksiyonunu farklı sırayla yazıyor:

d <- 2000; L <- 8000; c_oran <- 0.75

# Surum A
odeme_a <- function(x) c_oran * pmin(pmax(x - d, 0), L)

# Surum B
odeme_b <- function(x) pmin(c_oran * pmax(x - d, 0), L)
  1. \(X=5.000\), \(X=10.000\) ve \(X=30.000\) TL için iki sürümün sonuçlarını hesaplayın.
  2. İki sürüm hangi kayıp değerinden itibaren ayrışır? Sürüm B’nin ödemesi hangi kayıpta tavana ulaşır?
  3. Derste kullanılan tanımda \(L\), muafiyet sonrası ödeme limitidir. Bu tanım hangi sürüme karşılık gelir ve ayrım sözleşme yazımında neden önemlidir?

(a)

Kayıp \(X\) (TL) Sürüm A (TL) Sürüm B (TL)
5.000 2.250 2.250
10.000 6.000 6.000
30.000 6.000 8.000

30.000 TL’de A sürümü \(0{,}75\times\min\{28.000;\,8.000\}\) \(=0{,}75\times 8.000\) \(=6.000\) TL, B sürümü ise \(\min\{0{,}75\times 28.000;\,8.000\}\) \(=\min\{21.000;\,8.000\}\) \(=8.000\) TL verir.

(b) A sürümü \(X\ge d+L=10.000\) TL’den itibaren \(cL=6.000\) TL’de sabitlenir. B sürümü koasüransı önce uyguladığı için tavana ancak \(c(X-d)=L\) koşulunda, yani \[ \begin{aligned} X&=d+\frac{L}{c}=2.000+\frac{8.000}{0{,}75}\\ &\approx 12.666{,}67\ \text{TL} \end{aligned} \] kaybında ulaşır ve tavanı 8.000 TL olur.

İki sürüm 10.000 TL’ye kadar aynı sonucu verir. \(X\le d+L\) iken \((X-d)_+\le L\) olduğundan A’daki \(\min\) hiçbir şey kesmez ve A \(c\,(X-d)_+\) öder; B’de de \(c\,(X-d)_+\le cL\) \(=6.000<8.000\) olduğundan \(\min\) kesmez. 10.000 TL’nin üzerinde A 6.000 TL’de durur, B ise 12.666,67 TL’ye kadar \(0{,}75\,(X-2.000)\) ile artmaya devam eder; iki sürüm 10.000 TL’nin üzerindeki bütün kayıplarda ayrışır.

(c) Derste \(Y=c\min\{(X-d)_+,L\}\) tanımı kullanıldığı için Sürüm A doğrudur: limit, koasüranstan önce ve muafiyet sonrası tutara uygulanır. Gövdedeki uyarı kutusu “limit” sözcüğünün iki okumasını vermişti:

Okuma Ödeme Kutudaki örnek: \(d=1.000\), \(c=0{,}80\), “10.000 limit”, \(X=12.000\)
muafiyet sonrası ödeme limiti (bu ders) \(Y=c\min\{(X-d)_+,L\}\) 8.000 TL
toplam kayıp limiti \(Y=c\,\bigl(\min(X,u)-d\bigr)_+\) 7.200 TL

Sürüm B, \(Y=\min\{c\,(X-d)_+;\;L\}\), bu iki okumanın hiçbiri değildir; üçüncü bir okumadır: \(L\)’yi koasürans uygulandıktan sonra sigortacının ödemesine konan tavan, yani sigortacının ödeyeceği azami tutar diye yorumlar. Büyük hasarlarda \(8.000/6.000\), yani yaklaşık %33 daha yüksek ödeme üretir.

Aynı “8.000 limit” cümlesi böylece 30.000 TL’lik kayıpta üç ayrı ödemeye okunabilir: muafiyet sonrası ödeme limiti 6.000, toplam kayıp limiti \(0{,}75\times(8.000-2.000)\) \(=4.500\), Sürüm B 8.000 TL öder. Formül yazılmazsa iki taraf aynı cümleden farklı sözleşmeler anlayabilir.

Kodda bu tür bir sıra hatasını yalnız kaybın \(d+L\)’yi aştığı bir test yakalar; şık (a)’daki 5.000 ve 10.000 TL’lik satırlar iki sürümü ayırt edemez. Gövdedeki Sınır testleri bu yüzden limit üstü bir kayıp içerir. Sürüm B, gövdenin koşullarıyla (\(d=1.000\), \(L=10.000\), \(c=0{,}80\)), 30.000 TL’lik kayba 8.000 yerine \(\min\{0{,}80\times29.000;\;10.000\}\) \(=10.000\) TL öder ve üçüncü test durur; muafiyet altı ve ara kayıplı öbür iki test geçer.

Yorumlama alıştırmaları

Bu alıştırmalar hesaplamadan çok, kullanılan ölçünün anlamını ve analizin sınırlılıklarını kısa biçimde tartışmak içindir. Önce yanıtınızı oluşturun, ardından ilgili Çözümü göster düğmesiyle karşılaştırın.

Alıştırma 6 (Hasar sıklığı ve ödeme sıklığı). Muafiyet artınca hasar sıklığı mı, ödeme sıklığı mı değişir?

Muafiyet kaybın oluşmasını engellemez, yalnızca hangi kayıpların ödeme doğurduğunu değiştirir; bu yüzden değişen ödeme sıklığıdır, ham hasar sıklığı değildir. Alıştırma 2’nin kurulumunda ham kayıp sayısı \(\text{Poisson}(80)\) olarak sabit kalırken, muafiyet 2.000 TL’den 4.000 TL’ye çıkarıldığında aşma olasılığı 0,5625’ten 0,36’ya, beklenen ödeme sayısı 45’ten 28,8’e iner.

Gözlenen veride iki sıklık kolayca karışır, çünkü muafiyet altı kayıplar sigortacıya çoğu zaman hiç bildirilmez. Yalnız ödeme doğuran kayıplar bildiriliyorsa gözlenen sıklık ödeme sıklığıdır ve muafiyet artışından sonra 45’ten 28,8’e, %36 düşer; oysa kayıp sıklığı 80’de kalmıştır. Bu bir raporlama etkisidir, riskin azaldığının kanıtı değildir. Muafiyetin değiştiği yıllar bu yüzden aynı ölçüye getirilerek karşılaştırılır: eski yılların kayıtlarından da yalnız yeni muafiyeti, 4.000 TL’yi aşan kayıplar sayılır.

Alıştırma 7 (Limit ve kuyruk riski). Limit, büyük hasar kuyruğunun sigortacı üzerindeki etkisini nasıl değiştirir? Ders poliçesinde limitin beklenen ödemeyi, ödemenin standart sapmasını ve en büyük ödemeyi ne kadar değiştirdiğini karşılaştırın.

Limit, ödemeyi \(cL\) düzeyinde keser: ders parametrelerinde (\(\alpha=2{,}8\), \(\theta=6.000\), \(d=1.000\) TL, \(c=0{,}80\)) kayıp ne kadar büyürse büyüsün ödeme \(0{,}80\times 10.000=8.000\) TL’de sabitlenir; sayfadaki transfer eğrisinin sağ ucundaki yatay parça budur. Limitsiz poliçede en büyük ödeme sınırsızdır.

Limitsiz poliçenin iki momenti gövdedeki formüllerde (Sınırlı beklenen değer) \(d+L\) sınırsız büyütülerek bulunur: \(LEV_X(d+L)\) yerine \(E[X]=3.333{,}333\), \(E[\min(X,d+L)^2]\) yerine Hafta 3’teki Pareto II momenti \(E[X^2]=2\theta^2/((\alpha-1)(\alpha-2))\) \(=50.000.000\) gelir. Muafiyetteki \(LEV_X(1.000)=807{,}675\) gövdeden gelir, \(E[\min(X,1.000)^2]=749.671\)’i actuar::levpareto(1000, shape = 2.8, scale = 6000, order = 2) verir. Fark \(E[X]-LEV_X(1.000)\) \(=2.525{,}658\) olduğundan limitsiz beklenen ödeme: \[ \begin{aligned} E[Y]&=0{,}80\times2.525{,}658\\ &=2.020{,}53\ \text{TL}. \end{aligned} \]

İkinci moment, gövdedeki \(E[Y^2]\) formülünde aynı iki değiştirmeyle: \[ \begin{aligned} E[Y^2]&=0{,}64\times\bigl(50.000.000\\ &\qquad-749.671\\ &\qquad-2.000\times2.525{,}658\bigr)\\ &=28.287.368. \end{aligned} \]

Limitli poliçenin değerleri gövdeden gelir (Pareto kayıplarında beklenen ödeme bölümünün Ödemenin ikinci momenti alt bölümü); standart sapma \(\sqrt{E[Y^2]-(E[Y])^2}\)’dir:

limitsiz \(L=10.000\) TL
\(E[Y]\) (TL) 2.020,53 1.611,42
\(E[Y^2]\) 28.287.368 7.832.206
standart sapma (TL) 4.920 2.288
en büyük ödeme (TL) sınırsız 8.000

Limit beklenen ödemenin \(1-1.611{,}42/2.020{,}53\), yani yaklaşık %20,2’sini keser. Kesilen tutar \(c\,(E[X]-LEV_X(11.000))\) \(=c\,E[(X-11.000)_+]\), kaybın 11.000 TL’yi aşan kısmının beklenen değeridir ve yalnız \(X>11.000\) olduğunda sıfırdan büyüktür: kayıpların yalnızca yaklaşık %5,4’ü bu bölgeye düşer, ama limitsiz beklenen ödemenin beşte biri oradan gelir.

İkinci momentte etki çok daha büyüktür: limit onun %72,3’ünü keser ve ödemenin standart sapmasını yarısının altına indirir, çünkü kare alınınca büyük ödemelerin ağırlığı artar. Limit ortalamayı düşürmenin yanında değişkenliği ve en kötü durum ödemesini de sınırlar; buna karşılık kesilen kuyruk yok olmaz, onu sigortalı kendisi öder.

Alıştırma 8 (Koasüransın orantılı etkisi). Koasürans neden bütün pozitif ödemeleri aynı oranda azaltır?

Bu derste kullanılan tanımda \(Y=c\min\{(X-d)_+,L\}\): \(c\), muafiyet ve limit uygulandıktan sonra devreye giren sabit bir çarpandır. Sabit bir çarpan her pozitif değeri aynı oranda küçültür; Görev A’da \(c=1\) alınan sütun her pozitif satırda temel poliçenin tam \(1/0{,}80=1{,}25\) katıydı. Beklenen değer de aynı oranla ölçeklenir: iki \(LEV\) farkı \(2.821{,}95-807{,}68=2.014{,}27\) TL’dir ve \(c=0{,}80\) ile beklenen ödeme onun tam %80’i, \(0{,}80\times2.014{,}27=1.611{,}42\) TL’dir.

Koasürans hangi kayıpların ödeme doğuracağını değiştirmez: ödeme sıklığı yalnızca \(P(X>d)\)’ye bağlıdır ve sabit kalır, değişen ödeme büyüklüğüdür.

Bu orantılılık işlem sırasına bağlıdır. Alıştırma 5’teki Sürüm B koasüransı limitten önce uygular ve 30.000 TL’lik kayba \(c=0{,}75\) ile de \(c=1\) ile de 8.000 TL öder, çünkü iki durumda da tavana dayanır. Orada koasürans büyük hasarı hiç azaltmaz; etkisi büyük hasarlarda orantılı olmaktan çıkar.

Alıştırma 9 (Parametreleştirme kontrolü). Pareto parametreleştirmesini kontrol etmeden paket kullanmanın riski nedir?

Aynı \(\alpha\) ve \(\theta\) sembolleri kaynaktan kaynağa farklı dağılımlar tanımlar ve kod hata vermeden yanlış sayıyı üretir. actuar paketinin dpareto() adıyla kullandığı sıfır başlangıçlı biçimde \(\alpha=2{,}8\), \(\theta=6.000\) için \(P(X>11.000)=(6/17)^{2{,}8}\) \(=0{,}0541\) ve \(E[X]=3.333{,}33\) TL’dir.

Klasik Pareto (Pareto I) ise \(\theta\)’yı alt sınır olarak okur: \(x\ge\theta\) için \(P(X>x)=(\theta/x)^{\alpha}\) ve \(\theta\)’nın altında hiç kayıp yoktur. Aynı simgelerle \(P(X>11.000)=(6/11)^{2{,}8}\) \(=0{,}1832\) olur. Ortalama yine aşma olasılığının integralidir: 0–6.000 aralığı 6.000, ötesi \(\int_{\theta}^{\infty}(\theta/x)^{\alpha}dx\) \(=\theta/(\alpha-1)\) \(=3.333{,}33\) katkı yapar ve \(E[X]=9.333{,}33\) TL çıkar.

Beklenen ödeme de değişir. Klasik Pareto’da her kayıp en az 6.000 TL olduğundan muafiyet her kayıptan tam 1.000 TL düşer: \(LEV_X(1.000)=1.000\). \(LEV_X(11.000)\) ise 0–6.000 aralığının 6.000’i ile 6.000–11.000 aralığının katkısının toplamıdır. İkincisi, \(x^{-2{,}8}\)’in ilkeli \(x^{-1{,}8}/(-1{,}8)\) ile, \((6.000/1{,}8)\bigl(1-(6/11)^{1{,}8}\bigr)\) \(=2.213{,}782\)’dir. Toplam 8.213,782; iki \(LEV\) farkı 7.213,782 olur: \[ \begin{aligned} E[Y]&=0{,}80\times7.213{,}782\\ &=5.771{,}03\ \text{TL}. \end{aligned} \]

Bu, gövdedeki 1.611,42 TL’nin \(5.771{,}03/1.611{,}42=3{,}6\) katıdır ve fark ne bir uyarı ne bir hata mesajı üretir.

Paket de aynı türden bir tuzak taşır: actuar::levpareto1(1000, shape = 2.8, min = 6000) 1.000 yerine 0 döndürür; \(u\le6.000\) için \(\min(X,u)=u\) olduğunu hesaba katmaz. İki levpareto1() çağrısının farkı bu yüzden 5.771,03 yerine \(0{,}80\times8.213{,}782\) \(=6.571{,}03\) TL verir, yine uyarısız.

Korunma yolu sayfadaki yöntemdir: kapalı formülü bağımsız olarak kodlayıp paketin sonucuyla all.equal() üzerinden karşılaştırmak. Eşleşme, parametrelerin paketin beklediği anlamda yorumlandığının ve paketin o noktada doğru hesapladığının kanıtıdır; yukarıdaki iki hata da böyle bir karşılaştırmada görünür olurdu.

Alıştırma 10 (Ortalama ve kuyruk ayrımı). Beklenen değer primi ağır kuyruk riskini yeterince yansıtmayabilir mi?

Evet; beklenen değer prensibi yalnızca \(E[S]\)’yi kullandığı için aynı ortalamaya sahip iki portföyü hiçbir koşulda ayırt edemez. Gövdedeki bileşik toplam hasar örneğinde (\(\lambda=25\), A dağılımı) \(E[S]=52.500\) TL ve \(\sqrt{\operatorname{Var}(S)}=18.371{,}17\) TL’dir. Ödemenin %90 olasılıkla 0, %10 olasılıkla 21.000 TL olduğu ikinci bir dağılımda \(E[Y]=0{,}10\times21.000\) \(=2.100\) TL, A’nınkiyle aynıdır; ama \(E[Y^2]=0{,}10\times21.000^2\) \(=44.100.000\), A’nınkinin 3,27 katıdır.

Ortalama yine 52.500 TL’dir, ama standart sapma ve standart sapma primi büyür: \[ \begin{aligned} \sqrt{\operatorname{Var}(S)}&=\sqrt{25\times44.100.000}\\ &=33.203{,}915\ \text{TL},\\ P_{\text{SS}}&=52.500\\ &\quad+0{,}30\times33.203{,}915\\ &=62.461{,}17\ \text{TL}. \end{aligned} \]

\(\rho=0{,}20\) ile beklenen değer primi iki portföyde de tıpatıp 63.000 TL’dir; \(k=0{,}30\)’lu standart sapma primi ise 58.011,35 TL ile 62.461,17 TL diye ayrışır ve farkı görebilir.

“Yeterli mi?” sorusunun ölçütü bu yüzden portföyün değişim katsayısı (Görev C) ve kuyruk ağırlığıdır: A’da \(18.371{,}17/52.500=0{,}35\), ikinci dağılımda \(33.203{,}915/52.500=0{,}63\).

Değişim katsayısı büyüdükçe sabit bir \(\rho\) giderek daha yetersiz kalır. Standart sapma prensibi de her şeyi çözmez; ilk iki momenti aynı, kuyruğu çok farklı dağılımları o da ayıramaz. Gövdedeki A ve B dağılımları bunu gösterdi: en büyük ödemesi 15.000 TL olan B de A gibi 58.011,35 TL’lik standart sapma primi alır.

Gövdedeki iki ödeme dağılımı (\(\lambda=25\)); ikisinde de \(E[Y]=2.100\) TL ve \(E[Y^2]=13.500.000\):

Ödeme \(y\) (TL) A: \(P(Y=y)\) B: \(P(Y=y)\)
0 0,40 0,46
1.000 0,30 —
3.000 — 0,50
4.000 0,20 —
10.000 0,10 —
15.000 — 0,04

Alıştırma 11 (Bağımsızlık varsayımı ve afet). Toplam hasar formülündeki bağımsızlık varsayımı afet hasarlarında neden sorunludur?

\(\operatorname{Var}(S)=\lambda E[Y^2]\) formülü, hasar sayısı ile ödemelerin bağımsız ve ödemelerin birbirinden bağımsız aynı dağılımlı olmasına dayanır. Bir afette tek bir olay hem çok sayıda hasarı aynı anda tetikler hem de hepsinin büyüklüğünü aynı yönde iter; sayı ve büyüklük artık ortak şok (common shock) altında birlikte hareket eder.

Etkinin büyüklüğü bir uç durumda ölçülebilir. Gövdedeki örneğin ödeme dağılımını (A, \(\lambda=25\)) alalım:

Ödeme \(y\) (TL) \(P(Y=y)\)
0 0,40
1.000 0,30
4.000 0,20
10.000 0,10

Bu dağılımda \(E[Y]=2.100\) TL ve \(\operatorname{Var}(Y)=9.090.000\)’dir (Küçük bir portföyde beklenen değer ve varyans).

\(N\) yine bağımsız kalsın, ama bir yıldaki bütün ödemeler aynı değeri alsın: \(S=N\,Y\). Varyansın iki parçalı yazılışında (Bileşik toplam hasar) değişen yalnız birinci terimdir: \(N=n\) iken \(n\) bağımsız ödemenin toplamının varyansı \(n\operatorname{Var}(Y)\) idi, aynı ödemenin \(n\) katınınki ise \(n^{2}\operatorname{Var}(Y)\)’dir. Birinci terimde \(E[N]\)’nin yerini \(E[N^2]=\operatorname{Var}(N)+(E[N])^2\) \(=25+625=650\) alır: \[ \begin{aligned} \operatorname{Var}(S)&=650\times9.090.000\\ &\quad+25\times2.100^2\\ &=5.908.500.000\\ &\quad+110.250.000\\ &=6.018.750.000. \end{aligned} \]

Karekökü \(\sqrt{6.018.750.000}=77.580{,}60\) TL’dir. \(E[S]=E[N]E[Y]\) yine 52.500 TL kalır, ama standart sapma 18.371,17 TL’den 77.580,60 TL’ye, yaklaşık 4,2 katına çıkar. Bağımsızlıkta aynı iki terim \(25\times9.090.000=227.250.000\) ile 110.250.000’di; fark, birinci terimin \(650/25=26\) kat büyümesidir.

Uç durum yalnız ödemelerin birlikte hareketini ölçer; afette hasar sayısı da aynı anda arttığı için gerçek etki daha da büyüktür. Ortalamaya dayanan hesaplar değişmezken değişkenliğe dayanan her şey — standart sapma primi, sermaye ihtiyacı, reasürans kararı — ciddi biçimde eksik tahmin edilir. Bu sayfadaki hesaplar öğretim amaçlıdır; afet riski taşıyan gerçek bir portföyde bağımlılığı açıkça modelleyen bir kurulum gerekir.

Kaynaklar

  • Cossette, H., Frees, E. W., Hartman, B. ve Higgins, T. (ed.) (2024). Loss Data Analytics, 2. baskı: bölüm 5.1 (muafiyet, limit ve koasürans), 7 (toplam hasar modelleri) ve 10 (prim temelleri). Açık erişimli sürümü: openacttexts.github.io/LDAVer2
  • Klugman, S. A., Panjer, H. H. ve Willmot, G. E. (2019). Loss Models: From Data to Decisions, 5. baskı. Wiley: bölüm 8 (poliçe koşullarıyla sıklık ve büyüklük) ve 9 (toplam hasar modelleri).
  • Kaas, R., Goovaerts, M., Dhaene, J. ve Denuit, M. (2008). Modern Actuarial Risk Theory: Using R, 2. baskı. Springer: bölüm 3 (kolektif risk modelleri) ve 5 (prim prensipleri ve risk ölçüleri).
  • Dutang, C., Goulet, V. ve Pigeon, M. (2008). actuar: An R package for actuarial science. Journal of Statistical Software, 25(7), 1–37: Pareto dağılımı ve sınırlı beklenen değer işlevleri (levpareto()). doi:10.18637/jss.v025.i07
Başa dön