Insurance Domain Complete Guide -- From Life Insurance to Property Insurance and Premium Calculation

import numpy as np

# Individual accidents are unpredictable, but group accident rates are predictable!
n_people = [10, 100, 1000, 10000, 100000]
accident_rate = 0.05  # Actual accident rate 5%

for n in n_people:
    accidents = np.random.binomial(n, accident_rate)
    observed_rate = accidents / n
    print(f"  {n:>7} people: Observed rate = {observed_rate:.4f} (error: {abs(observed_rate - accident_rate):.4f})")

# 10: 0.1000 (error: 0.0500)       <- Inaccurate
# 100000: 0.0498 (error: 0.0002)   <- Nearly exact!
# -> The more policyholders, the more accurate the insurer's predictions

Total Premium Income = Total Claims Paid + Operating Expenses

Premium = Net Premium (Risk Premium) + Loading (Expenses)
          ├── Claims payment fund        ├── Agent commissions
          └── Insurance risk reserve     ├── Company operating costs
                                         └── Profit

Types:
├── Whole Life: Death benefit (lifetime coverage)
│   └── High premiums, for inheritance/dependents
├── Term Life: Death benefit within a set period
│   └── Low premiums, set for 20-30 years
├── Endowment: Benefit on death or maturity
│   └── Savings + coverage combined
└── Annuity: Pension payments from a certain age
    └── Retirement planning, tax benefits

# Term insurance premium calculation (simplified model)
def term_insurance_premium(age, coverage, term_years, mortality_table):
    """
    Net premium = Sum of (mortality rate x coverage x discount factor)
    """
    premium = 0
    discount_rate = 0.035  # Assumed interest rate 3.5%

    for year in range(term_years):
        current_age = age + year
        mortality = mortality_table[current_age]  # Mortality rate by age
        # Present value of death benefit for that year
        pv = coverage * mortality / (1 + discount_rate) ** (year + 1)
        premium += pv

    # Annual net premium = Total PV / Annuity factor
    annuity_factor = sum(1 / (1 + discount_rate) ** y for y in range(1, term_years + 1))
    annual_premium = premium / annuity_factor

    # Add loading (expense ratio ~30%)
    gross_premium = annual_premium / 0.7

    return gross_premium

# Age 30, 100M KRW coverage, 20 years
# premium = term_insurance_premium(30, 100_000_000, 20, mortality_table)

Types:
├── Fire Insurance: Building and movable property fire damage
├── Auto Insurance
│   ├── Bodily Injury I/II: Death/injury to others
│   ├── Property Damage: Damage to others' property
│   ├── Personal Injury: Own injuries
│   ├── Own Vehicle: Own car repair
│   └── Uninsured Motorist: Accidents with uninsured drivers
├── Liability Insurance: Damages caused to third parties
├── Marine Insurance: Ships, cargo
└── Surety Insurance: Debt default guarantee

# Auto insurance premium factors
auto_insurance_factors = {
    "vehicle": {
        "model": "K5 (midsize)",
        "year": 2024,
        "vehicle_value": 30_000_000,
        "usage": "commuting",
    },
    "driver": {
        "age": 30,
        "gender": "male",
        "license_type": "Class 1 Standard",
        "accident_history": 0,  # Last 3 years
        "insurance_tenure": 5,  # Years
    },
    "discounts_surcharges": {
        "no_claims_discount": -15,  # %
        "dashcam_discount": -5,
        "mileage_discount": -10,
        "multi_child_discount": 0,
        "accident_surcharge": 0,
    }
}

# Loss Ratio = Claims Paid / Earned Premium x 100%
# Combined Ratio = Loss Ratio + Expense Ratio
# Less than 100%: Profitable from insurance operations alone
# Greater than 100%: Must be covered by investment income

