quantark 0.2.2__tar.gz → 0.2.3__tar.gz

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

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

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

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

{quantark-0.2.2 → 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.2 → 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.2 → 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.2 → 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.2 → quantark-0.2.3}/quantark/asset/equity/engine/pde/snowball_pde_solver.py

@@ -427,17 +427,25 @@ class SnowballPDESolver(BasePDESolver):
                 )
             ko_index_by_tidx[t_idx] = k
 
-        # Surface columns: [KO_0..KO_{n-1}, <extra coupon cols>, KI_indicator]
+        # 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
-        n_cols = n_ko + n_extra + 1
+        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
@@ -447,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(
@@ -457,6 +468,8 @@ 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,
@@ -559,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(
@@ -569,6 +585,8 @@ 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,
@@ -624,13 +642,16 @@ 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)))
@@ -657,6 +678,13 @@ 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,
         )
 

{quantark-0.2.2 → quantark-0.2.3}/quantark/asset/equity/engine/quad/ko_reset_snowball_quad_engine.py

@@ -13,6 +13,7 @@ from typing import List, Optional, Sequence
 
 import numpy as np
 
+from quantark.asset.equity.engine.event_stats import KOResetEventStats
 from quantark.asset.equity.engine.quad.snowball_quad_engine import SnowballQuadEngine
 from quantark.asset.equity.engine.quad.quad_math import QuadratureMath
 from quantark.asset.equity.param import QuadParams
