Quantum advantage for actuaries

A high-level, pandas-integrated actuarial framework with optional quantum acceleration.

This package is not ready for use because it's still under preliminary development.
We are presently focused on building out Property & Casualty techniques.

Actuarial computations often involve heavy simulation and complex models for pricing and reserving. quActuary aims to empower actuaries with quantum computing speedups (e.g., quadratic Monte Carlo gains) without requiring quantum expertise.

The package will wrap IBM's Qiskit to abstract away the design of quantum circuits, leveraging existing actuarial Python libraries to minimize new implementations.

The API will feel familiar to actuaries (pandas data structures, common actuarial terminology) while hiding quantum mechanics details. Default model outputs will be provided as pandas Series or DataFrame for seamless downstream analysis.

Key Features

Actuarial-First Design

Work with familiar terminology and data structures that flatten the learning curve for actuarial professionals.

Intuitive Actuarial Interface

Perform pricing, reserving, and risk analysis using high-level, Pythonic pandas-like interfaces with minimal code.

Flexible Quantum Access

Run simulations with default settings or dive deeper to inspect and customize quantum circuits and algorithms.

Seamless Environment Switching

Develop on local simulators and deploy to IBM Quantum hardware with minimal configuration changes.

Development Roadmap

Phase 1: Core Simulation Functions for Risk Pricing

Statistical Distributions ✓
Policy and Portfolio Data Model ✓
Quantum Expected Loss
Quantum VaR and TVaR
Classical Monte Carlo
Quantum Monte Carlo
v0.1.0 Release

Phase 2: Reserving

IBNR Estimation
Basic Reserving Methods
Mack Method
Quantum Copula
Tail Risk, Risk Margin and Risk-of-Ruin Models

Phase 3: Advanced Models

Generalized Linear Models
Portfolio Optimization

Future Phases

Reinsurance
Life
Health
Quantum Data Privacy & Security

Usage Examples

Expected Loss

import quactuary as qa
import quactuary.book as book

from datetime import date
from quactuary.backend import set_backend
from quactuary.book import (
    ExposureBase, LOB, PolicyTerms, Inforce, Portfolio)
from quactuary.distributions.frequency import Poisson, NegativeBinomial
from quactuary.distributions.severity import Pareto, Lognormal
from quactuary.pricing import PricingModel


# Workers’ Comp Bucket
wc_policy = PolicyTerms(
    effective_date=date(2026, 1, 1),
    expiration_date=date(2027, 1, 1),
    lob=LOB.WC,
    exposure_base=book.PAYROLL,
    exposure_amount=100_000_000,
    retention_type="deductible",
    per_occ_retention=500_000,
    coverage="occ"
)

# General Liability Bucket
glpl_policy = PolicyTerms(
    effective_date=date(2026, 1, 1),
    expiration_date=date(2027, 1, 1),
    lob=LOB.GLPL,
    exposure_base=book.SALES,
    exposure_amount=10_000_000_000,
    retention_type="deductible",
    per_occ_retention=1_000_000,
    coverage="occ"
)

# Frequency-Severity Distributions
wc_freq = Poisson(100)
wc_sev = Pareto(1, 0, 40_000)

glpl_freq = NegativeBinomial(50, 0.5)
glpl_sev = Lognormal(2, 0, 100_000)

# Book of Business
wc_inforce = Inforce(
    n_policies=1000,
    terms=wc_policy,
    frequency=wc_freq,
    severity=wc_sev,
    name = "WC 2026 Bucket"
)

glpl_inforce = Inforce(
    n_policies=700,
    terms=glpl_policy,
    frequency=glpl_freq,
    severity=glpl_sev,
    name = "GLPL 2026 Bucket"
)

portfolio = wc_inforce + glpl_inforce

pm = PricingModel(portfolio)

# Test using Classical Monte Carlo
set_backend("classical")
classical_result = pm.simulate(n_sims=1_000)
classical_mean = classical_result.estimates["mean"]
print(f"Classical portfolio expected loss: {classical_mean}")

# When ready, run a quantum session
set_backend("quantum", provider="ibmq")
quantum_result = pm.simulate()
quantum_mean = quantum_result.estimates["mean"]
print(f"Quantum portfolio expected loss: {quantum_mean}")

In this example, quactuary loads the specified distributions into a quantum state (using an n-qubit discrete approximation) and builds the circuit needed for the excess loss algorithm on a book of business. The user is not expected to know anything about quantum circuit design.

The Portfolio can be built up using approximate Inforce buckets, or down to policy-level granularity with individual PolicyTerms tailored to each client from your policy administration system.

Risk Measures

Extend the portfolio above and calculate risk measures:

from quactuary.distributions.frequency import Geometric
from quactuary.distributions.severity import ContinuousUniformSeverity


# Commercial Auto Bucket
cauto_policy = PolicyTerms(
    effective_date=date(2026, 1, 1),
    expiration_date=date(2027, 1, 1),
    lob=LOB.CAuto,
    exposure_base=book.VEHICLES,
    exposure_amount=50,
    retention_type="deductible",
    per_occ_retention=100_000,
    coverage="occ"
)

# Frequency-Severity Distributions
cauto_freq = Geometric(1/8)
cauto_sev = ContinuousUniformSeverity(5_000, 95_000)

# Commercial Auto Inforce
cauto_inforce = Inforce(
    n_policies=400,
    terms=cauto_policy,
    frequency=cauto_freq,
    severity=cauto_sev,
    name = "CAuto 2026 Bucket"
)

# Add to Existing Portfolio
portfolio += cauto_inforce
pm2 = PricingModel(portfolio)

# Test using Classical Monte Carlo
with qa.use_backend("classical", num_simulations=1_000):
    classical_result = pm2.simulate(tail_alpha=0.05, n_sims=1_000)
    classical_VaR = classical_result.estimates["VaR"]
    classical_TVaR = classical_result.estimates["TVaR"]
    print(f"Classical portfolio VaR: {classical_VaR}")
    print(f"Classical portfolio TVaR: {classical_TVaR}")

# Evaluate using the Quantum session established earlier
quantum_result = pm2.simulate(tail_alpha=0.05)
quantum_VaR = quantum_result.estimates["VaR"]
quantum_TVaR = quantum_result.estimates["TVaR"]
print(f"Quantum portfolio VaR: {quantum_VaR}")
print(f"Quantum portfolio TVaR: {quantum_TVaR}")

Backends can be called as ContextManagers to be used across multiple statements. Again, all quantum circuits are taken care of behind the scenes.