startup-valuation 1.0.0__py3-none-any.whl

startup_valuation/__init__.py

@@ -0,0 +1,16 @@
+"""Startup Valuation — Comprehensive valuation library for startups."""
+
+from startup_valuation.types import (
+    ValuationResult,
+    Distribution,
+    Scenario,
+    SensitivityResult,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "ValuationResult",
+    "Distribution",
+    "Scenario",
+    "SensitivityResult",
+]

startup_valuation/advanced.py

@@ -0,0 +1,375 @@
+"""Advanced valuation techniques: Black-Scholes, Binomial, Monte Carlo, Scenario Analysis.
+
+Chapter 4: Advanced Techniques
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+from scipy import stats
+
+from startup_valuation.types import Distribution, Scenario, ValuationResult
+
+
+def black_scholes(
+    underlying: float,
+    strike: float,
+    risk_free_rate: float,
+    volatility: float,
+    time_to_maturity: float,
+) -> ValuationResult:
+    """Calculate call option value using Black-Scholes model.
+
+    Formula: C = N(d₁)S - N(d₂)Ke^(-rT)
+    where:
+        d₁ = [ln(S/K) + (r + σ²/2)T] / [σ√T]
+        d₂ = d₁ - σ√T
+
+    Args:
+        underlying: Current price of underlying asset (S).
+        strike: Strike price (K).
+        risk_free_rate: Risk-free rate (r).
+        volatility: Volatility of underlying (σ).
+        time_to_maturity: Time to maturity in years (T).
+
+    Returns:
+        ValuationResult with call option value.
+
+    Example:
+        >>> result = black_scholes(20_000_000, 5_000_000, 0.05, 0.40, 1.0)
+        >>> round(result.value / 1_000_000, 2)
+        15.24
+    """
+    if underlying <= 0 or strike <= 0:
+        raise ValueError("underlying and strike must be positive")
+    if volatility <= 0:
+        raise ValueError("volatility must be positive")
+    if time_to_maturity <= 0:
+        raise ValueError("time_to_maturity must be positive")
+
+    d1 = (math.log(underlying / strike) + (risk_free_rate + volatility**2 / 2) * time_to_maturity) / (
+        volatility * math.sqrt(time_to_maturity)
+    )
+    d2 = d1 - volatility * math.sqrt(time_to_maturity)
+
+    call_value = underlying * stats.norm.cdf(d1) - strike * math.exp(-risk_free_rate * time_to_maturity) * stats.norm.cdf(d2)
+
+    return ValuationResult(
+        value=call_value,
+        method="Black-Scholes",
+        inputs={
+            "underlying": underlying,
+            "strike": strike,
+            "risk_free_rate": risk_free_rate,
+            "volatility": volatility,
+            "time_to_maturity": time_to_maturity,
+        },
+        assumptions=[
+            "European-style option (exercise only at maturity)",
+            "Volatility is constant",
+            "No dividends",
+            "Continuous trading",
+        ],
+        chapter="4",
+    )
+
+
+def binomial_tree(
+    underlying: float,
+    strike: float,
+    risk_free_rate: float,
+    volatility: float,
+    time_to_maturity: float,
+    steps: int = 3,
+) -> ValuationResult:
+    """Value an option using a binomial tree model.
+
+    Formulas:
+        u = e^(σ√Δt)
+        d = e^(-σ√Δt)
+        p = (e^(rΔt) - d) / (u - d)
+
+    Args:
+        underlying: Current price of underlying asset.
+        strike: Strike price.
+        risk_free_rate: Risk-free rate.
+        volatility: Volatility.
+        time_to_maturity: Time to maturity in years.
+        steps: Number of time steps.
+
+    Returns:
+        ValuationResult with option value.
+    """
+    dt = time_to_maturity / steps
+    u = math.exp(volatility * math.sqrt(dt))
+    d = math.exp(-volatility * math.sqrt(dt))
+    p = (math.exp(risk_free_rate * dt) - d) / (u - d)
+
+    # Build terminal node values
+    node_values = [max(underlying * (u ** i) * (d ** (steps - i)) - strike, 0) for i in range(steps + 1)]
+
+    # Backward induction
+    for step in range(steps - 1, -1, -1):
+        node_values = [
+            math.exp(-risk_free_rate * dt) * (p * node_values[i + 1] + (1 - p) * node_values[i])
+            for i in range(step + 1)
+        ]
+
+    option_value = node_values[0]
+
+    return ValuationResult(
+        value=option_value,
+        method="Binomial Tree",
+        inputs={
+            "underlying": underlying,
+            "strike": strike,
+            "risk_free_rate": risk_free_rate,
+            "volatility": volatility,
+            "time_to_maturity": time_to_maturity,
+            "steps": steps,
+        },
+        assumptions=[
+            "American-style option (can exercise at any node)",
+            "Binomial tree converges to Black-Scholes as steps → ∞",
+        ],
+        chapter="4",
+    )
+
+
+def monte_carlo_valuation(
+    market_size_dist: Distribution,
+    market_share_dist: Distribution,
+    margin_dist: Distribution,
+    exit_multiple: float,
+    discount_rate: float,
+    years: float,
+    num_simulations: int = 10_000,
+    seed: int | None = None,
+) -> ValuationResult:
+    """Monte Carlo simulation for startup valuation.
+
+    Formula: PV = (Market Size × Market Share × Margin × Multiple) / (1 + r)^n
+
+    Args:
+        market_size_dist: Distribution for market size.
+        market_share_dist: Distribution for market share.
+        margin_dist: Distribution for profit margin.
+        exit_multiple: Exit multiple.
+        discount_rate: Discount rate.
+        years: Years to exit.
+        num_simulations: Number of simulations.
+        seed: Random seed for reproducibility.
+
+    Returns:
+        ValuationResult with mean, percentiles, and full distribution.
+    """
+    rng = np.random.default_rng(seed)
+
+    def sample(dist: Distribution, n: int) -> Any:
+        if dist.dist_type == "normal":
+            return rng.normal(dist.params["mean"], dist.params["std"], n)
+        elif dist.dist_type == "uniform":
+            return rng.uniform(dist.params["min"], dist.params["max"], n)
+        elif dist.dist_type == "triangular":
+            return rng.triangular(dist.params["min"], dist.params["mode"], dist.params["max"], n)
+        else:
+            raise ValueError(f"Unknown distribution type: {dist.dist_type}")
+
+    market_sizes = sample(market_size_dist, num_simulations)
+    market_shares = sample(market_share_dist, num_simulations)
+    margins = sample(margin_dist, num_simulations)
+
+    terminal_values = market_sizes * market_shares * margins * exit_multiple
+    present_values = terminal_values / ((1 + discount_rate) ** years)
+
+    present_values = present_values[present_values > 0]  # Filter negative values
+
+    mean_val = float(np.mean(present_values))
+    p10 = float(np.percentile(present_values, 10))
+    p50 = float(np.percentile(present_values, 50))
+    p90 = float(np.percentile(present_values, 90))
+    std_val = float(np.std(present_values))
+
+    return ValuationResult(
+        value=mean_val,
+        method="Monte Carlo Valuation",
+        inputs={
+            "market_size_dist": f"{market_size_dist.dist_type}({market_size_dist.params})",
+            "market_share_dist": f"{market_share_dist.dist_type}({market_share_dist.params})",
+            "margin_dist": f"{margin_dist.dist_type}({margin_dist.params})",
+            "exit_multiple": exit_multiple,
+            "discount_rate": discount_rate,
+            "years": years,
+            "num_simulations": num_simulations,
+        },
+        assumptions=[
+            f"Results based on {num_simulations:,} simulations",
+            "Distributions are independent",
+        ],
+        chapter="4",
+    )
+
+
+def scenario_analysis(scenarios: list[Scenario]) -> ValuationResult:
+    """Calculate expected value across scenarios.
+
+    Formula: E[V] = Σ pᵢ × Vᵢ
+
+    Args:
+        scenarios: List of scenarios with name, probability, and value.
+
+    Returns:
+        ValuationResult with expected value.
+
+    Example:
+        >>> scenarios = [
+        ...     Scenario("bull", 0.20, 10_000_000),
+        ...     Scenario("base", 0.60, 5_000_000),
+        ...     Scenario("bear", 0.20, 1_000_000),
+        ... ]
+        >>> result = scenario_analysis(scenarios)
+        >>> result.value
+        5200000.0
+    """
+    if not scenarios:
+        raise ValueError("at least one scenario required")
+
+    total_prob = sum(s.probability for s in scenarios)
+    if abs(total_prob - 1.0) > 0.01:
+        raise ValueError(f"scenario probabilities must sum to 1.0, got {total_prob}")
+
+    ev = sum(s.probability * s.value for s in scenarios)
+
+    return ValuationResult(
+        value=ev,
+        method="Scenario Analysis",
+        inputs={"scenarios": [(s.name, s.probability, s.value) for s in scenarios]},
+        assumptions=["Scenarios are mutually exclusive and exhaustive"],
+        chapter="4",
+    )
+
+
+def ltv_cac_valuation(
+    ltv_dist: Distribution,
+    cac_dist: Distribution,
+    market_size_dist: Distribution,
+    num_simulations: int = 10_000,
+    seed: int | None = None,
+) -> ValuationResult:
+    """Valuation using LTV/CAC ratio with Monte Carlo.
+
+    Formula: Valuation = (LTV/CAC) × Market Size × 0.1
+
+    Args:
+        ltv_dist: Distribution for LTV.
+        cac_dist: Distribution for CAC.
+        market_size_dist: Distribution for market size.
+        num_simulations: Number of simulations.
+        seed: Random seed.
+
+    Returns:
+        ValuationResult with mean valuation.
+    """
+    rng = np.random.default_rng(seed)
+
+    def sample(dist: Distribution, n: int) -> Any:
+        if dist.dist_type == "normal":
+            return rng.normal(dist.params["mean"], dist.params["std"], n)
+        elif dist.dist_type == "uniform":
+            return rng.uniform(dist.params["min"], dist.params["max"], n)
+        elif dist.dist_type == "triangular":
+            return rng.triangular(dist.params["min"], dist.params["mode"], dist.params["max"], n)
+        else:
+            raise ValueError(f"Unknown distribution type: {dist.dist_type}")
+
+    ltvs = sample(ltv_dist, num_simulations)
+    cacs = sample(cac_dist, num_simulations)
+    market_sizes = sample(market_size_dist, num_simulations)
+
+    cacs = np.maximum(cacs, 1e-6)  # Avoid division by zero
+    valuations = (ltvs / cacs) * market_sizes * 0.1
+    valuations = valuations[valuations > 0]
+
+    mean_val = float(np.mean(valuations))
+    std_val = float(np.std(valuations))
+    min_val = float(np.min(valuations))
+    max_val = float(np.max(valuations))
+
+    return ValuationResult(
+        value=mean_val,
+        method="LTV/CAC Valuation",
+        inputs={
+            "ltv_dist": f"{ltv_dist.dist_type}({ltv_dist.params})",
+            "cac_dist": f"{cac_dist.dist_type}({cac_dist.params})",
+            "market_size_dist": f"{market_size_dist.dist_type}({market_size_dist.params})",
+        },
+        assumptions=["LTV/CAC > 1 for viable business model"],
+        chapter="4",
+    )
+
+
+def binomial_valuation(
+    underlying: float,
+    strike: float,
+    risk_free_rate: float,
+    volatility: float,
+    time_to_maturity: float,
+    steps: int = 50,
+) -> ValuationResult:
+    """Value a startup option using binomial tree with high resolution.
+
+    Formula: Same as binomial_tree with steps=50 for convergence to Black-Scholes.
+
+    Args:
+        underlying: Current value of startup.
+        strike: Liquidation preference or strike price.
+        risk_free_rate: Risk-free rate.
+        volatility: Volatility of startup value.
+        time_to_maturity: Time to exit in years.
+        steps: Number of time steps (default 50 for convergence).
+
+    Returns:
+        ValuationResult with option value.
+
+    Example:
+        >>> result = binomial_valuation(20_000_000, 5_000_000, 0.05, 0.40, 1.0, 50)
+        >>> round(result.value / 1_000_000, 2)
+        15.24
+    """
+    dt = time_to_maturity / steps
+    u = math.exp(volatility * math.sqrt(dt))
+    d = math.exp(-volatility * math.sqrt(dt))
+    p = (math.exp(risk_free_rate * dt) - d) / (u - d)
+
+    # Build terminal node values
+    node_values = [max(underlying * (u ** i) * (d ** (steps - i)) - strike, 0) for i in range(steps + 1)]
+
+    # Backward induction
+    for step in range(steps - 1, -1, -1):
+        node_values = [
+            math.exp(-risk_free_rate * dt) * (p * node_values[i + 1] + (1 - p) * node_values[i])
+            for i in range(step + 1)
+        ]
+
+    option_value = node_values[0]
+
+    return ValuationResult(
+        value=option_value,
+        method="Binomial Valuation (High Resolution)",
+        inputs={
+            "underlying": underlying,
+            "strike": strike,
+            "risk_free_rate": risk_free_rate,
+            "volatility": volatility,
+            "time_to_maturity": time_to_maturity,
+            "steps": steps,
+        },
+        assumptions=[
+            f"Binomial tree with {steps} steps converges to Black-Scholes",
+            "European-style option",
+        ],
+        chapter="4",
+    )

startup_valuation/biotech.py

@@ -0,0 +1,161 @@
+"""Biotech and pharmaceutical valuation methods.
+
+Chapter 11: Industry-Specific Valuation Frameworks — Biotech
+"""
+
+from __future__ import annotations
+
+import math
+
+from startup_valuation.types import ValuationResult
+
+
+def rnPV(
+    cash_flows: list[float],
+    probabilities: list[float],
+    discount_rate: float,
+    development_costs: float = 0,
+) -> ValuationResult:
+    """Calculate risk-adjusted NPV for biotech.
+
+    Formula: rNPV = Σ[P_success × CFₜ / (1+r)ᵗ] - Development Costs
+
+    Args:
+        cash_flows: Cash flows at each period.
+        probabilities: Cumulative probability of success at each period.
+        discount_rate: Discount rate.
+        development_costs: Remaining development costs.
+
+    Returns:
+        ValuationResult with rNPV.
+    """
+    if len(cash_flows) != len(probabilities):
+        raise ValueError("cash_flows and probabilities must have same length")
+
+    rnpv = sum(
+        p * cf / ((1 + discount_rate) ** t)
+        for t, (cf, p) in enumerate(zip(cash_flows, probabilities))
+    ) - development_costs
+
+    return ValuationResult(
+        value=rnpv,
+        method="Risk-Adjusted NPV (rNPV)",
+        inputs={
+            "cash_flows": cash_flows,
+            "probabilities": probabilities,
+            "discount_rate": discount_rate,
+            "development_costs": development_costs,
+        },
+        assumptions=["Probabilities are cumulative success probabilities"],
+        chapter="11",
+    )
+
+
+def decision_tree_ev(
+    probabilities: list[float],
+    terminal_value: float,
+) -> ValuationResult:
+    """Calculate expected value from decision tree.
+
+    Formula: EV = Π pᵢ × Terminal Value
+
+    Example:
+        >>> result = decision_tree_ev([0.35, 0.60, 0.90], 500_000_000)
+        >>> result.value
+        94500000.0
+    """
+    joint_prob = math.prod(probabilities)
+    return ValuationResult(
+        value=joint_prob * terminal_value,
+        method="Decision Tree Expected Value",
+        inputs={"probabilities": probabilities, "terminal_value": terminal_value},
+        assumptions=["All stages must succeed sequentially"],
+        chapter="11",
+    )
+
+
+def peak_sales(
+    patient_population: float,
+    penetration_rate: float,
+    price: float,
+    compliance_rate: float = 1.0,
+) -> ValuationResult:
+    """Calculate peak sales for a drug.
+
+    Formula: Peak Sales = Population × Penetration × Price × Compliance
+
+    Example:
+        >>> result = peak_sales(50_000, 0.40, 150_000, 0.90)
+        >>> result.value
+        2700000000.0
+    """
+    return ValuationResult(
+        value=patient_population * penetration_rate * price * compliance_rate,
+        method="Peak Sales",
+        inputs={
+            "patient_population": patient_population,
+            "penetration_rate": penetration_rate,
+            "price": price,
+            "compliance_rate": compliance_rate,
+        },
+        chapter="11",
+    )
+
+
+def pipeline_valuation(
+    drugs: list[dict[str, float]],
+    discount_rate: float,
+) -> ValuationResult:
+    """Value a biotech pipeline.
+
+    Formula: V = Σ(Peak Sales × Multiple × P_success) / (1+r)ⁿ
+
+    Args:
+        drugs: List of dicts with keys: peak_sales, multiple, p_success, years_to_peak.
+        discount_rate: Discount rate.
+
+    Returns:
+        ValuationResult with pipeline value.
+
+    Example:
+        >>> drugs = [{"peak_sales": 2_000_000_000, "multiple": 5, "p_success": 0.60, "years_to_peak": 2}]
+        >>> result = pipeline_valuation(drugs, 0.12)
+        >>> round(result.value / 1_000_000_000, 2)
+        4.78
+    """
+    total_value = 0
+    for drug in drugs:
+        ps = drug["peak_sales"]
+        m = drug["multiple"]
+        p = drug["p_success"]
+        n = drug["years_to_peak"]
+        total_value += (ps * m * p) / ((1 + discount_rate) ** n)
+
+    return ValuationResult(
+        value=total_value,
+        method="Biotech Pipeline Valuation",
+        inputs={"num_drugs": len(drugs), "discount_rate": discount_rate},
+        assumptions=["Multiple is 3-5x peak sales for approved drugs"],
+        chapter="11",
+    )
+
+
+def overall_success_probability(
+    stage_probabilities: list[float],
+) -> ValuationResult:
+    """Calculate overall probability of success across all stages.
+
+    Formula: P_total = Π P_stage
+
+    Example:
+        >>> result = overall_success_probability([0.35, 0.60, 0.90])
+        >>> round(result.value, 4)
+        0.189
+    """
+    return ValuationResult(
+        value=math.prod(stage_probabilities),
+        method="Overall Success Probability",
+        inputs={"stage_probabilities": stage_probabilities},
+        assumptions=["Stages are sequential and independent"],
+        chapter="11",
+    )