@@ -317,8 +318,341 @@ class KOResetSnowballQuadEngine(SnowballQuadEngine):
 
     def calculate_event_stats(
         self, product: BaseEquityProduct, pricing_env: PricingEnvironment
-    ) -> Optional[object]:
-        return None
+    ) -> Optional[KOResetEventStats]:
+        if not isinstance(product, KnockOutResetSnowballOption):
+            return None
+        if pricing_env is None:
+            raise PricingError("PricingEnvironment is required for KOResetSnowballQuadEngine.")
+        return self._compute_event_stats(product, pricing_env)
+
+    def _compute_event_stats(
+        self,
+        product: KnockOutResetSnowballOption,
+        pricing_env: PricingEnvironment,
+    ) -> Optional[KOResetEventStats]:
+        self._validate_product(product)
+
+        spot = pricing_env.spot
+        maturity = product.get_maturity(pricing_env)
+        validate_positive(spot, "spot")
+        validate_positive(maturity, "maturity", allow_zero=True)
+        if is_zero(maturity, tol=Tolerance.ZERO):
+            return None
+
+        rate = pricing_env.get_rate(maturity)
+        div = pricing_env.get_div_yield(maturity)
+        vol = pricing_env.get_vol(product.strike, maturity)
+        validate_positive(vol, "volatility")
+        validate_non_negative(div, "dividend_yield")
+        if vol > 5.0:
+            raise ValidationError(f"Volatility too high for quadrature stability: {vol}")
+
+        pre_ko_records = self._resolve_ko_records(
+            product, pricing_env, product.barrier_config
+        )
+        pre_ko_records = [
+            rec
+            for rec in pre_ko_records
+            if rec.observation_time <= maturity
+            or is_close(rec.observation_time, maturity, abs_tol=Tolerance.PRECISION)
+        ]
+        if not pre_ko_records:
+            return None
+
+        post_ko_records = self._resolve_ko_records(
+            product, pricing_env, product.post_barrier_config
+        )
+        post_ko_records = [
+            rec
+            for rec in post_ko_records
+            if rec.observation_time <= maturity
+            or is_close(rec.observation_time, maturity, abs_tol=Tolerance.PRECISION)
+        ]
+        if not post_ko_records:
+            return None
+
+        ki_continuous = product.has_ki_barrier and (
+            product.barrier_config.ki_continuous
+            or product.barrier_config.ki_observation_type == ObservationType.CONTINUOUS
+        )
+        ki_records: Sequence = []
+        if product.has_ki_barrier and not ki_continuous:
+            ki_records = product.resolve_ki_observations(pricing_env)
+            if not ki_records:
+                raise PricingError("KI observation schedule is empty for KOResetSnowballQuadEngine.")
+
+        times = self._merge_times(
+            [rec.observation_time for rec in pre_ko_records]
+            + [rec.observation_time for rec in post_ko_records],
+            [rec.observation_time for rec in ki_records],
+            maturity,
+        )
+        if not times:
+            return None
+
+        align_log = self._select_alignment_log(spot, product)
+        fft_padding_factor = self._resolve_fft_padding_factor()
+        fft_filter_alpha, fft_filter_power = self._resolve_fft_filter()
+        math_utils = QuadratureMath(
+            grid_x=self.params.grid_points,
+            spot=spot,
+            maturity=maturity,
+            vol_max=vol,
+            num_std_devs=self.params.num_std_devs,
+            align_log=align_log,
+            fft_padding_factor=fft_padding_factor,
+            fft_filter_alpha=fft_filter_alpha,
+            fft_filter_power=fft_filter_power,
+        )
+        grid = math_utils.grid
+        spot_grid = spot * np.exp(grid)
+        dt = self._build_dt(times)
+        tau = 0.5 * vol * vol * dt
+        if np.any(tau[1:] <= 0.0):
+            raise ValidationError("time step too small for quadrature solver.")
+
+        alpha = (rate - div - 0.5 * vol * vol) / (vol * vol)
+        beta = (rate - div - 0.5 * vol * vol) ** 2 / (vol**4) + 2.0 * rate / (
+            vol * vol
+        )
+
+        n_pre = len(pre_ko_records)
+        n_post = len(post_ko_records)
+        post_offset = n_pre
+        ki_col = n_pre + n_post
+        ki_ever_col = ki_col + 1
+        n_rows = ki_ever_col + 1
+
+        v_in = np.zeros((n_rows, grid.size), dtype=float)
+        v_out = np.zeros((n_rows, grid.size), dtype=float)
+        v_in[ki_col] = 1.0
+        v_in[ki_ever_col] = 1.0
+
+        log_ki_barrier = None
+        if product.has_ki_barrier and ki_continuous:
+            if product.barrier_config.ki_barrier is None:
+                raise PricingError("KI barrier configuration is missing.")
+            if isinstance(product.barrier_config.ki_barrier, list):
+                raise PricingError("Continuous KI requires scalar ki_barrier.")
+            log_ki_barrier = safe_log(product.barrier_config.ki_barrier / spot)
+
+        knocked_in_at_valuation = self._is_knocked_in_at_valuation(
+            product,
+            spot,
+            pricing_env,
+            ki_continuous=ki_continuous,
+            ki_records=ki_records,
+        )
+        full_p_lr, full_p_ur, full_p0 = 0, len(grid) - 1, (len(grid) - 1) % 2
+        omega_grid = math_utils.z_grid
+        disable_ko_after_ki = product.barrier_config.disable_ko_after_ki
+        smoothing_width = self._resolve_event_smoothing_width(math_utils, product)
+
+        for step_index in range(len(times), 0, -1):
+            obs_time = times[step_index - 1]
+
+            pre_ko_record = self._match_record(obs_time, pre_ko_records)
+            if pre_ko_record is not None:
+                pre_idx = pre_ko_records.index(pre_ko_record)
+                ko_weight = self._smooth_step_weight(
+                    grid,
+                    pre_ko_record.barrier,
+                    spot,
+                    smoothing_width,
+                    trigger_is_down=product.is_reverse,
+                )
+                if ko_weight is None:
+                    ko_mask = (
+                        spot_grid <= pre_ko_record.barrier
+                        if product.is_reverse
+                        else spot_grid >= pre_ko_record.barrier
+                    )
+                    ko_weight = ko_mask.astype(float)
+
+                ever_before = v_out[ki_ever_col].copy()
+                v_out *= 1.0 - ko_weight
+                v_out[pre_idx] += ko_weight * float(
+                    self._ko_discount(rate, obs_time, pre_ko_record.settlement_time)
+                )
+                v_out[ki_ever_col] = ever_before
+
+            post_ko_record = self._match_record(obs_time, post_ko_records)
+            if post_ko_record is not None and not disable_ko_after_ki:
+                post_idx = post_ko_records.index(post_ko_record)
+                ko_weight = self._smooth_step_weight(
+                    grid,
+                    post_ko_record.barrier,
+                    spot,
+                    smoothing_width,
+                    trigger_is_down=product.is_reverse,
+                )
+                if ko_weight is None:
+                    ko_mask = (
+                        spot_grid <= post_ko_record.barrier
+                        if product.is_reverse
+                        else spot_grid >= post_ko_record.barrier
+                    )
+                    ko_weight = ko_mask.astype(float)
+
+                ever_before = v_in[ki_ever_col].copy()
+                v_in *= 1.0 - ko_weight
+                v_in[post_offset + post_idx] += ko_weight * float(
+                    self._ko_discount(rate, obs_time, post_ko_record.settlement_time)
+                )
+                v_in[ki_ever_col] = ever_before
+
+            if ki_continuous and log_ki_barrier is not None:
+                ki_mask = (
+                    spot_grid >= product.barrier_config.ki_barrier
+                    if product.is_reverse
+                    else spot_grid <= product.barrier_config.ki_barrier
+                )
+                v_out[:, ki_mask] = v_in[:, ki_mask]
+            elif ki_records:
+                ki_record = self._match_record(obs_time, ki_records)
+                if ki_record is not None:
+                    ki_mask = (
+                        spot_grid >= ki_record.barrier
+                        if product.is_reverse
+                        else spot_grid <= ki_record.barrier
+                    )
+                    v_out[:, ki_mask] = v_in[:, ki_mask]
+
+            tau_step = float(tau[step_index])
+            prefactor = math.exp(-beta * tau_step) / math.sqrt(math.pi * tau_step) / 2.0
+            omega_array = np.exp(
+                -(omega_grid**2) / (4.0 * tau_step) - alpha * omega_grid
+            )
+
+            v_in = self._diffuse_fft(
+                v_in,
+                math_utils,
+                omega_array,
+                prefactor,
+                full_p_lr,
+                full_p_ur,
+                full_p0,
+                alpha,
+                beta,
+                tau_step,
+            )
+
+            if ki_continuous and log_ki_barrier is not None:
+                v_out = self._diffuse_with_bridge(
+                    v_out,
+                    v_in,
+                    math_utils,
+                    omega_array,
+                    prefactor,
+                    full_p_lr,
+                    full_p_ur,
+                    full_p0,
+                    log_ki_barrier,
+                    alpha,
+                    beta,
+                    vol,
+                    dt[step_index],
+                    tau_step,
+                    product.is_reverse,
+                )
+            else:
+                v_out = self._diffuse_fft(
+                    v_out,
+                    math_utils,
+                    omega_array,
+                    prefactor,
+                    full_p_lr,
+                    full_p_ur,
+                    full_p0,
+                    alpha,
+                    beta,
+                    tau_step,
+                )
+
+        initial_surface = v_in if knocked_in_at_valuation else v_out
+        pre_unit = np.array(
+            [math_utils.interpolate(initial_surface[i], x=0.0) for i in range(n_pre)],
+            dtype=float,
+        )
+        post_unit = np.array(
+            [
+                math_utils.interpolate(initial_surface[post_offset + i], x=0.0)
+                for i in range(n_post)
+            ],
+            dtype=float,
+        )
+
+        pre_times = np.array([rec.observation_time for rec in pre_ko_records], dtype=float)
+        post_times = np.array([rec.observation_time for rec in post_ko_records], dtype=float)
+        pre_probability = np.zeros(n_pre, dtype=float)
+        post_probability = np.zeros(n_post, dtype=float)
+        expected_discounted_pre_ko_cashflow = np.zeros(n_pre, dtype=float)
+        expected_discounted_post_ko_cashflow = 0.0
+
+        for i, rec in enumerate(pre_ko_records):
+            df_total = math.exp(-rate * float(rec.observation_time)) * float(
+                self._ko_discount(rate, float(rec.observation_time), rec.settlement_time)
+            )
+            if df_total > 0:
+                pre_probability[i] = float(pre_unit[i] / df_total)
+            payoff = float(rec.payoff) if rec.payoff is not None else 0.0
+            expected_discounted_pre_ko_cashflow[i] = float(pre_unit[i] * payoff)
+
+        for i, rec in enumerate(post_ko_records):
+            df_total = math.exp(-rate * float(rec.observation_time)) * float(
+                self._ko_discount(rate, float(rec.observation_time), rec.settlement_time)
+            )
+            if df_total > 0:
+                post_probability[i] = float(post_unit[i] / df_total)
+            payoff = float(rec.payoff) if rec.payoff is not None else 0.0
+            expected_discounted_post_ko_cashflow += float(post_unit[i] * payoff)
+
+        df_maturity = math.exp(-rate * maturity)
+        ki_survive = 0.0
+        ki_ever = 0.0
+        if df_maturity > 0.0:
+            ki_survive = float(
+                math_utils.interpolate(initial_surface[ki_col], x=0.0) / df_maturity
+            )
+            ki_ever = float(
+                math_utils.interpolate(initial_surface[ki_ever_col], x=0.0)
+                / df_maturity
+            )
+
+        survival_probability = np.ones(n_pre, dtype=float)
+        cumulative_pre_ko = 0.0
+        for i in range(n_pre):
+            cumulative_pre_ko += pre_probability[i]
+            survival_probability[i] = max(0.0, 1.0 - cumulative_pre_ko)
+
+        pv = float(self.price(product, pricing_env))
+        expected_discounted_maturity_cashflow = float(
+            pv
+            - float(np.sum(expected_discounted_pre_ko_cashflow))
+            - expected_discounted_post_ko_cashflow
+        )
+
+        return KOResetEventStats(
+            pv=pv,
+            ko_times=pre_times,
+            ko_probability=pre_probability,
+            survival_probability=survival_probability,
+            expected_discounted_ko_cashflow=expected_discounted_pre_ko_cashflow,
+            ki_probability=ki_ever,
+            expected_discounted_maturity_cashflow=expected_discounted_maturity_cashflow,
+            reconciliation_error=0.0,
+            ki_ever_probability=ki_ever,
+            ki_survive_knocked_in_probability=ki_survive,
+            pre_ko_times=pre_times,
+            pre_ko_probability=pre_probability,
+            post_ko_times=post_times,
+            post_ko_probability=post_probability,
+            pre_ko_probability_total=float(np.sum(pre_probability)),
+            post_ko_probability_total=float(np.sum(post_probability)),
+            expected_discounted_post_ko_cashflow=float(
+                expected_discounted_post_ko_cashflow
+            ),
+        )
 
     def _validate_product(self, product: KnockOutResetSnowballOption) -> None:
         if product.barrier_config.ko_observation_type != ObservationType.DISCRETE: