quantark 0.2.1__tar.gz → 0.2.2__tar.gz

{quantark-0.2.1 → quantark-0.2.2}/CHANGELOG.md

@@ -5,6 +5,14 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project adheres to [Semantic Versioning](https://semver.org/).
 During 0.x the public API may still change between minor versions.
 
+## [0.2.2] - 2026-07-01
+
+### Fixed
+- PDE numerical Greeks: freeze the base spatial domain for finite-difference
+  bump repricing so rho and dividend rho measure market sensitivity without
+  contamination from auto-grid/domain movement under bumped rate, dividend,
+  volatility, or time inputs.
+
 ## [0.2.1] - 2026-06-30
 
 ### Fixed

{quantark-0.2.1 → quantark-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantark
-Version: 0.2.1
+Version: 0.2.2
 Summary: Modular derivatives pricing and risk library: options, autocallables, bonds, VaR, SIMM
 Project-URL: Homepage, https://github.com/deiiiiii93/quantark
 Project-URL: Repository, https://github.com/deiiiiii93/quantark

{quantark-0.2.1 → quantark-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quantark"
-version = "0.2.1"
+version = "0.2.2"
 description = "Modular derivatives pricing and risk library: options, autocallables, bonds, VaR, SIMM"
 readme = "README.md"
 requires-python = ">=3.10"

{quantark-0.2.1 → quantark-0.2.2}/quantark/__init__.py

@@ -1,3 +1,3 @@
 """QuantArk: professional financial derivatives pricing library."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{quantark-0.2.1 → quantark-0.2.2}/quantark/asset/equity/engine/base_engine.py

@@ -52,6 +52,18 @@ class BaseEngine(ABC):
         """
         pass
 
+    def create_bump_context(
+        self, product: BaseEquityProduct, pricing_env: PricingEnvironment
+    ) -> "BaseEngine":
+        """
+        Return an engine context for finite-difference bump repricing.
+
+        Engines with market-dependent numerical grids can override this hook to
+        freeze the base valuation grid/domain before bumped repricing. Engines
+        without such state explicitly fall back to the current repricing engine.
+        """
+        return self
+
     def price_with_events(
         self,
         product: BaseEquityProduct,

{quantark-0.2.1 → quantark-0.2.2}/quantark/asset/equity/engine/pde/base_pde_solver.py

@@ -7,6 +7,7 @@ backward in time, with support for Rannacher smoothing.
 
 from abc import abstractmethod
 from collections import OrderedDict
+from copy import deepcopy
 import math
 import threading
 from typing import Dict, Optional, Tuple, List, NamedTuple, Sequence
@@ -131,6 +132,35 @@ class BasePDESolver(BaseEngine):
             strategy = self._cache_strategy
         return strategy
 
+    def create_bump_context(
+        self, product: BaseEquityProduct, pricing_env: PricingEnvironment
+    ) -> "BasePDESolver":
+        """
+        Return a PDE solver clone with the base spatial domain frozen.
+
+        Auto spatial bounds depend on market drift/volatility. Freezing the
+        base valuation bounds keeps rate, dividend, volatility, and theta bumps
+        from mixing true market sensitivity with domain movement noise.
+        """
+        spot = pricing_env.spot
+        tau = product.get_maturity(pricing_env)
+        if tau <= 0:
+            return self
+
+        strike = getattr(product, "strike", spot)
+        r = pricing_env.get_rate(tau)
+        q = pricing_env.get_div_yield(tau)
+        sigma = pricing_env.get_vol(strike, tau)
+        barriers = self._get_barriers(product)
+        s_min, s_max = self._resolve_spatial_bounds(
+            product, spot, sigma, tau, r, q, barriers
+        )
+
+        fixed_params = deepcopy(self.params)
+        fixed_params.s_min = float(s_min)
+        fixed_params.s_max = float(s_max)
+        return type(self)(params=fixed_params)
+
     def _freeze_cache_value(self, value):
         if value is None or isinstance(value, (str, int, float, bool)):
             return value

{quantark-0.2.1 → quantark-0.2.2}/quantark/asset/equity/engine/pde/phoenix_pde_solver.py

@@ -43,6 +43,98 @@ class PhoenixPDESolver(SnowballPDESolver):
         self._coupon_amounts: np.ndarray = np.array([])
         self._coupon_cumulative: np.ndarray = np.array([])
 
+    # --- Native event stats (no MC): reuse the Snowball KO/KI machinery ---
+
+    def _event_stats_product_type(self) -> type:
+        return PhoenixOption
+
+    def _make_event_stats(self, **fields):
+        from quantark.asset.equity.engine.event_stats import PhoenixEventStats
+
+        return PhoenixEventStats(**fields)
+
+    def _n_extra_event_cols(self, n_ko: int) -> int:
+        # One coupon-trigger indicator column per observation.
+        return n_ko
+
+    def _set_extra_event_indicators(
+        self, v0, v1, s_vec, n_ko, ko_idx, rec, product, pricing_env, t_vec, t_idx
+    ) -> None:
+        # Set the coupon-trigger column on the coupon-pay mask AFTER the KO jump,
+        # so a coupon at a simultaneous KO is still counted (matches the Phoenix MC
+        # reference: coupon_hit gated on "alive entering obs i", incl. first_ko_idx==i).
+        if ko_idx is None or ko_idx >= self._coupon_barriers.shape[0]:
+            return
+        coupon_barrier = float(self._coupon_barriers[ko_idx])
+        pay_mask = self._get_barrier_mask(
+            s_vec, coupon_barrier, product.is_reverse, is_up_barrier=True
+        )
+        df_delay = self._cashflow_value_at_time(
+            pricing_env=pricing_env,
+            cashflow=1.0,
+            current_time=float(t_vec[t_idx]),
+            settlement_time=rec.settlement_time,
+        )
+        coup_col = n_ko + ko_idx
+        v0[pay_mask, coup_col] = df_delay
+        v1[pay_mask, coup_col] = df_delay
+
+    def _extract_extra_event_stats(
+        self, initial_grid, x_vec, spot_log, n_ko, ko_records, pricing_env, product
+    ) -> dict:
+        ed_coup = np.array(
+            [
+                float(np.interp(spot_log, x_vec, initial_grid[:, n_ko + i]))
+                for i in range(n_ko)
+            ],
+            dtype=float,
+        )
+        coupon_probability = np.zeros(n_ko, dtype=float)
+        for i, rec in enumerate(ko_records):
+            obs_time = float(rec.observation_time)
+            settle = float(
+                rec.settlement_time if rec.settlement_time is not None else obs_time
+            )
+            df0 = pricing_env.get_discount_factor(settle)
+            if df0 > 0.0:
+                coupon_probability[i] = float(ed_coup[i] / df0)
+        result = {"coupon_probability": coupon_probability}
+        ecc = self._coupon_cashflow_from_probability(
+            coupon_probability, n_ko, ko_records, pricing_env, product
+        )
+        if ecc is not None:
+            result["expected_discounted_coupon_cashflow"] = ecc
+        return result
+
+    def _coupon_cashflow_from_probability(
+        self, coupon_probability, n_ko, ko_records, pricing_env, product
+    ):
+        """Expected discounted coupon cashflow for non-memory coupons, else None.
+
+        With a deterministic per-period coupon amount and a deterministic
+        settlement time, E[DF(0->settle) * amount * 1{coupon}] factors exactly as
+        DF(0->settle) * amount * P(coupon). For memory coupons the paid amount is
+        path-dependent and cannot be recovered from the trigger indicator, so we
+        omit the field (probability stays correct) rather than report a wrong value.
+        """
+        if product.has_memory_coupon:
+            return None
+        expiry = product.coupon_config.coupon_pay_type == CouponPayType.EXPIRY
+        maturity = float(product.get_maturity(pricing_env))
+        ecc = np.zeros(n_ko, dtype=float)
+        for i, rec in enumerate(ko_records):
+            obs_time = float(rec.observation_time)
+            settle = maturity if expiry else obs_time
+            amt = (
+                float(self._coupon_amounts[i])
+                if i < self._coupon_amounts.shape[0]
+                else 0.0
+            )
+            ecc[i] = float(
+                pricing_env.get_discount_factor(settle) * amt * coupon_probability[i]
+            )
+        return ecc
+
     # price() and calculate_greeks() are inherited from SnowballPDESolver
     # The _check_product_type() method uses _supported_product_type to validate
 

{quantark-0.2.1 → quantark-0.2.2}/quantark/asset/equity/engine/pde/snowball_pde_solver.py

@@ -323,20 +323,49 @@ class SnowballPDESolver(BasePDESolver):
     def calculate_event_stats(
         self, product: BaseEquityProduct, pricing_env: PricingEnvironment
     ) -> Optional[AutocallableEventStats]:
-        """
-        Provide per-observation KO probabilities and expected discounted cashflows.
+        """Provide per-observation KO probabilities and expected discounted cashflows."""
+        if not isinstance(product, self._event_stats_product_type()):
+            return None
+        if pricing_env is None:
+            return None
+        return self._compute_event_stats(product, pricing_env)
+
+    def _event_stats_product_type(self) -> type:
+        """Product type accepted by ``calculate_event_stats`` (overridable)."""
+        return SnowballOption
+
+    def _make_event_stats(self, **fields) -> AutocallableEventStats:
+        """Construct the event-stats dataclass (overridable by subclasses)."""
+        return AutocallableEventStats(**fields)
+
+    # --- Extra indicator-surface hooks (overridden by Phoenix for coupons) ---
+
+    def _n_extra_event_cols(self, n_ko: int) -> int:
+        """Extra stacked indicator columns beyond ``[KO_0..KO_{n-1}]``."""
+        return 0
+
+    def _set_extra_event_indicators(
+        self, v0, v1, s_vec, n_ko, ko_idx, rec, product, pricing_env, t_vec, t_idx
+    ) -> None:
+        """Set extra indicator columns at an observation (no-op for Snowball)."""
+        return None
+
+    def _extract_extra_event_stats(
+        self, initial_grid, x_vec, spot_log, n_ko, ko_records, pricing_env, product
+    ) -> dict:
+        """Extra event-stats fields from the extra columns (none for Snowball)."""
+        return {}
 
+    def _compute_event_stats(
+        self, product: BaseEquityProduct, pricing_env: PricingEnvironment
+    ) -> Optional[AutocallableEventStats]:
+        """
         Native PDE implementation:
         - Propagates stacked indicator surfaces through the same backward PDE stepping.
         - Applies KO/KI jumps to all indicator surfaces at observation times.
         - Returns KO per-observation probabilities (by dividing discounted indicators by
           discount factors) and expected discounted KO cashflows.
         """
-        if not isinstance(product, SnowballOption):
-            return None
-        if pricing_env is None:
-            return None
-
         spot = pricing_env.spot
         tau = product.get_maturity(pricing_env)
         if tau <= 0 or is_zero(tau):
@@ -398,9 +427,10 @@ class SnowballPDESolver(BasePDESolver):
                 )
             ko_index_by_tidx[t_idx] = k
 
-        # Surface columns: [KO_0, ..., KO_{n_ko-1}, KI_indicator]
-        ki_col = n_ko
-        n_cols = n_ko + 1
+        # Surface columns: [KO_0..KO_{n-1}, <extra coupon cols>, KI_indicator]
+        n_extra = self._n_extra_event_cols(n_ko)
+        ki_col = n_ko + n_extra
+        n_cols = n_ko + n_extra + 1
 
         # Terminal conditions at maturity (t = T):
         # - KO indicators are zero at maturity (KO only at discrete observations via jumps)
@@ -427,6 +457,10 @@ class SnowballPDESolver(BasePDESolver):
             )
             v0_next[mask_ko, terminal_ko_idx] = df_delay
             v1_next[mask_ko, terminal_ko_idx] = df_delay
+            self._set_extra_event_indicators(
+                v0_next, v1_next, s_vec, n_ko, terminal_ko_idx, rec,
+                product, pricing_env, t_vec, terminal_tidx,
+            )
 
         is_terminal_ki = product.has_ki_barrier and (
             self._ki_continuous or terminal_tidx in self._ki_observation_indices
@@ -535,6 +569,10 @@ class SnowballPDESolver(BasePDESolver):
                 )
                 v0_cur[mask_ko, ko_idx] = df_delay
                 v1_cur[mask_ko, ko_idx] = df_delay
+                self._set_extra_event_indicators(
+                    v0_cur, v1_cur, s_vec, n_ko, ko_idx, rec,
+                    product, pricing_env, t_vec, j,
+                )
 
             # Apply KI jump (continuous or discrete at observation indices).
             if product.has_ki_barrier:
@@ -597,7 +635,17 @@ class SnowballPDESolver(BasePDESolver):
         pv = float(self.price(product, pricing_env))
         expected_discounted_maturity_cf = float(pv - float(np.sum(ed_ko_cf)))
 
-        return AutocallableEventStats(
+        extra_fields = self._extract_extra_event_stats(
+            initial_grid, x_vec, spot_log, n_ko, ko_records, pricing_env, product
+        )
+        # The maturity cashflow is pv minus KO cashflows; for products with extra
+        # cashflow streams (Phoenix coupons) also remove those so the decomposition
+        # pv = sum(ko) + sum(coupon) + maturity stays correctly classified.
+        coupon_cf = extra_fields.get("expected_discounted_coupon_cashflow")
+        if coupon_cf is not None:
+            expected_discounted_maturity_cf -= float(np.sum(coupon_cf))
+
+        return self._make_event_stats(
             pv=pv,
             ko_times=ko_times,
             ko_probability=ko_probability,
@@ -609,6 +657,7 @@ class SnowballPDESolver(BasePDESolver):
             ki_times=ki_times,
             ki_event_probability=ki_event_probability,
             ki_survival_probability=ki_survival_probability,
+            **extra_fields,
         )
 
     def calculate_greeks(
@@ -1620,7 +1669,7 @@ class SnowballPDESolver(BasePDESolver):
             )
 
         # Boundary fallback: use next scheduled KO record (ignore past observations).
-        ko_records = product.resolve_ko_observations(pricing_env)
+        ko_records = self._get_cached_ko_records(pricing_env, product)
         future_records = [
             rec for rec in ko_records if self._record_is_non_negative_time(rec)
         ]

{quantark-0.2.1 → quantark-0.2.2}/quantark/asset/equity/engine/pde_engine.py

@@ -213,6 +213,18 @@ class PDEEngine(BaseEngine):
         solver = self._get_solver(product)
         return solver.price(product, pricing_env)
 
+    def create_bump_context(
+        self, product: BaseEquityProduct, pricing_env: PricingEnvironment
+    ) -> "PDEEngine":
+        """
+        Return a facade engine whose dispatched solver uses fixed bump bounds.
+        """
+        solver = self._get_solver(product)
+        fixed_solver = solver.create_bump_context(product, pricing_env)
+        if fixed_solver is solver:
+            return self
+        return type(self)(params=fixed_solver.params, method=self.method)
+
     def calculate_greeks(
         self, product: BaseEquityProduct, pricing_env: PricingEnvironment
     ) -> Dict[str, float]:

{quantark-0.2.1 → quantark-0.2.2}/quantark/asset/equity/engine/quad/phoenix_quad_engine.py

@@ -14,7 +14,7 @@ import numpy as np
 
 from quantark.asset.equity.engine.quad.quad_math import QuadratureMath
 from quantark.asset.equity.engine.quad.snowball_quad_engine import SnowballQuadEngine
-from quantark.asset.equity.param import MCParams, QuadParams
+from quantark.asset.equity.param import QuadParams
 from quantark.asset.equity.product.base_equity_product import BaseEquityProduct
 from quantark.asset.equity.product.option.phoenix_option import PhoenixOption
 from quantark.priceenv import PricingEnvironment
@@ -483,16 +483,77 @@ class PhoenixQuadEngine(SnowballQuadEngine):
         self._last_spot_greeks_grid = (spot_grid.copy(), value_surface.copy())
         return math_utils.interpolate(value_surface, x=0.0)
 
-    def calculate_event_stats(
-        self, product: BaseEquityProduct, pricing_env: PricingEnvironment
-    ):
-        if not isinstance(product, PhoenixOption):
-            return None
+    def _event_stats_product_type(self) -> type:
+        return PhoenixOption
+
+    def _make_event_stats(self, **fields):
+        from quantark.asset.equity.engine.event_stats import PhoenixEventStats
 
-        from quantark.asset.equity.engine.mc.phoenix_mc_engine import PhoenixMCEngine
+        return PhoenixEventStats(**fields)
 
-        mc_engine = PhoenixMCEngine(params=MCParams())
-        return mc_engine.calculate_event_stats(product, pricing_env)
+    def _n_extra_quad_rows(self, n_ko: int) -> int:
+        # One coupon-trigger indicator row per observation.
+        return n_ko
+
+    def _coupon_barrier_for_obs(self, product, obs_index: int) -> float:
+        cb = product.coupon_config.coupon_barrier
+        if isinstance(cb, list):
+            return float(cb[obs_index])
+        return float(cb)
+
+    def _set_extra_quad_indicators(
+        self, v_in, v_out, spot_grid, n_ko, ko_index, ko_record, obs_time,
+        rate, product, disable_ko_after_ki,
+    ) -> None:
+        barrier = self._coupon_barrier_for_obs(product, ko_index)
+        pay_mask = (
+            spot_grid <= barrier if product.is_reverse else spot_grid >= barrier
+        )
+        coup_row = n_ko + ko_index
+        # Undiscounted coupon-hit indicator (1.0 at the observation); the
+        # probability is recovered by dividing by exp(-r*obs) at extraction,
+        # matching the Phoenix MC reference (coupon_probability = mean(coupon_hit)).
+        # Coupons are paid while ALIVE regardless of KI state, so set BOTH surfaces:
+        # disable_ko_after_ki only suppresses future KO, never coupons.
+        # LIMITATION: under CONTINUOUS KI the coupon rows ride the same Brownian-
+        # bridge diffusion as the value surfaces, which leaves a ~5-7% coupon-
+        # probability approximation vs MC (KO/survival remain tight). Prefer the MC
+        # engine for tight continuous-KI coupon valuation.
+        v_out[coup_row, pay_mask] = 1.0
+        v_in[coup_row, pay_mask] = 1.0
+
+    def _extract_extra_quad_stats(
+        self, initial_surface, math_utils, n_ko, ko_records, rate, product, maturity
+    ) -> dict:
+        coupon_probability = np.zeros(n_ko, dtype=float)
+        for i, rec in enumerate(ko_records):
+            obs_time = float(rec.observation_time)
+            # Coupon row was set to 1.0 (undiscounted indicator) at the observation,
+            # so ed_coup = E[DF(0->obs) * 1{coupon, alive}].
+            ed_coup = float(math_utils.interpolate(initial_surface[n_ko + i], x=0.0))
+            df_obs = math.exp(-rate * obs_time)
+            if df_obs > 0.0:
+                coupon_probability[i] = float(ed_coup / df_obs)
+        result = {"coupon_probability": coupon_probability}
+        # Expected discounted coupon cashflow only for non-memory coupons (the paid
+        # amount is path-dependent under memory). With a deterministic amount and
+        # settlement, E[DF*amount*1{coupon}] = DF(0->settle)*amount*P(coupon).
+        if not product.has_memory_coupon:
+            ko_times = [float(rec.observation_time) for rec in ko_records]
+            period_yf = product.get_coupon_period_year_fractions(ko_times)
+            coupon_amounts = [
+                float(product.get_coupon_payoff(i, year_fraction=period_yf[i]))
+                for i in range(n_ko)
+            ]
+            expiry = product.coupon_config.coupon_pay_type == CouponPayType.EXPIRY
+            ecc = np.zeros(n_ko, dtype=float)
+            for i in range(n_ko):
+                settle = float(maturity) if expiry else ko_times[i]
+                ecc[i] = float(
+                    math.exp(-rate * settle) * coupon_amounts[i] * coupon_probability[i]
+                )
+            result["expected_discounted_coupon_cashflow"] = ecc
+        return result
 
     def __repr__(self):
         return "PhoenixQuadEngine()"

{quantark-0.2.1 → quantark-0.2.2}/quantark/asset/equity/engine/quad/snowball_quad_engine.py

@@ -366,18 +366,60 @@ class SnowballQuadEngine(BaseEngine):
     def calculate_event_stats(
         self, product: BaseEquityProduct, pricing_env: PricingEnvironment
     ) -> Optional[AutocallableEventStats]:
-        """
-        Provide per-observation KO probabilities and expected discounted cashflows.
+        """Provide per-observation KO probabilities and expected discounted cashflows.
 
-        This implementation runs a single quadrature recursion for all KO observations
-        by propagating stacked indicator surfaces. It is typically much faster than MC
-        for risk-neutral event stats.
+        Runs a single quadrature recursion over stacked indicator surfaces; usually
+        much faster than MC for risk-neutral event stats.
         """
-        if not isinstance(product, SnowballOption):
+        if not isinstance(product, self._event_stats_product_type()):
             return None
         if pricing_env is None:
             raise PricingError("PricingEnvironment is required for SnowballQuadEngine.")
+        return self._compute_event_stats(product, pricing_env)
+
+    def _event_stats_product_type(self) -> type:
+        """Product type accepted by ``calculate_event_stats`` (overridable)."""
+        return SnowballOption
+
+    def _make_event_stats(self, **fields) -> AutocallableEventStats:
+        """Construct the event-stats dataclass (overridable by subclasses)."""
+        return AutocallableEventStats(**fields)
+
+    def _event_stats_alignment_log(
+        self, spot: float, product, ki_barrier_override: Optional[float] = None
+    ) -> Optional[float]:
+        """Grid-alignment log used by event stats.
+
+        Calls the Snowball implementation explicitly so a subclass that overrides
+        the price-path ``_select_alignment_log`` (e.g. PhoenixQuadEngine, with a
+        different signature) does not intercept the event-stats recursion.
+        """
+        return SnowballQuadEngine._select_alignment_log(
+            self, spot, product, ki_barrier_override=ki_barrier_override
+        )
+
+    # --- Extra indicator-row hooks (overridden by Phoenix for coupons) ---
+
+    def _n_extra_quad_rows(self, n_ko: int) -> int:
+        """Extra stacked indicator rows beyond the ``n_ko`` KO rows."""
+        return 0
 
+    def _set_extra_quad_indicators(
+        self, v_in, v_out, spot_grid, n_ko, ko_index, ko_record, obs_time,
+        rate, product, disable_ko_after_ki,
+    ) -> None:
+        """Set extra indicator rows at a KO observation (no-op for Snowball)."""
+        return None
+
+    def _extract_extra_quad_stats(
+        self, initial_surface, math_utils, n_ko, ko_records, rate, product, maturity
+    ) -> dict:
+        """Extra event-stats fields from the extra rows (none for Snowball)."""
+        return {}
+
+    def _compute_event_stats(
+        self, product: BaseEquityProduct, pricing_env: PricingEnvironment
+    ) -> Optional[AutocallableEventStats]:
         self._validate_product(product)
 
         spot = pricing_env.spot
@@ -447,7 +489,7 @@ class SnowballQuadEngine(BaseEngine):
         )
         dt = self._build_dt(times)
 
-        align_log = self._select_alignment_log(
+        align_log = self._event_stats_alignment_log(
             spot, product, ki_barrier_override=ki_barrier_continuous
         )
         fft_padding_factor = self._resolve_fft_padding_factor()
@@ -480,9 +522,12 @@ class SnowballQuadEngine(BaseEngine):
         disable_ko_after_ki = product.barrier_config.disable_ko_after_ki
 
         # --- KO indicator recursion (stacked over KO observations) ---
+        # Rows [0..n_ko-1] are KO indicators; subclasses may append extra rows
+        # (e.g. Phoenix coupon-trigger rows) that ride the same diffusion/jumps.
         n_ko = len(ko_records)
-        v_in = np.zeros((n_ko, grid.size), dtype=float)
-        v_out = np.zeros((n_ko, grid.size), dtype=float)
+        n_rows = n_ko + self._n_extra_quad_rows(n_ko)
+        v_in = np.zeros((n_rows, grid.size), dtype=float)
+        v_out = np.zeros((n_rows, grid.size), dtype=float)
 
         for step_index in range(len(times), 0, -1):
             obs_time = times[step_index - 1]
@@ -511,6 +556,12 @@ class SnowballQuadEngine(BaseEngine):
                 if not disable_ko_after_ki:
                     v_in[:, ko_mask] = 0.0
                     v_in[int(ko_index), ko_mask] = float(discount_delay)
+                # Extra rows (coupon) are set AFTER the KO zeroing so a coupon at a
+                # simultaneous KO is retained; future-coupon rows stay zeroed by KO.
+                self._set_extra_quad_indicators(
+                    v_in, v_out, spot_grid, n_ko, int(ko_index), ko_record,
+                    obs_time, rate, product, disable_ko_after_ki,
+                )
 
             if ki_continuous:
                 # KI transition handled via Brownian bridge in diffusion step.
@@ -700,7 +751,16 @@ class SnowballQuadEngine(BaseEngine):
             if df_T > 0:
                 ki_probability = float(pv_ki_no_ko / df_T)
 
-        return AutocallableEventStats(
+        extra_fields = self._extract_extra_quad_stats(
+            initial_surface, math_utils, n_ko, ko_records, rate, product, maturity
+        )
+        # Remove extra cashflow streams (Phoenix coupons) from the maturity field
+        # so pv = sum(ko) + sum(coupon) + maturity stays correctly classified.
+        coupon_cf = extra_fields.get("expected_discounted_coupon_cashflow")
+        if coupon_cf is not None:
+            expected_discounted_maturity_cf -= float(np.sum(coupon_cf))
+
+        return self._make_event_stats(
             pv=pv,
             ko_times=ko_times,
             ko_probability=ko_prob,
@@ -712,6 +772,7 @@ class SnowballQuadEngine(BaseEngine):
             ki_times=ki_times,
             ki_event_probability=ki_event_probability,
             ki_survival_probability=ki_survival_probability,
+            **extra_fields,
         )
 
     def _validate_product(self, product: SnowballOption) -> None:
@@ -1218,7 +1279,7 @@ class SnowballQuadEngine(BaseEngine):
             ki_event_probability = np.array([1.0], dtype=float)
             ki_survival_probability = np.array([0.0], dtype=float)
 
-        return AutocallableEventStats(
+        return self._make_event_stats(
             pv=pv,
             ko_times=ko_times,
             ko_probability=ko_probability,