From 8408b57a548d3dee266b3d419f7103fa29492a47 Mon Sep 17 00:00:00 2001 From: jsboige Date: Tue, 6 Oct 2026 19:56:33 +0200 Subject: [PATCH 1/6] feat(kelly,#19516): MultiIssue.lean + companion -- allocation Kelly jointe pour paris independants (carnet 3) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Carnet 3 du plan #16231 / issue #19516. Lake MultiIssue.lean (sibling FR + EN, convention i18n #4980) etend Kelly.Kelly au cas multi-pari independant a deux paris : l'allocation Kelly jointe (kellyFrac beta_1, kellyFrac beta_2) maximise la somme des log-croissances individuelles. Theoreme phare : multiKelly_optimal_2 (β₁ β₂) (f₁ f₂) (hf₁) (hf₂) : jointGrowth2 β₁ β₂ f₁ f₂ ≤ jointGrowth2 β₁ β₂ (kellyFrac β₁) (kellyFrac β₂) preuve : linarith sur kelly_optimal applique par composante (additivite des inegalites pour paris independants). Unicite (multiKelly_unique_2 / _2') : si f_i differe de kellyFrac β_i, la log-croissance jointe est strictement inferieure (linarith sur kelly_unique pour la composante differenciante + kelly_optimal pour l'autre). Companion Python : Kelly_companion-Multi-Issue-Python.ipynb, 4 strategies d'allocation comparees (Kelly jointe, Kelly-1 + shrink-2, Kelly-2 + shrink-1, Equal-split 0.15/0.15), 8 seeds parmi {0, 1, 7, 42, 99, 123, 456, 789}, T = 2000 pas. Mesure : Kelly jointe (optimal) 0.027797 (110.55 % de g_joint*) Kelly-1, shrink-2 (x0.5) 0.021116 ( 83.98 % -- shrinkage sur grand edge) Kelly-2, shrink-1 (x0.5) 0.026787 (106.53 %) Equal-split Kelly (0.15) 0.024191 ( 96.21 %) Asymetrie shrinkage : shrink sur le pari a grand edge detruit 2x plus de croissance que shrink sur le petit edge. Implications pratiques pour le position sizing multi-issue. Build verification : OWED a la CI (lake build local non complete dans cette session, Mathlib v4.33.0 pas pre-build sur WSL). Voir le precedent c.55-c.56 PR #19534 (Fractional.lean) qui suit le meme pattern. Le CI `lean-axiom` du runner GitHub reproduira le build rapidement (son cache Mathlib est distinct du local). Refs #19516 (carnet 3), #16231. Co-Authored-By: Claude Haiku 4.5 (1M context) --- .../kelly_lean/Kelly/MultiIssue.lean | 106 ++++++ .../kelly_lean/Kelly/MultiIssue_en.lean | 106 ++++++ .../Kelly_companion-Multi-Issue-Python.ipynb | 355 ++++++++++++++++++ .../kelly_lean/multi_issue_growth.png | Bin 0 -> 41741 bytes 4 files changed, 567 insertions(+) create mode 100644 MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean create mode 100644 MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean create mode 100644 MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Multi-Issue-Python.ipynb create mode 100644 MyIA.AI.Notebooks/QuantConnect/kelly_lean/multi_issue_growth.png 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..1195a8f339 --- /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). -/ +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..fad6ecbbc0 --- /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). -/ +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..64eef11695 --- /dev/null +++ b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly_companion-Multi-Issue-Python.ipynb @@ -0,0 +1,355 @@ +{ + "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 = -3.98 % de perte seulement).\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", + "- Shrink-2 (sur `f_2* = 0.20`) detruit 2x plus de croissance que shrink-1\n", + " (sur `f_1* = 0.10`). 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", + "- 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), 4 cellules code avec\n", + " `execution_count = 1..4`, 0 erreur, 0 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 +} 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 0000000000000000000000000000000000000000..f03d0e92a1e796bfc49bd5c03b62770e83e2959d GIT binary patch literal 41741 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 Date: Wed, 7 Oct 2026 00:40:26 +0200 Subject: [PATCH 2/6] fix(lean,19516): jointGrowth2 -- marquer noncomputable (depend de growth noncomputable) Le CI kelly_lean rougissait sur MultiIssue.lean:58:4 et MultiIssue_en.lean:58:4 avec : "failed to compile definition, consider marking it as 'noncomputable' because it depends on 'growth', which is 'noncomputable'". La definition `jointGrowth2` somme deux appels a `growth`, qui est `noncomputable` (dans Kelly.Growth). Le compilateur Lean refuse de generer du code executable pour un `def` qui depend d'une definition `noncomputable` -- d'ou le hint explicite du compilateur. Fix : `def` -> `noncomputable def` dans les deux siblings. Pas de changement de semantique (la fonction reste inaccessible a l'exec), juste la declaration formelle qui reflete la realite de la dependance. Le byte-identity FR/EN est preserve sur le modificateur (les deux passent a `noncomputable def` simultanement), seul le docstring differe. Refs #19516, #19551, #16231. Co-Authored-By: Claude Haiku 4.5 (1M context) --- MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean | 2 +- .../QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean index 1195a8f339..c685a74d6c 100644 --- a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean +++ b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue.lean @@ -55,7 +55,7 @@ open Real 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). -/ -def jointGrowth2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) : ℝ := +noncomputable def jointGrowth2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) : ℝ := growth β₁ f₁ + growth β₂ f₂ /-- **Théorème de Kelly multi-pari à 2 paris (maximiseur)** : pour deux paris diff --git a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean index fad6ecbbc0..1660f18fe4 100644 --- a/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean +++ b/MyIA.AI.Notebooks/QuantConnect/kelly_lean/Kelly/MultiIssue_en.lean @@ -55,7 +55,7 @@ open Real 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). -/ -def jointGrowth2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) : ℝ := +noncomputable def jointGrowth2 (β₁ β₂ : Bet) (f₁ f₂ : ℝ) : ℝ := growth β₁ f₁ + growth β₂ f₂ /-- **Multi-bet Kelly theorem at 2 bets (maximiser)**: for two independent From 10709d8c4a80de690eabeeaac3531bdcc40d5601 Mon Sep 17 00:00:00 2001 From: jsboige Date: Wed, 7 Oct 2026 01:43:44 +0200 Subject: [PATCH 3/6] =?UTF-8?q?fix(quant,#19551):=20MultiIssue=20companion?= =?UTF-8?q?=20--=20verdict=20chiffres=20non=20sourc=C3=A9s=20+=20port?= =?UTF-8?q?=C3=A9e=20additivit=C3=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit NanoClaw review (cycle ~22 06/10, VERDICT: CONCERNS) a relevé 2 claims non sourcés dans le verdict du companion (cellule 8, MD) : 1. "Kelly-2, shrink-1 = -3.98 % de perte seulement" -- la mesure donne +6.53 % de g_joint* theorique (gain MC, pas perte). Le -3.98 % venait d'une convention mixte (vs Kelly jointe mesurée) qui n'était pas explicite. Remplacement par le % vs g_joint* + flag variance MC. 2. "Shrink-2 détruit 2x plus de croissance que shrink-1" -- le ratio exact est 2.45x en valeur absolue (16.02 % / 6.53 % en convention vs g_joint* theorique ; 6.6x en convention vs Kelly jointe mesurée). Le 2x est qualitativement OK mais le ratio precis depend de la convention. Remplacement par les deux ratios explicites. 3. Portée du modèle : ajout d'un paragraphe distinguant capitalisation composée (le modèle du carnet, W <- W * mult1 * mult2, où l'additivité g_joint = g_1 + g_2 tient exactement, ce que le lake prouve) des paris simultanés sur bankroll partagée (terme croisé f1*f2*b1*b2 non nul, optimum légèrement sous les Kelly individuels, hors scope du lake). Pas de re-exec kernel (Tell c.18570 : Python 3.13 local vs 3.11.9 CI, kernel drift, sorties MC intactes). Modification MD-only sur la cellule 8 du verdict, code cells et outputs préservés. Co-Authored-By: Claude Haiku 4.5 (1M context) --- .../Kelly_companion-Multi-Issue-Python.ipynb | 21 +++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) 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 index 64eef11695..56b235cf75 100644 --- 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 @@ -305,7 +305,7 @@ " 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 = -3.98 % de perte seulement).\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", @@ -313,8 +313,12 @@ "\n", "**Asymetrie shrinkage** :\n", "\n", - "- Shrink-2 (sur `f_2* = 0.20`) detruit 2x plus de croissance que shrink-1\n", - " (sur `f_1* = 0.10`). C'est coherent avec la **sensibilite lineaire** du\n", + "- En valeur absolue, |shrink-2| = 16.02 % de deviation a `g_joint*`\n", + " et |shrink-1| = 6.53 % de deviation a `g_joint*`, ratio 2.45x -- Shrink-2\n", + " est environ 2x plus severe en valeur absolue que Shrink-1 (en convention\n", + " vs `g_joint*` theorique ; en convention vs Kelly jointe mesuree, le ratio\n", + " passe a 6.6x). L'ordre de grandeur qualitative (Shrink-2 plus severe que\n", + " Shrink-1) tient dans les deux conventions. 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", @@ -326,6 +330,15 @@ "- 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", @@ -352,4 +365,4 @@ "metadata": {}, "nbformat": 4, "nbformat_minor": 5 -} +} \ No newline at end of file From f7f6f350e01f360662112a2cd37e5aa4b5320891 Mon Sep 17 00:00:00 2001 From: jsboige Date: Wed, 7 Oct 2026 02:21:29 +0200 Subject: [PATCH 4/6] fix(quant,#19551): MultiIssue companion -- retrait compteurs cellule (prose-counts) Tell c.9377 -- Les donnees quantitatives sont tenues par le CI, pas par la prose. Supprimer la mesure, garder le predicat : - "4 cellules code avec" -> "cellules code avec" (predicate : cellules code existent) - "0 cellule NotImplementedError" -> "aucune cellule NotImplementedError" (predicate : pas de cellule NotImplementedError) MD-only, pas de re-exec (Tell c.18570 : kernel drift 3.13 local vs 3.11.9 CI). Co-Authored-By: Claude Haiku 4.5 (1M context) --- .../kelly_lean/Kelly_companion-Multi-Issue-Python.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 index 56b235cf75..043fc1363f 100644 --- 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 @@ -346,8 +346,8 @@ "**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), 4 cellules code avec\n", - " `execution_count = 1..4`, 0 erreur, 0 cellule `NotImplementedError` (C.1).\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", From 73d0e8aeb44f34f34bc7ad84d6718401b29b2703 Mon Sep 17 00:00:00 2001 From: jsboige Date: Wed, 7 Oct 2026 04:42:37 +0200 Subject: [PATCH 5/6] fix(kelly,#19551): ratio 2.45x -> convention unique Kelly jointe mesuree (markdown seul) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Le coordinateur (myia-ai-01:CoursIA, DM msg-20261007T023016-0kgabi) a releve que la phrase « Shrink-2 est environ 2x plus severe en valeur absolue » avec le ratio 2.45x = 16.02 / 6.53 comparait une perte reelle a un ecart de variance Monte-Carlo, que la review disait justement non comparables. Fix : une seule convention de perte, par rapport a la Kelly jointe mesuree (0.027797) : |shrink-2| = 24.0 % et |shrink-1| = 3.6 %, ratio 6.6x. Par rapport au theorique `g_joint*` (0.025144), on retient seulement que shrink-1 est au-dessus (+6.53 %, variance MC), sans ratio. On **ne tire pas de ratio** entre les deux conventions, elles mesurent des grandeurs distinctes (ecart a la mesure vs ecart au theorique). L'ordre qualitatif (Shrink-2 plus severe que Shrink-1) tient. Markdown seul (1 cellule dba4d10a du carnet companion, +6/-5 lignes). Pas de re-execution : les sorties MC sont deja en place, seul le texte de la cellule d'interpretation est reformule. Tell c.18570 (MD-only preferable quand le re-exec drifterait). Refs #19551, #19516, #16231, #4980. Co-Authored-By: Claude Haiku 4.5 (1M context) --- .../Kelly_companion-Multi-Issue-Python.ipynb | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) 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 index 043fc1363f..336a8f9840 100644 --- 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 @@ -314,11 +314,12 @@ "**Asymetrie shrinkage** :\n", "\n", "- En valeur absolue, |shrink-2| = 16.02 % de deviation a `g_joint*`\n", - " et |shrink-1| = 6.53 % de deviation a `g_joint*`, ratio 2.45x -- Shrink-2\n", - " est environ 2x plus severe en valeur absolue que Shrink-1 (en convention\n", - " vs `g_joint*` theorique ; en convention vs Kelly jointe mesuree, le ratio\n", - " passe a 6.6x). L'ordre de grandeur qualitative (Shrink-2 plus severe que\n", - " Shrink-1) tient dans les deux conventions. C'est coherent avec la **sensibilite lineaire** du\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", From 267d4cbac082c704a4fb909722fe4105e45632df Mon Sep 17 00:00:00 2001 From: jsboige Date: Wed, 7 Oct 2026 08:51:52 +0200 Subject: [PATCH 6/6] fix(kelly,#19551): shrink-2 -- convention unique Kelly jointe mesuree (16.02 -> 24.0 %) Cellule markdown 8, puce "Asymetrie shrinkage" : |shrink-2| etait imprime comme "16.02 % de deviation a g_joint*" (convention theorique) alors que |shrink-1| etait imprime en convention Kelly jointe mesuree (0.027797). Le ratio annonce 6.6x ne se calculait pas depuis le 16.02 imprime (16.02/3.6 = 4.45), il vaut 24.0/3.6. Fix : passer |shrink-2| en convention unique Kelly jointe mesuree aussi. Markdown seul, pas de re-execution (Tell c.18570). Co-Authored-By: Claude Haiku 4.5 (1M context) --- .../kelly_lean/Kelly_companion-Multi-Issue-Python.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 index 336a8f9840..2d981b24c8 100644 --- 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 @@ -313,7 +313,7 @@ "\n", "**Asymetrie shrinkage** :\n", "\n", - "- En valeur absolue, |shrink-2| = 16.02 % de deviation a `g_joint*`\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",