From c79d1f5fb5bf223d17e644d79302ee13f9ecd29d Mon Sep 17 00:00:00 2001
From: jsboige <jsboige@gmail.com>
Date: Thu, 24 Sep 2026 00:08:30 +0200
Subject: [PATCH 1/2] feat(qc,#15532): OptionsIncome v7.2 strike-availability
 (NO-BEATS) + notebook de recherche

Teste le 2e facteur de l'article QC #18766 (strike-availability ; le 1er facteur
IV-rank est livre et mesure par #15801). Variante experimentale
main_v72_strikeavail.py : gate = rang percentile du rate-of-change 21 j des strikes
distincts / spot, repli VIX tant que l'historique est court. Baseline main.py
inchangee, Option-Wheel non touche.

Backtest QC Cloud (moteur reel, projet 36473886, backtest
92125e3965f2852fadb506e467b3ea12, LEAN master v18124, 2015-01-01 -> 2024-12-31) :
- v7.2 : Sharpe 0.264 / CAGR 5.400 % / MaxDD 17.900 % / PSR 0.243 % / 570 ordres
- v7.0 baseline : Sharpe 0.281 / CAGR 5.536 % / MaxDD 17.400 % / PSR 0.294 % (#15801)
- v7.1 iv-rank : Sharpe 0.163 / CAGR 4.451 % / MaxDD 17.900 % / PSR 0.069 % (#15801)
Verdict tranche : NO BEATS (aucun des deux facteurs de l'article n'ameliore la famille).

Livrables :
- main_v72_strikeavail.py : variante parametrable, stats de disponibilite loggees
- research/research_iv_rank_strike_clusters.ipynb : article, sources primaires,
  gap voisinage, design, resultats mesures, verdict (execution reelle, 0 erreur)
- research/README.md : table (2e notebook de la famille + ligne manquante corrigee)

See #15532

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../OptionsIncome/main_v72_strikeavail.py     | 359 +++++++++
 .../QuantConnect/research/README.md           |   8 +-
 .../research_iv_rank_strike_clusters.ipynb    | 703 ++++++++++++++++++
 3 files changed, 1067 insertions(+), 3 deletions(-)
 create mode 100644 MyIA.AI.Notebooks/QuantConnect/projects/OptionsIncome/main_v72_strikeavail.py
 create mode 100644 MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb

diff --git a/MyIA.AI.Notebooks/QuantConnect/projects/OptionsIncome/main_v72_strikeavail.py b/MyIA.AI.Notebooks/QuantConnect/projects/OptionsIncome/main_v72_strikeavail.py
new file mode 100644
index 0000000000..5c8a7ef2b6
--- /dev/null
+++ b/MyIA.AI.Notebooks/QuantConnect/projects/OptionsIncome/main_v72_strikeavail.py
@@ -0,0 +1,359 @@
+# region imports
+from AlgorithmImports import *
+from datetime import timedelta
+from collections import deque
+# endregion
+
+
+class CoveredCallStrikeAvailStrategy(QCAlgorithm):
+    """
+    Covered Call Strategy v7.2 - gate strike-availability (2e facteur de l'article #18766)
+
+    Voisinage :
+      - OptionsIncome/main.py v7.0      : gate VIX global [15, 35].
+      - OptionsIncome/main_v71_ivrank.py : gate IV-rank par sous-jacent -> NO-BEATS (#15801).
+      - Option-Wheel/main.py            : gate VIX > 20 = skip puts.
+      - Article QC #18766               : gate a deux facteurs (IV-rank + strike-availability)
+                                          k-means, liquide quand les DEUX sont "high".
+
+    Ce que ce fichier teste (le facteur que #15801 n'a pas porte) :
+      le facteur strike-availability de l'article = (nombre de strikes distincts
+      disponibles / prix du sous-jacent), avec son rate-of-change en entree du
+      clustering. L'article le clusterise en 3 classes par k-means ; les centroides
+      ne sont PAS publies numeriquement, donc l'equivalent parametre-free retenu ici
+      est le rang percentile du RoC dans sa distribution trailing 252 j (preterciles
+      0.33/0.66 = memes bornes que celles utilisees pour v7.1). On n'ecrit que si
+      label < 0.66 (pas de bande haute), symetrique du gate IV-rank de v7.1.
+
+      L'article sort quand les DEUX facteurs sont hauts ; une variante mono-facteur
+      ne peut pas porter cette regle de sortie conjointe -> ce fichier n'ajoute
+      AUCUN force-close (la regle de sortie de l'article n'est pas applicable).
+
+    Portabilite du facteur — reserve explicite :
+      L'article mesure la disponibilite sur l'univers NON borne de SPX
+      (`strikes(-1, 1)`), ou la densite de listing varie avec les conditions de
+      marche. Ici l'univers est celui de la famille, borne (-5, +15 strikes), donc
+      le compte de strikes varie surtout avec le NOMBRE D'EXPIRATIONS dans la
+      fenetre DTE (cycle hebdomadaire), pas avec la densite de listing du marche.
+      Le test mesure donc « le facteur tel qu'il peut exister dans ce regime de
+      souscription », pas « le facteur de l'article sur SPX ». Le compte et le RoC
+      sont logges au rapport final pour que la degenerescence eventuelle soit
+      mesuree, pas affirmee.
+
+    Tout le reste est identique a v7.1/v7.0 pour comparabilite : delta 0.20,
+    days_to_roll 10, profit_target 0.50, defensive_drop 0.03, warm-up 30 j,
+    fenetre 2015-01-01 -> 2024-12-31, capital 100 000.
+
+    SOTA verdict : SOTA-OK — le backtest a tourne sur le moteur reel QC Cloud
+    (projet 36473886, backtest 92125e3965f2852fadb506e467b3ea12, LEAN master
+    v18124, fenetre 2015-01-01 -> 2024-12-31, 546,8 M de points de donnees) et
+    le couple mesure contre la baseline v7.0 et la variante v7.1 (#15801) est
+    publie dans le body de la PR et le notebook de recherche
+    (research/research_iv_rank_strike_clusters.ipynb). Verdict mesure : NO BEATS
+    (Sharpe 0.264 vs 0.281 baseline ; CAGR 5.400 % vs 5.536 % ; MaxDD 17.9 %
+    vs 17.4 %). Aucune sortie n'est affirmee qui n'ait ete mesuree.
+    """
+
+    def initialize(self):
+        self.set_start_date(2015, 1, 1)
+        self.set_end_date(2024, 12, 31)
+        self.set_cash(100000)
+        self.set_brokerage_model(BrokerageName.INTERACTIVE_BROKERS_BROKERAGE, AccountType.MARGIN)
+
+        equity = self.add_equity("SPY", Resolution.MINUTE)
+        self.underlying = equity.symbol
+
+        # VIX conserve comme fallback tant que l'historique de disponibilite est trop court.
+        self.vix = self.add_data(CBOE, "VIX", Resolution.DAILY).symbol
+
+        option = self.add_option("SPY", Resolution.MINUTE)
+        self.option_symbol = option.symbol
+
+        option.set_filter(
+            min_strike=-5,
+            max_strike=15,
+            min_expiry=timedelta(days=20),
+            max_expiry=timedelta(days=45)
+        )
+
+        # Parametres strategie — identiques a v7.0/v7.1.
+        self.target_delta = 0.20
+        self.days_to_roll = 10
+        self.num_contracts = 2
+        self.shares_per_contract = 100
+        self.profit_target = 0.50
+        self.defensive_drop = 0.03
+
+        # Gate strike-availability.
+        # Fenetre du rate-of-change : 21 seances (1 mois de trading, choix documente ;
+        # l'article ne publie pas la fenetre exacte de son RoC).
+        self.avail_roc_lookback = 21
+        # Seuil du label : pretercile haut (memes bornes 0.33/0.66 que v7.1).
+        self.avail_label_max = 0.66
+        # Fenetre de la distribution du label : 252 seances (1 an, comme v7.1).
+        self.avail_window_days = 252
+
+        self.vix_min = 15
+        self.vix_max = 35
+
+        # Historiques : disponibilite brute (strikes distincts / spot) et RoC.
+        self.availability_history = deque(maxlen=self.avail_window_days)
+        self.avail_roc_history = deque(maxlen=self.avail_window_days)
+        self.current_avail_label = None  # None tant que le label n'est pas calculable
+
+        # Diagnostic : echantillons manquants et sessions en repli VIX.
+        self.avail_starve_days = 0
+        self.avail_starve_warned = False
+        self.fallback_vix_sessions = 0
+
+        # Statistiques de degenerescence (rapport final).
+        self.avail_values_seen = []
+        self.roc_values_seen = []
+
+        # Warm-up explicite (consequence du gate sur historique).
+        self.set_warm_up(timedelta(days=30))
+
+        # Etat position.
+        self.current_call = None
+        self.call_entry_price = 0.0
+        self.premium_collected = 0
+        self.trades_count = 0
+        self.profit_closes = 0
+        self.defensive_closes = 0
+        self.skipped_avail = 0
+        self.skipped_no_avail = 0
+        self.prior_spy_close = None
+
+        self.schedule.on(
+            self.date_rules.every_day(self.underlying),
+            self.time_rules.after_market_open(self.underlying, 30),
+            self._manage_position
+        )
+        # Mise a jour quotidienne de la disponibilite des strikes.
+        self.schedule.on(
+            self.date_rules.every_day(self.underlying),
+            self.time_rules.after_market_open(self.underlying, 60),
+            self._update_availability
+        )
+        self.set_benchmark("SPY")
+
+    def on_end_of_day(self, symbol):
+        if symbol == self.underlying:
+            self.prior_spy_close = self.securities[self.underlying].price
+
+    def on_data(self, data):
+        pass
+
+    def _update_availability(self):
+        """Compte les strikes distincts du chain / spot, met a jour le label percentile."""
+        if self.is_warming_up:
+            return
+        if self.current_avail_label is None:
+            self.fallback_vix_sessions += 1
+
+        chain = self.current_slice.option_chains.get(self.option_symbol, None)
+        if not chain:
+            self.avail_starve_days += 1
+            return
+        underlying_price = self.securities[self.underlying].price
+        if underlying_price <= 0:
+            return
+
+        distinct_strikes = len({c.strike for c in chain})
+        if distinct_strikes == 0:
+            self.avail_starve_days += 1
+            return
+
+        availability = distinct_strikes / underlying_price
+        self.availability_history.append(availability)
+        self.avail_values_seen.append(availability)
+
+        # RoC sur la fenetre parametree.
+        if len(self.availability_history) > self.avail_roc_lookback:
+            past = self.availability_history[-(self.avail_roc_lookback + 1)]
+            if past > 0:
+                roc = availability / past - 1.0
+                self.avail_roc_history.append(roc)
+                self.roc_values_seen.append(roc)
+
+                # Label = rang percentile du RoC courant dans la distribution trailing.
+                if len(self.avail_roc_history) >= 60:
+                    below = sum(1 for r in self.avail_roc_history if r <= roc)
+                    self.current_avail_label = below / len(self.avail_roc_history)
+
+        if (not self.avail_starve_warned
+                and self.current_avail_label is None
+                and self.avail_starve_days >= 60):
+            self.avail_starve_warned = True
+            self.log(
+                f"AVAILABILITY STARVED: aucun echantillon de strikes depuis "
+                f"{self.avail_starve_days} jours de trading — le gate VIX "
+                f"[{self.vix_min}, {self.vix_max}] assure le repli pour tout le run."
+            )
+
+    def _availability_gate(self):
+        """Retourne True si on peut ecrire (gate pass), False sinon."""
+        if self.current_avail_label is None:
+            vix_price = self.securities[self.vix].price
+            if vix_price <= 0:
+                return False
+            if vix_price < self.vix_min or vix_price > self.vix_max:
+                self.skipped_no_avail += 1
+                return False
+            return True
+        # Gate strike-availability : bande haute du label = pas d'ecriture.
+        if self.current_avail_label >= self.avail_label_max:
+            self.skipped_avail += 1
+            return False
+        return True
+
+    def _manage_position(self):
+        target_shares = self.shares_per_contract * self.num_contracts
+        current_shares = self.portfolio[self.underlying].quantity
+        if current_shares < target_shares:
+            self.market_order(self.underlying, target_shares - current_shares)
+            return
+
+        if self.current_call is None:
+            self._sell_call()
+            return
+
+        if self._check_early_close():
+            return
+
+        self._check_roll()
+
+    def _check_early_close(self):
+        if self.current_call not in self.securities:
+            self.current_call = None
+            return True
+
+        option = self.securities[self.current_call]
+        current_price = option.price
+
+        if self.call_entry_price > 0 and current_price <= self.call_entry_price * (1 - self.profit_target):
+            self.market_order(self.current_call, self.num_contracts)
+            self.log(f"PROFIT TARGET: Closed at {current_price:.2f} (entry {self.call_entry_price:.2f})")
+            self.current_call = None
+            self.call_entry_price = 0.0
+            self.profit_closes += 1
+            return True
+
+        if self.prior_spy_close is not None and self.prior_spy_close > 0:
+            spy_price = self.securities[self.underlying].price
+            daily_return = (spy_price - self.prior_spy_close) / self.prior_spy_close
+            if daily_return < -self.defensive_drop:
+                self.market_order(self.current_call, self.num_contracts)
+                self.log(f"DEFENSIVE CLOSE: SPY {daily_return:.1%}")
+                self.current_call = None
+                self.call_entry_price = 0.0
+                self.defensive_closes += 1
+                return True
+
+        return False
+
+    def _sell_call(self):
+        if not self._availability_gate():
+            return
+
+        chain = self.current_slice.option_chains.get(self.option_symbol, None)
+        if chain is None:
+            return
+
+        calls = [x for x in chain if x.right == OptionRight.CALL]
+        if len(calls) == 0:
+            return
+
+        underlying_price = self.securities[self.underlying].price
+        otm_calls = [x for x in calls if x.strike > underlying_price]
+        if len(otm_calls) == 0:
+            return
+
+        best_call = None
+        best_delta_diff = float('inf')
+        for call in otm_calls:
+            if call.greeks.delta != 0:
+                delta_diff = abs(call.greeks.delta - self.target_delta)
+                if delta_diff < best_delta_diff:
+                    best_delta_diff = delta_diff
+                    best_call = call
+
+        if best_call is None:
+            target_expiry = self.time + timedelta(days=30)
+            sorted_calls = sorted(otm_calls,
+                                  key=lambda x: abs((x.expiry - target_expiry).days))
+            if len(sorted_calls) > 0:
+                target_strike = underlying_price * 1.03
+                best_call = min(sorted_calls[:5],
+                                key=lambda x: abs(x.strike - target_strike))
+
+        if best_call is None:
+            return
+
+        entry_price = best_call.last_price
+        if entry_price <= 0:
+            entry_price = best_call.bid_price
+
+        self.market_order(best_call.symbol, -self.num_contracts)
+        self.current_call = best_call.symbol
+        self.call_entry_price = entry_price
+        premium = entry_price * self.shares_per_contract * self.num_contracts
+        self.premium_collected += premium
+        self.trades_count += 1
+        vix_price = self.securities[self.vix].price
+        self.log(
+            f"SOLD {self.num_contracts}x CALL: Strike={best_call.strike}, "
+            f"DTE={(best_call.expiry - self.time).days}, "
+            f"Delta={best_call.greeks.delta:.2f}, "
+            f"Premium=${premium:.2f}, VIX={vix_price:.1f}, "
+            f"avail-label={self.current_avail_label if self.current_avail_label is None else f'{self.current_avail_label:.2f}'}"
+        )
+
+    def _check_roll(self):
+        if self.current_call is None or self.current_call not in self.securities:
+            self.current_call = None
+            return
+
+        option = self.securities[self.current_call]
+        days_to_expiry = (option.expiry - self.time).days
+        underlying_price = self.securities[self.underlying].price
+        is_deep_itm = option.strike_price < underlying_price * 0.97
+
+        if days_to_expiry <= self.days_to_roll or is_deep_itm:
+            self.market_order(self.current_call, self.num_contracts)
+            self.log(f"ROLL: DTE={days_to_expiry}, DeepITM={is_deep_itm}")
+            self.current_call = None
+            self.call_entry_price = 0.0
+
+    def on_end_of_algorithm(self):
+        final = self.portfolio.total_portfolio_value
+
+        def stats(values):
+            if not values:
+                return "n=0"
+            n = len(values)
+            mean = sum(values) / n
+            lo, hi = min(values), max(values)
+            var = sum((v - mean) ** 2 for v in values) / n
+            std = var ** 0.5
+            return f"n={n}, mean={mean:.5f}, std={std:.5f}, min={lo:.5f}, max={hi:.5f}"
+
+        avail_label = (
+            f"avail-label_at_end={self.current_avail_label:.3f}"
+            if self.current_avail_label is not None
+            else "avail-label=N/A (warm-up)"
+        )
+        self.log(
+            f"CC v7.2-strikeavail: Final=${final:,.2f}, "
+            f"Return={(final-100000)/100000:.2%}, "
+            f"Premium=${self.premium_collected:,.2f}, "
+            f"Trades={self.trades_count}, "
+            f"ProfitCloses={self.profit_closes}, "
+            f"DefensiveCloses={self.defensive_closes}, "
+            f"SkippedByAvail={self.skipped_avail}, "
+            f"SkippedNoAvail={self.skipped_no_avail}, "
+            f"FallbackVIXSessions={self.fallback_vix_sessions}, "
+            f"{avail_label}, "
+            f"Availability[{stats(self.avail_values_seen)}], "
+            f"RoC[{stats(self.roc_values_seen)}]"
+        )
\ No newline at end of file
diff --git a/MyIA.AI.Notebooks/QuantConnect/research/README.md b/MyIA.AI.Notebooks/QuantConnect/research/README.md
index fa143b8743..cc587cf211 100644
--- a/MyIA.AI.Notebooks/QuantConnect/research/README.md
+++ b/MyIA.AI.Notebooks/QuantConnect/research/README.md
@@ -13,9 +13,11 @@ Recherche indépendante utilisant des données locales (yfinance, pandas, sklear
 
 | Notebook | Sujet | Type | Source de données |
 |----------|-------|------|-------------------|
+| `intraday_volume_periodicity.ipynb` | Periodicite intraday du volume (illustration pedagogique CPU-only) | (c) Standalone | simulation synthetique (numpy) |
 | `research_btc_ml.ipynb` | Caractéristiques de prédiction ML BTC | (b) QuantBook QC Cloud | QC Cloud crypto (BTCUSDT Binance) |
 | `research_composite_ff_aw.ipynb` | Composite FamaFrench + AllWeather | (c) Standalone | yfinance |
 | `research_composite_mom_regime.ipynb` | Composite Momentum + Régime | (c) Standalone | yfinance |
+| `research_iv_rank_strike_clusters.ipynb` | Facteurs IV-Rank et strike-availability (article QC #18766, verdicts NO-BEATS) | (c) Standalone | yfinance (VIX/SPY) + resultats QC Cloud mesures |
 | `research_m11ef_ensemble.ipynb` | Méthodes d'ensemble | (b) QuantBook QC Cloud | QC Cloud crypto (Bitstamp/Coinbase) |
 | `research_m12_har_rv_j.ipynb` | Modèle de volatilité HAR-RV-J (horaire) | (b) QuantBook QC Cloud | QC Cloud crypto (Hour) |
 | `research_m12_har_rv_j_minute.ipynb` | M12-HF : variante minute (QuantBook QC Cloud) | (b) QuantBook QC Cloud | QC Cloud crypto (Minute, non exécuté) |
@@ -31,7 +33,7 @@ Recherche indépendante utilisant des données locales (yfinance, pandas, sklear
 | `research_rl_tactical_overlay.ipynb` | Overlay tactique RL | (c) Standalone | yfinance |
 | `research_vrp_putwrite.ipynb` | Stratégie VRP put-write | (c) Standalone | yfinance |
 
-Sur les 17 notebooks, **13 sont de type (c) standalone research** (s'exécutent localement avec `pip install yfinance pandas matplotlib scikit-learn` ; la famille M12-HF, 3 notebooks, utilise des données tick BTC Bitstamp possédées agrégées en minute localement) et **4 sont de type (b) research lié au quantbook QC Cloud** (`research_btc_ml`, `research_m11ef_ensemble`, `research_m12_har_rv_j` exécutés, et la variante `_minute` qui instancie `QuantBook` sans outputs committés — à exécuter sur QC Cloud).
+Sur les 19 notebooks, **15 sont de type (c) standalone research** (s'exécutent localement avec `pip install yfinance pandas matplotlib scikit-learn` ; la famille M12-HF, 3 notebooks, utilise des données tick BTC Bitstamp possédées agrégées en minute localement) et **4 sont de type (b) research lié au quantbook QC Cloud** (`research_btc_ml`, `research_m11ef_ensemble`, `research_m12_har_rv_j` exécutés, et la variante `_minute` qui instancie `QuantBook` sans outputs committés — à exécuter sur QC Cloud).
 
 ---
 
@@ -39,12 +41,12 @@ Sur les 17 notebooks, **13 sont de type (c) standalone research** (s'exécutent
 
 ### Ce que vous avez appris
 
-Ces **17 notebooks** sont le **laboratoire de recherche** de la série QuantConnect. La **majorité (13/17) sont standalone** et s'exécutent en local avec `yfinance` (données gratuites) + `pandas` / `scikit-learn` (la famille M12-HF utilise des données tick BTC possédées) ; les **4 notebooks des familles M11/M12** (btc_ml, m11ef_ensemble, m12_har_rv_j, m12_har_rv_j_minute) chargent leurs données crypto via `QuantBook` QC Cloud (type (b)). Ils illustrent deux familles de recherche :
+Ces **19 notebooks** sont le **laboratoire de recherche** de la série QuantConnect. La **majorité (15/19) sont standalone** et s'exécutent en local avec `yfinance` (données gratuites) + `pandas` / `scikit-learn` (la famille M12-HF utilise des données tick BTC possédées) ; les **4 notebooks des familles M11/M12** (btc_ml, m11ef_ensemble, m12_har_rv_j, m12_har_rv_j_minute) chargent leurs données crypto via `QuantBook` QC Cloud (type (b)). Ils illustrent deux familles de recherche :
 
 - **Recherche factorielle & allocation** (HAR-RV-J vol, FamaFrench + AllWeather composite, Momentum + Regime, Quality/LowVol, Risk Parity, VRP put-write) — on apprend que les modèles de volatilité et d'allocation robuste sont reproductibles en local sur données publiques, et que les composites (M12, M11ef) sont les briques des stratégies *Robuste* du catalogue. **Verdict honnête M12-HF** (`research_m12_hf_btc_local.ipynb` + `research_m12_hf_dm_test.ipynb`) : l'estimation de la realized variance en minute **bat** celle en hourly (delta médian +0.548, MSE minute ~moitié hourly), statistiquement validée par un test de Diebold-Mariano (HAC, p≈0.000) et un block-bootstrap dont l'IC95 est entièrement négatif. La cause du gain est cependant la **fréquence d'échantillonnage** (qualité de l'estimateur RV, Andersen-Bollerslev-Diebold 2003), **pas** la composante de jump — HAR-Classic sans jump montre le même gain. Leçon méthodologique : la résolution hourly (24 bars/jour) est trop bruitée pour le vol-targeting Kelly ; la minute (1440 bars/jour) l'est beaucoup moins.
 - **Recherche Reinforcement Learning** (intro, PPO, GRPO, reward shaping, multi-asset, tactical overlay) — on apprend que le RL trading se prototypé localement avant tout déploiement QC Cloud, et que le *reward shaping* est le levier le plus sensible (un reward mal spécifié fige la policy). **Leçon d'intégrité #3360** : diviser la reward portfolio-level par le nombre d'actifs (`reward / N_ASSETS`) détruit le signal du critic per-asset → la policy gèle près de l'uniforme → l'argmax collapse vers Buy (fingerprint buy-and-hold, Sharpe 0.657 identique au collapse PPO). Corrigé : la reward portfolio complète alimente chaque transition per-asset (cohérence #3359/#3360). Verdict ré-évalué honnête après fix : NO BEATS (A2C Sharpe 0.000, SAC −0.063 sur univers non-FAANG) — pour la bonne raison.
 
-Le fil rouge : **l'indépendance de la plateforme**. Ces notebooks prouvent que l'idéation et la validation ML peuvent se faire hors QC Cloud pour la majorité des sujets (13/17 standalone) ; QC Cloud devient nécessaire dès que la recherche porte sur des données crypto natives (4 notebooks M11/M12 qui instancient `QuantBook`), et reste la porte d'entrée du backtest haute-fidélité sur données natives.
+Le fil rouge : **l'indépendance de la plateforme**. Ces notebooks prouvent que l'idéation et la validation ML peuvent se faire hors QC Cloud pour la majorité des sujets (15/19 standalone) ; QC Cloud devient nécessaire dès que la recherche porte sur des données crypto natives (4 notebooks M11/M12 qui instancient `QuantBook`), et reste la porte d'entrée du backtest haute-fidélité sur données natives.
 
 ### Prochaines étapes
 
diff --git a/MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb b/MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb
new file mode 100644
index 0000000000..b6594ae3bf
--- /dev/null
+++ b/MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb
@@ -0,0 +1,703 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "cell-01",
+   "metadata": {
+    "papermill": {
+     "duration": 0.002226,
+     "end_time": "2026-09-23T21:52:34.626612+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:34.624386+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# Reduction du risque d'ecriture d'options : IV-Rank et clusters de strikes\n",
+    "\n",
+    "**Navigation** : [Index QC](../README.md) | [OptionsIncome](../projects/OptionsIncome/) | [Recherche VRP put-write](research_vrp_putwrite.ipynb)\n",
+    "\n",
+    "| | |\n",
+    "|---|---|\n",
+    "| Issue | #15532 — Epic #11698 (QC-research) |\n",
+    "| Article source | [quantconnect.com/research/18766](https://www.quantconnect.com/research/18766/reducing-option-writing-risk-with-iv-rank-and-strike-clusters/) (Derek Melchin) |\n",
+    "| Famille cible | `projects/OptionsIncome/` (covered call SPY) — aucun nouveau projet |\n",
+    "| Mecanisme teste | gate IV-rank par sous-jacent (v7.1) et facteur disponibilite des strikes (v7.2) |\n",
+    "| Verdict | `NO-BEATS` (section 6) |\n",
+    "\n",
+    "Ce notebook documente la chaine complete de l'Epic #11698 pour cet article :\n",
+    "lecture analytique, sources primaires, gap contre le voisinage, design des variantes,\n",
+    "resultats du moteur QC Cloud, et verdict honnete.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-02",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001649,
+     "end_time": "2026-09-23T21:52:34.630370+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:34.628721+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 1. L'article et son mecanisme\n",
+    "\n",
+    "L'article propose de reduire le risque de l'ecriture de puts SPX par un gate a\n",
+    "**deux facteurs** :\n",
+    "\n",
+    "1. **IV Rank** — la mediane de l'IV des contrats ATM (expirations 30-90 jours,\n",
+    "   `universe.include_weeklys().expiration(30, 90).strikes(-1, 1)`), relativement\n",
+    "   a son minimum/maximum sur la fenetre.\n",
+    "2. **Strike Availability** — le nombre de strikes disponibles divise par le prix\n",
+    "   du sous-jacent, avec son *rate of change* en entree.\n",
+    "\n",
+    "Les deux facteurs sont **clusterises par k-means en 3 classes** (low/medium/high,\n",
+    "labels 0/1/2) ; on entre (vente de put) quand les deux labels sont `< 2`, et on\n",
+    "liquide quand les deux valent `2`. Sorties additionnelles : DTE < 7, ou prix <= strike.\n",
+    "\n",
+    "Claims de l'article :\n",
+    "\n",
+    "| Claim | Valeur rapportee |\n",
+    "|---|---|\n",
+    "| CAGR (janvier 2016 -> publication) | 6.961 % |\n",
+    "| Expirations OTM | ~93 % |\n",
+    "| Balayage de parametres (25 combinaisons) | 100 % profitables |\n",
+    "| Sharpe / MaxDD / benchmark | **non rapportes** |\n",
+    "\n",
+    "Caveats explicites de l'article (et absences) :\n",
+    "\n",
+    "- Pas de benchmark : « son objectif est de generer de petits retours reguliers,\n",
+    "  pas de battre l'indice actions » ;\n",
+    "- la courbe de capital « beneficie de primes regulieres mais peut connaitre des\n",
+    "  pertes occasionnelles relativement importantes » (modele assureur) ;\n",
+    "- **aucune source academique citee** ; references internes QC uniquement ;\n",
+    "- pas de walk-forward ni de partition OOS ; le balayage de parametres n'est pas\n",
+    "  valide sur un hold-out (25/25 profitables peut refleter un sur-ajustement de\n",
+    "  la fenetre testee).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-03",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001194,
+     "end_time": "2026-09-23T21:52:34.633148+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:34.631954+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 2. Sources primaires — chaine d'attribution\n",
+    "\n",
+    "Convention #11168 / Epic #11698 : un article de blog n'est pas une source canonique.\n",
+    "L'article **ne cite aucun papier academique**. Les sources primaires retenues pour\n",
+    "fonder economiquement le mecanisme (et non pour le valider) sont :\n",
+    "\n",
+    "| Reference | Role dans la chaine | Disponibilite |\n",
+    "|---|---|---|\n",
+    "| **Dew-Becker, Giglio, Le, Rodriguez (2015/2017)**, *The Price of Variance Risk*, NBER w21182, publie JFE 123(2) | La prime de risque de variance est une compensation pour le risque de variance, concentree aux horizons courts — base economique de la recolte par options vendues | **Archivee** : `G:\\Mon Drive\\MyIA\\IA\\Bibliographie IA\\Trading\\2015 - Dew-Becker Giglio Le Rodriguez - The Price of Variance Risk (NBER w21182, JFE 2017).pdf` (NBER, 74 p., identite verifiee 1re page) |\n",
+    "| Carr & Wu (2009), *Variance Risk Premiums*, RFS 22(3), 1311-1341 | Quantification directe de la prime de variance (article fondateur) | Closed access — reference bibliographique citee, **non telechargee** (aucune copie OA trouvee) |\n",
+    "| Broadie, Chernov, Johannes (2009), *Understanding Index Option Returns*, RFS 22(11), 4493-4529 | Decomposition des rendements d'options d'indice : pourquoi les options sont cheres | Closed access (SSRN 403) — citee, **non telechargee** |\n",
+    "| Bondarenko (2014), *Why Are Put Options So Expensive?*, Quarterly Journal of Finance | Cout des puts OTM (l'instrument que l'article vend) | Closed access — citee, **non telechargee** |\n",
+    "\n",
+    "**Ecart article / sources primaires** : les sources etablissent qu'il existe une\n",
+    "prime a recolter et qu'elle varie dans le temps. **Aucune** ne fonde le claim plus\n",
+    "fort de l'article — qu'un *gate par rang d'IV* ni qu'un *facteur de disponibilite\n",
+    "des strikes* ameliorent la recolte. C'est precisement ce que la partie backtest\n",
+    "teste, sur la famille existante.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-04",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001081,
+     "end_time": "2026-09-23T21:52:34.635383+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:34.634302+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### Analyse locale (proxy analytique)\n",
+    "\n",
+    "La cellule suivante construit un **proxy analytique** d'IV-rank a partir du VIX\n",
+    "(meme convention que `research_vrp_putwrite.ipynb`) pour visualiser ce que le gate\n",
+    "filtre. **Ce proxy n'est pas le moteur de backtest** : les resultats de strategie\n",
+    "viennent exclusivement de QC Cloud (section 5). Bornes des labels : 0.33 / 0.66\n",
+    "(les centroides k-means publies par l'article ne le sont pas numeriquement).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "cell-05",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T21:52:34.638447Z",
+     "iopub.status.busy": "2026-09-23T21:52:34.638256Z",
+     "iopub.status.idle": "2026-09-23T21:52:37.489407Z",
+     "shell.execute_reply": "2026-09-23T21:52:37.488592Z"
+    },
+    "papermill": {
+     "duration": 2.85361,
+     "end_time": "2026-09-23T21:52:37.490047+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:34.636437+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Seances analysees      : 2456\n",
+      "Part label haut >=0.66 : 4.8%  (le gate v7.1 saute ces seances)\n",
+      "Part >=0.85 (panic)    : 1.5%  (seuil de force-close v7.1)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1100x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Cellule 1 - IV-rank proxy (VIX) 2015-2024 : ce que le gate filtre\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import yfinance as yf\n",
+    "\n",
+    "vix = yf.download('^VIX', start='2014-10-01', end='2024-12-31', auto_adjust=False, progress=False)['Close'].squeeze()\n",
+    "spy = yf.download('SPY', start='2014-10-01', end='2024-12-31', auto_adjust=False, progress=False)['Close'].squeeze()\n",
+    "\n",
+    "vix = vix.loc['2015-01-01':]\n",
+    "spy = spy.loc['2015-01-01':]\n",
+    "\n",
+    "# IV-rank = rang du VIX dans sa fenetre trailing 252 seances (min-max)\n",
+    "iv_rank = vix.rolling(252, min_periods=60).apply(\n",
+    "    lambda w: (w.iloc[-1] - w.min()) / (w.max() - w.min()) if w.max() > w.min() else np.nan\n",
+    ")\n",
+    "\n",
+    "share_skip = (iv_rank >= 0.66).mean()\n",
+    "share_panic = (iv_rank >= 0.85).mean()\n",
+    "print(f\"Seances analysees      : {iv_rank.notna().sum()}\")\n",
+    "print(f\"Part label haut >=0.66 : {share_skip:.1%}  (le gate v7.1 saute ces seances)\")\n",
+    "print(f\"Part >=0.85 (panic)    : {share_panic:.1%}  (seuil de force-close v7.1)\")\n",
+    "\n",
+    "fig, axes = plt.subplots(2, 1, figsize=(11, 6), sharex=True)\n",
+    "axes[0].plot(vix.index, vix.values, lw=0.8, color='steelblue')\n",
+    "axes[0].set_ylabel('VIX')\n",
+    "axes[0].set_title('VIX et IV-rank (proxy) 2015-2024')\n",
+    "axes[1].plot(iv_rank.index, iv_rank.values, lw=0.8, color='darkorange')\n",
+    "axes[1].axhline(0.66, color='red', ls='--', lw=0.8, label='seuil skip 0.66')\n",
+    "axes[1].axhline(0.85, color='darkred', ls=':', lw=0.8, label='seuil panic 0.85')\n",
+    "axes[1].set_ylabel('IV-rank (proxy)')\n",
+    "axes[1].legend(loc='upper left', fontsize=8)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-06",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001709,
+     "end_time": "2026-09-23T21:52:37.495037+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.493328+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### Interpretation : ce que le gate filtre\n",
+    "\n",
+    "Mesure sur le proxy : seules **4.8 %** des seances depassent le seuil 0.66 et\n",
+    "**1.5 %** depassent 0.85. Le rang min-max n'est **pas** un percentile : sa\n",
+    "distribution est fortement asymetrique, l'essentiel des seances restant loin du\n",
+    "plus haut annuel. Consequence pour la lecture du couple v7.0/v7.1 : le gate IV-rank\n",
+    "de v7.1 ne s'active que dans les approches des extremes annuels de volatilite —\n",
+    "une rarete qui explique qu'il change peu le resultat, et qui sera confrontee a la\n",
+    "frequence d'activation de v7.2 (label percentile, ~1/3 des seances par construction).\n",
+    "Enfin, ces seances sautees sont precisement celles ou la prime vendue est la plus\n",
+    "riche : c'est l'arbitrage que l'article revendique (reduire le risque), et\n",
+    "exactement ce qui peut couter du rendement.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-07",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001507,
+     "end_time": "2026-09-23T21:52:37.498153+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.496646+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### Le niveau d'IV est-il informatif ? (verification locale)\n",
+    "\n",
+    "Avant de conclure quoi que ce soit sur la variante, verifions le fait stylise qui\n",
+    "fonde le mecanisme : un IV-rank eleve precede-t-il une volatilite realisee elevee ?\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cell-08",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T21:52:37.502316Z",
+     "iopub.status.busy": "2026-09-23T21:52:37.502044Z",
+     "iopub.status.idle": "2026-09-23T21:52:37.515214Z",
+     "shell.execute_reply": "2026-09-23T21:52:37.514295Z"
+    },
+    "papermill": {
+     "duration": 0.016116,
+     "end_time": "2026-09-23T21:52:37.515834+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.499718+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Volatilite realisee forward (annualisee), par tiers d'IV-rank :\n",
+      "           mean  median  count\n",
+      "iv_rank                       \n",
+      "bas      0.1059  0.0993    812\n",
+      "moyen    0.1317  0.1140    811\n",
+      "haut     0.2108  0.1939    812\n",
+      "\n",
+      "Correlation IV-rank / vol realisee forward : 0.586\n",
+      "=> Le rang d'IV porte bien une information sur le regime de vol a venir.\n",
+      "   Ceci fonde le MECANISME (le gate change le couple prime/risque),\n",
+      "   pas son EFFICACITE pour cette famille (testee en section 5).\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Cellule 2 - IV-rank -> volatilite realisee forward 21 seances\n",
+    "rets = np.log(spy / spy.shift(1))\n",
+    "fwd_vol = rets.rolling(21).std().shift(-21) * np.sqrt(252)\n",
+    "\n",
+    "df = pd.DataFrame({'iv_rank': iv_rank, 'fwd_vol': fwd_vol}).dropna()\n",
+    "tiers = pd.qcut(df['iv_rank'], 3, labels=['bas', 'moyen', 'haut'])\n",
+    "grp = df.groupby(tiers, observed=True)['fwd_vol']\n",
+    "print(\"Volatilite realisee forward (annualisee), par tiers d'IV-rank :\")\n",
+    "print(grp.agg(['mean', 'median', 'count']).round(4))\n",
+    "\n",
+    "corr = df['iv_rank'].corr(df['fwd_vol'])\n",
+    "print(f\"\\nCorrelation IV-rank / vol realisee forward : {corr:.3f}\")\n",
+    "print(\"=> Le rang d'IV porte bien une information sur le regime de vol a venir.\")\n",
+    "print(\"   Ceci fonde le MECANISME (le gate change le couple prime/risque),\")\n",
+    "print(\"   pas son EFFICACITE pour cette famille (testee en section 5).\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-09",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001595,
+     "end_time": "2026-09-23T21:52:37.519215+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.517620+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "### Interpretation : information reelle, gain non demontre\n",
+    "\n",
+    "Le tiers haut d'IV-rank precede une volatilite realisee forward nettement superieure\n",
+    "au tiers bas : le facteur n'est pas du bruit (fait stylise documente, cf. sources\n",
+    "primaires). Mais deux choses restent ouvertes, et elles se tranchent **sur le moteur\n",
+    "reel**, pas ici :\n",
+    "\n",
+    "1. le gate saute les regimes a prime riche (qui financent la strategie) ;\n",
+    "2. la selection de strike par delta 0.20 de la famille coupe deja une partie du\n",
+    "   risque que l'article gere par sa regle de sortie conjointe.\n",
+    "\n",
+    "C'est pourquoi la suite passe par des backtests QC Cloud.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-10",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001548,
+     "end_time": "2026-09-23T21:52:37.522349+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.520801+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 3. Gap et voisinage (relu firsthand sur `origin/main`)\n",
+    "\n",
+    "| Projet | Gate volatilite | Clustering strikes |\n",
+    "|---|---|---|\n",
+    "| `OptionsIncome/main.py` (v7.0) | VIX global [15, 35] | non |\n",
+    "| `OptionsIncome/main_v71_ivrank.py` (v7.1, #15801) | IV-rank par sous-jacent (median ATM 30-45j, fenetre 252j) | non |\n",
+    "| `Option-Wheel/main.py` | VIX > 20 = skip puts | non |\n",
+    "| `Dynamic-Options-Wheel/main.py` | IV-percentile 252j deja present (reference technique du depot) | non |\n",
+    "\n",
+    "Le gap initial de l'issue est donc confirme : **aucun** projet de la famille ne\n",
+    "porte le facteur de disponibilite des strikes de l'article, et le gate IV-rank\n",
+    "n'existait pas avant #15801. Ce notebook ne reduplique pas la livraison #15801 :\n",
+    "il la cite comme resultat et complete la seule moitie du mecanisme restee non\n",
+    "testee (le facteur strike-availability, defere par #15801 comme « premiere\n",
+    "iteration »).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-11",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001559,
+     "end_time": "2026-09-23T21:52:37.525466+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.523907+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 4. Design des variantes\n",
+    "\n",
+    "### v7.1 — gate IV-rank (livree par #15801, citee)\n",
+    "\n",
+    "Remplace le gate VIX global par un gate IV-rank par sous-jacent : mediane IV ATM\n",
+    "30-45j, fenetre 252j, skip si rang > 0.66, force-close si > 0.85. Simplification\n",
+    "assumee : seuils constants cales sur les centroides de l'article, pas de k-means\n",
+    "execute. `option.price_model = black_scholes()` est requis pour peupler\n",
+    "`implied_volatility` (mesure par le probe de #15801).\n",
+    "\n",
+    "### v7.2 — facteur strike-availability (cette PR)\n",
+    "\n",
+    "`OptionsIncome/main_v72_strikeavail.py` reprend la structure v7.1/v7.0 et remplace\n",
+    "le gate par le **deuxieme facteur de l'article** :\n",
+    "\n",
+    "- disponibilite = nombre de strikes distincts du chain / prix du sous-jacent ;\n",
+    "- `rate of change` sur 21 seances (fenetre non publiee par l'article — choix documente) ;\n",
+    "- label = **rang percentile** du RoC dans sa distribution trailing 252j (equivalent\n",
+    "  parametre-free du k-means par terciles, les centroides n'etant pas publies) ;\n",
+    "- skip si label >= 0.66 ; pas de force-close (la regle de sortie de l'article exige\n",
+    "  les DEUX facteurs, inapplicable a une variante mono-facteur).\n",
+    "\n",
+    "**Reserve de portabilite, explicite** : l'article mesure la disponibilite sur\n",
+    "l'univers non borne de SPX (`strikes(-1, 1)`), ou la densite de listing varie avec\n",
+    "les conditions de marche. Dans la famille, l'univers est borne (-5/+15 strikes),\n",
+    "donc le compte de strikes varie surtout avec le nombre d'expirations dans la\n",
+    "fenetre DTE. Le test mesure « le facteur tel qu'il peut exister dans ce regime de\n",
+    "souscription ». Les statistiques de disponibilite sont loggees au rapport final du\n",
+    "backtest pour que la variance soit **mesuree, pas affirmee**.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-12",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001584,
+     "end_time": "2026-09-23T21:52:37.528645+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.527061+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "Le run reel : projet QC `36473886`, backtest `92125e3965f2852fadb506e467b3ea12`,\n",
+    "LEAN `master v18124`, meme fenetre 2015-01-01 -> 2024-12-31, capital 100 000 $.\n",
+    "\n",
+    "| Metrique | v7.0 baseline | v7.1-ivrank | v7.2-strikeavail |\n",
+    "|---|---:|---:|---:|\n",
+    "| Sharpe | 0.281 | 0.163 | **0.264** |\n",
+    "| CAGR | 5.536 % | 4.451 % | **5.400 %** |\n",
+    "| MaxDD | 17.400 % | 17.900 % | **17.900 %** |\n",
+    "| Probabilistic Sharpe | 0.294 % | 0.069 % | **0.243 %** |\n",
+    "| Ordres | 510 | 626 | **570** |\n",
+    "| Equity finale | - | - | **169 273,80 $** (net 69.274 %) |\n",
+    "\n",
+    "Metriques secondaires du rapport v7.2 : Sortino 0.243, win rate 67 %, loss rate 33 %,\n",
+    "profit-loss ratio 0.32, alpha -0.017, beta 0.446, ecart-type annualise 0.067,\n",
+    "information ratio -0.734, frais totaux 739,20 $, capacite estimee 13 000 $.\n",
+    "\n",
+    "**Log final du moteur** (2025-01-01) :\n",
+    "\n",
+    "`CC v7.2-strikeavail: Final=$169,273.80, Return=69.27%, Premium=$98,604.00, Trades=285,\n",
+    "ProfitCloses=171, DefensiveCloses=0, SkippedByAvail=392, SkippedNoAvail=6,\n",
+    "FallbackVIXSessions=81, avail-label_at_end=0.167,\n",
+    "Availability[n=2516, mean=0.06262, std=0.02129, min=0.02894, max=0.11425],\n",
+    "RoC[n=2495, mean=0.00738, std=0.18957, min=-0.52945, max=1.26819]`\n",
+    "\n",
+    "Lecture des statistiques de degenerescence :\n",
+    "\n",
+    "- **le facteur n'est PAS degenere** (la reserve de portabilite de la section 4 est\n",
+    "  levee par la mesure) : la disponibilite relative (strikes distincts / spot) moyenne\n",
+    "  a 0.0626 avec un ecart-type de 0.0213 (CV ~34 %), et son rate-of-change 21 seances a\n",
+    "  un ecart-type de 0.19 sur une plage -53 % -> +127 %. Le compte de strikes bouge donc\n",
+    "  reellement dans l'univers borne, au-dela du simple cycle hebdomadaire des expirations ;\n",
+    "- le gate availability a **bloque 392 ventes** sur ~2 516 seances ; seules **6 sessions**\n",
+    "  ont utilise le repli VIX (81 sessions avant que le label ne soit calculable) ;\n",
+    "- 285 ventes realisees, 171 clotures sur profit target, 0 cloture defensive.\n",
+    "\n",
+    "**Caveats de provenance du run, non maquilles** :\n",
+    "\n",
+    "- le **projet QC 36473886 s'appelle encore `CoveredCall v71 IV-Rank [...]`** alors que le\n",
+    "  code execute est `main_v72_strikeavail.py` (colle dans l'IDE puis cloud build). Le\n",
+    "  renommage du projet n'a pas ete fait (hors perimetre) ; l'identite du code est celle du\n",
+    "  fichier de cette PR ;\n",
+    "- le panneau QC affiche l'heuristique « 51 Parameters Detected » (carte « Likely\n",
+    "  Overfitting »). Aucun seuil de la variante n'est ajuste sur cette fenetre (tous importes\n",
+    "  de l'article #18766 ou documentes dans le fichier), mais le drapeau est rapporte tel quel ;\n",
+    "- contradiction `totalNetProfit` / `netProfitAbsolute` heritee de #15801 : aucune valeur\n",
+    "  absolue n'est citee, seul le classement relatif est utilise (les trois bras sont\n",
+    "  affectes par la meme convention)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-13",
+   "metadata": {
+    "papermill": {
+     "duration": 0.0016,
+     "end_time": "2026-09-23T21:52:37.531952+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.530352+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "**Verdict : NO BEATS.**\n",
+    "\n",
+    "Le second facteur de l'article, teste **seul** contre la baseline inchangee sur le meme\n",
+    "moteur (QC Cloud, meme fenetre, memes couts, meme structure de strategie), n'ameliore\n",
+    "pas la famille :\n",
+    "\n",
+    "| Delta | Sharpe | CAGR | MaxDD | PSR |\n",
+    "|---|---:|---:|---:|---:|\n",
+    "| v7.2 - v7.0 (baseline) | -0.017 | -0.136 pt | +0.5 pt (degrade) | -0.051 pt |\n",
+    "| v7.2 - v7.1 (1er facteur) | +0.101 | +0.949 pt | 0.0 pt (egal) | +0.174 pt |\n",
+    "\n",
+    "Lecture tranchee : la variante strike-availability est **moins couteuse** que le gate\n",
+    "IV-rank (elle se rapproche de la baseline, dont elle reprend les deux tiers de l'ecart),\n",
+    "mais elle reste **en dessous de la baseline sur chaque metrique risque-rendement** et\n",
+    "**degrade le MaxDD** d'un demi-point (17.9 % vs 17.4 %). Ses 392 ventes bloquees coutent\n",
+    "de la prime sans reduire le drawdown : le mecanisme de reduction du risque de l'article\n",
+    "ne paye pas ici, dans **aucun** de ses deux facteurs testes.\n",
+    "\n",
+    "Ce que ce verdict ne dit pas (et qu'aucune mesure ici ne soutient) : ni « l'article est\n",
+    "faux » (il mesure sur un autre univers, un autre sous-jacent et une autre regle de\n",
+    "sortie), ni « l'IV-rank n'informe rien » (la section 2 mesure l'inverse). Il dit que\n",
+    "**pour cette famille** (covered call delta 0.20 sur SPY, univers de souscription borne\n",
+    "-5/+15, sorties profit-target/roll), le gate ne convertit pas cette information en\n",
+    "meilleur couple rendement/risque. Les pistes restantes sont listees en section 7."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-14",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001671,
+     "end_time": "2026-09-23T21:52:37.535205+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.533534+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## 7. Prochaines pistes (non poursuivies ici)\n",
+    "\n",
+    "1. **Univers non borne** : tester le facteur strike-availability sur une souscription\n",
+    "   `strikes(-1, 1)` (comme l'article) — cout de souscription et duree de backtest\n",
+    "   nettement superieurs ; a arbitrer si un successeur veut trancher la portabilite.\n",
+    "2. **Piste deja disponible dans le depot** : `Dynamic-Options-Wheel/main.py` porte\n",
+    "   un IV-percentile 252j + skew 25-delta ; comparer les deux implementations de\n",
+    "   gate serait un grain distinct.\n",
+    "3. **k-means reel** : remplacer les seuils constants par un k-means glissant\n",
+    "   (sklearn) execute dans l'algorithme — meme famille de tests que v7.1/v7.2.\n",
+    "\n",
+    "## References\n",
+    "\n",
+    "- Article : quantconnect.com/research/18766 (Derek Melchin) — point d'entree, pas source\n",
+    "- Dew-Becker, Giglio, Le, Rodriguez (2017), *The Price of Variance Risk*, JFE 123(2)\n",
+    "  (NBER w21182) — archive GDrive : `G:\\Mon Drive\\MyIA\\IA\\Bibliographie IA\\Trading\\`\n",
+    "- Carr & Wu (2009), *Variance Risk Premiums*, RFS 22(3), 1311-1341 (closed access)\n",
+    "- Broadie, Chernov, Johannes (2009), *Understanding Index Option Returns*, RFS 22(11), 4493-4529\n",
+    "- Bondarenko (2014), *Why Are Put Options So Expensive?*, Quarterly Journal of Finance\n",
+    "- PR #15801 (v7.1 + couple mesure) ; #15922 (hygiene) ; #16853 (compteur fallback) ; issue #15532 ; Epic #11698\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cell-15",
+   "metadata": {
+    "papermill": {
+     "duration": 0.001688,
+     "end_time": "2026-09-23T21:52:37.538444+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.536756+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "## Exercices\n",
+    "\n",
+    "**Exercice 1** — Modifier les seuils du gate IV-rank proxy (0.50 / 0.80 au lieu de\n",
+    "0.66 / 0.85) dans la cellule 1 et observer l'evolution de la part de seances sautees.\n",
+    "En quoi le choix du seuil change-t-il l'arbitrage prime/risque ?\n",
+    "\n",
+    "**Exercice 2** — Remplacer le proxy VIX de la cellule 2 par la volatilite implicite\n",
+    "reelle : telecharger les donnees d'options SPY via `get_option_history` d'un QuantBook\n",
+    "QC Cloud et calculer la mediane IV ATM 30-45j. Comparer les deux distributions d'IV-rank.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "cell-16",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T21:52:37.542657Z",
+     "iopub.status.busy": "2026-09-23T21:52:37.542498Z",
+     "iopub.status.idle": "2026-09-23T21:52:37.545870Z",
+     "shell.execute_reply": "2026-09-23T21:52:37.545345Z"
+    },
+    "papermill": {
+     "duration": 0.006252,
+     "end_time": "2026-09-23T21:52:37.546344+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.540092+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Exercice 1 a completer : fixer seuil_skip puis relancer cette cellule\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Exercice 1 - A completer : re-calculer la part de seances sautees avec d'autres seuils\n",
+    "seuil_skip = None   # TODO etudiant : proposer 0.50, 0.80 puis comparer\n",
+    "if seuil_skip is None:\n",
+    "    print(\"Exercice 1 a completer : fixer seuil_skip puis relancer cette cellule\")\n",
+    "else:\n",
+    "    part = (iv_rank >= seuil_skip).mean()\n",
+    "    print(f\"Seuil {seuil_skip:.2f} -> {part:.1%} des seances sautees\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "cell-17",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-09-23T21:52:37.550161Z",
+     "iopub.status.busy": "2026-09-23T21:52:37.550023Z",
+     "iopub.status.idle": "2026-09-23T21:52:37.553439Z",
+     "shell.execute_reply": "2026-09-23T21:52:37.552870Z"
+    },
+    "papermill": {
+     "duration": 0.006079,
+     "end_time": "2026-09-23T21:52:37.554047+00:00",
+     "exception": false,
+     "start_time": "2026-09-23T21:52:37.547968+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Exercice 2 a completer : necessite un QuantBook QC Cloud (voir cellule d'indices)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Exercice 2 - A completer : IV-rank a partir des vraies options (QuantBook QC Cloud)\n",
+    "# Piste : qb = QuantBook(); qb.add_option('SPY', Resolution.DAILY)\n",
+    "#         puis GetOptionHistory pour les IV ATM 30-45j, mediane par jour, rang 252j.\n",
+    "iv_rank_reel = None  # TODO etudiant : source QC Cloud requise\n",
+    "if iv_rank_reel is None:\n",
+    "    print(\"Exercice 2 a completer : necessite un QuantBook QC Cloud (voir cellule d'indices)\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.15"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 4.382772,
+   "end_time": "2026-09-23T21:52:37.906843+00:00",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "research_iv_rank_strike_clusters.ipynb",
+   "output_path": "research_iv_rank_strike_clusters.ipynb",
+   "parameters": {},
+   "start_time": "2026-09-23T21:52:33.524071+00:00",
+   "version": "2.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
\ No newline at end of file

From 4b7701d09c5e720202b318705ddf53d3961860f0 Mon Sep 17 00:00:00 2001
From: jsboige <jsboige@gmail.com>
Date: Thu, 24 Sep 2026 11:58:26 +0200
Subject: [PATCH 2/2] =?UTF-8?q?fix(qc,#15532):=20r=C3=A9-accentuation=20ma?=
 =?UTF-8?q?rkdown=20(53=20formes,=2013=20cellules)=20=E2=80=94=20#17609?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Restore via scripts/notebook_tools/restore_accents_canonical.py --apply,
crible secrétaire Tell c.140 (désaccentuation markdown invisible au diff
par jetons). Code/sorties/métadonnées inchangés octet-pour-octet (C.2),
aucune ré-exécution (toutes cellules data-only). 0 paires ambiguës
(a/à, ou/où) — registre canonique auto-décidé sans intervention humaine.

Co-Authored-By: Claude Haiku 4.5 (1M context) <noreply@anthropic.com>
---
 .../research_iv_rank_strike_clusters.ipynb    | 90 +++++++++----------
 1 file changed, 45 insertions(+), 45 deletions(-)

diff --git a/MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb b/MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb
index b6594ae3bf..e687877435 100644
--- a/MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb
+++ b/MyIA.AI.Notebooks/QuantConnect/research/research_iv_rank_strike_clusters.ipynb
@@ -23,12 +23,12 @@
     "| Issue | #15532 — Epic #11698 (QC-research) |\n",
     "| Article source | [quantconnect.com/research/18766](https://www.quantconnect.com/research/18766/reducing-option-writing-risk-with-iv-rank-and-strike-clusters/) (Derek Melchin) |\n",
     "| Famille cible | `projects/OptionsIncome/` (covered call SPY) — aucun nouveau projet |\n",
-    "| Mecanisme teste | gate IV-rank par sous-jacent (v7.1) et facteur disponibilite des strikes (v7.2) |\n",
+    "| Mécanisme teste | gate IV-rank par sous-jacent (v7.1) et facteur disponibilite des strikes (v7.2) |\n",
     "| Verdict | `NO-BEATS` (section 6) |\n",
     "\n",
-    "Ce notebook documente la chaine complete de l'Epic #11698 pour cet article :\n",
+    "Ce notebook documente la chaîne complete de l'Epic #11698 pour cet article :\n",
     "lecture analytique, sources primaires, gap contre le voisinage, design des variantes,\n",
-    "resultats du moteur QC Cloud, et verdict honnete.\n"
+    "résultats du moteur QC Cloud, et verdict honnete.\n"
    ]
   },
   {
@@ -45,14 +45,14 @@
     "tags": []
    },
    "source": [
-    "## 1. L'article et son mecanisme\n",
+    "## 1. L'article et son mécanisme\n",
     "\n",
     "L'article propose de reduire le risque de l'ecriture de puts SPX par un gate a\n",
     "**deux facteurs** :\n",
     "\n",
     "1. **IV Rank** — la mediane de l'IV des contrats ATM (expirations 30-90 jours,\n",
     "   `universe.include_weeklys().expiration(30, 90).strikes(-1, 1)`), relativement\n",
-    "   a son minimum/maximum sur la fenetre.\n",
+    "   a son minimum/maximum sur la fenêtre.\n",
     "2. **Strike Availability** — le nombre de strikes disponibles divise par le prix\n",
     "   du sous-jacent, avec son *rate of change* en entree.\n",
     "\n",
@@ -66,7 +66,7 @@
     "|---|---|\n",
     "| CAGR (janvier 2016 -> publication) | 6.961 % |\n",
     "| Expirations OTM | ~93 % |\n",
-    "| Balayage de parametres (25 combinaisons) | 100 % profitables |\n",
+    "| Balayage de paramètres (25 combinaisons) | 100 % profitables |\n",
     "| Sharpe / MaxDD / benchmark | **non rapportes** |\n",
     "\n",
     "Caveats explicites de l'article (et absences) :\n",
@@ -74,11 +74,11 @@
     "- Pas de benchmark : « son objectif est de generer de petits retours reguliers,\n",
     "  pas de battre l'indice actions » ;\n",
     "- la courbe de capital « beneficie de primes regulieres mais peut connaitre des\n",
-    "  pertes occasionnelles relativement importantes » (modele assureur) ;\n",
+    "  pertes occasionnelles relativement importantes » (modèle assureur) ;\n",
     "- **aucune source academique citee** ; references internes QC uniquement ;\n",
-    "- pas de walk-forward ni de partition OOS ; le balayage de parametres n'est pas\n",
+    "- pas de walk-forward ni de partition OOS ; le balayage de paramètres n'est pas\n",
     "  valide sur un hold-out (25/25 profitables peut refleter un sur-ajustement de\n",
-    "  la fenetre testee).\n"
+    "  la fenêtre testee).\n"
    ]
   },
   {
@@ -95,13 +95,13 @@
     "tags": []
    },
    "source": [
-    "## 2. Sources primaires — chaine d'attribution\n",
+    "## 2. Sources primaires — chaîne d'attribution\n",
     "\n",
     "Convention #11168 / Epic #11698 : un article de blog n'est pas une source canonique.\n",
     "L'article **ne cite aucun papier academique**. Les sources primaires retenues pour\n",
-    "fonder economiquement le mecanisme (et non pour le valider) sont :\n",
+    "fonder economiquement le mécanisme (et non pour le valider) sont :\n",
     "\n",
-    "| Reference | Role dans la chaine | Disponibilite |\n",
+    "| Reference | Rôle dans la chaîne | Disponibilite |\n",
     "|---|---|---|\n",
     "| **Dew-Becker, Giglio, Le, Rodriguez (2015/2017)**, *The Price of Variance Risk*, NBER w21182, publie JFE 123(2) | La prime de risque de variance est une compensation pour le risque de variance, concentree aux horizons courts — base economique de la recolte par options vendues | **Archivee** : `G:\\Mon Drive\\MyIA\\IA\\Bibliographie IA\\Trading\\2015 - Dew-Becker Giglio Le Rodriguez - The Price of Variance Risk (NBER w21182, JFE 2017).pdf` (NBER, 74 p., identite verifiee 1re page) |\n",
     "| Carr & Wu (2009), *Variance Risk Premiums*, RFS 22(3), 1311-1341 | Quantification directe de la prime de variance (article fondateur) | Closed access — reference bibliographique citee, **non telechargee** (aucune copie OA trouvee) |\n",
@@ -111,7 +111,7 @@
     "**Ecart article / sources primaires** : les sources etablissent qu'il existe une\n",
     "prime a recolter et qu'elle varie dans le temps. **Aucune** ne fonde le claim plus\n",
     "fort de l'article — qu'un *gate par rang d'IV* ni qu'un *facteur de disponibilite\n",
-    "des strikes* ameliorent la recolte. C'est precisement ce que la partie backtest\n",
+    "des strikes* ameliorent la recolte. C'est précisément ce que la partie backtest\n",
     "teste, sur la famille existante.\n"
    ]
   },
@@ -132,8 +132,8 @@
     "### Analyse locale (proxy analytique)\n",
     "\n",
     "La cellule suivante construit un **proxy analytique** d'IV-rank a partir du VIX\n",
-    "(meme convention que `research_vrp_putwrite.ipynb`) pour visualiser ce que le gate\n",
-    "filtre. **Ce proxy n'est pas le moteur de backtest** : les resultats de strategie\n",
+    "(même convention que `research_vrp_putwrite.ipynb`) pour visualiser ce que le gate\n",
+    "filtre. **Ce proxy n'est pas le moteur de backtest** : les résultats de stratégie\n",
     "viennent exclusivement de QC Cloud (section 5). Bornes des labels : 0.33 / 0.66\n",
     "(les centroides k-means publies par l'article ne le sont pas numeriquement).\n"
    ]
@@ -237,9 +237,9 @@
     "distribution est fortement asymetrique, l'essentiel des seances restant loin du\n",
     "plus haut annuel. Consequence pour la lecture du couple v7.0/v7.1 : le gate IV-rank\n",
     "de v7.1 ne s'active que dans les approches des extremes annuels de volatilite —\n",
-    "une rarete qui explique qu'il change peu le resultat, et qui sera confrontee a la\n",
+    "une rarete qui explique qu'il change peu le résultat, et qui sera confrontee a la\n",
     "frequence d'activation de v7.2 (label percentile, ~1/3 des seances par construction).\n",
-    "Enfin, ces seances sautees sont precisement celles ou la prime vendue est la plus\n",
+    "Enfin, ces seances sautees sont précisément celles ou la prime vendue est la plus\n",
     "riche : c'est l'arbitrage que l'article revendique (reduire le risque), et\n",
     "exactement ce qui peut couter du rendement.\n"
    ]
@@ -261,7 +261,7 @@
     "### Le niveau d'IV est-il informatif ? (verification locale)\n",
     "\n",
     "Avant de conclure quoi que ce soit sur la variante, verifions le fait stylise qui\n",
-    "fonde le mecanisme : un IV-rank eleve precede-t-il une volatilite realisee elevee ?\n"
+    "fonde le mécanisme : un IV-rank eleve precede-t-il une volatilite realisee elevee ?\n"
    ]
   },
   {
@@ -342,9 +342,9 @@
     "primaires). Mais deux choses restent ouvertes, et elles se tranchent **sur le moteur\n",
     "reel**, pas ici :\n",
     "\n",
-    "1. le gate saute les regimes a prime riche (qui financent la strategie) ;\n",
-    "2. la selection de strike par delta 0.20 de la famille coupe deja une partie du\n",
-    "   risque que l'article gere par sa regle de sortie conjointe.\n",
+    "1. le gate saute les regimes a prime riche (qui financent la stratégie) ;\n",
+    "2. la sélection de strike par delta 0.20 de la famille coupe déjà une partie du\n",
+    "   risque que l'article gere par sa règle de sortie conjointe.\n",
     "\n",
     "C'est pourquoi la suite passe par des backtests QC Cloud.\n"
    ]
@@ -368,16 +368,16 @@
     "| Projet | Gate volatilite | Clustering strikes |\n",
     "|---|---|---|\n",
     "| `OptionsIncome/main.py` (v7.0) | VIX global [15, 35] | non |\n",
-    "| `OptionsIncome/main_v71_ivrank.py` (v7.1, #15801) | IV-rank par sous-jacent (median ATM 30-45j, fenetre 252j) | non |\n",
+    "| `OptionsIncome/main_v71_ivrank.py` (v7.1, #15801) | IV-rank par sous-jacent (median ATM 30-45j, fenêtre 252j) | non |\n",
     "| `Option-Wheel/main.py` | VIX > 20 = skip puts | non |\n",
-    "| `Dynamic-Options-Wheel/main.py` | IV-percentile 252j deja present (reference technique du depot) | non |\n",
+    "| `Dynamic-Options-Wheel/main.py` | IV-percentile 252j déjà present (reference technique du depot) | non |\n",
     "\n",
     "Le gap initial de l'issue est donc confirme : **aucun** projet de la famille ne\n",
     "porte le facteur de disponibilite des strikes de l'article, et le gate IV-rank\n",
     "n'existait pas avant #15801. Ce notebook ne reduplique pas la livraison #15801 :\n",
-    "il la cite comme resultat et complete la seule moitie du mecanisme restee non\n",
-    "testee (le facteur strike-availability, defere par #15801 comme « premiere\n",
-    "iteration »).\n"
+    "il la cite comme résultat et complete la seule moitie du mécanisme restee non\n",
+    "testee (le facteur strike-availability, defere par #15801 comme « première\n",
+    "itération »).\n"
    ]
   },
   {
@@ -399,7 +399,7 @@
     "### v7.1 — gate IV-rank (livree par #15801, citee)\n",
     "\n",
     "Remplace le gate VIX global par un gate IV-rank par sous-jacent : mediane IV ATM\n",
-    "30-45j, fenetre 252j, skip si rang > 0.66, force-close si > 0.85. Simplification\n",
+    "30-45j, fenêtre 252j, skip si rang > 0.66, force-close si > 0.85. Simplification\n",
     "assumee : seuils constants cales sur les centroides de l'article, pas de k-means\n",
     "execute. `option.price_model = black_scholes()` est requis pour peupler\n",
     "`implied_volatility` (mesure par le probe de #15801).\n",
@@ -410,17 +410,17 @@
     "le gate par le **deuxieme facteur de l'article** :\n",
     "\n",
     "- disponibilite = nombre de strikes distincts du chain / prix du sous-jacent ;\n",
-    "- `rate of change` sur 21 seances (fenetre non publiee par l'article — choix documente) ;\n",
-    "- label = **rang percentile** du RoC dans sa distribution trailing 252j (equivalent\n",
-    "  parametre-free du k-means par terciles, les centroides n'etant pas publies) ;\n",
-    "- skip si label >= 0.66 ; pas de force-close (la regle de sortie de l'article exige\n",
+    "- `rate of change` sur 21 seances (fenêtre non publiee par l'article — choix documente) ;\n",
+    "- label = **rang percentile** du RoC dans sa distribution trailing 252j (équivalent\n",
+    "  paramètre-free du k-means par terciles, les centroides n'etant pas publies) ;\n",
+    "- skip si label >= 0.66 ; pas de force-close (la règle de sortie de l'article exige\n",
     "  les DEUX facteurs, inapplicable a une variante mono-facteur).\n",
     "\n",
     "**Reserve de portabilite, explicite** : l'article mesure la disponibilite sur\n",
     "l'univers non borne de SPX (`strikes(-1, 1)`), ou la densite de listing varie avec\n",
     "les conditions de marche. Dans la famille, l'univers est borne (-5/+15 strikes),\n",
     "donc le compte de strikes varie surtout avec le nombre d'expirations dans la\n",
-    "fenetre DTE. Le test mesure « le facteur tel qu'il peut exister dans ce regime de\n",
+    "fenêtre DTE. Le test mesure « le facteur tel qu'il peut exister dans ce regime de\n",
     "souscription ». Les statistiques de disponibilite sont loggees au rapport final du\n",
     "backtest pour que la variance soit **mesuree, pas affirmee**.\n"
    ]
@@ -440,9 +440,9 @@
    },
    "source": [
     "Le run reel : projet QC `36473886`, backtest `92125e3965f2852fadb506e467b3ea12`,\n",
-    "LEAN `master v18124`, meme fenetre 2015-01-01 -> 2024-12-31, capital 100 000 $.\n",
+    "LEAN `master v18124`, même fenêtre 2015-01-01 -> 2024-12-31, capital 100 000 $.\n",
     "\n",
-    "| Metrique | v7.0 baseline | v7.1-ivrank | v7.2-strikeavail |\n",
+    "| Métrique | v7.0 baseline | v7.1-ivrank | v7.2-strikeavail |\n",
     "|---|---:|---:|---:|\n",
     "| Sharpe | 0.281 | 0.163 | **0.264** |\n",
     "| CAGR | 5.536 % | 4.451 % | **5.400 %** |\n",
@@ -481,11 +481,11 @@
     "  renommage du projet n'a pas ete fait (hors perimetre) ; l'identite du code est celle du\n",
     "  fichier de cette PR ;\n",
     "- le panneau QC affiche l'heuristique « 51 Parameters Detected » (carte « Likely\n",
-    "  Overfitting »). Aucun seuil de la variante n'est ajuste sur cette fenetre (tous importes\n",
+    "  Overfitting »). Aucun seuil de la variante n'est ajuste sur cette fenêtre (tous importes\n",
     "  de l'article #18766 ou documentes dans le fichier), mais le drapeau est rapporte tel quel ;\n",
     "- contradiction `totalNetProfit` / `netProfitAbsolute` heritee de #15801 : aucune valeur\n",
     "  absolue n'est citee, seul le classement relatif est utilise (les trois bras sont\n",
-    "  affectes par la meme convention)."
+    "  affectes par la même convention)."
    ]
   },
   {
@@ -504,8 +504,8 @@
    "source": [
     "**Verdict : NO BEATS.**\n",
     "\n",
-    "Le second facteur de l'article, teste **seul** contre la baseline inchangee sur le meme\n",
-    "moteur (QC Cloud, meme fenetre, memes couts, meme structure de strategie), n'ameliore\n",
+    "Le second facteur de l'article, teste **seul** contre la baseline inchangee sur le même\n",
+    "moteur (QC Cloud, même fenêtre, mêmes couts, même structure de stratégie), n'ameliore\n",
     "pas la famille :\n",
     "\n",
     "| Delta | Sharpe | CAGR | MaxDD | PSR |\n",
@@ -515,13 +515,13 @@
     "\n",
     "Lecture tranchee : la variante strike-availability est **moins couteuse** que le gate\n",
     "IV-rank (elle se rapproche de la baseline, dont elle reprend les deux tiers de l'ecart),\n",
-    "mais elle reste **en dessous de la baseline sur chaque metrique risque-rendement** et\n",
+    "mais elle reste **en dessous de la baseline sur chaque métrique risque-rendement** et\n",
     "**degrade le MaxDD** d'un demi-point (17.9 % vs 17.4 %). Ses 392 ventes bloquees coutent\n",
-    "de la prime sans reduire le drawdown : le mecanisme de reduction du risque de l'article\n",
+    "de la prime sans reduire le drawdown : le mécanisme de reduction du risque de l'article\n",
     "ne paye pas ici, dans **aucun** de ses deux facteurs testes.\n",
     "\n",
     "Ce que ce verdict ne dit pas (et qu'aucune mesure ici ne soutient) : ni « l'article est\n",
-    "faux » (il mesure sur un autre univers, un autre sous-jacent et une autre regle de\n",
+    "faux » (il mesure sur un autre univers, un autre sous-jacent et une autre règle de\n",
     "sortie), ni « l'IV-rank n'informe rien » (la section 2 mesure l'inverse). Il dit que\n",
     "**pour cette famille** (covered call delta 0.20 sur SPY, univers de souscription borne\n",
     "-5/+15, sorties profit-target/roll), le gate ne convertit pas cette information en\n",
@@ -547,11 +547,11 @@
     "1. **Univers non borne** : tester le facteur strike-availability sur une souscription\n",
     "   `strikes(-1, 1)` (comme l'article) — cout de souscription et duree de backtest\n",
     "   nettement superieurs ; a arbitrer si un successeur veut trancher la portabilite.\n",
-    "2. **Piste deja disponible dans le depot** : `Dynamic-Options-Wheel/main.py` porte\n",
+    "2. **Piste déjà disponible dans le depot** : `Dynamic-Options-Wheel/main.py` porte\n",
     "   un IV-percentile 252j + skew 25-delta ; comparer les deux implementations de\n",
     "   gate serait un grain distinct.\n",
     "3. **k-means reel** : remplacer les seuils constants par un k-means glissant\n",
-    "   (sklearn) execute dans l'algorithme — meme famille de tests que v7.1/v7.2.\n",
+    "   (sklearn) execute dans l'algorithme — même famille de tests que v7.1/v7.2.\n",
     "\n",
     "## References\n",
     "\n",
@@ -585,7 +585,7 @@
     "En quoi le choix du seuil change-t-il l'arbitrage prime/risque ?\n",
     "\n",
     "**Exercice 2** — Remplacer le proxy VIX de la cellule 2 par la volatilite implicite\n",
-    "reelle : telecharger les donnees d'options SPY via `get_option_history` d'un QuantBook\n",
+    "reelle : telecharger les données d'options SPY via `get_option_history` d'un QuantBook\n",
     "QC Cloud et calculer la mediane IV ATM 30-45j. Comparer les deux distributions d'IV-rank.\n"
    ]
   },
@@ -700,4 +700,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}