<< Sommaire QC | Précédent : QC-Py-05-Universe-Selection << | Suivant : QC-Py-06b-Derivatives-Valuation-From-Scratch >>

QC-Py-06 : Options Trading dans QuantConnect

[QC CLOUD] Ce notebook utilise QuantBook / AlgorithmImports et necessite un environnement QuantConnect Cloud. Les cellules de code ne sont pas executables localement.

Duree estimee : 75 minutes

Objectifs d’apprentissage : 1. Comprendre les concepts fondamentaux des options (Call, Put, Strike, Expiration) 2. Ajouter et configurer des options dans QuantConnect 3. Naviguer dans l’OptionChain pour sélectionner des contrats 4. Utiliser les Greeks pour la gestion du risque 5. Implementer des stratégies classiques (Covered Call, Protective Put, Spreads, Iron Condor)

Prerequis : - Notebooks QC-Py-01 a QC-Py-04 completes - Comprehension de base des marches financiers - Notions de Python intermediaire

Note importante : Les données d’options sont disponibles gratuitement sur QuantConnect (free tier) pour les equities US comme SPY.

Note de conception : Ce notebook contient du code de reference a copier dans QuantConnect Lab (main.py). Les cellules ne sont pas prevues pour etre executees en tant que notebook Jupyter. L’absence d’outputs (execution_count: null) est intentionnelle.

[REFERENCE QC Cloud] Ce notebook illustre du code QuantConnect a executer dans l’IDE Cloud (https://www.quantconnect.com/research). L’environnement local ne dispose pas de QuantBook ni de l’historical data feed. Pour executer : cloner le projet QC associe, ouvrir research.ipynb, executer cellule par cellule.

Mode d’emploi : Ce notebook est un document de reference (non executable). Le code QCAlgorithm presente ici est a copier dans main.py de votre projet QuantConnect Lab. Ne tentez pas de faire “Run All” – les imports AlgorithmImports n’existent pas en Jupyter local.

Pour demarrer un projet QC : copiez un main.py depuis projects/ ou partner-course-quant-trading/templates/, puis adaptez-le.

Plan du notebook

Introduction aux Options (10 min)
Ajouter des Options dans QuantConnect (15 min)
Options Chain : Navigation et Sélection (20 min)
Les Greeks (15 min)
Stratégies de Base (30 min)
- Covered Call
- Protective Put
- Vertical Spread
Iron Condor (15 min)
Exercise et Assignment (10 min)
Stratégie Complete : Covered Call sur SPY (20 min)
Conclusion

1. Introduction aux Options (10 min)

Qu’est-ce qu’une option ?

Une option est un contrat derivatif qui donne a son detenteur le droit (mais pas l’obligation) d’acheter ou de vendre un actif sous-jacent a un prix predetermine, avant ou a une date d’expiration.

Les deux types d’options

Type	Definition	Acheteur	Vendeur
CALL	Droit d’acheter le sous-jacent	Paye la prime, espere hausse	Recoit la prime, risque hausse
PUT	Droit de vendre le sous-jacent	Paye la prime, espere baisse	Recoit la prime, risque baisse

Terminologie essentielle

Terme | Definition | Exemple (SPY a 450$) |

ITM / ATM / OTM

Ces termes decrivent la relation entre le strike et le prix actuel du sous-jacent :

Terme	Call	Put	Signification
ITM (In-The-Money)	Strike < Prix	Strike > Prix	Option a de la valeur intrinseque
ATM (At-The-Money)	Strike = Prix	Strike = Prix	Strike proche du prix actuel
OTM (Out-of-The-Money)	Strike > Prix	Strike < Prix	Option n’a que de la valeur temporelle

Exemple : SPY se trade a 450$ - Call strike 440$ : ITM (peut acheter a 440$ un actif valant 450$) - Call strike 450$ : ATM (strike = prix actuel) - Call strike 460$ : OTM (peut acheter a 460$ un actif valant 450$, pas interessant)

Pourquoi trader des options ?

Objectif	Stratégie	Exemple
Speculation	Acheter calls/puts	Pari sur hausse/baisse avec effet de levier
Couverture (Hedging)	Protective Put	Proteger un portefeuille contre la baisse
Revenu	Covered Call	Generer du premium sur des actions detenues
Volatilite	Straddle, Iron Condor	Profiter de marches calmes ou volatils

Diagramme des payoffs

LONG CALL (Achat d'un Call)              LONG PUT (Achat d'un Put)

Profit                                    Profit
  ^                                         ^
  |           /                             |  \                     
  |          /                              |   \                    
  |         /                               |    \                   
--|--------/--------> Prix                  --|----\-------> Prix    
  |  -P   K                                 |      K   -P            
  |                                         |                        
                                                                     
K = Strike                                  K = Strike               
P = Premium paye                            P = Premium paye         
Gain max = Illimite                         Gain max = K - P         
Perte max = Premium                         Perte max = Premium

Point cle : L’acheteur d’une option a un risque limite (premium paye) mais un gain potentiel eleve. Le vendeur a un gain limite (premium recu) mais un risque potentiel eleve.

2. Ajouter des Options dans QuantConnect (15 min)

Méthode de base : AddOption()

Pour trader des options sur QuantConnect, il faut d’abord les ajouter a l’univers de l’algorithme avec AddOption().

# Ajouter les options sur SPY
option = self.AddOption("SPY", Resolution.Minute)

Important : Les options necessitent Resolution.Minute au minimum. Resolution.Daily n’est pas supporte pour les options car les prix changent frequemment durant la journee.

Configuration du filtre avec SetFilter()

Les options sur un actif populaire comme SPY ont des centaines de contrats disponibles (différents strikes et expirations). Pour eviter de surcharger l’algorithme, on utilise SetFilter() pour filtrer les contrats :

option.SetFilter(minStrike, maxStrike, minExpiry, maxExpiry)

Paramètre	Description	Exemple
`minStrike`	Strike minimum (relatif au prix)	-5 (5 strikes sous le prix actuel)
`maxStrike`	Strike maximum (relatif au prix)	+5 (5 strikes au-dessus)
`minExpiry`	Expiration minimum	`timedelta(30)` (min 30 jours)
`maxExpiry`	Expiration maximum	`timedelta(60)` (max 60 jours)

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Configuration de base des options sur SPY
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class BasicOptionsSetup(QCAlgorithm):
    """
    Configuration de base pour trader des options sur SPY.
    """
    
    def Initialize(self):
        # Configuration du backtest
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(100000)
        
        # Ajouter l'equity sous-jacent (facultatif mais recommande)
        self.equity = self.AddEquity("SPY", Resolution.Minute)
        
        # Ajouter les options sur SPY
        self.option = self.AddOption("SPY", Resolution.Minute)
        
        # Stocker le symbol de l'option pour reference
        self.option_symbol = self.option.Symbol
        
        # Configurer le filtre d'options
        # -5/+5 strikes autour du prix actuel
        # Expiration entre 30 et 60 jours
        self.option.SetFilter(
            minStrike=-5,
            maxStrike=5,
            minExpiry=timedelta(days=30),
            maxExpiry=timedelta(days=60)
        )
        
        self.Log("Options setup completed")
        self.Log(f"Option Symbol: {self.option_symbol}")
    
    def OnData(self, slice):
        # Verifier si des options sont disponibles
        if not slice.OptionChains.ContainsKey(self.option_symbol):
            return
        
        # Obtenir la chaine d'options
        chain = slice.OptionChains[self.option_symbol]
        
        # Compter les contrats disponibles
        contracts = list(chain)
        if len(contracts) > 0:
            self.Debug(f"Found {len(contracts)} option contracts")

Résultats du backtest QC Cloud (BasicOptionsSetup)

Metrique	Valeur
Dates negociables	62
Ordres executes	0
Sharpe Ratio	0
CAGR	0%
Max Drawdown	0%
Net Profit	0%
Equity finale	$100,000.00

Options setup exploration, Q1 2023

Résultats backtest QC Cloud : BasicOptionsSetup (2023, $100k) — 0 ordres, Net Profit 0%. Demo de configuration de base (AddOption, SetFilter, OptionChains). Pas de logique de trading.

Filtres avances

Vous pouvez créer des filtres plus sophistiques avec une fonction lambda :

# Filtre personnalise
self.option.SetFilter(lambda universe: universe
    .Strikes(-10, +10)              # 10 strikes de chaque cote
    .Expiration(timedelta(7), timedelta(45))  # 7 a 45 jours
    .IncludeWeeklys()               # Inclure les options hebdomadaires
)

Options hebdomadaires (Weeklys) : Expirent chaque vendredi, très populaires pour le trading a court terme.

3. Options Chain : Navigation et Sélection (20 min)

Structure de l’OptionChain

Dans OnData, les données d’options sont disponibles via slice.OptionChains. C’est un dictionnaire dont les cles sont les symbols d’options et les valeurs sont des OptionChain.

def OnData(self, slice):
    # Verifier la disponibilite
    if not slice.OptionChains.ContainsKey(self.option_symbol):
        return
    
    # Obtenir la chaîne
    chain = slice.OptionChains[self.option_symbol]
    
    # chain est iterable - chaque élément est un OptionContract
    for contract in chain:
        # contract.Strike, contract.Expiry, contract.Right, etc.
        pass

Proprietes d’un OptionContract

Propriete	Type	Description
`Symbol`	Symbol	Identifiant unique du contrat
`Strike`	Decimal	Prix d’exercice
`Expiry`	DateTime	Date d’expiration
`Right`	OptionRight	`OptionRight.Call` ou `OptionRight.Put`
`UnderlyingLastPrice`	Decimal	Dernier prix du sous-jacent
`BidPrice`	Decimal	Prix d’achat (bid)
`AskPrice`	Decimal	Prix de vente (ask)
`LastPrice`	Decimal	Dernier prix echange
`OpenInterest`	int	Nombre de contrats ouverts
`ImpliedVolatility`	Decimal	Volatilite implicite
`Greeks`	Greeks	Delta, Gamma, Theta, Vega, Rho

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Navigation dans l'OptionChain
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class OptionChainNavigation(QCAlgorithm):
    """
    Demonstration de la navigation dans l'OptionChain.
    """
    
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 3, 31)
        self.SetCash(100000)
        
        self.equity = self.AddEquity("SPY", Resolution.Minute)
        self.option = self.AddOption("SPY", Resolution.Minute)
        self.option_symbol = self.option.Symbol
        
        self.option.SetFilter(-5, 5, timedelta(30), timedelta(60))
        
        # Flag pour n'afficher qu'une fois
        self.logged = False
    
    def OnData(self, slice):
        if self.logged:
            return
        
        if not slice.OptionChains.ContainsKey(self.option_symbol):
            return
        
        chain = slice.OptionChains[self.option_symbol]
        contracts = list(chain)
        
        if len(contracts) == 0:
            return
        
        # Prix actuel du sous-jacent
        underlying_price = chain.Underlying.Price
        self.Log(f"\n=== Option Chain Analysis ===")
        self.Log(f"SPY Price: ${underlying_price:.2f}")
        self.Log(f"Total contracts: {len(contracts)}")
        
        # Separer calls et puts
        calls = [c for c in chain if c.Right == OptionRight.Call]
        puts = [c for c in chain if c.Right == OptionRight.Put]
        
        self.Log(f"Calls: {len(calls)} | Puts: {len(puts)}")
        
        # Trouver le call ATM (strike le plus proche du prix)
        if calls:
            atm_call = min(calls, key=lambda x: abs(x.Strike - underlying_price))
            self.Log(f"\nATM Call: Strike={atm_call.Strike}, Expiry={atm_call.Expiry.date()}")
            self.Log(f"  Bid: ${atm_call.BidPrice:.2f} | Ask: ${atm_call.AskPrice:.2f}")
            self.Log(f"  IV: {atm_call.ImpliedVolatility:.2%} | OI: {atm_call.OpenInterest}")
        
        # Trouver le put ATM
        if puts:
            atm_put = min(puts, key=lambda x: abs(x.Strike - underlying_price))
            self.Log(f"\nATM Put: Strike={atm_put.Strike}, Expiry={atm_put.Expiry.date()}")
            self.Log(f"  Bid: ${atm_put.BidPrice:.2f} | Ask: ${atm_put.AskPrice:.2f}")
            self.Log(f"  IV: {atm_put.ImpliedVolatility:.2%} | OI: {atm_put.OpenInterest}")
        
        self.logged = True

Résultats du backtest QC Cloud (OptionChainNavigation)

Metrique	Valeur
Dates negociables	62
Ordres executes	0
Sharpe Ratio	0
CAGR	0%
Max Drawdown	0%
Net Profit	0%
Equity finale	$100,000.00

Option chain navigation exploration, Q1 2023

Résultats backtest QC Cloud : OptionChainNavigation (2023 Q1, $100k) — 0 ordres, Net Profit 0%. Demo de navigation dans l’OptionChain (calls/puts, ATM/ITM/OTM, IV, Open Interest). Analyse unique, pas de trading.

Sélection de contrats par critères

Pour sélectionner des contrats spécifiques, utilisez des list comprehensions avec des filtres :

# Exemples de selection de contrats
# A copier dans l'IDE QuantConnect

def select_contracts(self, chain, underlying_price):
    """
    Exemples de selection de contrats d'options.
    """
    
    # 1. Tous les calls
    calls = [c for c in chain if c.Right == OptionRight.Call]
    
    # 2. Tous les puts
    puts = [c for c in chain if c.Right == OptionRight.Put]
    
    # 3. Call ATM (strike le plus proche du prix)
    atm_call = min(calls, key=lambda x: abs(x.Strike - underlying_price)) if calls else None
    
    # 4. Put ATM
    atm_put = min(puts, key=lambda x: abs(x.Strike - underlying_price)) if puts else None
    
    # 5. Calls OTM (strike > prix)
    otm_calls = [c for c in calls if c.Strike > underlying_price]
    
    # 6. Puts OTM (strike < prix)
    otm_puts = [c for c in puts if c.Strike < underlying_price]
    
    # 7. Calls ITM (strike < prix)
    itm_calls = [c for c in calls if c.Strike < underlying_price]
    
    # 8. Contrats expirant dans exactement X jours
    target_expiry = self.Time + timedelta(days=45)
    contracts_45d = [c for c in chain 
                     if abs((c.Expiry - target_expiry).days) <= 3]  # tolerance 3 jours
    
    # 9. Contrats avec volume suffisant (OpenInterest > 100)
    liquid_contracts = [c for c in chain if c.OpenInterest > 100]
    
    # 10. Call OTM le plus proche (pour covered call)
    if otm_calls:
        nearest_otm_call = min(otm_calls, key=lambda x: x.Strike)
    
    # 11. Selection combinee: Call OTM, expiration 30-45 jours, delta ~0.30
    ideal_calls = [c for c in otm_calls 
                   if 30 <= (c.Expiry - self.Time).days <= 45
                   and 0.25 <= c.Greeks.Delta <= 0.35]
    
    return {
        'atm_call': atm_call,
        'atm_put': atm_put,
        'otm_calls': otm_calls,
        'otm_puts': otm_puts,
        'ideal_calls': ideal_calls
    }

Bonnes pratiques de sélection

Critere	Pourquoi	Valeur recommandee
Open Interest	Liquidite, facilite d’exécution	> 100 pour options liquides
Bid-Ask Spread	Cout de transaction	< 5% du prix de l’option
Expiration	Decay temporel, flexibilite	30-60 jours pour stratégies de revenu
Strike	Probabilite d’exercice	OTM 5-10% pour covered calls

4. Les Greeks (15 min)

Introduction aux Greeks

Les Greeks sont des mesures de sensibilite qui quantifient comment le prix d’une option change en fonction de différents facteurs. Ils sont essentiels pour la gestion du risque.

Les 5 Greeks principaux

Greek	Mesure	Interpretation	Valeur typique
Delta	Sensibilite au prix du sous-jacent	+1$ sous-jacent = +Delta$ option	Call: 0 a 1, Put: -1 a 0
Gamma	Acceleration du delta	Mesure la courbure	Eleve pres ATM
Theta	Decay temporel (par jour)	Perte de valeur avec le temps	Toujours negatif (pour acheteur)
Vega	Sensibilite a la volatilite	+1% IV = +Vega$ option	Eleve pour options longues
Rho	Sensibilite aux taux d’intérêt	+1% taux = +Rho$ option	Faible impact a court terme

Delta en detail

Le Delta est le Greek le plus utilise. Il represente :

Sensibilite au prix : Si delta = 0.50, une hausse de 1$ du sous-jacent augmente l’option de 0.50$
Probabilite approximative : Delta ~= probabilite que l’option expire ITM
Equivalent actions : Un call avec delta 0.50 se comporte comme 50 actions

Delta selon le strike:

Delta
  1.0 |  ______
      |        \
  0.5 |         \____  <- ATM (delta ~0.50)
      |               \
  0.0 |________________\
      ITM    ATM    OTM

Theta - Le temps joue contre l’acheteur

Le Theta represente la perte de valeur quotidienne due au passage du temps. C’est le principal ennemi de l’acheteur d’options.

Valeur de l'option vs Temps restant:

Valeur
  ^                      | Decay accelere
  |  \                   | proche de
  |    \                 | l'expiration
  |      \               v
  |        \__
  |            \___
  |                 \____
  +------------------------> Temps
  90j    60j    30j    0j

Conseil : Les vendeurs d’options profitent du theta decay, les acheteurs le subissent.

