""" compounding_analysis_v1.py =========================== Answers the question: what does true compounding look like vs fixed notional? Three scenarios shown side by side: Scenario A — Fixed notional (current FTMO challenge model) Notional stays at $300k regardless of account growth. This is what the annual_pnl_analysis showed — $ P&L stays roughly constant each year (~$40-80k) but % of growing balance shrinks. This is correct for FTMO challenges (always start fresh at $100k). Scenario B — Compounding: scale notional with balance (personal account) As profits accumulate, notional scales proportionally. $100k → $300k notional (0.75% risk stays fixed) $200k → $600k notional $500k → $1.5M notional $1M → $3.0M notional This is true compounding — the dollar engine scales up. This is what you'd do running this on a personal account or after scaling up through prop firm tiers. Scenario C — FTMO challenge reinvestment model Each time Phase 1 + Phase 2 is passed, the funded account grows. FTMO funded accounts scale: $10k → $25k → $50k → $100k → $200k → $400k Profits from each funded account are reinvested to fund the next tier. This is the realistic path through the FTMO ecosystem. Place this file in: C:\\Users\\paul_\\OneDrive\\fx_macro_intraday\\src\\research\\compounding_analysis_v1.py Run from project root: python src/research/compounding_analysis_v1.py """ import pandas as pd import numpy as np import matplotlib matplotlib.use("Agg") import matplotlib as mpl mpl.rcParams["text.usetex"] = False import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec import matplotlib.ticker as mticker from pathlib import Path import sys BASE_PATH = Path(__file__).resolve().parents[2] SRC_PATH = BASE_PATH / "src" if str(SRC_PATH) not in sys.path: sys.path.append(str(SRC_PATH)) TRADES_DIR = BASE_PATH / "data" / "processed" / "trades" CHARTS_DIR = BASE_PATH / "data" / "processed" # ── Constants ───────────────────────────────────────────────────────────────── ACCOUNT_START = 100_000.0 STOP_PCT = 0.0025 BASE_RISK_PCT = 0.0075 BASE_NOTIONAL = (ACCOUNT_START * BASE_RISK_PCT) / STOP_PCT # $300k ZSCORE_BANDS = [ (2.75, 3.50, 1.0), (3.50, 4.50, 1.5), (4.50, 99.0, 2.0), ] # FTMO funded account tiers and profit splits # Each tier: (account_size, profit_split_pct, max_drawdown_pct) FTMO_TIERS = [ (10_000, 80, 5), (25_000, 80, 5), (50_000, 80, 5), (100_000, 80, 10), (200_000, 80, 10), (400_000, 90, 10), ] def get_multiplier(z): for lo, hi, mult in ZSCORE_BANDS: if lo <= z < hi: return mult return ZSCORE_BANDS[-1][2] # ── Load trades ─────────────────────────────────────────────────────────────── def load_trades(): for fname in ["trades_real_costs.csv", "trades_eurusd_final.csv"]: path = TRADES_DIR / fname if path.exists(): df = pd.read_csv(path, parse_dates=["entry_time", "exit_time"]) ret_col = "return_real" if "return_real" in df.columns else "return" df["ret"] = df[ret_col] df["zscore_abs"] = df.get("zscore_abs", pd.Series([2.75] * len(df))) df["multiplier"] = df["zscore_abs"].apply(get_multiplier) df = df.sort_values("exit_time").reset_index(drop=True) print(f" Loaded {len(df):,} trades from {fname}") return df raise FileNotFoundError("Run real_world_costs_v1.py first.") # ── Scenario A: Fixed notional ──────────────────────────────────────────────── def scenario_a_fixed(df): """Fixed $300k notional throughout. Balance grows but notional stays same.""" balance = ACCOUNT_START records = [] for _, row in df.iterrows(): notional = min(BASE_NOTIONAL * row["multiplier"], BASE_NOTIONAL * 3) pnl = row["ret"] * notional balance += pnl records.append({ "exit_time": row["exit_time"], "balance" : balance, "pnl" : pnl, }) return pd.DataFrame(records) # ── Scenario B: Compounding notional ───────────────────────────────────────── def scenario_b_compound(df): """ Notional scales proportionally with account balance. BASE_RISK_PCT stays fixed at 0.75% of current balance. Every trade: notional = current_balance * 0.75% / stop_pct """ balance = ACCOUNT_START records = [] for _, row in df.iterrows(): # Recalculate notional based on current balance current_notional = (balance * BASE_RISK_PCT) / STOP_PCT scaled_notional = min( current_notional * row["multiplier"], current_notional * 3 ) pnl = row["ret"] * scaled_notional balance += pnl records.append({ "exit_time": row["exit_time"], "balance" : balance, "pnl" : pnl, }) return pd.DataFrame(records) # ── Scenario C: FTMO tiered reinvestment ────────────────────────────────────── def scenario_c_ftmo_tiers(df): """ Simulates progressing through FTMO funded account tiers. Timeline: 1. Start with $100k challenge account 2. Pass Phase 1 + Phase 2 → get funded at current tier 3. Trade funded account until 10% profit target hit 4. Receive profit split (80-90%) 5. Reinvest profits into next tier challenge fee 6. Repeat at next tier FTMO challenge fees (approximate): $10k = $155 $25k = $250 $50k = $345 $100k = $499 $200k = $1,099 $400k = $1,999 This shows realistic capital growth path through the FTMO ecosystem. """ CHALLENGE_FEES = { 10_000 : 155, 25_000 : 250, 50_000 : 345, 100_000: 499, 200_000: 1099, 400_000: 1999, } # Start: personal capital = $2,000 (enough to fund multiple challenges) personal_capital = 2_000.0 current_tier_idx = 3 # Start at $100k challenge (index 3 in FTMO_TIERS) funded_balance = 0.0 total_balance = personal_capital tier_profits = [] records = [] events = [] df_sorted = df.sort_values("exit_time").reset_index(drop=True) trade_idx = 0 n_trades = len(df_sorted) # Phase tracking # Each "challenge" goes: Phase1 (need 10%), Phase2 (need 5%), Funded (need 10%) PHASE1_TARGET_PCT = 0.10 PHASE2_TARGET_PCT = 0.05 FUNDED_TARGET_PCT = 0.10 phase = "P1" phase_start_bal = 0.0 # P&L from start of current phase phase_pnl = 0.0 challenges = 0 funded_rounds= 0 tier_size, split_pct, dd_limit_pct = FTMO_TIERS[current_tier_idx] phase_target = tier_size * PHASE1_TARGET_PCT for _, row in df_sorted.iterrows(): # Notional based on tier account size notional = min( (tier_size * BASE_RISK_PCT / STOP_PCT) * row["multiplier"], (tier_size * BASE_RISK_PCT / STOP_PCT) * 3 ) pnl = row["ret"] * notional phase_pnl += pnl total_balance += pnl records.append({ "exit_time" : row["exit_time"], "total_balance": total_balance, "phase" : phase, "tier" : tier_size, "pnl" : pnl, }) # Check phase completion if phase == "P1" and phase_pnl >= tier_size * PHASE1_TARGET_PCT: events.append(f"{row['exit_time'].date()} P1 passed at tier {tier_size:,}") phase = "P2" phase_pnl = 0.0 challenges += 1 elif phase == "P2" and phase_pnl >= tier_size * PHASE2_TARGET_PCT: events.append(f"{row['exit_time'].date()} P2 passed at tier {tier_size:,}") phase = "FUNDED" phase_pnl = 0.0 elif phase == "FUNDED" and phase_pnl >= tier_size * FUNDED_TARGET_PCT: # Collect profit split gross_profit = tier_size * FUNDED_TARGET_PCT trader_share = gross_profit * (split_pct / 100) personal_capital+= trader_share funded_rounds += 1 events.append( f"{row['exit_time'].date()} FUNDED profit collected: " f"+{trader_share:,.0f} at tier {tier_size:,} " f"({split_pct}% split)" ) # Try to move to next tier next_tier_idx = min(current_tier_idx + 1, len(FTMO_TIERS) - 1) next_tier_size, next_split, next_dd = FTMO_TIERS[next_tier_idx] fee = CHALLENGE_FEES.get(next_tier_size, 2000) if personal_capital >= fee: personal_capital -= fee current_tier_idx = next_tier_idx tier_size, split_pct, dd_limit_pct = FTMO_TIERS[current_tier_idx] events.append( f" -> Upgraded to tier {tier_size:,} " f"(fee: {fee}) personal capital: {personal_capital:,.0f}" ) else: # Stay at current tier events.append( f" -> Staying at tier {tier_size:,} " f"(insufficient capital for next tier)" ) total_balance = personal_capital phase = "P1" phase_pnl = 0.0 # Check breach (simplified — overall DD) elif phase_pnl <= -(tier_size * dd_limit_pct / 100): events.append( f"{row['exit_time'].date()} BREACH at tier {tier_size:,} " f"({phase}) — restarting" ) # Pay new challenge fee fee = CHALLENGE_FEES.get(tier_size, 500) personal_capital = max(0, personal_capital - fee) total_balance = personal_capital phase = "P1" phase_pnl = 0.0 return pd.DataFrame(records), events, funded_rounds, challenges # ── Chart ───────────────────────────────────────────────────────────────────── def make_chart(df_a, df_b, df_c, save_path): BG = "#0d1117" PANEL = "#161b22" GRID = "#21262d" TEXT = "#e6edf3" MUTED = "#8b949e" CYAN = "#00d4ff" GREEN = "#00ff88" GOLD = "#ffd700" ORNG = "#ff8c00" PURP = "#cc88ff" fig = plt.figure(figsize=(22, 18), facecolor=BG) gs = gridspec.GridSpec(2, 2, figure=fig, hspace=0.45, wspace=0.28, left=0.07, right=0.97, top=0.91, bottom=0.05) def style(ax, title): ax.set_facecolor(PANEL) ax.set_title(title, color=TEXT, fontsize=11, fontweight="bold", pad=10) ax.tick_params(colors=TEXT, labelsize=9) for sp in ax.spines.values(): sp.set_color(GRID) ax.grid(True, color=GRID, linewidth=0.5, alpha=0.7) ax.yaxis.label.set_color(TEXT) ax.xaxis.label.set_color(TEXT) def fmt_millions(x, _): if abs(x) >= 1e6: return f"{x/1e6:.1f}M" elif abs(x) >= 1e3: return f"{x/1e3:.0f}k" return f"{x:.0f}" # ── Panel 1: All three equity curves overlaid ────────────────────────── ax1 = fig.add_subplot(gs[0, :]) style(ax1, "Three Growth Scenarios - 100k Starting Capital - 22 Years") ax1.plot(df_a["exit_time"], df_a["balance"] / 1e3, color=CYAN, linewidth=1.4, alpha=0.9, label=f"A: Fixed 300k notional " f"(final: {df_a['balance'].iloc[-1]/1e3:.0f}k)") ax1.plot(df_b["exit_time"], df_b["balance"] / 1e3, color=GREEN, linewidth=1.8, alpha=0.95, label=f"B: Compounding notional (0.75% of balance) " f"(final: {df_b['balance'].iloc[-1]/1e3:.0f}k)") ax1.plot(df_c["exit_time"], df_c["total_balance"] / 1e3, color=GOLD, linewidth=1.4, alpha=0.85, linestyle="--", label=f"C: FTMO tier progression " f"(final: {df_c['total_balance'].iloc[-1]/1e3:.0f}k)") ax1.axhline(y=100, color=MUTED, linewidth=0.8, linestyle=":", alpha=0.6) # Final balance annotations for df_, col, offset in [ (df_a, CYAN, 60), (df_b, GREEN, 60), (df_c, GOLD, 60) ]: last = df_.iloc[-1] bal = last["balance"] if "balance" in last else last["total_balance"] ax1.annotate( f"{bal/1e3:.0f}k", xy=(last["exit_time"], bal / 1e3), xytext=(-80, offset), textcoords="offset points", color=col, fontsize=10, fontweight="bold", arrowprops=dict(arrowstyle="->", color=col, lw=1.0) ) ax1.yaxis.set_major_formatter(mticker.FuncFormatter(fmt_millions)) ax1.set_ylabel("Account Balance", fontsize=10) ax1.legend(facecolor=PANEL, edgecolor=GRID, labelcolor=TEXT, fontsize=9, loc="upper left") # ── Panel 2: Annual returns comparison ──────────────────────────────── ax2 = fig.add_subplot(gs[1, 0]) style(ax2, "Annual Return % by Scenario") # Build annual returns for each scenario years = sorted(df_a["exit_time"].dt.year.unique()) def annual_pct(df_, bal_col="balance"): rows = [] prev = ACCOUNT_START for yr in years: mask = df_["exit_time"].dt.year == yr if mask.any(): end = df_[mask][bal_col].iloc[-1] rows.append((yr, (end - prev) / prev * 100)) prev = end else: rows.append((yr, 0)) return rows ret_a = annual_pct(df_a) ret_b = annual_pct(df_b) x = np.arange(len(years)) w = 0.35 ax2.bar(x - w/2, [r for _, r in ret_a], w, color=CYAN, alpha=0.75, label="A: Fixed notional") ax2.bar(x + w/2, [r for _, r in ret_b], w, color=GREEN, alpha=0.75, label="B: Compounding") ax2.axhline(y=0, color=MUTED, linewidth=0.8) ax2.set_xticks(x) ax2.set_xticklabels(years, rotation=45, fontsize=7) ax2.yaxis.set_major_formatter( mticker.FuncFormatter(lambda v, _: f"{v:.0f}%")) ax2.set_ylabel("Annual Return %", fontsize=9) ax2.legend(facecolor=PANEL, edgecolor=GRID, labelcolor=TEXT, fontsize=8) avg_a = np.mean([r for _, r in ret_a]) avg_b = np.mean([r for _, r in ret_b]) ax2.axhline(y=avg_a, color=CYAN, linewidth=1, linestyle="--", alpha=0.6, label=f"Avg A: {avg_a:.0f}%") ax2.axhline(y=avg_b, color=GREEN, linewidth=1, linestyle="--", alpha=0.6, label=f"Avg B: {avg_b:.0f}%") ax2.text(0.02, 0.96, f"Avg A: {avg_a:.1f}%/yr", transform=ax2.transAxes, color=CYAN, fontsize=9, va="top") ax2.text(0.02, 0.88, f"Avg B: {avg_b:.1f}%/yr", transform=ax2.transAxes, color=GREEN, fontsize=9, va="top") # ── Panel 3: Compounding scenario monthly PnL ───────────────────────── ax3 = fig.add_subplot(gs[1, 1]) style(ax3, "Scenario B Compounding - Monthly PnL in Dollars") df_b["month"] = df_b["exit_time"].dt.to_period("M") monthly_b = df_b.groupby("month")["pnl"].sum().reset_index() monthly_b["month_dt"] = monthly_b["month"].dt.to_timestamp() cols_b = [GREEN if v >= 0 else "#ff4444" for v in monthly_b["pnl"]] ax3.bar(range(len(monthly_b)), monthly_b["pnl"] / 1e3, color=cols_b, alpha=0.8, width=1.0) ax3.axhline(y=0, color=MUTED, linewidth=0.8) # Year markers prev_yr = None for i, m in enumerate(monthly_b["month_dt"]): if m.year != prev_yr: if i > 0: ax3.axvline(x=i, color=GRID, linewidth=1, alpha=0.8) prev_yr = m.year # Annotate last few years to show scale growth ax3.yaxis.set_major_formatter( mticker.FuncFormatter(lambda v, _: f"{v:.0f}k")) ax3.set_ylabel("Monthly PnL (thousands)", fontsize=9) pos = (monthly_b["pnl"] > 0).sum() ax3.text(0.01, 0.97, f"Positive months: {pos}/{len(monthly_b)} " f"({pos/len(monthly_b)*100:.0f}%)", transform=ax3.transAxes, ha="left", va="top", color=TEXT, fontsize=8, fontweight="bold") ax3.text(0.01, 0.89, f"Note: later months larger because notional scales with balance", transform=ax3.transAxes, ha="left", va="top", color=MUTED, fontsize=7, style="italic") # ── Suptitle ─────────────────────────────────────────────────────────── final_a = df_a["balance"].iloc[-1] final_b = df_b["balance"].iloc[-1] final_c = df_c["total_balance"].iloc[-1] fig.suptitle( f"Compounding Analysis - 100k Starting Capital | 22 Years | Real Costs Applied\n" f"A Fixed 300k: {final_a/1e3:.0f}k | " f"B Compounding: {final_b/1e6:.2f}M | " f"C FTMO Tiers: {final_c/1e3:.0f}k", color=TEXT, fontsize=13, fontweight="bold", y=0.965 ) plt.savefig(save_path, dpi=150, bbox_inches="tight", facecolor=fig.get_facecolor()) plt.close() print(f" Chart saved: {save_path}") # ── Main ────────────────────────────────────────────────────────────────────── def main(): print("=" * 70) print("COMPOUNDING ANALYSIS V1") print(" Three scenarios on the same trade sequence") print("=" * 70) print("\nLoading trades...") df = load_trades() print("\nScenario A: Fixed $300k notional...") df_a = scenario_a_fixed(df) print("Scenario B: Compounding notional (0.75% of current balance)...") df_b = scenario_b_compound(df) print("Scenario C: FTMO tier progression...") df_c, events_c, funded_rounds, challenges = scenario_c_ftmo_tiers(df) # ── Print summary ───────────────────────────────────────────────────── years = 22.0 final_a = df_a["balance"].iloc[-1] final_b = df_b["balance"].iloc[-1] final_c = df_c["total_balance"].iloc[-1] cagr_a = (final_a / ACCOUNT_START) ** (1/years) - 1 cagr_b = (final_b / ACCOUNT_START) ** (1/years) - 1 print(f"\n{'='*70}") print("RESULTS SUMMARY") print(f"{'='*70}") print(f""" Starting capital: 100,000 SCENARIO A — Fixed 300k notional (FTMO challenge model) ───────────────────────────────────────────────────────── Final balance : {final_a:>12,.0f} Total return : {(final_a/ACCOUNT_START - 1)*100:>10.0f}% CAGR : {cagr_a*100:>10.2f}% per year Avg annual PnL: {(final_a-ACCOUNT_START)/years:>10,.0f} Note: Dollar engine is constant (~40-80k/yr) but % shrinks because denominator grows while notional stays fixed. For FTMO challenges this is irrelevant — every challenge starts fresh at 100k with 300k notional. SCENARIO B — Compounding notional (scale with balance) ───────────────────────────────────────────────────────── Final balance : {final_b:>12,.0f} Total return : {(final_b/ACCOUNT_START - 1)*100:>10.0f}% CAGR : {cagr_b*100:>10.2f}% per year Note: This is what happens if you keep 100% of profits and scale notional with balance — pure compound growth. Win rate and edge stay identical — only position size grows. This is realistic if running on a personal funded account where you control sizing directly. SCENARIO C — FTMO tier progression ───────────────────────────────────────────────────────── Final capital : {final_c:>12,.0f} Challenges run: {challenges:>10} Funded rounds : {funded_rounds:>10} Note: Realistic path through FTMO ecosystem — start 100k challenge, pass, trade funded, collect profit split, reinvest into larger tier. Progress is slower than B because profit splits are 80-90% not 100% and challenge fees are paid each tier. FTMO CHALLENGE CONTEXT (the number that matters day-to-day) ───────────────────────────────────────────────────────── Avg dollar PnL per year (Scenario A) : {(final_a-ACCOUNT_START)/years:>8,.0f} Phase 1 target (10% of 100k) : {10000:>8,.0f} Avg months to Phase 1 target : ~2.2 months Avg months to Phase 2 target : ~1.1 months Avg total challenge duration : ~3.4 months Why does 3.5% annual on the compounding chart still pass a challenge in 3 months? ───────────────────────────────────────────────────────── Year 2023 example: Compounding balance at start of 2023 : ~1,100,000 Annual PnL in 2023 : +41,025 As % of 1.1M balance : 3.7% <- this is the 3.5% you see As % of 100k challenge account : 41.0% <- this is what FTMO sees Phase 1 needs 10% of 100k = 10,000 41,025 / 12 months = 3,419/month avg Months to 10,000 : ~2.9 months """) print("FTMO Tier Events:") for event in events_c[:25]: print(f" {event}") if len(events_c) > 25: print(f" ... and {len(events_c)-25} more events") print(f"\nGenerating chart...") chart_path = CHARTS_DIR / "compounding_analysis_chart.png" make_chart(df_a, df_b, df_c, chart_path) print(f"\n{'='*70}") print("KEY TAKEAWAY") print(f"{'='*70}") print(f""" The confusion about 3.5% vs 3-month challenge duration: The annual % return in the compounding chart divides by the GROWING balance (eventually 1M+). The FTMO challenge always resets to 100k. So the same dollar output that looks like 3.5% of 1M is actually 35-40% on a fresh 100k account. Your model generates roughly 40-80k in dollar PnL per year regardless of what balance it is measured against. The Phase 1 target is always 10k on 100k. 40-80k per year means you hit 10k in 1.5-3 months. That is consistent with the 2.2 month Monte Carlo result. Scenario B shows what happens with true compounding: {cagr_b*100:.1f}% CAGR — the same 75% win rate and 0.07% avg return per trade, just with position size growing proportionally. """) if __name__ == "__main__": main()