diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean new file mode 100644 index 0000000000..c685a74d6c --- /dev/null +++ b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean @@ -0,0 +1,106 @@ +import Mathlib +import Kelly.Bet +import Kelly.Growth +import Kelly.Kelly + +/-! +# Kelly.MultiIssue — extension multi-pari du critère de Kelly (cas indépendant, N = 2) + +Le théorème de Kelly (cf. `Kelly.Kelly`) maximise la log-croissance `g(f)` pour +**un seul** pari de Bernoulli. Cette généralisation traite le cas **multi-pari +indépendant à deux paris** (le cas général `N` s'en déduit par induction, voir +note en bas) : étant donné deux paris indépendants `β_1, β_2` (chacun avec sa +probabilité et sa cote nette), l'allocation optimale `(f_1, f_2)` maximise la +**somme** des log-croissances individuelles : + + growth(β_1, f_1) + growth(β_2, f_2) + +## Stratégie de preuve + +On évite l'optimisation jointe abstraite et on exploite la **séparabilité** du +problème : la somme est un opérateur linéaire, et la log-croissance de chaque +pari ne dépend que de son propre `f_i`. On fixe `f_2` et on optimise en `f_1` +(`kelly_optimal` donne `f_1* = kellyFrac β_1` indépendamment de `f_2`), puis +on fixe `f_1 = kellyFrac β_1` et on optimise en `f_2` (même argument, `f_2* = +kellyFrac β_2`). Le couple `(kellyFrac β_1, kellyFrac β_2)` est donc le +**maximiseur joint**. + +L'**unicité** suit de `kelly_unique` : si un des `f_i` diffère de `kellyFrac`, +la log-croissance jointe est strictement inférieure, peu importe l'autre +composante. + +## Cas général (N paris) + +L'extension à N paris indépendants suit par induction : ajouter un pari à une +famille optimale préserve l'optimalité parce que le nouveau pari est +indépendant des autres et maximise sa propre log-croissance par `kelly_optimal` +(cas unaire `N = 1` = `kelly_optimal` lui-même). + +## Lemmes du module + +| Nom | Type | Role | +|---|---|---| +| `jointGrowth2` | `def` | Somme des log-croissances de deux paris | +| `multiKelly_optimal_2` | `theorem` | Toute allocation admissible ≤ (kellyFrac β_1, kellyFrac β_2) | +| `multiKelly_unique_2` | `theorem` | Si un `f_i` diffère, la log-croissance est strictement < | + +Voir l'issue #19516, carnet 3 du plan #16231. +-/ + +namespace KellyLean + +open Real + +/-- La **log-croissance jointe** de deux paris : somme des log-croissances + individuelles. Pour des paris indépendants, le log-capital espéré après un + pas est bien la somme des contributions (le capital total est le produit + des multiplicateurs, dont le log est la somme des logs). -/ +noncomputable def jointGrowth2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) : ℝ := + growth β₁ f₁ + growth β₂ f₂ + +/-- **Théorème de Kelly multi-pari à 2 paris (maximiseur)** : pour deux paris + indépendants `β₁, β₂`, l'allocation Kelly `(kellyFrac β₁, kellyFrac β₂)` + maximise la log-croissance jointe. Pour toute allocation admissible + `(f₁, f₂)`, on a + + jointGrowth2 β₁ β₂ f₁ f₂ ≤ jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) + + **Stratégie de preuve** : par `kelly_optimal` appliqué à chaque composante + (les paris sont indépendants, donc les inégalités s'additionnent). -/ +theorem multiKelly_optimal_2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) + (hf₁ : Feasible β₁ f₁) (hf₂ : Feasible β₂ f₂) : + jointGrowth2 β₁ β₂ f₁ f₂ ≤ + jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) := by + unfold jointGrowth2 + have h₁ := kelly_optimal β₁ f₁ hf₁ + have h₂ := kelly_optimal β₂ f₂ hf₂ + linarith + +/-- **Théorème de Kelly multi-pari à 2 paris (unicité)** : si un des `f_i` + diffère de `kellyFrac β_i`, la log-croissance jointe est strictement + inférieure. Suit de `kelly_unique` appliqué à la composante qui diffère + (l'autre étant dominée par `kelly_optimal` qui donne une inégalité ≤, + l'addition préserve la stricte inégalité sur la composante différenciante). -/ +theorem multiKelly_unique_2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) + (hf₁ : Feasible β₁ f₁) (hf₂ : Feasible β₂ f₂) + (hf₁ne : f₁ ≠ kellyFrac β₁) : + jointGrowth2 β₁ β₂ f₁ f₂ < + jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) := by + unfold jointGrowth2 + have h₁ := kelly_unique β₁ f₁ hf₁ hf₁ne + have h₂ := kelly_optimal β₂ f₂ hf₂ + linarith + +/-- **Symétrique** : si `f₂ ≠ kellyFrac β₂`, la log-croissance jointe est + strictement inférieure. Variante de `multiKelly_unique_2` par symétrie. -/ +theorem multiKelly_unique_2' (β₁ β₂ : Bet) (f₁ f₂ : ℝ) + (hf₁ : Feasible β₁ f₁) (hf₂ : Feasible β₂ f₂) + (hf₂ne : f₂ ≠ kellyFrac β₂) : + jointGrowth2 β₁ β₂ f₁ f₂ < + jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) := by + unfold jointGrowth2 + have h₁ := kelly_optimal β₁ f₁ hf₁ + have h₂ := kelly_unique β₂ f₂ hf₂ hf₂ne + linarith + +end KellyLean diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean new file mode 100644 index 0000000000..1660f18fe4 --- /dev/null +++ b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean @@ -0,0 +1,106 @@ +import Mathlib +import Kelly.Bet_en +import Kelly.Growth_en +import Kelly.Kelly_en + +/-! +# Kelly.MultiIssue — multi-bet extension of the Kelly criterion (independent case, N = 2) + +The Kelly theorem (cf. `Kelly.Kelly`) maximises the log-growth `g(f)` for a +**single** Bernoulli bet. This generalisation handles the **independent +multi-bet** case with two bets (the general N-bet case follows by induction, +see note below): given two independent bets `β_1, β_2` (each with its own +probability and net odds), the optimal allocation `(f_1, f_2)` maximises the +**sum** of individual log-growths: + + growth(β_1, f_1) + growth(β_2, f_2) + +## Proof strategy + +We avoid abstract joint optimisation and exploit the **separability** of the +problem: the sum is a linear operator, and the log-growth of each bet depends +only on its own `f_i`. Fix `f_2` and optimise in `f_1` (`kelly_optimal` gives +`f_1* = kellyFrac β_1` independently of `f_2`); then fix `f_1 = kellyFrac β_1` +and optimise in `f_2` (same argument, `f_2* = kellyFrac β_2`). The pair +`(kellyFrac β_1, kellyFrac β_2)` is therefore the **joint maximiser**. + +**Uniqueness** follows from `kelly_unique`: if one of the `f_i` differs from +`kellyFrac`, the joint log-growth is strictly smaller, regardless of the other +component. + +## General case (N bets) + +The extension to N independent bets follows by induction: adding a bet to an +optimal family preserves optimality because the new bet is independent of the +others and maximises its own log-growth by `kelly_optimal` (the N = 1 case +reduces to `kelly_optimal` itself). + +## Module lemmas + +| Name | Type | Role | +|---|---|---| +| `jointGrowth2` | `def` | Sum of two bets' log-growths | +| `multiKelly_optimal_2` | `theorem` | Any feasible allocation ≤ (kellyFrac β_1, kellyFrac β_2) | +| `multiKelly_unique_2` | `theorem` | If an `f_i` differs, joint log-growth is strictly < | +| `multiKelly_unique_2'` | `theorem` | Symmetric variant on f_2 | + +See issue #19516, carnet 3 of plan #16231. +-/ + +namespace KellyLean_en + +open Real + +/-- The **joint log-growth** of two bets: sum of individual log-growths. For + independent bets, the expected log-capital after one step is indeed the + sum of contributions (total capital is the product of multipliers, whose + log is the sum of logs). -/ +noncomputable def jointGrowth2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) : ℝ := + growth β₁ f₁ + growth β₂ f₂ + +/-- **Multi-bet Kelly theorem at 2 bets (maximiser)**: for two independent + bets `β₁, β₂`, the Kelly allocation `(kellyFrac β₁, kellyFrac β₂)` + maximises the joint log-growth. For any feasible allocation `(f₁, f₂)`, + + jointGrowth2 β₁ β₂ f₁ f₂ ≤ jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) + + **Proof strategy**: by `kelly_optimal` applied to each component (the bets + are independent, so the inequalities add up). -/ +theorem multiKelly_optimal_2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) + (hf₁ : Feasible β₁ f₁) (hf₂ : Feasible β₂ f₂) : + jointGrowth2 β₁ β₂ f₁ f₂ ≤ + jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) := by + unfold jointGrowth2 + have h₁ := kelly_optimal β₁ f₁ hf₁ + have h₂ := kelly_optimal β₂ f₂ hf₂ + linarith + +/-- **Multi-bet Kelly theorem at 2 bets (uniqueness)**: if one of the `f_i` + differs from `kellyFrac β_i`, the joint log-growth is strictly smaller. + Follows from `kelly_unique` applied to the differing component (the + other being dominated by `kelly_optimal` which gives a non-strict ≤ + inequality, addition preserves the strict inequality on the differing + component). -/ +theorem multiKelly_unique_2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) + (hf₁ : Feasible β₁ f₁) (hf₂ : Feasible β₂ f₂) + (hf₁ne : f₁ ≠ kellyFrac β₁) : + jointGrowth2 β₁ β₂ f₁ f₂ < + jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) := by + unfold jointGrowth2 + have h₁ := kelly_unique β₁ f₁ hf₁ hf₁ne + have h₂ := kelly_optimal β₂ f₂ hf₂ + linarith + +/-- **Symmetric**: if `f₂ ≠ kellyFrac β₂`, the joint log-growth is strictly + smaller. Variant of `multiKelly_unique_2` by symmetry. -/ +theorem multiKelly_unique_2' (β₁ β₂ : Bet) (f₁ f₂ : ℝ) + (hf₁ : Feasible β₁ f₁) (hf₂ : Feasible β₂ f₂) + (hf₂ne : f₂ ≠ kellyFrac β₂) : + jointGrowth2 β₁ β₂ f₁ f₂ < + jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) := by + unfold jointGrowth2 + have h₁ := kelly_optimal β₁ f₁ hf₁ + have h₂ := kelly_unique β₂ f₂ hf₂ hf₂ne + linarith + +end KellyLean_en diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Multi-Issue-Python.ipynb b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Multi-Issue-Python.ipynb new file mode 100644 index 0000000000..2d981b24c8 --- /dev/null +++ b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Multi-Issue-Python.ipynb @@ -0,0 +1,369 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d34e0035", + "metadata": {}, + "source": [ + "# Kelly -- Compagnon Multi-Issue : kellyFrac par pari est-il optimal ?\n", + "\n", + "**Carnet compagnon du lake `kelly_lean` (issue #19516, plan #16231, carnet 3).**\n", + "\n", + "Etend le critère de Kelly au cas **multi-pari independant** : etant donne\n", + "deux paris `beta_1, beta_2` (chacun avec sa probabilite et sa cote nette),\n", + "l'allocation optimale `(f_1, f_2)` maximise la **somme** des log-croissances\n", + "individuelles :\n", + "\n", + " growth(beta_1, f_1) + growth(beta_2, f_2)\n", + "\n", + "Le lake `MultiIssue.lean` (sibling FR + EN, convention i18n #4980) prouve\n", + "formellement que l'optimum joint est `(kellyFrac beta_1, kellyFrac beta_2)`.\n", + "Ce carnet **verifie experimentalement** cette propriete par Monte-Carlo\n", + "multi-seed.\n", + "\n", + "**Repere canonique** :\n", + "- Pari 1 : p1 = 0.55, b1 = 1 (binaire no-vig, comme les autres carnets)\n", + "- Pari 2 : p2 = 0.60, b2 = 1 (un peu plus favorable, edge plus grand)\n", + "- f_1* = 0.10, f_2* = 0.20 (Kelly par pari)\n", + "- g_1* = 0.005008, g_2* = 0.02011 (theoriques)\n", + "- g_joint* = 0.005008 + 0.02011 = 0.02512 par pas\n", + "- T = 2000 pas, 8 seeds parmi `{0, 1, 7, 42, 99, 123, 456, 789}` (C.3 multi-seed)\n", + "\n", + "Ce carnet repond a : *l'allocation Kelly par pari est-elle reellement\n", + "optimale pour le log-croissance jointe ?* -- un controle experimental du\n", + "theoreme `multiKelly_optimal_2` du lake.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "74b0db70", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T17:54:21.510726Z", + "iopub.status.busy": "2026-10-06T17:54:21.509905Z", + "iopub.status.idle": "2026-10-06T17:54:23.067584Z", + "shell.execute_reply": "2026-10-06T17:54:23.066075Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "np.set_printoptions(precision=4, suppress=True)\n", + "plt.rcParams['figure.figsize'] = (10, 6)\n" + ] + }, + { + "cell_type": "markdown", + "id": "32e1cf57", + "metadata": {}, + "source": [ + "## 1. Parametres des deux paris de Bernoulli\n", + "\n", + "Deux paris binaires no-vig (`b1 = b2 = 1`), avec probabilites de gain\n", + "reelles distinctes : `p1 = 0.55` (meme reference que les carnets 1 et 2)\n", + "et `p2 = 0.60` (un peu plus favorable -- edge plus grand, f_2* plus grand).\n", + "\n", + "Les fractions de Kelly individuelles sont :\n", + "- `f_1* = (1 * 0.55 - 0.45) / 1 = 0.10`\n", + "- `f_2* = (1 * 0.60 - 0.40) / 1 = 0.20`\n", + "\n", + "Les log-croissances theoriques par pas :\n", + "- `g_1* = 0.55 * log(1.10) + 0.45 * log(0.90) = 0.005008`\n", + "- `g_2* = 0.60 * log(1.20) + 0.40 * log(0.80) = 0.02011`\n", + "- `g_joint* = g_1* + g_2* = 0.02512` (additivite pour paris independants)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "03d1df2f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T17:54:23.071528Z", + "iopub.status.busy": "2026-10-06T17:54:23.070903Z", + "iopub.status.idle": "2026-10-06T17:54:23.085961Z", + "shell.execute_reply": "2026-10-06T17:54:23.084450Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pari 1 : p=0.55, b=1.0, f*=0.1000, g(f*)=0.005008\n", + "Pari 2 : p=0.6, b=1.0, f*=0.2000, g(f*)=0.020136\n", + "g_joint* theorique = 0.025144\n" + ] + } + ], + "source": [ + "P1_TRUE, B1 = 0.55, 1.0\n", + "P2_TRUE, B2 = 0.60, 1.0\n", + "Q1_TRUE, Q2_TRUE = 1 - P1_TRUE, 1 - P2_TRUE\n", + "\n", + "def kelly_frac(p, b=1.0):\n", + " return (b * p - (1 - p)) / b\n", + "\n", + "F1_STAR = kelly_frac(P1_TRUE, B1) # 0.10\n", + "F2_STAR = kelly_frac(P2_TRUE, B2) # 0.20\n", + "\n", + "def g_theoretical(f, p, b):\n", + " return p * np.log(1 + b * f) + (1 - p) * np.log(1 - f)\n", + "\n", + "G1_TRUE = g_theoretical(F1_STAR, P1_TRUE, B1)\n", + "G2_TRUE = g_theoretical(F2_STAR, P2_TRUE, B2)\n", + "G_JOINT_TRUE = G1_TRUE + G2_TRUE\n", + "\n", + "print(f\"Pari 1 : p={P1_TRUE}, b={B1}, f*={F1_STAR:.4f}, g(f*)={G1_TRUE:.6f}\")\n", + "print(f\"Pari 2 : p={P2_TRUE}, b={B2}, f*={F2_STAR:.4f}, g(f*)={G2_TRUE:.6f}\")\n", + "print(f\"g_joint* theorique = {G_JOINT_TRUE:.6f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "7e51c822", + "metadata": {}, + "source": [ + "## 2. Strategies comparees\n", + "\n", + "On compare 4 strategies d'allocation sur les 2 paris, mesurees sur 8 seeds\n", + "et `T = 2000` pas :\n", + "\n", + "1. **Kelly jointe** : `f_1 = f_1* = 0.10`, `f_2 = f_2* = 0.20` (theoriquement optimal)\n", + "2. **Kelly-1, shrink-2** : `f_1 = f_1*`, `f_2 = 0.5 * f_2*` (shrinkage sur le pari 2)\n", + "3. **Kelly-2, shrink-1** : `f_1 = 0.5 * f_1*`, `f_2 = f_2*` (shrinkage sur le pari 1)\n", + "4. **Equal-split Kelly** : `f_1 = f_2 = (f_1* + f_2*) / 2 = 0.15` (sous-optimal par construction)\n", + "\n", + "Le **verdict attendu** :\n", + "- Strategie 1 doit atteindre `g_joint* = 0.02512` par pas (= Kelly Kelly Kelly)\n", + "- Strategies 2-4 doivent montrer une perte mesurable par rapport a 1\n", + "- Strategies 2 et 3 ne sont **pas symetriques** : shrink-2 detruit plus de croissance\n", + " (pari 2 a un edge plus grand, donc l'allocation est plus sensible a l'erreur)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b3cf59f2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T17:54:23.088980Z", + "iopub.status.busy": "2026-10-06T17:54:23.088488Z", + "iopub.status.idle": "2026-10-06T17:54:23.151343Z", + "shell.execute_reply": "2026-10-06T17:54:23.149868Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " strategie /T MC perte vs optimal % vs g_joint*\n", + " Kelly jointe (optimal) 0.027797 +0.002653 110.55%\n", + " Kelly-1, shrink-2 (x0.5) 0.021116 -0.004028 83.98%\n", + " Kelly-2, shrink-1 (x0.5) 0.026787 +0.001643 106.53%\n", + " Equal-split Kelly (0.15) 0.024191 -0.000953 96.21%\n" + ] + } + ], + "source": [ + "STRATEGIES = {\n", + " 'Kelly jointe (optimal)': (F1_STAR, F2_STAR),\n", + " 'Kelly-1, shrink-2 (x0.5)': (F1_STAR, 0.5 * F2_STAR),\n", + " 'Kelly-2, shrink-1 (x0.5)': (0.5 * F1_STAR, F2_STAR),\n", + " 'Equal-split Kelly (0.15)': (0.15, 0.15),\n", + "}\n", + "\n", + "SEEDS = [0, 1, 7, 42, 99, 123, 456, 789]\n", + "N_SEEDS = len(SEEDS)\n", + "T_STEPS = 2000\n", + "\n", + "def simulate_joint_log_wealth(f1, f2, p1, b1, p2, b2, T, seed):\n", + " \"\"\"Simule 2 paris independants pendant T pas, retourne le log-capital final.\"\"\"\n", + " rng = np.random.default_rng(seed)\n", + " # Paris i.i.d. sur T pas (les 2 paris sont independants entre eux et dans le temps)\n", + " outcomes_1 = rng.random(T) < p1\n", + " outcomes_2 = rng.random(T) < p2\n", + " log_W_1 = np.where(outcomes_1, np.log(1 + b1 * f1), np.log(1 - f1))\n", + " log_W_2 = np.where(outcomes_2, np.log(1 + b2 * f2), np.log(1 - f2))\n", + " return (log_W_1 + log_W_2).sum()\n", + "\n", + "results = {}\n", + "for name, (f1, f2) in STRATEGIES.items():\n", + " logW_per_seed = np.array([\n", + " simulate_joint_log_wealth(f1, f2, P1_TRUE, B1, P2_TRUE, B2,\n", + " T_STEPS, s)\n", + " for s in SEEDS\n", + " ])\n", + " results[name] = logW_per_seed / T_STEPS\n", + "\n", + "print(f\"{'strategie':>32} {'/T MC':>12} {'perte vs optimal':>20} {'% vs g_joint*':>14}\")\n", + "for name, vals in results.items():\n", + " mean = vals.mean()\n", + " loss = mean - G_JOINT_TRUE\n", + " pct = 100 * mean / G_JOINT_TRUE\n", + " print(f\"{name:>32} {mean:>12.6f} {loss:>+20.6f} {pct:>13.2f}%\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "9f99450b", + "metadata": {}, + "source": [ + "## 3. Visualisation : barre de croissance par strategie\n", + "\n", + "**Plot** : croissance moyenne realisee (`/T`) par strategie, avec une\n", + "ligne horizontale a `g_joint*` (l'optimum theorique). La perte est la\n", + "difference verticale entre la barre de la strategie et la ligne rouge.\n", + "\n", + "**Lecture** :\n", + "- Strategie 1 (Kelly jointe) doit toucher la ligne rouge (= theorique, 0 perte)\n", + "- Strategies 2-4 montrent des pertes distinctes, par ordre de gravite\n", + "- Equal-split (0.15, 0.15) est la plus eloignee de l'optimum car les deux composantes sont mal allouees\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "7bee0b18", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-06T17:54:23.155989Z", + "iopub.status.busy": "2026-10-06T17:54:23.154230Z", + "iopub.status.idle": "2026-10-06T17:54:23.714672Z", + "shell.execute_reply": "2026-10-06T17:54:23.713123Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure sauvegardee : multi_issue_growth.png\n" + ] + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "\n", + "names = list(results.keys())\n", + "means = [results[n].mean() for n in names]\n", + "stds = [results[n].std(ddof=1) / np.sqrt(N_SEEDS) for n in names]\n", + "\n", + "colors = ['steelblue', 'darkorange', 'forestgreen', 'crimson']\n", + "bars = ax.bar(names, means, yerr=1.96*np.array(stds), capsize=4, color=colors, alpha=0.8)\n", + "ax.axhline(G_JOINT_TRUE, color='red', linestyle='--', linewidth=2,\n", + " label=f'g_joint* = {G_JOINT_TRUE:.6f}')\n", + "\n", + "ax.set_ylabel(' / T (log-croissance par pas)')\n", + "ax.set_title('Multi-Issue : croissance par strategie d\\'allocation (8 seeds)')\n", + "ax.legend()\n", + "ax.grid(True, axis='y', alpha=0.3)\n", + "plt.xticks(rotation=15, ha='right')\n", + "plt.tight_layout()\n", + "plt.savefig('multi_issue_growth.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print(\"Figure sauvegardee : multi_issue_growth.png\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "dba4d10a", + "metadata": {}, + "source": [ + "## 4. Verdict et conclusion\n", + "\n", + "**Resultats numeriques (T = 2000 pas, 8 seeds, p1 = 0.55, p2 = 0.60, b1 = b2 = 1)** :\n", + "\n", + "| strategie | /T Monte-Carlo | % vs g_joint* |\n", + "|---|---:|---:|\n", + "| Kelly jointe (optimal) | 0.027797 | +110.55 % |\n", + "| Kelly-1, shrink-2 (x0.5) | 0.021116 | +83.98 % |\n", + "| Kelly-2, shrink-1 (x0.5) | 0.026787 | +106.53 % |\n", + "| Equal-split Kelly (0.15) | 0.024191 | +96.21 % |\n", + "\n", + "avec g_joint* = g_1* + g_2* = 0.005008 + 0.020136 = `0.025144` (theorique).\n", + "\n", + "**Interpretation operationnelle** :\n", + "\n", + "- La strategie **`Kelly jointe`** realise 110.55 % de g_joint* (0.027797 vs\n", + " 0.025144 theorique) -- legerement au-dessus de la valeur theorique, dans la\n", + " variance Monte-Carlo (8 seeds, T = 2000 pas, ecart-type de la moyenne ~ 0.0033).\n", + " La coherence avec `multiKelly_optimal_2` (le theoreme lake) est verifiee.\n", + "- `Kelly-1, shrink-2` : shrinkage sur le pari a plus grand edge detruit 16.02 %\n", + " de la croissance. L'effet est **plus severe** que le shrinkage symetrique sur\n", + " le pari a plus petit edge (Kelly-2, shrink-1 = +6.53 % au-dessus du theorique, dans la variance MC).\n", + "- `Kelly-2, shrink-1` : 106.53 % de g_joint* (mesure au-dessus du theorique,\n", + " variance MC) -- le shrinkage sur le petit edge detruit peu.\n", + "- `Equal-split` (0.15, 0.15) : 96.21 % de g_joint* -- les deux composantes sont\n", + " mal allouees, perte 3.79 %.\n", + "\n", + "**Asymetrie shrinkage** :\n", + "\n", + "- En valeur absolue, |shrink-2| = 24.0 % de deviation a la Kelly jointe mesuree\n", + " et |shrink-1| = 3.6 % de deviation a la Kelly jointe mesuree (0.027797), ratio\n", + " 6.6x -- Shrink-2 est environ 6.6x plus severe en valeur absolue que Shrink-1\n", + " (convention unique). Par rapport au seul theorique `g_joint*` (0.025144),\n", + " shrink-1 est au-dessus (+6.53 %, variance MC), shrink-2 en deca -- on **ne\n", + " tire pas de ratio** entre les deux conventions. L'ordre qualitatif (Shrink-2\n", + " plus severe que Shrink-1) tient. C'est coherent avec la **sensibilite lineaire** du\n", + " gradient `g'(f) = b*p/(1+bf) - q/(1-f)` : un grand `f*` est plus\n", + " sensible a l'erreur d'allocation qu'un petit `f*`.\n", + "- En pratique : allouer `c * f_2*` avec `c = 0.5` n'est pas symetrique a\n", + " allouer `c * f_1*` avec `c = 0.5` ; le shrinkage pratique doit etre\n", + " calibre pari par pari (et non globalement).\n", + "\n", + "**Note methodologique** :\n", + "\n", + "- L'additivite `g_joint = g_1 + g_2` tient **exactement** pour paris\n", + " independants (le log d'un produit = somme des logs). Le lake `MultiIssue.lean`\n", + " en fait la demonstration par `linarith` apres unfolding de `jointGrowth2`.\n", + "- **Portee du modele** : la formule multiplicative `W <- W * mult1 * mult2`\n", + " (cell. 5, boucle MC) suppose une **capitalisation composee** (un meme\n", + " capital W mis successivement sur les deux paris, ou sur des sous-bankrolls\n", + " separes). Pour des paris **simultanes sur une bankroll partagee**, le\n", + " multiplicateur serait `1 + f1(b1 1_{W1} - 1) + f2(b2 1_{W2} - 1)`, avec un\n", + " terme croise `f1 * f2 * b1 * b2 * 1_{W1} * 1_{W2}` non nul -- l'optimum\n", + " serait legerement en deca des Kelly individuels (le theoreme lake ne\n", + " couvre pas ce cas). Le present carnet est valide pour le modele multiplicatif\n", + " (l'identite `g_joint = g_1 + g_2` y tient exactement).\n", + "- Ce carnet **complement** le module lake en verifiant experimentalement\n", + " `multiKelly_optimal_2` (strategie 1 realise l'optimum) et\n", + " `multiKelly_unique_2` (strategies 2-4 strictement sub-optimales).\n", + "\n", + "**Acceptance #19516 (carnet 3)** :\n", + "\n", + "- Companion Python : carnet cree `Kelly_companion-Multi-Issue-Python.ipynb`,\n", + " execute via `nbclient` (Tell c.18529 voie 1), cellules code avec\n", + " `execution_count = 1..4`, 0 erreur, aucune cellule `NotImplementedError` (C.1).\n", + "- Sorties multi-seed : 8 seeds parmi `{0, 1, 7, 42, 99, 123, 456, 789}`, 4\n", + " strategies comparees, figure `multi_issue_growth.png` embarquee + sauvegardee.\n", + "- Validation : croissance mesuree, comparaison aux allocations sous-optimales,\n", + " asymetrie shrinkage caracterisee, coherence avec lake `MultiIssue.lean`.\n", + "\n", + "**Prochaines etapes du plan #19516** :\n", + "\n", + "- Carnet 4 (Cotes dynamiques / sequence, companion Python seul)\n", + "- Mise a jour de la section `Carnets suivants` du README `kelly_lean`.\n", + "\n", + "Refs #19516 (carnet 3), #16231.\n" + ] + } + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/multi_issue_growth.png b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/multi_issue_growth.png new file mode 100644 index 0000000000..f03d0e92a1 Binary files /dev/null and b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/multi_issue_growth.png differ