Ancres savantes – Black, F. & Scholes, M. (1973), The Pricing of Options and Corporate Liabilities, Journal of Political Economy 81(3):637-654. DOI 10.1086/260062 (formule d’evaluation des options dont les Greeks sont les derivees partielles : delta/gamma/theta/vega/rho) ; Merton, R.C. (1973), Theory of Rational Option Pricing, Bell Journal of Economics and Management Science 4(1):141-183 (argument de couverture dynamique / delta-neutral, valuation risque-neutre). Ces deux travaux fondateurs ont value le prix Nobel d’economie 1997 a Merton et Scholes).

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Acces aux Greeks dans QuantConnect
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class GreeksAnalysis(QCAlgorithm):
    """
    Analyse des Greeks pour la gestion du risque.
    """
    
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 3, 31)
        self.SetCash(100000)
        
        self.equity = self.AddEquity("SPY", Resolution.Minute)
        self.option = self.AddOption("SPY", Resolution.Minute)
        self.option_symbol = self.option.Symbol
        
        self.option.SetFilter(-3, 3, timedelta(30), timedelta(45))
        
        self.logged = False
    
    def OnData(self, slice):
        if self.logged:
            return
        
        if not slice.OptionChains.ContainsKey(self.option_symbol):
            return
        
        chain = slice.OptionChains[self.option_symbol]
        underlying_price = chain.Underlying.Price
        
        # Selectionner le call ATM
        calls = [c for c in chain if c.Right == OptionRight.Call]
        if not calls:
            return
        
        atm_call = min(calls, key=lambda x: abs(x.Strike - underlying_price))
        
        # Afficher les Greeks
        self.Log(f"\n=== Greeks Analysis for ATM Call ===")
        self.Log(f"Underlying: SPY @ ${underlying_price:.2f}")
        self.Log(f"Contract: Strike={atm_call.Strike}, Expiry={atm_call.Expiry.date()}")
        self.Log(f"Price: ${atm_call.LastPrice:.2f}")
        self.Log(f"")
        
        # Acces aux Greeks via contract.Greeks
        greeks = atm_call.Greeks
        
        self.Log(f"DELTA: {greeks.Delta:.4f}")
        self.Log(f"  -> Si SPY +$1, option +${greeks.Delta:.4f}")
        self.Log(f"  -> Probabilite ITM: ~{greeks.Delta*100:.1f}%")
        self.Log(f"")
        
        self.Log(f"GAMMA: {greeks.Gamma:.4f}")
        self.Log(f"  -> Si SPY +$1, delta change de {greeks.Gamma:.4f}")
        self.Log(f"")
        
        self.Log(f"THETA: {greeks.Theta:.4f}")
        self.Log(f"  -> Perte quotidienne: ${abs(greeks.Theta):.4f}")
        self.Log(f"")
        
        self.Log(f"VEGA: {greeks.Vega:.4f}")
        self.Log(f"  -> Si IV +1%, option +${greeks.Vega:.4f}")
        self.Log(f"")
        
        self.Log(f"RHO: {greeks.Rho:.4f}")
        self.Log(f"  -> Si taux +1%, option +${greeks.Rho:.4f}")
        
        self.logged = True
    
    def SelectByDelta(self, calls, target_delta=0.30, tolerance=0.05):
        """
        Selectionner un call par son delta.
        Utile pour les covered calls (delta 0.25-0.35 recommande).
        """
        matching = [c for c in calls 
                    if abs(c.Greeks.Delta - target_delta) <= tolerance]
        
        if matching:
            # Prendre celui le plus proche du delta cible
            return min(matching, key=lambda x: abs(x.Greeks.Delta - target_delta))
        return None

Résultats du backtest QC Cloud (GreeksAnalysis)

Metrique	Valeur
Dates negociables	62
Ordres executes	0
Sharpe Ratio	0
CAGR	0%
Max Drawdown	0%
Net Profit	0%
Equity finale	$100,000.00

Greeks analysis exploration, Q1 2023

Résultats backtest QC Cloud : GreeksAnalysis (2023 Q1, $100k) — 0 ordres, Net Profit 0%. Demo d’analyse des Greeks (Delta, Gamma, Theta, Vega, Rho). Affiche les Greeks du call ATM une seule fois, pas de trading.

Utilisation des Greeks pour le Risk Management

Objectif	Greek a surveiller	Action
Limiter l’exposition au prix	Delta	Maintenir delta total proche de 0 (delta neutral)
Reduire le decay temporel	Theta	Vendre des options (theta positif)
Profiter de la volatilite	Vega	Acheter options si IV attendue en hausse
Position conservatrice	Delta	Choisir des options avec delta < 0.30

5. Stratégies de Base (30 min)

Vue d’ensemble des stratégies

Stratégie	Composition	Objectif	Risque max	Gain max
Covered Call	Long stock + Short call OTM	Revenu (premium)	Stock -> 0	Premium + (Strike - Achat)
Protective Put	Long stock + Long put	Protection baisse	Premium paye	Illimite
Bull Call Spread	Long call + Short call (strike+)	Hausse limitee	Premium net	Diff strikes - Premium
Bear Put Spread	Long put + Short put (strike-)	Baisse limitee	Premium net	Diff strikes - Premium

5a. Covered Call (10 min)

Principe

Le Covered Call est la stratégie d’options la plus populaire pour generer du revenu. Elle consiste a :

Detenir 100 actions du sous-jacent (ou un multiple de 100)
Vendre un call OTM (strike au-dessus du prix actuel)

COVERED CALL = Long 100 shares + Short 1 Call OTM

Payoff:
         ___________
        /
       /
------/-------------> Prix
     Strike

Gain max = Premium + (Strike - Prix d'achat)
Perte max = Prix d'achat - Premium (si action -> 0)

Avantages et inconvenients

Avantages	Inconvenients
Genere du revenu regulier	Limite le gain potentiel
Reduit le cout d’achat (breakeven)	Oblige a vendre si assigne
Stratégie simple a executer	Necessite de detenir l’action

Quand utiliser

Vous etes neutre a moderement haussier sur l’action
Vous acceptez de vendre a un prix cible (strike)
Vous voulez reduire la volatilite de votre portefeuille

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Implementation d'un Covered Call
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class CoveredCallStrategy(QCAlgorithm):
    """
    Strategie Covered Call sur SPY.
    
    1. Acheter 100 actions SPY
    2. Vendre un call OTM (delta ~0.30)
    3. Laisser expirer ou roller avant expiration
    """
    
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(50000)  # Capital suffisant pour 100 SPY
        
        # Ajouter l'equity et les options
        self.equity = self.AddEquity("SPY", Resolution.Minute)
        self.spy = self.equity.Symbol
        
        self.option = self.AddOption("SPY", Resolution.Minute)
        self.option_symbol = self.option.Symbol
        
        # Filtre: calls OTM, expiration 30-45 jours
        self.option.SetFilter(
            minStrike=0,   # ATM et au-dessus
            maxStrike=10,  # 10 strikes OTM max
            minExpiry=timedelta(days=30),
            maxExpiry=timedelta(days=45)
        )
        
        # Tracking
        self.current_call = None
        self.premium_collected = 0
        
        self.Log("Covered Call Strategy initialized")
    
    def OnData(self, slice):
        # Etape 1: Acheter 100 actions si pas deja fait
        if not self.Portfolio[self.spy].Invested:
            self.MarketOrder(self.spy, 100)
            self.Log(f"Bought 100 SPY shares")
            return  # Attendre le prochain tick pour vendre le call
        
        # Etape 2: Verifier si on a deja un call vendu
        if self.current_call is not None:
            # Verifier si le call a expire
            if self.Time >= self.current_call.ID.Date:
                self.Log(f"Call expired: {self.current_call}")
                self.current_call = None
            else:
                return  # On a deja un call, attendre
        
        # Etape 3: Vendre un nouveau call OTM
        if not slice.OptionChains.ContainsKey(self.option_symbol):
            return
        
        chain = slice.OptionChains[self.option_symbol]
        underlying_price = chain.Underlying.Price
        
        # Filtrer les calls OTM
        calls = [c for c in chain 
                 if c.Right == OptionRight.Call 
                 and c.Strike > underlying_price]
        
        if not calls:
            return
        
        # Selectionner le call avec delta proche de 0.30
        target_delta = 0.30
        selected_call = min(calls, 
                           key=lambda x: abs(x.Greeks.Delta - target_delta))
        
        # Verifier que le delta est raisonnable
        if selected_call.Greeks.Delta < 0.20 or selected_call.Greeks.Delta > 0.40:
            self.Debug(f"No suitable call found (delta={selected_call.Greeks.Delta:.2f})")
            return
        
        # Vendre le call (quantity negative = vente)
        self.MarketOrder(selected_call.Symbol, -1)
        self.current_call = selected_call.Symbol
        
        # Calculer le premium (approximation avec mid price)
        premium = (selected_call.BidPrice + selected_call.AskPrice) / 2 * 100
        self.premium_collected += premium
        
        self.Log(f"Sold Call: Strike={selected_call.Strike}, " +
                 f"Expiry={selected_call.Expiry.date()}, " +
                 f"Delta={selected_call.Greeks.Delta:.2f}, " +
                 f"Premium=${premium:.2f}")
    
    def OnEndOfAlgorithm(self):
        self.Log(f"\n=== Covered Call Summary ===")
        self.Log(f"Total Premium Collected: ${self.premium_collected:.2f}")
        self.Log(f"Final Portfolio Value: ${self.Portfolio.TotalPortfolioValue:.2f}")

Exercice 1 : Sélection de Contrats par Greeks

Dans cet exercice, vous allez implementer une fonction de sélection de contrats d’options basee sur des critères de Greeks. Cette competence est essentielle pour construire des stratégies d’options reelles.

Objectif : Completer select_contracts_by_greeks() qui filtre et trie les contrats selon des critères de Delta, Theta et Vega.

Indices : - Indice : Utilisez des list comprehensions avec des filtres sur contract.Greeks.Delta - Indice : Pour un covered call, on cherche delta entre 0.20 et 0.40 - Étape 1 : Filtrer les calls par type (OptionRight.Call) - Étape 2 : Appliquer le filtre de delta - Étape 3 : Trier par premium decroissant et retourner les N meilleurs

# Exercice 1 : Selection de contrats par Greeks
def select_contracts_by_greeks(chain, underlying_price,
                              option_type="call",
                              min_delta=0.20, max_delta=0.40,
                              min_theta=None, max_theta=None,
                              top_n=5):
    """
    Selectionne les contrats d’options les mieux adaptes selon les Greeks.
    
    Args:
        chain: OptionChain iterable
        underlying_price: Prix actuel du sous-jacent
        option_type: "call" ou "put"
        min_delta: Delta minimum acceptable
        max_delta: Delta maximum acceptable
        top_n: Nombre de contrats a retourner
    
    Returns:
        list: Liste des N meilleurs contrats tries par premium
    """
    # TODO etudiant : Filtrer par type d’option
    # TODO etudiant : Filtrer par delta
    # TODO etudiant : Trier et retourner les top_n
    return []  # Exercice a completer

Résultats backtest QC Cloud : CoveredCallStrategy (2023, $50k) — 26 ordres, Net Profit +12.9%, Sharpe 0.608, CAGR 13.0%, MaxDD 6.1%, Win Rate 57%. Performance solide : premium regulier + appreciation du sous-jacent SPY en 2023. MaxDD maitrise (6.1%). Stratégie de revenu confirmee.

Backtest QC Cloud verifie 2023 (projet 33409983, bt 86b0191aa6dc0d1c981d4b3c07bbda51) : Sharpe 0.608 / CAGR 13.016% / MaxDD 6.100% / 250 dates / PSR 66.8% (ground-truth QC Cloud). Ordres (26), Net Profit +12.9% et Win Rate 57% : valeurs descriptives de l’auteur (totalOrders et totalNetProfit non exposes par le wrapper API).

5b. Protective Put (10 min)

Principe

Le Protective Put est une stratégie de couverture (hedging). Elle consiste a :

Detenir 100 actions du sous-jacent
Acheter un put (généralement ATM ou legerement OTM)

PROTECTIVE PUT = Long 100 shares + Long 1 Put

Payoff:
          /
         /
        /
-------/____________ <- Protection en cas de baisse
      Strike

Gain max = Illimite (hausse de l'action)
Perte max = (Prix achat - Strike) + Premium

Analogie avec l’assurance

Le Protective Put est souvent compare a une police d’assurance :

Assurance auto	Protective Put
Prime mensuelle	Premium du put
Franchise	Différence (Prix - Strike)
Indemnisation si accident	Protection si chute du cours
Expire après 1 an	Expire a l’echeance

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Implementation d'un Protective Put
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class ProtectivePutStrategy(QCAlgorithm):
    """
    Strategie Protective Put sur SPY.
    
    Acheter 100 actions + un put ATM pour se proteger.
    """
    
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 6, 30)
        self.SetCash(60000)
        
        self.equity = self.AddEquity("SPY", Resolution.Minute)
        self.spy = self.equity.Symbol
        
        self.option = self.AddOption("SPY", Resolution.Minute)
        self.option_symbol = self.option.Symbol
        
        # Filtre: puts ATM et OTM, expiration 30-60 jours
        self.option.SetFilter(
            minStrike=-5,  # 5 strikes sous ATM
            maxStrike=0,   # jusqu'a ATM
            minExpiry=timedelta(days=30),
            maxExpiry=timedelta(days=60)
        )
        
        self.current_put = None
        self.protection_cost = 0
        
        self.Log("Protective Put Strategy initialized")
    
    def OnData(self, slice):
        # Etape 1: Acheter 100 actions
        if not self.Portfolio[self.spy].Invested:
            self.MarketOrder(self.spy, 100)
            self.Log(f"Bought 100 SPY shares")
            return
        
        # Etape 2: Verifier si on a deja un put
        if self.current_put is not None:
            if self.Time >= self.current_put.ID.Date:
                self.Log(f"Put expired: {self.current_put}")
                self.current_put = None
            else:
                return
        
        # Etape 3: Acheter un put de protection
        if not slice.OptionChains.ContainsKey(self.option_symbol):
            return
        
        chain = slice.OptionChains[self.option_symbol]
        underlying_price = chain.Underlying.Price
        
        # Filtrer les puts
        puts = [c for c in chain if c.Right == OptionRight.Put]
        
        if not puts:
            return
        
        # Selectionner le put ATM (strike le plus proche du prix)
        atm_put = min(puts, key=lambda x: abs(x.Strike - underlying_price))
        
        # Acheter le put
        self.MarketOrder(atm_put.Symbol, 1)
        self.current_put = atm_put.Symbol
        
        # Cout de la protection
        cost = (atm_put.AskPrice) * 100
        self.protection_cost += cost
        
        self.Log(f"Bought Put: Strike={atm_put.Strike}, " +
                 f"Expiry={atm_put.Expiry.date()}, " +
                 f"Cost=${cost:.2f}")
        self.Log(f"Protected from losses below ${atm_put.Strike}")
    
    def OnEndOfAlgorithm(self):
        self.Log(f"\n=== Protective Put Summary ===")
        self.Log(f"Total Protection Cost: ${self.protection_cost:.2f}")
        self.Log(f"Final Portfolio Value: ${self.Portfolio.TotalPortfolioValue:.2f}")

Exercice 2 : Covered Call avec Gestion du Roll

Dans cet exercice, vous allez implementer la logique de decision pour un covered call : quand vendre, quand roller, et quand laisser expirer.

Objectif : Completer la fonction should_roll_call() qui decide si un covered call doit etre roule avant expiration.

Indices : - Indice : Rouler si le temps restant < seuil ET le call est encore OTM - Indice : Ne pas rouler si le call est ITM (risque d’assignation) - Étape 1 : Calculer les jours restants avant expiration - Étape 2 : Verifier si le strike est OTM par rapport au prix actuel - Étape 3 : Retourner la decision et la raison

# Exercice 2 : Covered Call avec gestion du roll
def should_roll_call(call_strike, call_expiry, current_price,
                    current_time, roll_threshold_days=7):
    """
    Determine si un covered call doit etre roule.
    
    Args:
        call_strike: Prix d’exercice du call vendu
        call_expiry: Date d’expiration du call
        current_price: Prix actuel du sous-jacent
        current_time: Date/heure actuelle
        roll_threshold_days: Jours avant expiration pour declencher
    
    Returns:
        dict: should_roll (bool), reason (str)
    """
    # TODO etudiant : Implementer la logique de decision
    return None  # Exercice a completer

Résultats backtest QC Cloud : ProtectivePutStrategy (2023 H1, $60k) — 13 ordres, Net Profit +8.1%, Sharpe 1.362, CAGR 17.0%, MaxDD 2.2%, Win Rate 33%. Excelle protection : MaxDD très faible (2.2%) grace au put de couverture. Sharpe eleve car volatilite reduite. Le cout du put limite le gain mais protege efficacement.

Backtest QC Cloud verifie 2023 H1 (projet 33409983, bt 7d2ef26535e035cad14467ea3ded7a64) : Sharpe 1.362 / CAGR 16.968% / MaxDD 2.200% / 124 dates / PSR 86.1% (ground-truth QC Cloud). Ordres (13), Net Profit +8.1% et Win Rate 33% : valeurs descriptives de l’auteur (totalOrders et totalNetProfit non exposes par le wrapper API).

5c. Vertical Spread (10 min)

Bull Call Spread

Un Bull Call Spread est une stratégie haussiere a risque et gain limites :

Acheter un call (strike bas, plus cher)
Vendre un call (strike plus haut, moins cher)

BULL CALL SPREAD = Long Call (K1) + Short Call (K2, K2 > K1)

Payoff:
           _________  <- Gain max = K2 - K1 - Premium net
          /
         /
--------/____________ <- Perte max = Premium net
       K1    K2

Bear Put Spread

Un Bear Put Spread est l’equivalent baissier :

Acheter un put (strike haut, plus cher)
Vendre un put (strike bas, moins cher)

Avantages des spreads

Avantage	Explication
Cout reduit	La vente finance partiellement l’achat
Risque limite	Perte max = premium net paye
Meilleur breakeven	Point mort plus proche du prix actuel

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Implementation d'un Bull Call Spread
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class BullCallSpreadStrategy(QCAlgorithm):
    """
    Strategie Bull Call Spread sur SPY.
    
    Acheter un call ATM + Vendre un call OTM.
    """
    
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 6, 30)
        self.SetCash(10000)
        
        self.option = self.AddOption("SPY", Resolution.Minute)
        self.option_symbol = self.option.Symbol
        
        self.option.SetFilter(-2, 5, timedelta(30), timedelta(45))
        
        self.spread_opened = False
        
        self.Log("Bull Call Spread Strategy initialized")
    
    def OnData(self, slice):
        if self.spread_opened:
            return
        
        if not slice.OptionChains.ContainsKey(self.option_symbol):
            return
        
        chain = slice.OptionChains[self.option_symbol]
        underlying_price = chain.Underlying.Price
        
        # Filtrer les calls
        calls = [c for c in chain if c.Right == OptionRight.Call]
        
        if len(calls) < 2:
            return
        
        # Trier par strike
        calls = sorted(calls, key=lambda x: x.Strike)
        
        # Trouver le call ATM (long leg)
        long_call = min(calls, key=lambda x: abs(x.Strike - underlying_price))
        
        # Trouver le call OTM (short leg) - environ 5$ au-dessus
        short_calls = [c for c in calls 
                       if c.Strike > long_call.Strike 
                       and c.Expiry == long_call.Expiry]
        
        if not short_calls:
            return
        
        # Prendre le premier call OTM
        short_call = short_calls[0]
        
        # Calculer les couts
        long_cost = long_call.AskPrice * 100
        short_credit = short_call.BidPrice * 100
        net_debit = long_cost - short_credit
        max_profit = (short_call.Strike - long_call.Strike) * 100 - net_debit
        
        self.Log(f"\n=== Bull Call Spread ===")
        self.Log(f"SPY @ ${underlying_price:.2f}")
        self.Log(f"Long Call: Strike={long_call.Strike}, Cost=${long_cost:.2f}")
        self.Log(f"Short Call: Strike={short_call.Strike}, Credit=${short_credit:.2f}")
        self.Log(f"Net Debit (Max Loss): ${net_debit:.2f}")
        self.Log(f"Max Profit: ${max_profit:.2f}")
        self.Log(f"Breakeven: ${long_call.Strike + net_debit/100:.2f}")
        
        # Executer le spread
        self.MarketOrder(long_call.Symbol, 1)   # Acheter 1 call
        self.MarketOrder(short_call.Symbol, -1) # Vendre 1 call
        
        self.spread_opened = True

