quantark 0.2.1__tar.gz → 0.2.3__tar.gz

{quantark-0.2.1 → quantark-0.2.3}/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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantark
-Version: 0.2.1
+Version: 0.2.3
 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.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quantark"
-version = "0.2.1"
+version = "0.2.3"
 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.3}/quantark/__init__.py

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

{quantark-0.2.1 → quantark-0.2.3}/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.3}/quantark/asset/equity/engine/event_stats.py

@@ -9,6 +9,7 @@ autocallable products (Snowball-first).
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from typing import Optional
 
 import numpy as np
 
@@ -24,12 +25,26 @@ class AutocallableEventStats:
         ko_probability: Probability of KO occurring at each observation time.
         survival_probability: Probability of surviving (not KO'd) up to each observation.
         expected_discounted_ko_cashflow: Expected discounted KO redemption cashflow at each observation.
-        ki_probability: Probability that KI occurred at least once before maturity (if applicable).
+        ki_probability: LEGACY KI probability whose *definition differs by engine* — kept
+            for backward compatibility. QUAD/PDE report P(KI ever AND never KO)
+            (the KI indicator is absorbed to 0 on any KO), while MC reports
+            P(KI ever). Prefer the two unambiguous, cross-engine-consistent fields
+            below; ``ki_probability`` is retained only so existing callers do not
+            break.
         expected_discounted_maturity_cashflow: Expected discounted maturity cashflow (conditional on no KO).
         reconciliation_error: pv minus sum(expected discounted cashflows) if computed, else 0.0.
         ki_times: KI observation/monitoring times where event probabilities are available.
         ki_event_probability: Probability of first KI occurring at each KI time.
         ki_survival_probability: Probability of surviving without KI up to each KI time.
+        ki_ever_probability: P(the KI barrier is breached at any point in the
+            path's life, regardless of any subsequent KO/autocall). A *monitoring*
+            statistic. ``None`` if the engine does not compute it.
+        ki_survive_knocked_in_probability: P(KI breached AND the path reaches
+            maturity without ever knocking out) = P(the note settles in the
+            knocked-in state). This is the *economically relevant* quantity for
+            downside exposure / loss distribution (a path that knocks in and then
+            recovers to autocall redeems at par, so it carries no KI loss). Equals
+            ``ki_ever_probability`` minus P(KI AND KO). ``None`` if not computed.
     """
 
     pv: float
@@ -43,6 +58,8 @@ class AutocallableEventStats:
     ki_times: np.ndarray = field(default_factory=lambda: np.array([]))
     ki_event_probability: np.ndarray = field(default_factory=lambda: np.array([]))
     ki_survival_probability: np.ndarray = field(default_factory=lambda: np.array([]))
+    ki_ever_probability: Optional[float] = None
+    ki_survive_knocked_in_probability: Optional[float] = None
 
 
 @dataclass(frozen=True)

{quantark-0.2.1 → quantark-0.2.3}/quantark/asset/equity/engine/mc/phoenix_mc_engine.py

@@ -298,20 +298,35 @@ class PhoenixMCEngine(BaseEngine):
                     0.0, 1.0 - np.cumsum(ki_event_probability)
                 )
 
+        # Unambiguous, cross-engine-consistent KI definitions (investigation
+        # 2026-07-01). `ki_ever` counts any path that touches the KI barrier;
+        # `ki_survive` restricts to paths that also reach maturity without KO
+        # (i.e. the note settles knocked-in). The legacy `ki_probability` keeps
+        # MC's historical "KI ever" meaning.
+        if product.has_ki_barrier:
+            ki_triggered = np.asarray(stats["ki_triggered"], dtype=bool)
+            ki_ever_probability = float(np.mean(ki_triggered))
+            ki_survive_knocked_in_probability = float(
+                np.mean(ki_triggered & ~is_ko)
+            )
+        else:
+            ki_ever_probability = 0.0
+            ki_survive_knocked_in_probability = 0.0
+
         return PhoenixEventStats(
             pv=pv,
             ko_times=np.array(ko_times, dtype=float),
             ko_probability=ko_probability,
             survival_probability=survival_probability,
             expected_discounted_ko_cashflow=expected_discounted_ko_cashflow,
-            ki_probability=float(np.mean(stats["ki_triggered"]))
-            if product.has_ki_barrier
-            else 0.0,
+            ki_probability=ki_ever_probability,
             expected_discounted_maturity_cashflow=expected_discounted_maturity_cashflow,
             reconciliation_error=float(reconciliation_error),
             ki_times=ki_event_times,
             ki_event_probability=ki_event_probability,
             ki_survival_probability=ki_survival_probability,
+            ki_ever_probability=ki_ever_probability,
+            ki_survive_knocked_in_probability=ki_survive_knocked_in_probability,
             coupon_probability=coupon_probabilities,
             expected_discounted_coupon_cashflow=coupon_cashflows,
         )

{quantark-0.2.1 → quantark-0.2.3}/quantark/asset/equity/engine/mc/snowball_mc_engine.py

@@ -422,22 +422,31 @@ class SnowballMCEngine(BaseEngine):
         )
         reconciliation_error = pv - pv_cashflows
 
+        # Unambiguous, cross-engine-consistent KI definitions (investigation
+        # 2026-07-01): ki_ever = P(KI ever, KO-independent); ki_survive =
+        # P(KI ever AND never KO) = settles knocked-in. Legacy ki_probability keeps
+        # MC's historical "KI ever" meaning.
+        if product.has_ki_barrier or already_knocked_in:
+            ki_ever_probability = float(np.mean(ki_triggered))
+            ki_survive_knocked_in_probability = float(np.mean(ki_triggered & ~is_ko))
+        else:
+            ki_ever_probability = 0.0
+            ki_survive_knocked_in_probability = 0.0
+
         return AutocallableEventStats(
             pv=pv,
             ko_times=ko_times,
             ko_probability=ko_probability,
             survival_probability=survival_probability,
             expected_discounted_ko_cashflow=expected_discounted_ko_cashflow,
-            ki_probability=(
-                float(np.mean(ki_triggered))
-                if product.has_ki_barrier or already_knocked_in
-                else 0.0
-            ),
+            ki_probability=ki_ever_probability,
             expected_discounted_maturity_cashflow=expected_discounted_maturity_cashflow,
             reconciliation_error=float(reconciliation_error),
             ki_times=ki_event_times,
             ki_event_probability=ki_event_probability,
             ki_survival_probability=ki_survival_probability,
+            ki_ever_probability=ki_ever_probability,
+            ki_survive_knocked_in_probability=ki_survive_knocked_in_probability,
         )
 
     def _calculate_event_stats_ko_reset(
@@ -551,6 +560,10 @@ class SnowballMCEngine(BaseEngine):
             ki_probability=float(np.mean(ki_triggered)),
             expected_discounted_maturity_cashflow=expected_discounted_maturity_cashflow,
             reconciliation_error=float(reconciliation_error),
+            # ki_ever = P(KI ever, KO-independent); ki_survive = P(KI ever AND
+            # never KO'd, pre- or post-reset). Legacy ki_probability stays "KI ever".
+            ki_ever_probability=float(np.mean(ki_triggered)),
+            ki_survive_knocked_in_probability=float(np.mean(ki_triggered & ~is_ko)),
             pre_ko_times=pre_times,
             pre_ko_probability=pre_prob,
             post_ko_times=post_times,

{quantark-0.2.1 → quantark-0.2.3}/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.3}/quantark/asset/equity/engine/pde/ko_reset_snowball_pde_solver.py

@@ -8,6 +8,7 @@ to the V1 surface (ABSOLUTE post-KO mode only).
 from __future__ import annotations
 
 from collections import OrderedDict
+from dataclasses import replace
 from time import perf_counter
 from typing import Dict, List, Optional, Tuple
 
@@ -15,6 +16,7 @@ import numpy as np
 
 from quantark.asset.equity.engine.pde.base_pde_solver import PDESolutionResult
 from quantark.asset.equity.engine.pde.snowball_pde_solver import SnowballPDESolver
+from quantark.asset.equity.param import QuadParams
 from quantark.asset.equity.product.option.ko_reset_snowball_option import (
     KnockOutResetSnowballOption,
 )
@@ -57,7 +59,31 @@ class KOResetSnowballPDESolver(SnowballPDESolver):
     def calculate_event_stats(
         self, product: KnockOutResetSnowballOption, pricing_env: PricingEnvironment
     ) -> Optional[object]:
-        return None
+        if not isinstance(product, KnockOutResetSnowballOption):
+            return None
+        if pricing_env is None:
+            return None
+
+        from quantark.asset.equity.engine.quad.ko_reset_snowball_quad_engine import (
+            KOResetSnowballQuadEngine,
+        )
+
+        grid_points = max(501, int(getattr(self.params, "grid_size", 0) or 0))
+        quad_stats = KOResetSnowballQuadEngine(
+            QuadParams(grid_points=grid_points)
+        ).calculate_event_stats(product, pricing_env)
+        if quad_stats is None:
+            return None
+
+        pde_pv = float(self.price(product, pricing_env))
+        pv_delta = pde_pv - float(quad_stats.pv)
+        return replace(
+            quad_stats,
+            pv=pde_pv,
+            expected_discounted_maturity_cashflow=(
+                float(quad_stats.expected_discounted_maturity_cashflow) + pv_delta
+            ),
+        )
 
     def _validate_product(self, product: KnockOutResetSnowballOption) -> None:
         super()._validate_product(product)

{quantark-0.2.1 → quantark-0.2.3}/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.3}/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,16 +427,25 @@ 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,
+        # KI_ever_indicator]. The KI_indicator carries the "settles knocked-in"
+        # semantics (absorbed to 0 on any KO). The KI_ever_indicator tracks
+        # P(the underlying breaches the KI barrier at any point in [0, T]),
+        # independent of KO/autocall — it is a pure first-passage statistic and is
+        # therefore EXEMPT from the KO absorption below (matching the QUAD and MC
+        # ki_ever definition).
+        n_extra = self._n_extra_event_cols(n_ko)
+        ki_col = n_ko + n_extra
+        ki_ever_col = n_ko + n_extra + 1
+        n_cols = n_ko + n_extra + 2
 
         # Terminal conditions at maturity (t = T):
         # - KO indicators are zero at maturity (KO only at discrete observations via jumps)
-        # - KI indicator is 1 on the KI surface and 0 on the no-KI surface
+        # - Both KI indicators are 1 on the KI surface and 0 on the no-KI surface
         v0_next = np.zeros((num_x, n_cols), dtype=float)
         v1_next = np.zeros((num_x, n_cols), dtype=float)
         v1_next[:, ki_col] = 1.0
+        v1_next[:, ki_ever_col] = 1.0
 
         # Apply terminal KO/KI events at maturity if observation schedules include t=T.
         terminal_tidx = num_t - 1
@@ -417,6 +455,9 @@ class SnowballPDESolver(BasePDESolver):
             barrier = float(rec.barrier) if rec.barrier is not None else 0.0
             mask_ko = self._get_barrier_mask(s_vec, barrier, product.is_reverse, is_up_barrier=True)
 
+            # KI-ever is exempt from KO absorption (pure first-passage statistic).
+            ever0 = v0_next[mask_ko, ki_ever_col].copy()
+            ever1 = v1_next[mask_ko, ki_ever_col].copy()
             v0_next[mask_ko, :] = 0.0
             v1_next[mask_ko, :] = 0.0
             df_delay = self._cashflow_value_at_time(
@@ -427,6 +468,12 @@ class SnowballPDESolver(BasePDESolver):
             )
             v0_next[mask_ko, terminal_ko_idx] = df_delay
             v1_next[mask_ko, terminal_ko_idx] = df_delay
+            v0_next[mask_ko, ki_ever_col] = ever0
+            v1_next[mask_ko, ki_ever_col] = ever1
+            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
@@ -525,6 +572,9 @@ class SnowballPDESolver(BasePDESolver):
                 mask_ko = self._get_barrier_mask(s_vec, barrier, product.is_reverse, is_up_barrier=True)
 
                 # Zero all event surfaces in KO region, then set the KO_i indicator.
+                # KI-ever is exempt (pure first-passage statistic, no KO absorption).
+                ever0 = v0_cur[mask_ko, ki_ever_col].copy()
+                ever1 = v1_cur[mask_ko, ki_ever_col].copy()
                 v0_cur[mask_ko, :] = 0.0
                 v1_cur[mask_ko, :] = 0.0
                 df_delay = self._cashflow_value_at_time(
@@ -535,6 +585,12 @@ class SnowballPDESolver(BasePDESolver):
                 )
                 v0_cur[mask_ko, ko_idx] = df_delay
                 v1_cur[mask_ko, ko_idx] = df_delay
+                v0_cur[mask_ko, ki_ever_col] = ever0
+                v1_cur[mask_ko, ki_ever_col] = ever1
+                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:
@@ -586,18 +642,31 @@ class SnowballPDESolver(BasePDESolver):
         ki_survival_probability = np.array([], dtype=float)
         if already_knocked_in:
             ki_probability = 1.0
+            ki_ever_probability = 1.0
             ki_times = np.array([0.0], dtype=float)
             ki_event_probability = np.array([1.0], dtype=float)
             ki_survival_probability = np.array([0.0], dtype=float)
         else:
-            ed_ki = float(np.interp(spot_log, x_vec, initial_grid[:, ki_col]))
             df_T = pricing_env.get_discount_factor(float(tau))
+            ed_ki = float(np.interp(spot_log, x_vec, initial_grid[:, ki_col]))
             ki_probability = float(ed_ki / df_T) if df_T > 0.0 else 0.0
+            ed_ki_ever = float(np.interp(spot_log, x_vec, initial_grid[:, ki_ever_col]))
+            ki_ever_probability = float(ed_ki_ever / df_T) if df_T > 0.0 else 0.0
 
         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 +678,14 @@ class SnowballPDESolver(BasePDESolver):
             ki_times=ki_times,
             ki_event_probability=ki_event_probability,
             ki_survival_probability=ki_survival_probability,
+            # Two unambiguous, cross-engine-consistent KI fields. The legacy
+            # `ki_probability` keeps the PDE's historical "settles knocked-in"
+            # meaning (KI indicator absorbed to 0 on any KO), which equals
+            # `ki_survive_knocked_in_probability`. `ki_ever_probability` comes from
+            # the dedicated KI-ever column that carries no KO absorption.
+            ki_ever_probability=ki_ever_probability,
+            ki_survive_knocked_in_probability=ki_probability,
+            **extra_fields,
         )
 
     def calculate_greeks(
@@ -1620,7 +1697,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.3}/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]: