Grok 4.1 Fast· xai
Frontier Reasoning Traces
Build a bank treasury digital twin that mirrors liquidity ladders, collateral pools, and…
- User
Build a bank treasury digital twin that mirrors liquidity ladders, collateral pools, and funding costs for sand-boxing regulatory asks.
- Assistant
import pandas as pd import numpy as np import plotly.graph_objects as go from plotly.subplots import make_subplots from dataclasses import dataclass from typing import Dict, List, Tuple, Optional from enum import Enum import warnings warnings.filterwarnings('ignore') class AssetClass(Enum): """Enum for asset classes in collateral pools.""" CASH = "Cash" GOV_BONDS = "Gov Bonds" CORP_BONDS = "Corp Bonds" EQUITIES = "Equities" LOANS = "Loans" class FundingType(Enum): """Enum for funding types.""" SECURED = "Secured (Repo)" UNSECURED = "Unsecured (Deposits/CP)" CENTRAL_BANK = "Central Bank" @dataclass class CollateralItem: """Data class for individual collateral items.""" asset_class: AssetClass notional: float # Face value in USD millions haircut: float # Regulatory haircut (e.g., 0.02 for 2%) maturity_bucket: str # e.g., '0-7d', '7-30d' eligibility_lcr: float # HQLA eligibility factor (0-1) current_usage: float = 0.0 # Fraction pledged class ScenarioType(Enum): """Pre-defined regulatory stress scenarios.""" BASE = "Base" LCR_STRESS = "LCR 30-day Stress (Outflows +20%, Inflows -75%)" NSFR_STRESS = "NSFR 1-year Stress (Deposit Runoff 10%, Loan Drawdown 20%)" MARKET_SHOCK = "Market Shock (Spreads +100bps, Collateral Haircut +10%)" class BankTreasuryDigitalTwin: """ A Python-based Digital Twin for Bank Treasury mirroring: - Liquidity Ladders: Inflow/outflow profiles across time buckets. - Collateral Pools: Inventory with haircuts, eligibility, and usage. - Funding Costs: Yield curves for secured/unsecured funding. Designed for sandboxing regulatory asks (e.g., LCR/NSFR what-ifs). """ def __init__(self): self.liquidity_ladders: Dict[str, pd.DataFrame] = {} # Buckets: inflows, outflows self.collateral_pools: Dict[str, List[CollateralItem]] = {} # Pools by currency/quality self.funding_curves: Dict[FundingType, pd.Series] = {} # Tenor -> rate (%) self.time_buckets = ['0-7d', '7-30d', '30-90d', '90d-1y', '1y-5y', '5y+'] self.currency = 'USD' # Simplified to single currency def load_sample_data(self): """Load realistic sample data for demo.""" # Liquidity Ladders (USD millions) inflows = pd.DataFrame({ 'bucket': self.time_buckets, 'amount': [500, 1200, 800, 1500, 2000, 3000] }) outflows = pd.DataFrame({ 'bucket': self.time_buckets, 'amount': [2000, 1500, 1000, 800, 500, 300] }) self.liquidity_ladders['inflows'] = inflows.set_index('bucket') self.liquidity_ladders['outflows'] = outflows.set_index('bucket') # Collateral Pools self.collateral_pools['HQLA'] = [ CollateralItem(AssetClass.CASH, 1000, 0.00, '0-7d', 1.0), CollateralItem(AssetClass.GOV_BONDS, 2000, 0.02, '7-30d', 1.0), CollateralItem(AssetClass.CORP_BONDS, 1500, 0.15, '30-90d', 0.85), ] self.collateral_pools['NON_HQLA'] = [ CollateralItem(AssetClass.LOANS, 5000, 0.25, '90d-1y', 0.0), CollateralItem(AssetClass.EQUITIES, 300, 0.50, '1y-5y', 0.0), ] # Funding Curves (annualized rates %) tenors = self.time_buckets self.funding_curves[FundingType.SECURED] = pd.Series([0.5, 1.2, 2.0, 2.8, 3.5, 4.0], index=tenors) self.funding_curves[FundingType.UNSECURED] = pd.Series([1.5, 2.5, 3.5, 4.5, 5.5, 6.0], index=tenors) self.funding_curves[FundingType.CENTRAL_BANK] = pd.Series([0.25, 0.75, 1.5, 2.0, 2.5, 3.0], index=tenors) def get_net_liquidity_position(self, scenario: ScenarioType = ScenarioType.BASE) -> pd.DataFrame: """Compute cumulative net liquidity across buckets under scenario.""" inflows = self.liquidity_ladders['inflows'].copy() outflows = self.liquidity_ladders['outflows'].copy() if scenario == ScenarioType.LCR_STRESS: inflows *= 0.25 # 75% haircut on inflows outflows *= 1.20 # 20% extra outflows elif scenario == ScenarioType.NSFR_STRESS: outflows['0-7d'] *= 1.10 # Short-term deposit runoff elif scenario == ScenarioType.MARKET_SHOCK: inflows *= 0.90 # Market illiquidity net = inflows - outflows net['cumulative'] = net.cumsum() return net def get_available_collateral(self, pool_name: str, stress_factor: float = 1.0) -> Dict: """Calculate available collateral post-haircut and usage.""" pool = self.collateral_pools.get(pool_name, []) total_notional = sum(item.notional for item in pool) total_haircut_value = sum(item.notional * (1 - item.haircut * stress_factor) * (1 - item.current_usage) for item in pool) total_hqla = sum(item.notional * item.eligibility_lcr * (1 - item.haircut * stress_factor) * (1 - item.current_usage) for item in pool) return { 'total_notional': total_notional, 'haircut_value': total_haircut_value, 'hqla_value': total_hqla } def calculate_funding_needs_and_costs(self, net_position: pd.DataFrame, funding_type: FundingType) -> Tuple[float, float]: """Estimate funding gap and annualized cost.""" shortfall = net_position['cumulative'].min() if shortfall >= 0: return 0.0, 0.0 # Funding needed in shortest bucket gap_bucket = net_position['cumulative'].idxmin() gap = abs(shortfall) # Cost: Interpolate curve for gap tenor rate = self.funding_curves[funding_type].get(gap_bucket, self.funding_curves[funding_type].mean()) annual_cost = gap * (rate / 100) return gap, annual_cost def simulate_regulatory_scenario(self, scenario: ScenarioType) -> Dict: """Full sandbox simulation for a regulatory ask.""" net_liq = self.get_net_liquidity_position(scenario) gap_sec, cost_sec = self.calculate_funding_needs_and_costs(net_liq, FundingType.SECURED) gap_cb, cost_cb = self.calculate_funding_needs_and_costs(net_liq, FundingType.CENTRAL_BANK) hqla_avail = self.get_available_collateral('HQLA', stress_factor=1.1 if scenario == ScenarioType.MARKET_SHOCK else 1.0) # Pseudo LCR/NSFR (simplified) lcr = hqla_avail['hqla_value'] / abs(net_liq['cumulative'].min() * 30/365) if net_liq['cumulative'].min() < 0 else float('inf') nsfr_stable_funding = hqla_avail['haircut_value'] * 0.9 # Assume 90% stable return { 'scenario': scenario.value, 'max_liquidity_shortfall': float(net_liq['cumulative'].min()), 'secured_funding_gap': gap_sec, 'secured_annual_cost': cost_sec, 'cb_funding_gap': gap_cb, 'cb_annual_cost': cost_cb, 'available_hqla': hqla_avail['hqla_value'], 'pseudo_lcr': lcr, 'pseudo_nsfr_stable': nsfr_stable_funding } def visualize_twin(self): """Interactive Plotly dashboard.""" fig = make_subplots( rows=2, cols=2, subplot_titles=('Liquidity Ladder (Base)', 'Funding Curves', 'Collateral Breakdown', 'Scenario Shortfalls'), specs=[[{"secondary_y": False}, {"secondary_y": False}], [{"secondary_y": False}, {"secondary_y": False}]] ) # Liquidity Ladder net_liq = self.get_net_liquidity_position(ScenarioType.BASE) fig.add_trace(go.Bar(x=net_liq.index, y=net_liq['cumulative'], name='Cum. Net Liq', marker_color='green'), row=1, col=1) # Funding Curves for ft, curve in self.funding_curves.items(): fig.add_trace(go.Scatter(x=curve.index, y=curve.values, mode='lines+markers', name=ft.value), row=1, col=2) # Collateral Pie hqla_data = self.get_available_collateral('HQLA') non_hqla_data = self.get_available_collateral('NON_HQLA') fig.add_trace(go.Pie(labels=['HQLA', 'Non-HQLA'], values=[hqla_data['haircut_value'], non_hqla_data['haircut_value']], name='Collateral'), row=2, col=1) # Scenario Shortfalls scenarios = [ScenarioType.BASE, ScenarioType.LCR_STRESS, ScenarioType.NSFR_STRESS, ScenarioType.MARKET_SHOCK] shortfalls = [self.simulate_regulatory_scenario(s)['max_liquidity_shortfall'] for s in scenarios] fig.add_trace(go.Bar(x=[s.value for s in scenarios], y=shortfalls, name='Shortfall'), row=2, col=2) fig.update_layout(title_text="Bank Treasury Digital Twin Dashboard", height=800) fig.show() # Demo Usage: Sandbox Regulatory Asks if __name__ == "__main__": twin = BankTreasuryDigitalTwin() twin.load_sample_data() print("=== Digital Twin Initialized ===") print("\nBase Net Liquidity Position:") print(twin.get_net_liquidity_position(ScenarioType.BASE)) print("\nAvailable HQLA Collateral:") print(twin.get_available_collateral('HQLA')) print("\nRegulatory Scenario Sandbox:") for scenario in ScenarioType: results = twin.simulate_regulatory_scenario(scenario) print(f"{results['scenario']}: Shortfall=${results['max_liquidity_shortfall']:,.0f}M, LCR={results['pseudo_lcr']:.2f}, Secured Cost=${results['secured_annual_cost']:,.0f}M/yr") print("\nLaunch Interactive Dashboard (requires Plotly):") twin.visualize_twin() print("\n=== Ready for Custom Data/Scenarios! ===") print("Extend by: twin.liquidity_ladders['inflows'] = your_df")Key Features & Extensibility
- Mirrors Core Elements: Liquidity ladders (in/outflows), collateral (with haircuts/eligibility), funding costs (curves).
- Sandboxing Regulatory Asks: Pre-built scenarios for LCR/NSFR/market stress. Run
simulate_regulatory_scenario()for what-ifs. - Outputs: Tables, metrics (gaps, costs, pseudo-ratios), interactive Plotly viz.
- Realistic Sample Data: USD millions; tweak for your bank.
- Customize:
- Load real data: Replace
load_sample_data()with CSV/Excel ingestion. - Add scenarios: Extend
ScenarioTypeand modify multipliers. - Multi-currency: Key pools/curves by ISO code.
- Advanced: Integrate Monte Carlo (numpy.random), optimize funding mix (scipy.optimize).
- Load real data: Replace
This is production-ready for prototyping—deploy via Streamlit/Flask for a web sandbox. Questions? Let's iterate! 🕵️♂️