Résultats backtest QC Cloud : BullCallSpreadStrategy (2023 H1, $10k) — 4 ordres, Net Profit +0.37%, Sharpe -3.2, CAGR 0.7%, MaxDD 0.7%, Win Rate 67%. Spread unique execute (Long Call ATM + Short Call OTM). Gain marginal, Sharpe negatif indique un rendement inferieur au risk-free.

Backtest QC Cloud verifie 2023 H1 (projet 33409983, bt d6128b1a11e2123562634da90711ec77) : Sharpe -3.2 / CAGR 0.748% / MaxDD 0.700% / 124 dates / PSR 29.6% (ground-truth QC Cloud). Ordres (4), Net Profit +0.37% et Win Rate 67% : valeurs descriptives de l’auteur (totalOrders et totalNetProfit non exposes par le wrapper API).

5d. Put-Call Parity et Conversion Arbitrage (15 min)

La parité put-call est la relation de non-arbitrage qui lie le prix d’un call, d’un put, de l’action et du zéro-coupon de même strike et maturité : C - P = S - K·e^(-rT). Quand elle est respectée, aucune combinaison de ces quatre instruments ne peut rapporter plus que le taux sans risque — c’est une identité, pas une stratégie. Mais les dévitions transitoires de cette relation (options légèrement mal pricées l’une par rapport à l’autre) créent un rendement excédentaire mesurable : c’est ce que chasse le conversion arbitrage.

Une conversion = long action + long put + short call, même strike K et même échéance. A l’échéance, quelle que soit la trajectoire de l’action, le package paie exactement K : le put et le call « convertissent » l’action en cash au strike. La conversion se comporte donc comme une obligation courte, et son rendement annualisé se calcule directement : (K / cout - 1) · 365/T où cout = S + P - C.

L’article QuantConnect « Conversion Arbitrage on the Magnificent 7 » (research 20937) systématise cette chasse : scanner les conversions disponibles sur les 7 grandes valeurs technologiques, retenir celles dont le rendement annualisé dépasse un seuil, swapper dynamiquement vers une meilleure conversion si elle apparaît, et parker le capital inactif dans l’ETF monétaire SHV. Résultat sur janvier 2023 - juin 2026 : 7.5 % de rendement annuel composé avec un max drawdown de 1.1 % et un beta de 0.017 — un profil quasi obligataire, exactement ce que la théorie prédit pour un payoff constant.

# Demonstration : la conversion paie K quel que soit S_T, et la parite fixe son rendement
# (pricer Black-Scholes ferme en numpy pur -- aucune dependance externe)

import numpy as np
import math

K = 100.0
S_T = np.linspace(60, 140, 200)
payoff_conv = S_T + np.maximum(K - S_T, 0.0) - np.maximum(S_T - K, 0.0)
print(f"Payoff conversion sur S_T in [60,140] : min {payoff_conv.min():.4f} / max {payoff_conv.max():.4f}")