Insurance related to "the human body" that is neither life nor P&C:
├── Indemnity Health Insurance: Reimburses actual medical costs (most important!)
├── Accident Insurance: Injuries from external accidents
├── Disease Insurance: Cancer, stroke, heart attack, etc.
├── Long-term Care Insurance: Long-term nursing state
└── Dental Insurance: Dental treatment

Gross Premium
├── Net Premium -- Source for claims payment
│   ├── Risk Premium: Based on death/accident probability
│   └── Savings Premium: Source for maturity refund (savings-type insurance)
│
└── Loading -- Company operating expenses
    ├── Acquisition Cost: Agent commissions (concentrated in first year)
    ├── Maintenance Cost: Annual management expenses
    └── Collection Cost: Premium collection expenses

# Three fundamental rates for premium calculation
class InsuranceBasicRates:
    # 1. Assumed Mortality/Morbidity Rate
    #    -> Death/accident probability by age/gender/occupation
    #    -> Based on life tables and experience statistics
    mortality_30_male = 0.00098  # 30-year-old male annual mortality 0.098%

    # 2. Assumed Interest Rate
    #    -> Rate of return insurers expect from investment operations
    #    -> Higher rate means lower premiums (offset by future investment returns)
    assumed_rate = 0.025  # 2.5% (current low-interest era)

    # 3. Assumed Expense Ratio
    #    -> Proportion of premium allocated to expenses
    expense_ratio = 0.25  # 25%

def loss_ratio(claims_paid, earned_premium):
    """Loss Ratio = Claims Paid / Earned Premium x 100"""
    return (claims_paid / earned_premium) * 100

# Auto insurance: Loss ratio 80% (high)
# Life insurance: Loss ratio 50% (low)
# Indemnity health: Loss ratio 120% (operating at a loss!)

def combined_ratio(loss_ratio, expense_ratio):
    """Combined Ratio = Loss Ratio + Expense Ratio"""
    return loss_ratio + expense_ratio

# Less than 100%: Profit from insurance operations alone (underwriting profit)
# Equal to 100%: Break-even
# Greater than 100%: Operating loss -> must be covered by investment income

# Korean P&C insurance average: ~105% (operating loss, covered by investment returns)

# Insurance company soundness indicator (FSS supervision)
def rbc_ratio(available_capital, required_capital):
    """RBC Ratio = Available Capital / Required Capital x 100"""
    return (available_capital / required_capital) * 100

# Must maintain at least 100%
# 150% or above: Sound (FSS recommendation)
# Below 100%: Subject to prompt corrective action!

Traditional Insurance       ->    InsurTech
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
In-person agent sales         ->    App/web direct enrollment
Paper claim forms             ->    OCR + AI automated review
Uniform premiums              ->    IoT + AI personalized premiums
Manual fraud detection        ->    ML anomaly detection
Months for claim payment      ->    Real-time automatic payment

# AI insurance fraud detection model (concept)
features = {
    "claim_amount": 50_000_000,      # Claim amount
    "days_since_policy": 30,          # Days since enrollment (too quick a claim?)
    "previous_claims": 5,             # Past claim count
    "medical_consistency": 0.3,       # Diagnosis-claim consistency (low = suspicious)
    "provider_fraud_score": 0.8,      # Hospital's fraud history score
    "claimant_network_risk": 0.6,     # Claimant network risk
}

# Predict fraud probability with XGBoost / LightGBM
# fraud_probability = model.predict(features)
# If greater than 0.7, automatically escalate to SIU (Special Investigation Unit)

Insurance System Architecture:
├── Policy Administration
│   └── Enrollment, changes, cancellation, renewal
├── Underwriting
│   └── Enrollment screening, risk assessment
├── Rating Engine
│   └── Actuarial-based premium calculation
├── Claims
│   └── Filing, review, payment, fraud detection
├── Billing
│   └── Premium collection, delinquency management
├── Reinsurance
│   └── Risk distribution (insurance for insurers)
└── Actuarial
    └── Reserve calculation, product design