The Subsidy Immunity Formula (SIF)

An Optimal Stopping Framework for Retail Mean Reversion Strategies

Author: Emmanuel Normabuena
Affiliation: Independent Researcher / Systems Architect
Location: Santiago, Chile
Date: January 2026

---

📄 Abstract

Retail investors frequently suffer from the Disposition Effect, holding losing positions due to a lack of explicit opportunity cost quantification. This repository hosts the technical whitepaper and reference implementation for the Subsidy Immunity Formula (SIF).

The SIF model is derived from the Principle of Indifference and solves the implicit circularity of first-passage time probabilities. By algebraically isolating the volatility time horizon from the Reflection Principle equation, we define two novel metrics:

• Intrinsic Duration (D_i): The linear sensitivity of funding capital.
• Dynamic Convexity (C): The quadratic penalty imposed by volatility.

The interaction of these terms determines the Strategic Shielding Time (SST), identifying the critical "Log-Moneyness" barrier (δ_crit) where a position becomes mathematically insolvent.

🧩 Key Definitions

The framework establishes the following canonical equation for optimal stopping:

SST = D_i · δ - C(δ) · δ²

Where:

• D_i = 1/r (Inverse of the risk-free rate)
• C(δ) = 1 / [σ · EC(δ)]² (Volatility penalty scaled by the Exigence Coefficient)

📂 Repository Contents

• SIF_Whitepaper.pdf: The complete technical paper explaining the derivation, proofs, and scenario analysis (Hawk vs. Panic regimes).
• sif_model.py: Python reference implementation. It replicates the figures found in the paper, simulating the SST collapse and calculating the Greeks (ρ_sif, ν_sif).

🚀 Quick Start

To run the simulation and generate the sensitivity graphs, execute the following commands in your terminal:

# Clone the repository
git clone https://github.com/eanorambuena/SIF-Model-Paper.git

# Navigate to the directory
cd SIF-Model-Paper

# Run the model
python sif_model.py

⚠️ Numerical Stability & Overflow Solutions

The Probit Function Overflow Problem & Solution

The core calculation uses the exact inverse-probit formula for the Exigence Coefficient:

EC(δ) = |Φ^-1( 1 / (2·e^δ) )|

The Problem (Before)

The naive implementation had numerical limitations:

• Mathematically: The formula is valid for all δ ∈ ℝ.
• Computationally (IEEE 754): Computing exp(δ) directly overflows for δ > 709.
• Symptom: For δ ≥ 710, the term 1/(2·exp(δ)) collapsed to exactly zero, causing a discontinuous jump in EC and SST.
• Result: Figures were artificially limited to δ ≤ 700, missing important parameter regimes.

The Solution (Log-Space)

We implemented the mathematically equivalent but numerically stable form:

Form	Formula	Stability	Notes
Original (Naive)	P = 1 / (2·eδ)	❌ Overflows for δ > 709	Direct computation of eδ causes overflow
Log-Space (Stable)	P = e−(δ + ln 2)	✓ Stable for δ up to ~1,000,000	Exponential of negative number never overflows

Mathematical Equivalence

Both forms are algebraically identical:

1/(2·e^δ) = e^−ln(2) · e^−δ = e^{−(δ + ln 2)}

This is simply a rearrangement of the exponent rules. The only difference is which route we take through the computation:

• Route 1 (naive): Calculate huge e^δ, then divide 1 by it → OVERFLOW
• Route 2 (stable): Add negative numbers (−δ − ln 2), then take e^... → ALWAYS SAFE

Solution: Hybrid Exact + Asymptotic

The log-space formula solved the overflow problem, but introduced a second numerical limit:

The Underflow Problem (After Log-Space)

• Issue: The log-space formula P = e^{−(δ + ln 2)} works great for overflow, but for δ > ~755, this underflows to exactly 0.0 in IEEE 754.
• Consequence: When P = 0.0, calling Φ⁻¹(0) returns −∞, making EC undefined and SST collapse to −∞.
• Result: Even with log-space, the figures still had a discontinuity at δ ≈ 755.

Why We Needed Asymptotic Approximation

The solution was to abandon the attempt to compute exact probabilities for very large δ and instead use the mathematical asymptotic expansion of the inverse-probit function:

For small p: Φ⁻¹(p) ≈ −√(2·ln(1/p))

This avoids computing tiny probabilities altogether. When p = e^{−(δ + ln 2)}:

ln(1/p) = δ + ln 2 → EC(δ) ≈ √(2·(δ + ln 2)) ≈ √(2·δ)

Key insight: By working in log-space at the asymptotic formula level, we never compute e^{−(δ + ln 2)} directly. Instead, we compute √(2·δ) algebraically, which is always safe.

Hybrid Implementation Strategy

To maintain both accuracy and stability across all δ ranges, we use a hybrid approach:

Range	Method	Formula	Why
δ < 700	Exact Probit (Log-Space)	EC = |Φ−1(e−(δ + ln 2))|	Probability is computable; use exact value for machine precision
δ ≥ 700	Asymptotic Expansion	EC ≈ √(2·δ)	Probability has underflowed; use algebraic asymptotic form to avoid computing it

Accuracy of Asymptotic Approximation

At the transition point δ = 700:

• Exact: EC(700) = |Φ⁻¹(e^−702.693)| ≈ 37.416
• Asymptotic: EC ≈ √(2·700) = √1400 ≈ 37.417
• Relative Error: < 0.003% (0.3 basis points)

The error remains < 0.3% for all δ ≥ 700, making this an excellent practical approximation.

Why Asymptotic Works

For very small probabilities p, the inverse-probit function has a known asymptotic expansion:

Φ^-1(p) ≈ −√(2·ln(1/p))

When p = e^{−(δ + ln 2)}, this becomes:

EC(δ) ≈ √(2·(δ + ln 2)) ≈ √(2·δ)

(The ln(2) term becomes negligible for δ >> 1.)

Impact

• Figure 3 now extends to δ = 2000 without discontinuities, showing all curves smoothly through their zero crossings and beyond.
• No new dependencies: Uses only NumPy, no mpmath or external libraries required.
• Computational cost: Negligible; asymptotic branch is faster than probit.
• Accuracy: Exact where possible, < 0.3% error in asymptotic regime.

Example: σ=10% now visibly crosses zero at δ ≈ 712 and continues smoothly up to δ = 2000, demonstrating the model's behavior across a wide range of displacement values.

⚖️ License & Legal Warning

Copyright © 2026 Emmanuel Normabuena. All Rights Reserved.

This repository is dual-licensed to ensure maximum protection of the intellectual property while allowing academic transparency.

1. The Source Code (Software)

The code provided in sif_model.py and any associated scripts are licensed under the GNU Affero General Public License v3.0 (AGPLv3).

• ✅ Open Source: You are free to run, study, share, and modify the code.
• ⚠️ Network Use Clause: If you run this software on a server (e.g., a web service, SaaS, or internal bank backend) and let users interact with it remotely, you MUST release your full source code under this same license.
• See the LICENSE file for the full legal text.

2. The Whitepaper (PDF)

The academic paper "The Subsidy Immunity Formula (SIF)" is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License (CC BY-NC-ND 4.0).

• ✅ You are free to: Share, copy, and redistribute the material in any medium or format.
• ❌ You may NOT: Use the material for commercial purposes (selling, training paid models, inclusion in paid courses).
• ❌ You may NOT: Remix, transform, or build upon the material. If you modify the material, you may not distribute the modified material.

---

For commercial licensing inquiries or academic collaboration, please contact the author directly.