Notre émulateur appliquait la marge au fill sur l’open de la barre suivante ; TradingView au signal sur le close courant. Un écart de 3 cents entre ces deux prix a suffi pour qu’un ordre dimensionné sur la totalité de l’equity soit rejeté. Comment six sondes d’isolation ont permis de remonter de la dérive de PnL d’une stratégie communautaire jusqu’à ce contrôle de marge.
Les chiffres de cet article ont été mesurés le 9 mai 2026 et sont conservés tels quels. Pour les résultats actuels, consultez notre protocole de mesure de la parité.
Une stratégie Pine communautaire de notre corpus de parité, baptisée IES, était la seule au niveau de parité moderate face à TradingView une fois toutes les stratégies notées selon des seuils stricts. Les nombres de trades concordaient. Les prix d’entrée concordaient au centime près. Les prix de sortie aussi. Mais en avril 2026, l’écart de PnL cumulé atteignait environ 29 000 $.
Voici comment nous en avons trouvé la cause : un seul contrôle de marge, exécuté une barre trop tard.
L’empreinte asymétrique
Voici ce que verify_corpus.py remontait sur cette stratégie avant que nous commencions à creuser :
community/IES (pre-fix)
Profile: strict
TV trades: 2668 (raw 2668)
Engine trades: 2663 (raw 2663)
Matched: 2632 (98.7% of TV)
Count delta: 0.1874% (OK)
Entry-price p90 delta: 0.0000% (OK)
Exit-price p90 delta: 0.0000% (OK)
PnL p90 delta: 2.5412% (X)
-> moderate
Cette ligne est un diagnostic à elle seule. Quand le nombre de trades, le prix d’entrée et le prix de sortie concordent mais que le PnL par trade dérive de 2,5 %, vous n’avez affaire ni à un bug de logique de signal ni à un bug de prix d’exécution. Les deux moteurs prennent les mêmes trades aux mêmes prix. Ils les dimensionnent différemment.
Vers la fin de la fenêtre de comparaison, sur chaque trade apparié, la quantité côté moteur valait environ 97,3 % de celle de TradingView, soit le rapport d’equity entre les deux comptes. La divergence se logeait dans strategy.equity, la variable de rétroaction récursive dont dépend toute formule de dimensionnement des positions, et non dans l’arithmétique d’un trade en particulier.
Ce que nous avons essayé d’abord (et pourquoi rien n’a marché)
Avant de tenir la bonne hypothèse, nous en avons épuisé trois mauvaises. Elles valent d’être racontées, parce qu’elles montrent à quoi ressemble vraiment le débogage : l’essentiel du travail consiste à éliminer des hypothèses, pas à les confirmer.
Divergence de préchauffage des indicateurs. Le moteur préchauffe sa pile d’analyse technique avec cinq mois d’OHLCV avant l’ouverture de la fenêtre de comparaison ; l’historique du graphique TradingView ne remonte pas forcément aussi loin. Nous avons construit un harnais de traçage de l’analyse technique barre par barre et, au passage, trouvé neuf vrais bugs d’indicateurs : sémantique de ta.pivothigh / ta.pivotlow, formule de ta.iii, codegen et mise à l’échelle de ta.tsi, pondération de ta.cog, pourcentage de ta.bbw, ancrage journalier de ta.vwap, valeur de la ligne de ta.supertrend, HLC de la barre précédente pour ta.pivot_point_levels, et sémantique de ta.cross qui ignore les égalités. Nous avons corrigé les neuf. Aucun n’a fait sortir IES du niveau moderate.
Timing d’exécution des stops et des limites. Une autre stratégie communautaire (scalping-wunder-bots) montrait un motif net : le moteur sortait une barre plus tôt que TradingView. Notre hypothèse : le moteur évaluait les stops de strategy.exit dès la barre d’entrée, alors que TV attendait la barre suivante. Nous avons construit parity-probe-01-stop-limit-timing pour isoler exactement ce cas. Résultat : 778 trades appariés sur 778, les quatre seuils stricts au vert. Hypothèse réfutée.
Suivi des swings CHoCH / BOS. Une autre stratégie (VCP) présentait une entrée parasite le 2025-05-12 à 12:15, que nous soupçonnions de venir d’une évolution divergente de l’état des pivots. Nous avons construit parity-probe-02-choch-bos-isolator, qui reproduit exactement sa signature de pivots. 1026 appariés sur 1026. Encore réfutée.
Trois hypothèses plus tard, aucune amélioration sur IES, mais un acquis de méthode : écrire des stratégies Pine minimales qui isolent une hypothèse à la fois allait beaucoup plus vite que tracer des variables internes dans un script communautaire de 700 lignes. Nous avons donc écrit une troisième sonde.
La sonde qui a trouvé le bug
L’astuce de parity-probe-03-equity-mirror, c’est que la quantité de l’ordre encode elle-même strategy.equity :
//@version=6
strategy("Parity probe 03 - equity mirror",
shorttitle="par_p03", overlay=true, initial_capital=1000000,
default_qty_type=strategy.fixed, default_qty_value=1,
pyramiding=0, process_orders_on_close=false,
commission_value=0, slippage=0)
bool fire = dayofweek == 2 and hour == 0 and minute == 0
and strategy.position_size == 0
float qty_dyn = math.round(strategy.equity / close * 1000) / 1000
if fire and qty_dyn > 0
strategy.entry("E", strategy.long, qty=qty_dyn)
if strategy.position_size > 0 and bar_index >
strategy.opentrades.entry_bar_index(0)
strategy.close("E")
Avec qty = round(strategy.equity / close * 1000) / 1000, arrondi à trois décimales, la colonne Size (qty) du CSV « List of Trades » exporté par TradingView devient un oracle, barre par barre, de la valeur de strategy.equity côté TV. Appariez les trades du moteur et de TV par horodatage d’entrée, alignez les colonnes de quantité, et vous lisez la divergence d’equity directement dans le diff.
Les huit premiers trades appariés :
2025-03-31 00:15 eng_qty=553.1490 tv_qty=553.1490 diff=+0.000%
2025-04-14 00:15 eng_qty=612.9970 tv_qty=612.1600 diff=+0.137%
2025-04-21 00:15 eng_qty=623.1630 tv_qty=622.3110 diff=+0.137%
2025-08-25 00:15 eng_qty=207.2020 tv_qty=209.8110 diff=-1.244%
2025-11-03 00:15 eng_qty=242.4760 tv_qty=251.9860 diff=-3.774%
2025-11-24 00:15 eng_qty=339.1820 tv_qty=361.0170 diff=-6.048%
2025-12-22 00:15 eng_qty=307.0180 tv_qty=330.5680 diff=-7.124%
2026-01-05 00:15 eng_qty=295.2650 tv_qty=320.1020 diff=-7.759%
Le trade 1 concordait parfaitement. Les deux côtés partaient de 1 M$ d’equity. À partir du trade 2, les colonnes de quantité se sont écartées et ne se sont jamais rejointes. L’écart s’est stabilisé autour de 7,76 % au trade 8.
La cause n’était pas une dérive de calcul. C’était un trade manqué. L’entrée qui aurait dû être le trade 2, le 2025-04-07, figurait dans la liste de trades de TV mais pas dans celle du moteur. TV a pris le trade et encaissé une perte de 1 345 $, son equity tombant à environ 984 k$. Le moteur n’a jamais pris ce trade : son equity est restée autour de 985 k$. Sur les deux trades suivants, les positions du moteur étaient 0,137 % plus grosses que celles de TV ; ensuite, les deux côtés n’ont plus accepté ni rejeté les mêmes lundis, les pertes cumulées ont divergé sur des trajectoires d’equity différentes, et l’écart ne s’est jamais refermé.
Une exécution fantôme
Nous avons ajouté des logs std::cerr dans strategy_entry, process_pending_orders, enter_market_from_flat et apply_market_order_fill, tous conditionnés à une variable d’environnement pour que le bruit ne déborde pas sur les autres exécutions de tests.
Sur la barre de signal, le 2025-04-07 à 00:00 :
[entry CALL] ts=1743984000000 bar=16236 id=E is_long=1 qty=627.312
pending_orders.size=0 pos_qty=0 pos_side=0
strategy.entry a bien été appelé. L’ordre a été mis en file. Jusque-là, rien d’anormal.
Sur la barre d’exécution, le 2025-04-07 à 00:15 :
[ppo] ts=1743984900000 bar=16237 pass=0 i=0 id=E type=0 is_long=1
qty=627.312 eligib=FILL_TRY
-> fill.kind=0 fill_price=1566.69
-> AFTER apply: pos_qty=0 pos_side=0 pyramid.size=0 trades.size=14
fill.kind=0 correspond à FillEvaluation::Kind::Fill. L’évaluateur de prix a dit d’exécuter. apply_filled_order_to_state a été appelé. Et l’état de la position n’a pas bougé. Une exécution fantôme.
Une ligne de débogage de plus, cette fois dans enter_market_from_flat, pour afficher les entrées du garde-fou de marge :
[margin] ts=1743984900000 qty=627.312 fill_px=1566.69 margin_pct=100
required=982803 available_equity=982785 net_profit_sum=-17215.4
initial=1e+06 block=YES
Marge requise : 982 803 $. Equity disponible : 982 785 $. Le garde-fou de marge exigeait environ 19 $ de plus que ce dont disposait le compte ; il est sorti prématurément sans mettre à jour le moindre état, sans erreur et sans aucune ligne de log visible. Du point de vue de la stratégie, le trade n’avait tout simplement jamais existé. (Cette exécution de débogage ouvrait des trades dès le début des données de préchauffage : son equity et sa quantité diffèrent donc légèrement de celles de l’exécution de comparaison ci-dessous.)
Pourquoi TradingView a pris ce même trade
Voici l’OHLC des deux barres concernées :
04-07 00:00 (signal): O=1579.98 H=1585.57 L=1566.00 C=1566.66
04-07 00:15 (fill): O=1566.69
La sonde a dimensionné l’ordre sur la clôture de la barre de signal : qty = round(985319.43 / 1566.66 * 1000) / 1000 = 628.93. La marge requise calculée sur cette clôture ne dépasse l’equity disponible que de quatre centimes. Calculée sur l’ouverture de la barre suivante, elle la dépasse de 18,91 $.
| Prix utilisé | Marge requise | Equity | Dépassement |
|---|---|---|---|
| Clôture du signal (1566,66 $) | 985 319,47 $ | 985 319,43 $ | +0,04 $ |
| Ouverture d’exécution (1566,69 $) | 985 338,34 $ | 985 319,43 $ | +18,91 $ |
Un mouvement de trois centimes sur l’ETH, multiplié par 628,93 contrats, a ajouté 18,87 $ de marge requise, soit un dépassement total de 18,91 $. Le contrôle de marge du moteur avait lieu au moment de l’exécution, sur le prix d’exécution, et rejetait l’ordre. L’émulateur de courtier de TradingView, pensions-nous désormais, faisait le même contrôle au moment du signal, sur la clôture de la barre de signal, et acceptait l’ordre : quatre centimes sur une position de 985 k$ restent sous la tolérance de virgule flottante, quelle qu’elle soit, que TV applique à la limite.
Trianguler avec trois sondes de plus
Pour prouver qu’il ne s’agissait pas d’une coïncidence sur un seul trade, et que le bug tenait précisément à la limite de 1× l’equity, nous avons construit trois sondes de plus qui l’encadrent :
| Sonde | Dimensionnement | Pression sur la marge |
|---|---|---|
parity-probe-04-percent-of-equity-sizing | default_qty_type=percent_of_equity, default_qty_value=99 | ~99 % de l’equity |
parity-probe-05-small-equity-fraction | qty = round(equity / close * 100) / 1000 | ~10 % de l’equity |
parity-probe-06-edge-margin-sizing | qty = round(equity * 0.5 / close * 1000) / 1000 | ~50 % de l’equity |
Pour les trois sondes, nous avons comparé la liste de trades du moteur à la liste de trades de TradingView (Strategy Tester › List of trades) :
parity-probe-04: TV=57 engine=57 matched=57/57 (100.0%) PnL p90=0.0006% → excellent
parity-probe-05: TV=57 engine=57 matched=57/57 (100.0%) PnL p90=0.0698% → excellent
parity-probe-06: TV=57 engine=57 matched=57/57 (100.0%) PnL p90=0.0700% → excellent
Quand le dimensionnement n’était pas collé à la limite de marge de 1×, le moteur et TV concordaient parfaitement sur les 57 trades de chaque sonde. Le bug ne se manifestait qu’à la limite, là où l’écart entre la clôture du signal et l’ouverture d’exécution pouvait inverser l’issue du contrôle de marge.
Le correctif
Déplacer le contrôle de marge de enter_market_from_flat (appelé au moment de l’exécution, avec le prix d’exécution) vers strategy_entry (appelé au moment du signal, avec la clôture de la barre courante) :
void BacktestEngine::strategy_entry(const std::string& id, bool is_long,
double limit_price, double stop_price,
double qty, ...) {
if (!trading_is_active(...)) return;
+
+ // TradingView broker rule: market-entry orders are admitted only
+ // when qty * <signal-bar close> * margin_pct/100 <= equity. Check
+ // happens HERE at signal time with current_bar_.close, NOT later
+ // in apply_market_order_fill where fill_price is the next bar's
+ // open. Verified empirically by parity-probe-{03..06}.
+ if (!std::isnan(qty) && std::isnan(limit_price) && std::isnan(stop_price)) {
+ double margin_pct = is_long ? margin_long_ : margin_short_;
+ if (margin_pct > 0.0 && !std::isnan(current_bar_.close)) {
+ double required = std::abs(qty) * current_bar_.close * (margin_pct / 100.0);
+ double available = current_equity();
+ double epsilon = std::max(1e-9, std::abs(available) * 1e-12);
+ if (required > available + epsilon) {
+ return;
+ }
+ }
+ }
...
Une douzaine de lignes dans strategy_entry (le commit comporte un commentaire plus long), plus la suppression des huit lignes correspondantes dans enter_market_from_flat. Nouvelle exécution sur IES :
community/IES (post-fix)
TV trades: 2668 (raw 2668)
Engine trades: 2643 (raw 2643)
Matched: 2618 (98.1% of TV)
Count delta: 0.9370% (OK)
Entry-price p90 delta: 0.0000% (OK)
Exit-price p90 delta: 0.0000% (OK)
PnL p90 delta: 0.7809% (OK) ← was 2.5412%
-> excellent
La dérive du PnL est passée de 2,54 % à 0,78 %. IES est passée de moderate à excellent. Sur le reste du corpus de l’époque : 165 stratégies sur 168 en excellent, 2 en strong, 0 en moderate, et la sonde 03 en weak (voir plus bas). Les 16 binaires ctest passaient, les 313 cas pytest du codegen aussi, et aucune régression n’est apparue sur les 161 autres stratégies.
Le rebondissement
Après le correctif, parity-probe-03-equity-mirror elle-même ne concordait toujours pas entièrement avec TV. Le moteur a pris 25 entrées, TV 24, et seules 13 étaient communes. La sonde 03 est conçue pour vivre exactement sur la limite de 1× l’equity : tout désaccord de tolérance entre les deux implémentations s’y manifeste avant de se voir ailleurs.
Pour chacun des 57 lundis de la fenêtre de comparaison, nous avons calculé qty * signal_close - equity et relevé la décision de TV, acceptation ou rejet. En voici huit :
| Lundi | Dépassement à la clôture du signal | Décision de TV |
|---|---|---|
| 2025-04-07 | +0,04 $ | PRIS |
| 2025-04-14 | -0,76 $ | PRIS |
| 2025-04-21 | -0,19 $ | PRIS |
| 2025-04-28 | +0,34 $ | REJETÉ |
| 2025-05-12 | -0,18 $ | REJETÉ (pourtant sous l’equity) |
| 2025-05-26 | -0,89 $ | REJETÉ (pourtant sous l’equity) |
| 2025-08-18 | +0,24 $ | REJETÉ |
| 2025-11-10 | +0,24 $ | PRIS (dépassement identique, issue inverse) |
Le 18 août et le 10 novembre présentent le même dépassement de +0,24 $ et aboutissent à des décisions opposées. Aucune règle de contrôle de marge pure, quels que soient le seuil ou la tolérance, ne peut produire ce motif. À cette limite, l’émulateur de courtier de TV dépend de quelque chose qu’aucune variable Pine documentée ne laisse voir : l’historique de chargement du graphique, l’ordre dans lequel les barres sont devenues visibles pour la stratégie au moment où l’utilisateur l’a publiée, ou un état interne caché que nous n’avons aucun moyen d’observer.
La lecture honnête : il s’agit d’un recoin non documenté de l’émulateur de courtier de TradingView, qui ne se manifeste que lorsque le dimensionnement est calé exactement sur la limite de 1× l’equity. Les stratégies réelles se trouvent rarement pile sur cette limite. La stratégie community/IES est celle qui s’en approche le plus : elle dimensionne chaque trade à partir d’un petit budget de risque et de la distance de son stop, si bien que certains de ses ordres mobilisent la quasi-totalité de l’equity du compte, et elle a pourtant atteint excellent après le correctif. Nous ne nous attendons pas à ce que ce recoin pèse beaucoup en usage réel. Nous avons choisi de garder le correctif et de documenter la sonde 03 comme limitation connue. La perte de niveau, purement cosmétique, de la sonde de diagnostic est un prix raisonnable pour le gain sur IES.
Six leçons de cette histoire de débogage
1. Les empreintes asymétriques des métriques révèlent la classe du bug. Quand le nombre de trades, le prix d’entrée et le prix de sortie concordent mais que le PnL dérive, vous avez affaire à un bug de dimensionnement. Nous aurions dû regarder le code de dimensionnement avant d’auditer les formules d’indicateurs.
2. Les sondes d’isolation passent mieux à l’échelle que le traçage de grosses stratégies. Six petites sondes Pine, testant chacune une hypothèse, ont trouvé le bug. Tracer chaque variable interne d’un script communautaire de 700 lignes, avec son calcul d’equity en rétroaction, aurait pris plus longtemps et produit plus de bruit. C’est la même raison pour laquelle on écrit des tests unitaires au lieu de déboguer uniquement au niveau de l’intégration.
3. Le paramètre qty= de TradingView applique la marge au moment du signal. Le contrôle utilise la barre où strategy.entry est appelé, pas la barre d’exécution. Ce n’est pas documenté dans la référence Pine. Quiconque implémente un émulateur de courtier compatible Pine devrait s’y conformer ; l’implémentation naturelle place le contrôle au moment de l’exécution (quand le prix d’exécution est connu) et casse sans bruit.
4. La virgule flottante aux limites est toujours l’ennemi. L’unique trade qui a fait bifurquer les deux trajectoires d’equity de la sonde 03 tenait à un dépassement de quatre centimes sur une position de 985 k$. Les stratégies de production devraient garder une marge de sécurité de 1 à 5 % (un * 0.99 ou un * 0.95 dans la formule de dimensionnement) pour ne jamais vivre sur la limite.
5. La composition amplifie un trade manqué. Dans la sonde 03, le trade manqué du 04-07 représentait à lui seul 1 345 $ ; au trade 8, les tailles de position des deux côtés différaient de 7,76 % et l’écart s’est maintenu, parce que chaque trade manqué déplaçait la trajectoire d’equity, ce qui changeait le dimensionnement suivant, qui changeait à son tour la décision d’acceptation ou de rejet suivante. Sur IES, la même règle, sur 13 mois de trades, a fini par creuser un écart d’environ 29 000 $. Les stratégies à rétroaction d’equity ne pardonnent pas les ratés d’exécution isolés.
6. Parfois, le bug est de l’autre côté, et on le documente honnêtement. Le comportement de TV à la limite de 1× est un vrai recoin que nous ne pouvons pas corriger de notre côté. Le documenter franchement vaut mieux que courir en silence après une métrique impossible à atteindre.
La méthode vaut au-delà de ce bug précis. Les sondes de parité complètent notre campagne de validation croisée avec PyneCore : PyneCore nous dit quand notre moteur diffère d’un autre moteur ; les sondes de parité nous disent pourquoi il diffère de TradingView. Quand nous trouvons un nouvel écart, la marche à suivre est désormais : écrire le plus petit script Pine qui le reproduit, comparer les listes de trades, instrumenter le moteur, corriger le désaccord, et documenter tout recoin de TV qui ne peut pas être réconcilié.
Pour aller plus loin
- Transpiler et backtester depuis Claude ou Cursor : l’outil
transpile_pinedu serveur MCP local renvoie le C++ que PineForge génère à partir de votre code Pine ; le contrôle de marge lui-même s’exécute dans le runtime du moteur, pas dans ce code généré. - Parcourir la galerie : les 312 stratégies actuelles du corpus ouvert, chacune comparée trade par trade avec TradingView.
- Comment nous mesurons la parité : les résultats actuels et leurs sources.