def bs_price(S, K_, T, r, sigma, is_call):
    d1 = (np.log(S / K_) + (r + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
    d2 = d1 - sigma * np.sqrt(T)
    N = lambda x: 0.5 * (1.0 + np.vectorize(math.erf)(x / np.sqrt(2.0)))
    if is_call:
        return S * N(d1) - K_ * np.exp(-r * T) * N(d2)
    return K_ * np.exp(-r * T) * N(-d2) - S * N(-d1)

S0, r, T = 100.0, 0.04, 30 / 365

# Cas 1 : vols identiques -> parite exacte, la conversion ne rapporte que r
C = bs_price(S0, K, T, r, 0.20, True)
P = bs_price(S0, K, T, r, 0.20, False)
cout = S0 + P - C
ret_ann = (K / cout - 1) * 365 / 30
print(f"Parite (vol 20/20)  : cout {cout:.4f}  rendement annualise {ret_ann:.4%}  (r = {r:.2%})")

# Cas 2 : call sur-price (vol implicite 24%) -> deviation de parite exploitable
C2 = bs_price(S0, K, T, r, 0.24, True)
P2 = bs_price(S0, K, T, r, 0.20, False)
cout2 = S0 + P2 - C2
ret2 = (K / cout2 - 1) * 365 / 30
print(f"Deviation (call 24) : cout {cout2:.4f}  rendement annualise {ret2:.4%}")

seuil = 0.05  # seuil de l'article : rendement annualise minimum pour ouvrir
for nom, ret in [("parite", ret_ann), ("deviation", ret2)]:
    print(f"Conversion {nom:10s} vs seuil {seuil:.0%} : {'RETENUE' if ret >= seuil else 'rejetee'}")

Payoff conversion sur S_T in [60,140] : min 100.0000 / max 100.0000
Parite (vol 20/20)  : cout 99.6718  rendement annualise 4.0066%  (r = 4.00%)
Deviation (call 24) : cout 99.2159  rendement annualise 9.6155%
Conversion parite     vs seuil 5% : rejetee
Conversion deviation  vs seuil 5% : RETENUE

Lecture de la sortie. Première ligne : le payoff de la conversion est exactement constant à 100.0000 sur tout le domaine S_T — la théorie se vérifie numériquement, le package est une obligation déguisée. Cas 1 : quand les deux options sont pricées à la même volatilité (20 %), le coût de la conversion est 99.6718 et son rendement annualisé ressort à 4.0066 %, soit précisément le taux sans risque r = 4 % — la parité ne laisse rien sur la table. Cas 2 : il suffit que le call soit pricé à une vol implicite de 24 % contre 20 % pour le put (une déviation de 4 points de vol) pour que le coût tombe à 99.2159 et que le rendement annualisé grimpe à 9.6155 % — au-dessus du seuil de 5 % que fixe l’article, la conversion est « RETENUE ». C’est tout le métier de la stratégie : les déviations de parité sont petites et transitoires, mais annualisées sur des échéances courtes, elles deviennent des rendements comparables à ceux d’une obligation haute qualité.

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# ConversionArbitrageAlgorithm : scan des conversions Mag7 par rendement annualise
# (article research 20937) -- selection, swap dynamique, capital idle en SHV

from AlgorithmImports import *

class ConversionArbitrageAlgorithm(QCAlgorithm):
    def initialize(self):
        self.set_start_date(2023, 1, 1)
        self.set_cash(100000)
        self.mag7 = ["AAPL", "MSFT", "NVDA", "GOOGL", "AMZN", "META", "TSLA"]
        self.seuil_rendement = 0.05      # rendement annualise minimum pour ouvrir
        self.equity = {}
        for t in self.mag7:
            eq = self.add_equity(t, Resolution.MINUTE).symbol
            self.add_option(eq, Resolution.MINUTE)
            self.equity[t] = eq
        self.shv = self.add_equity("SHV", Resolution.MINUTE).symbol  # capital idle
        self.conversion_active = None

    def rendement_annualise(self, chain):
        # Meilleure conversion de la chaine : cout = S + P - C, payoff = K a l'echeance
        best = None
        for contract in chain:
            if contract.right != OptionRight.CALL:
                continue
            put = chain.get_contract(contract.strike, contract.expiry, OptionRight.PUT)
            if put is None:
                continue
            S = self.securities[contract.underlying_symbol].price
            cout = S + put.ask_price - contract.bid_price
            T = (contract.expiry - self.time).days / 365
            if T <= 0 or cout <= 0:
                continue
            ret = (contract.strike / cout - 1) / T
            if best is None or ret > best[0]:
                best = (ret, contract, put)
        return best

    def on_data(self, data):
        for t, eq in self.equity.items():
            chain = data.option_chains.get(eq)
            if chain is None:
                continue
            best = self.rendement_annualise(chain)
            if best is None:
                continue
            ret, call, put = best
            # Swap dynamique : fermer si une meilleure conversion depasse l'active
            if self.conversion_active and ret > self.conversion_active[0] + 0.005:
                self.liquidate()
                self.conversion_active = None
            if self.conversion_active is None and ret >= self.seuil_rendement:
                # Conversion : achat action + achat put + vente call
                self.market_order(eq, 100)
                self.market_order(put.symbol, 1)
                self.sell(call.symbol, 1)
                self.conversion_active = (ret, call, put)
        # Capital inutilise -> SHV (l'article garde 100% d'exposition brute)
        if self.conversion_active is None and not self.portfolio[self.shv].invested:
            self.set_holdings(self.shv, 1.0)

Les limites, et pourquoi ça marche quand même. Une conversion « pure » (rendement > r sans risque) ne devrait pas exister plus de quelques millisecondes : les market makers la ferment immédiatement. Ce que capte la stratégie, ce sont des quasi-conversions — des déviations assez petites pour survivre aux coûts de transaction, assez courtes pour se refermer vite. Trois risques réels, non visibles dans le payoff :

L’assignation anticipée du call vendu (options américaines) : traitée en détail à la section 7 ci-dessous — c’est LE risque opérationnel de la stratégie ;
Le risque de dividende : l’ex-dividende entre l’ouverture et l’échéance change la valeur des jambes et motive l’assignation juste avant détachement ;
Les coûts : quatre jambes d’exécution + le swap dynamique grignotent le rendement annualisé affiché par le scanner.

Le profil mesuré par l’article — max drawdown 1.1 %, beta 0.017 — confirme le caractère obligataire : la stratégie n’essaye pas de battre le marché directionnellement, elle collecte des écarts de parité annualisés. Sur le plan pédagogique, c’est l’illustration la plus pure de la section : quand une relation de non-arbitrage tient, elle ne rapporte que r ; c’est son imperfection passagère qui est monnayable.

6. Iron Condor (15 min)

Principe

L’Iron Condor est une stratégie neutre qui profite des marches lateraux (peu de mouvement). Elle combine un Bull Put Spread et un Bear Call Spread :

IRON CONDOR = Bull Put Spread + Bear Call Spread

Composition:
1. Sell Put (OTM, strike bas)      <- Genere du credit
2. Buy Put (plus OTM, strike+bas)  <- Limite le risque
3. Sell Call (OTM, strike haut)    <- Genere du credit
4. Buy Call (plus OTM, strike+haut) <- Limite le risque

Diagramme de payoff

Profit
   ^            ___________  <- Max profit = Credit total
   |           /           \
   |          /             \
---+---------/---------------\---------> Prix
   |        /                 \
   |       /                   \______  <- Max loss
   |      K1   K2       K3    K4
   
K1 = Long Put strike
K2 = Short Put strike  
K3 = Short Call strike
K4 = Long Call strike

Zone de profit: Prix reste entre K2 et K3

Caractéristiques

Caractéristique	Valeur
Max Profit	Credit net recu
Max Loss	(Largeur du spread - Credit)
Breakeven bas	K2 - Credit
Breakeven haut	K3 + Credit
Probabilite de profit	~60-70% (si strikes bien places)

Quand utiliser

Marche range-bound (sans tendance claire)
Volatilite implicite elevee (pour recevoir plus de premium)
Vous anticipez peu de mouvement jusqu’a expiration

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Implementation d'un Iron Condor
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class IronCondorStrategy(QCAlgorithm):
    """
    Strategie Iron Condor sur SPY.
    
    Strategie neutre pour marches lateraux.
    """
    
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetEndDate(2023, 6, 30)
        self.SetCash(20000)
        
        self.option = self.AddOption("SPY", Resolution.Minute)
        self.option_symbol = self.option.Symbol
        
        # Filtre large pour avoir assez de strikes
        self.option.SetFilter(-10, 10, timedelta(30), timedelta(45))
        
        self.condor_opened = False
        
        self.Log("Iron Condor Strategy initialized")
    
    def OnData(self, slice):
        if self.condor_opened:
            return
        
        if not slice.OptionChains.ContainsKey(self.option_symbol):
            return
        
        chain = slice.OptionChains[self.option_symbol]
        underlying_price = chain.Underlying.Price
        
        # Separer calls et puts
        calls = sorted([c for c in chain if c.Right == OptionRight.Call], 
                       key=lambda x: x.Strike)
        puts = sorted([c for c in chain if c.Right == OptionRight.Put], 
                      key=lambda x: x.Strike)
        
        if len(calls) < 4 or len(puts) < 4:
            return
        
        # Configuration: wings a 5% du prix, spreads de 5$
        put_wing_strike = underlying_price * 0.95
        call_wing_strike = underlying_price * 1.05
        
        # Trouver les contrats
        # Put side: Buy put (K1) + Sell put (K2, K2 > K1)
        short_put = min(puts, key=lambda x: abs(x.Strike - put_wing_strike))
        long_puts = [p for p in puts if p.Strike < short_put.Strike 
                     and p.Expiry == short_put.Expiry]
        
        # Call side: Sell call (K3) + Buy call (K4, K4 > K3)
        short_call = min(calls, key=lambda x: abs(x.Strike - call_wing_strike))
        long_calls = [c for c in calls if c.Strike > short_call.Strike 
                      and c.Expiry == short_call.Expiry]
        
        if not long_puts or not long_calls:
            return
        
        long_put = long_puts[-1]  # Le plus proche du short
        long_call = long_calls[0]  # Le plus proche du short
        
        # Calculer le credit et risque
        credit_put = (short_put.BidPrice - long_put.AskPrice) * 100
        credit_call = (short_call.BidPrice - long_call.AskPrice) * 100
        total_credit = credit_put + credit_call
        
        put_spread_width = (short_put.Strike - long_put.Strike) * 100
        call_spread_width = (long_call.Strike - short_call.Strike) * 100
        max_loss = max(put_spread_width, call_spread_width) - total_credit
        
        self.Log(f"\n=== Iron Condor ===")
        self.Log(f"SPY @ ${underlying_price:.2f}")
        self.Log(f"Expiry: {short_put.Expiry.date()}")
        self.Log(f"")
        self.Log(f"PUT SIDE (Bull Put Spread):")
        self.Log(f"  Long Put: K={long_put.Strike}")
        self.Log(f"  Short Put: K={short_put.Strike}")
        self.Log(f"  Credit: ${credit_put:.2f}")
        self.Log(f"")
        self.Log(f"CALL SIDE (Bear Call Spread):")
        self.Log(f"  Short Call: K={short_call.Strike}")
        self.Log(f"  Long Call: K={long_call.Strike}")
        self.Log(f"  Credit: ${credit_call:.2f}")
        self.Log(f"")
        self.Log(f"Total Credit (Max Profit): ${total_credit:.2f}")
        self.Log(f"Max Loss: ${max_loss:.2f}")
        self.Log(f"Profit Zone: ${short_put.Strike} - ${short_call.Strike}")
        
        # Executer l'Iron Condor (4 ordres)
        self.MarketOrder(long_put.Symbol, 1)     # Buy put
        self.MarketOrder(short_put.Symbol, -1)   # Sell put
        self.MarketOrder(short_call.Symbol, -1)  # Sell call
        self.MarketOrder(long_call.Symbol, 1)    # Buy call
        
        self.condor_opened = True

Résultats du backtest QC Cloud (IronCondorStrategy)

Metrique	Valeur
Dates negociables	62
Ordres executes	0
Sharpe Ratio	0
CAGR	0%
Max Drawdown	0%
Net Profit	0%
Equity finale	$20,000.00

Iron Condor exploration, Q1 2023 (no matching contracts)

Résultats backtest QC Cloud : IronCondorStrategy (2023 H1, $20k) — 0 ordres, Net Profit 0%. L’Iron Condor n’a pas execute de trades. Possible cause : filtre de liquidite trop strict ou aucun contrat avec les strikes/expiration cibles dans la range -10/+10 strikes.

7. Exemple guide et Assignment (10 min)

Options europeennes vs americaines

Type	Exercise	Utilisation
Americaine	A tout moment avant expiration	Actions US (SPY, AAPL, etc.)
Europeenne	Uniquement a l’expiration	Indices (SPX), certaines options

Note : Les options sur ETF comme SPY sont americaines, donc peuvent etre exercees/assignees a tout moment.

Exemple guide manuel

Pour exercer une option que vous detenez :

# Exercer un call (acheter 100 actions au strike)
self.ExerciseOption(call_symbol, 1)  # 1 contrat

# Exercer un put (vendre 100 actions au strike)
self.ExerciseOption(put_symbol, 1)

Assignment automatique

Si vous avez vendu une option :

Assignment possible : A tout moment (options americaines) si ITM
Assignment garanti : A l’expiration si ITM

Consequences : - Call assigne : Vous devez vendre 100 actions au strike - Put assigne : Vous devez acheter 100 actions au strike

Événement OnAssignmentOrderEvent

QuantConnect declenche cet événement lors d’un assignment :

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Gestion des assignments
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *

class AssignmentHandling(QCAlgorithm):
    """
    Exemple de gestion des assignments d'options.
    """
    
    def Initialize(self):
        self.SetStartDate(2023, 1, 1)
        self.SetCash(100000)
        
        self.equity = self.AddEquity("SPY", Resolution.Minute)
        self.option = self.AddOption("SPY", Resolution.Minute)
    
    def OnAssignmentOrderEvent(self, assignmentEvent):
        """
        Appele lorsqu'une option vendue est assignee.
        """
        self.Log(f"\n!!! ASSIGNMENT !!!")
        self.Log(f"Symbol: {assignmentEvent.Symbol}")
        self.Log(f"Quantity: {assignmentEvent.FillQuantity}")
        self.Log(f"Fill Price: ${assignmentEvent.FillPrice:.2f}")
        
        # Actions potentielles apres assignment:
        # 1. Laisser la position (si covered call, vous avez deja les actions)
        # 2. Racheter les actions (si call nu assigne)
        # 3. Vendre les actions recues (si put assigne)
    
    def OnOrderEvent(self, orderEvent):
        """
        Appele pour tout evenement d'ordre (fill, cancel, etc.)
        """
        if orderEvent.Status == OrderStatus.Filled:
            self.Debug(f"Order filled: {orderEvent.Symbol}, " +
                       f"Qty: {orderEvent.FillQuantity}, " +
                       f"Price: ${orderEvent.FillPrice:.2f}")

Résultats du backtest QC Cloud (AssignmentHandling)

Metrique	Valeur
Dates negociables	62
Ordres executes	0
Sharpe Ratio	0
CAGR	0%
Max Drawdown	0%
Net Profit	0%
Equity finale	$100,000.00

Assignment event handler demo, Q1 2023

Résultats backtest QC Cloud : AssignmentHandling (2023 Q1, $100k) — 0 ordres, Net Profit 0%. Demo de gestion des événements d’assignment (OnAssignmentOrderEvent, OnOrderEvent). Pas de logique de trading.

Early assignment - Quand se mefier

L’assignment anticipe (avant expiration) est plus probable dans ces cas :

Situation	Risque d’assignment
Call ITM proche du dividende	Eleve - L’acheteur veut le dividende
Put profondement ITM	Moyen - L’acheteur veut le cash
Proche de l’expiration	Eleve - Plus de valeur temporelle
Option sans valeur temporelle	Eleve - Pas de raison d’attendre

Conseil : Pour eviter l’assignment anticipe, fermez vos positions short quelques jours avant l’expiration si elles sont ITM.

Exercice 3 : Detection du Risque d’Assignation

Dans cet exercice, vous allez construire une fonction qui detecte le risque d’assignation prematuree d’une option vendue et propose une action protective.

Objectif : Implementer detect_assignment_risk() qui analyse la profondeur ITM et le theta residual.

Indices : - Indice : Une option est fortement ITM si abs(delta) > 0.80 - Indice : Le theta accelere la degradation temporelle dans les derniers jours - Étape 1 : Calculer le pourcentage ITM du contrat - Étape 2 : Verifier le temps restant jusqu’a expiration - Étape 3 : Retourner un score de risque entre 0 et 1

# Exercice 3 : Detection du risque d’assignation
def detect_assignment_risk(contract, underlying_price, current_time):
    """
    Detecte le risque d’assignation prematuree d’une option vendue.
    
    Args:
        contract: OptionContract avec Greeks
        underlying_price: Prix actuel du sous-jacent
        current_time: Datetime actuel
    
    Returns:
        dict: risque (0-1), action recommandee, raison
    """
    # TODO etudiant : Calculer le pourcentage ITM
    pass  # Exercice a completer

8. Stratégie Complete : Covered Call sur SPY (20 min)

Objectif

Implementer une stratégie Covered Call systématique qui :

Achete 100 actions SPY
Vend un call OTM mensuel (delta ~0.30)
Roll le call avant expiration (si non assigne)
Track le premium total collecte

Paramètres de la stratégie

Paramètre	Valeur	Justification
Delta cible	0.25-0.35	Balance entre premium et probabilite d’assignment
Expiration	30-45 jours	Bon decay theta, pas trop de risque gamma
Roll	7 jours avant expiry	Eviter le gamma risk de fin de mois
Capital	50,000$	Suffisant pour 100 SPY + marge

Critères de sélection du call

Type : Call
Strike : OTM (strike > prix actuel)
Delta : Entre 0.25 et 0.35
Expiration : 30-45 jours
Open Interest : > 100 (liquidite)

# [REFERENCE QC] Code a copier dans main.py QC Lab (non executable ici)
# Strategie Covered Call complete avec roll
# A copier dans l'IDE QuantConnect

from AlgorithmImports import *
from datetime import timedelta

class CoveredCallWithRoll(QCAlgorithm):
    """
    Strategie Covered Call systematique sur SPY avec roll automatique.
    
    Features:
    - Achat initial de 100 SPY
    - Vente de calls OTM (delta 0.30)
    - Roll 7 jours avant expiration
    - Tracking du premium collecte
    """
    
    def Initialize(self):
        # Configuration
        self.SetStartDate(2022, 1, 1)
        self.SetEndDate(2023, 12, 31)
        self.SetCash(55000)  # Suffisant pour 100 SPY
        
        # Ajouter l'equity
        self.equity = self.AddEquity("SPY", Resolution.Minute)
        self.spy = self.equity.Symbol
        
        # Ajouter les options
        self.option = self.AddOption("SPY", Resolution.Minute)
        self.option_symbol = self.option.Symbol
        
        # Filtre: calls OTM, 30-50 jours
        self.option.SetFilter(
            minStrike=0,
            maxStrike=15,
            minExpiry=timedelta(days=25),
            maxExpiry=timedelta(days=50)
        )
        
        # Parametres de la strategie
        self.target_delta = 0.30
        self.delta_tolerance = 0.05
        self.days_to_roll = 7  # Roll 7 jours avant expiration
        
        # Tracking
        self.current_call = None
        self.current_call_expiry = None
        self.total_premium = 0
        self.trades_count = 0
        
        # Scheduled function pour check quotidien
        self.Schedule.On(
            self.DateRules.EveryDay("SPY"),
            self.TimeRules.AfterMarketOpen("SPY", 30),
            self.ManageCoveredCall
        )
        
        self.Log("=== Covered Call Strategy Initialized ===")
        self.Log(f"Target Delta: {self.target_delta}")
        self.Log(f"Roll {self.days_to_roll} days before expiry")
    
    def ManageCoveredCall(self):
        """
        Fonction quotidienne pour gerer le covered call.
        """
        # Etape 1: Acheter 100 SPY si necessaire
        if not self.Portfolio[self.spy].Invested:
            quantity = 100
            self.MarketOrder(self.spy, quantity)
            self.Log(f"[INIT] Bought {quantity} SPY shares")
            return
        
        # Etape 2: Verifier si on doit roller
        if self.current_call_expiry is not None:
            days_to_expiry = (self.current_call_expiry - self.Time.date()).days
            
            if days_to_expiry <= self.days_to_roll:
                self.RollCall()
                return
        
        # Etape 3: Vendre un call si on n'en a pas
        if self.current_call is None:
            self.SellCall()
    
    def SellCall(self):
        """
        Vendre un call OTM avec le delta cible.
        """
        # Obtenir la chaine d'options
        chain = self.CurrentSlice.OptionChains.get(self.option_symbol)
        if chain is None:
            return
        
        underlying_price = chain.Underlying.Price
        
        # Filtrer les calls OTM
        calls = [c for c in chain 
                 if c.Right == OptionRight.Call
                 and c.Strike > underlying_price
                 and c.OpenInterest > 100]  # Liquidite
        
        if not calls:
            self.Debug("No suitable calls found")
            return
        
        # Selectionner par delta
        suitable_calls = [c for c in calls 
                          if abs(c.Greeks.Delta - self.target_delta) <= self.delta_tolerance]
        
        if not suitable_calls:
            # Si pas de call avec bon delta, prendre le plus proche
            selected = min(calls, key=lambda x: abs(x.Greeks.Delta - self.target_delta))
        else:
            # Prendre celui avec le meilleur premium parmi les candidats
            selected = max(suitable_calls, key=lambda x: x.BidPrice)
        
        # Vendre le call
        self.MarketOrder(selected.Symbol, -1)
        
        # Mettre a jour le tracking
        self.current_call = selected.Symbol
        self.current_call_expiry = selected.Expiry.date()
        
        premium = selected.BidPrice * 100
        self.total_premium += premium
        self.trades_count += 1
        
        self.Log(f"[SELL] Call Strike={selected.Strike}, " +
                 f"Expiry={selected.Expiry.date()}, " +
                 f"Delta={selected.Greeks.Delta:.3f}, " +
                 f"Premium=${premium:.2f}")
    
    def RollCall(self):
        """
        Fermer le call actuel et en vendre un nouveau.
        """
        self.Log(f"[ROLL] Rolling call before expiration")
        
        # Fermer le call actuel (acheter pour couvrir)
        if self.current_call is not None:
            self.MarketOrder(self.current_call, 1)  # Buy to close
            self.current_call = None
            self.current_call_expiry = None
        
        # Vendre un nouveau call
        self.SellCall()
    
    def OnAssignmentOrderEvent(self, assignmentEvent):
        """
        Gerer l'assignment du call.
        """
        self.Log(f"[ASSIGNMENT] Call assigned at {assignmentEvent.FillPrice}")
        self.Log(f"Actions vendues, rachat necessaire")
        
        # Reset le tracking
        self.current_call = None
        self.current_call_expiry = None
        
        # Note: A la prochaine iteration, on rachete 100 SPY
    
    def OnEndOfAlgorithm(self):
        """
        Resume de la performance.
        """
        initial_value = self.StartingCash
        final_value = self.Portfolio.TotalPortfolioValue
        total_return = (final_value - initial_value) / initial_value * 100
        
        self.Log(f"\n{'='*60}")
        self.Log(f"COVERED CALL STRATEGY - FINAL REPORT")
        self.Log(f"{'='*60}")
        self.Log(f"Period: {self.StartDate.date()} to {self.EndDate.date()}")
        self.Log(f"Initial Capital: ${initial_value:,.2f}")
        self.Log(f"Final Value: ${final_value:,.2f}")
        self.Log(f"Total Return: {total_return:.2f}%")
        self.Log(f"")
        self.Log(f"PREMIUM COLLECTION:")
        self.Log(f"  Total Premium Collected: ${self.total_premium:,.2f}")
        self.Log(f"  Number of Trades: {self.trades_count}")
        if self.trades_count > 0:
            self.Log(f"  Average Premium/Trade: ${self.total_premium/self.trades_count:.2f}")
        self.Log(f"{'='*60}")

Résultats Backtest QC Cloud - Backtest QC Cloud 2022-2023 (projet 33177683, bt d0e9475dfa3f3424b926e2a5d88e98b6)

Metrique	Valeur
Status	Runtime Error (OnEndOfAlgorithm)
Sharpe Ratio	-0.414
CAGR	-1.934%
Max Drawdown	19.600%
PSR	3.361%
Jours boursiers	501
Backtest ID	d0e9475dfa3f3424b926e2a5d88e98b6

CoveredCallWithRoll — verbatim re-exec 2022-2023 (501 jours boursiers). Verdict #3801 : RECOVERABLE-LOCAL. La stratégie a tourne sur toute la periode (2 ans) puis Runtime-Errored a la toute fin dans OnEndOfAlgorithm : self.StartingCash n’existe pas en API QC Python (bug de reporting, pas de trading). Les metriques ci-dessus (calculees sur la courbe d’equity des 501 jours) sont REELLES : la stratégie PERD de l’argent (Sharpe -0.414, CAGR -1.934%) - l’inverse de la caption fabriquee d’origine (Sharpe 0.493 / +2.69% sur pretendu Q1 2023 / 62 dates). Le bug StartingCash = fix local trivial (tracker le cash initial en variable membre, ou self.Portfolio.CashBook.TotalAmountInAccountCurrency), follow-up RECOVERABLE-LOCAL.

Backtest QC Cloud 2022-01-01 -> 2023-12-31 (projet 33177683, bt d0e9475dfa3f3424b926e2a5d88e98b6) - 501 jours boursiers, Capital initial: $55,000

Résultats backtest QC Cloud : CoveredCallWithRoll (2022-2023, $55k) — 48 ordres, Net Profit -3.8%, Sharpe -0.414, CAGR -1.9%, MaxDD 19.6%, Win Rate 61%. Runtime Error en fin de periode. Covered call systématique avec roll automatique 7j avant expiration. Premium collecte insuffisant pour compenser la baisse du sous-jacent.

Points cles de l’implementation

Schedule.On : Exécution quotidienne de ManageCoveredCall 30 minutes après l’ouverture du marche
Sélection du call :
- Filtre par delta (0.25-0.35)
- Verifie la liquidite (Open Interest > 100)
- Prend le meilleur premium parmi les candidats
Roll automatique :
- Ferme la position 7 jours avant expiration
- Evite le risque gamma eleve de fin de mois
- Ouvre immediatement une nouvelle position
Gestion de l’assignment :
- Log l’événement
- Reset le tracking
- Rachete 100 SPY a la prochaine itération

Metriques a analyser

Metrique	Description	Valeur cible
Total Premium	Somme des premiums collectes	> 5% du capital/an
Win Rate	% des trades expires worthless	> 70%
Sharpe Ratio	Rendement ajuste au risque	> 1.0
Max Drawdown	Perte maximale	< 20%

Conclusion

Recapitulatif

Dans ce notebook, nous avons couvert :

1. Fondamentaux des Options

Call : Droit d’acheter
Put : Droit de vendre
ITM/ATM/OTM : Relation strike/prix

2. Configuration dans QuantConnect

AddOption("SPY", Resolution.Minute)
SetFilter(-5, 5, timedelta(30), timedelta(60))

4. Greeks

Delta : Sensibilite au prix
Theta : Decay temporel
Vega : Sensibilite a la volatilite

5. Stratégies

Stratégie	Objectif	Complexite
Covered Call	Revenu	Simple
Protective Put	Protection	Simple
Bull Call Spread	Hausse limitee	Moyen
Iron Condor	Marche lateral	Avance

Points importants a retenir

Resolution.Minute obligatoire pour les options
1 contrat = 100 actions - Attention au sizing
Toujours verifier la liquidite (Open Interest, Bid-Ask spread)
Greeks pour le risk management - Surtout Delta et Theta
Assignment possible a tout moment pour options americaines

Prochaines étapes

Pour approfondir :

Tester les stratégies sur QuantConnect avec différents paramètres
Analyser les résultats : Sharpe, Drawdown, Win Rate
Explorer les stratégies avancees : Butterfly, Calendar Spread, Straddle
Combiner avec analyse technique : RSI, MACD pour timing d’entree

Ressources supplementaires

Documentation QuantConnect : - Options Trading Documentation - Greeks Reference

Livres recommandes : - Options, Futures, and Other Derivatives - John C. Hull - The Options Playbook - Brian Overby

Felicitations ! Vous maitrisez maintenant les bases du trading d’options sur QuantConnect. Les options offrent une flexibilite enorme pour la gestion de portefeuille, la generation de revenus, et la speculation. Utilisez ces connaissances avec prudence et commencez toujours par des positions petites.

Prochain notebook : QC-Py-07 - Futures et Commodities

References academiques

Black, F. & Scholes, M. (1973). The Pricing of Options and Corporate Liabilities. Journal of Political Economy 81(3):637-654. DOI 10.1086/260062.
Merton, R.C. (1973). Theory of Rational Option Pricing. Bell Journal of Economics and Management Science 4(1):141-183.

Retour au sommet

QC-Py-06 : Options Trading dans QuantConnect

Plan du notebook

1. Introduction aux Options (10 min)

Qu’est-ce qu’une option ?

Les deux types d’options

Terminologie essentielle

ITM / ATM / OTM

Pourquoi trader des options ?

Diagramme des payoffs

2. Ajouter des Options dans QuantConnect (15 min)

Méthode de base : AddOption()

Configuration du filtre avec SetFilter()

Filtres avances

3. Options Chain : Navigation et Sélection (20 min)

Structure de l’OptionChain

Proprietes d’un OptionContract

Sélection de contrats par critères

Bonnes pratiques de sélection

4. Les Greeks (15 min)

Introduction aux Greeks

Les 5 Greeks principaux

Delta en detail

Theta - Le temps joue contre l’acheteur

Utilisation des Greeks pour le Risk Management

5. Stratégies de Base (30 min)

Vue d’ensemble des stratégies

5a. Covered Call (10 min)

Principe

Avantages et inconvenients

Quand utiliser

Exercice 1 : Sélection de Contrats par Greeks

5b. Protective Put (10 min)

Principe

Analogie avec l’assurance

Exercice 2 : Covered Call avec Gestion du Roll

5c. Vertical Spread (10 min)

Bull Call Spread

Bear Put Spread

Avantages des spreads

5d. Put-Call Parity et Conversion Arbitrage (15 min)

6. Iron Condor (15 min)

Principe

Diagramme de payoff

Caractéristiques

Quand utiliser

7. Exemple guide et Assignment (10 min)

Options europeennes vs americaines

Exemple guide manuel

Assignment automatique

Événement OnAssignmentOrderEvent

Early assignment - Quand se mefier

Exercice 3 : Detection du Risque d’Assignation

8. Stratégie Complete : Covered Call sur SPY (20 min)

Objectif

Paramètres de la stratégie

Critères de sélection du call

Points cles de l’implementation

Metriques a analyser

Conclusion

Recapitulatif

1. Fondamentaux des Options

2. Configuration dans QuantConnect

3. Navigation dans l’OptionChain

4. Greeks

5. Stratégies

Points importants a retenir

Prochaines étapes

Ressources supplementaires

References academiques