Saltar al contenido

Margen en la señal vs en el fill: una historia de paridad con TradingView

11 min de lectura

Nuestro emulador aplicaba el chequeo de margen en el fill con el open de la siguiente barra; TradingView lo hace en la señal con el cierre actual. Una diferencia de 3 centavos entre ambos precios bastó para rechazar una orden dimensionada con todo el equity. Cómo seis sondas de aislamiento rastrearon la deriva de PnL de una estrategia de la comunidad hasta ese chequeo de margen.

Las cifras de este artículo se midieron el 9 de mayo de 2026 y se mantienen tal cual. Para ver los resultados actuales, consulta cómo medimos la paridad.

Una estrategia Pine de la comunidad de nuestro corpus de paridad, llamada IES, era la única en paridad moderate frente a TradingView una vez que evaluamos todas las estrategias con umbrales estrictos. Los recuentos coincidían. Los precios de entrada coincidían al centavo. Los de salida, también. Pero en abril de 2026 el PnL acumulado de los dos lados ya se había separado en unos $29.000.

Esta es la historia de cómo encontramos la causa: una única comprobación de margen que llegaba una barra tarde.

La huella asimétrica

Esto es lo que informaba verify_corpus.py sobre la estrategia antes de que empezáramos a investigar:

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

Esa fila ya es un diagnóstico por sí sola. Cuando el recuento, el precio de entrada y el precio de salida coinciden pero el PnL por operación se desvía un 2,5 %, no estás ante un bug de lógica de señales ni de precio de fill. Los dos motores eligen las mismas operaciones a los mismos precios. Lo que cambia es el tamaño que les dan.

Hacia el final de la ventana de comparación, la qty del motor en cada operación emparejada rondaba el 97,3 % de la de TradingView, la misma proporción que había entre el equity de las dos cuentas. La divergencia estaba en strategy.equity, la variable de realimentación recursiva de la que depende cualquier fórmula de dimensionamiento de la posición, y no en la aritmética de cada operación.

Lo que probamos primero (y por qué nada funcionó)

Antes de dar con la hipótesis correcta, quemamos tres equivocadas. Vale la pena contarlas porque reflejan cómo es de verdad depurar: la mayor parte del trabajo consiste en descartar hipótesis, no en confirmarlas.

Divergencia en el calentamiento de los indicadores. El motor calienta su pila de indicadores técnicos con cinco meses de OHLCV antes de que se abra la ventana de comparación; puede que el historial del gráfico de TradingView no llegue tan atrás. Construimos una herramienta para trazar los indicadores barra a barra y, por el camino, encontramos nueve bugs reales en indicadores: la semántica de ta.pivothigh / ta.pivotlow, la fórmula de ta.iii, el codegen y el escalado de ta.tsi, la ponderación de ta.cog, el porcentaje de ta.bbw, el anclaje diario de ta.vwap, el valor de la línea de ta.supertrend, el HLC de la barra anterior en ta.pivot_point_levels y la semántica de omisión de empates de ta.cross. Corregimos los nueve. Ninguno sacó a IES de moderate.

Momento del fill de stops y límites. Otra estrategia de la comunidad (scalping-wunder-bots) mostraba un patrón claro: el motor salía una barra antes que TradingView. Nuestra hipótesis era que el motor evaluaba los stops de strategy.exit en la barra de entrada, mientras que TV los aplazaba a la barra siguiente. Construimos una sonda de paridad, parity-probe-01-stop-limit-timing, para aislar exactamente eso. El resultado: 778 de 778 operaciones emparejadas, con los cuatro criterios estrictos en verde. Hipótesis refutada.

Seguimiento de swings CHoCH / BOS. Otra estrategia (VCP) tenía una entrada espuria el 2025-05-12 a las 12:15 que sospechábamos que venía de una evolución divergente del estado de los pivotes. Construimos parity-probe-02-choch-bos-isolator, que reproducía exactamente su firma de pivotes. 1026 de 1026 emparejadas. Refutada otra vez.

Tras tres hipótesis, IES no había mejorado nada, pero teníamos una pieza nueva de metodología: escribir estrategias Pine mínimas que aíslen una hipótesis cada vez era muchísimo más rápido que trazar variables internas dentro de un script de la comunidad de 700 líneas. Así que escribimos una tercera sonda.

La sonda que lo encontró

El truco de parity-probe-03-equity-mirror es que la propia cantidad de la orden codifica 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")

Como qty = round(strategy.equity / close * 1000) / 1000 se redondea a tres decimales, la columna Size (qty) del CSV «List of Trades» que exporta TradingView se convierte en un oráculo, barra a barra, del valor de strategy.equity en TV. Empareja las operaciones del motor y de TV por la marca de tiempo de entrada, alinea las columnas de qty y leerás la divergencia de equity directamente en el diff.

Las ocho primeras operaciones emparejadas:

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%

La operación 1 coincidía a la perfección. Los dos lados empezaron con 1 millón de dólares de equity. A partir de la operación 2, las columnas de qty se separaron y nunca volvieron a converger. La diferencia se estabilizó en torno al 7,76 % hacia la operación 8.

La causa no era una deriva de cálculo. Era una operación perdida. La entrada que habría sido la operación 2 (el 2025-04-07) aparecía en la lista de operaciones de TV, pero no en la del motor. TV tomó la operación y absorbió una pérdida de $1.345, con lo que su equity bajó a unos 984 mil dólares. El motor nunca la tomó, así que su equity se quedó en unos 985 mil dólares. En las dos operaciones siguientes, el motor abrió posiciones un 0,137 % más grandes que las de TV; a partir de ahí, los dos lados aceptaron y rechazaron entradas en lunes distintos, las pérdidas acumuladas divergieron sobre trayectorias de equity distintas y la diferencia no volvió a cerrarse.

Un fill fantasma

Añadimos logs con std::cerr en strategy_entry, process_pending_orders, enter_market_from_flat y apply_market_order_fill, todos activados por una variable de entorno para que el ruido no se colara en otras ejecuciones de tests.

En la barra de la señal, 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

Se llamó a strategy.entry. La orden quedó en cola. Hasta aquí, todo bien.

En la barra del fill, 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 es FillEvaluation::Kind::Fill. El evaluador de precios decía que había que ejecutarla. Se llamó a apply_filled_order_to_state. Y el estado de la posición no se actualizó. Un fill fantasma.

Una línea de depuración más, esta vez dentro de enter_market_from_flat, para imprimir los datos que recibía la guarda de margen:

[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

Margen requerido: $982.803. Equity disponible: $982.785. La guarda de margen pedía unos $19 más de lo que tenía la cuenta, retornaba antes de tiempo sin actualizar ningún estado y no generaba ningún error ni ninguna línea de log pública. Desde el punto de vista de la estrategia, la operación simplemente no existió. (Esta ejecución de depuración operaba desde el inicio de los datos de calentamiento, así que su equity y su qty difieren ligeramente de los de la ejecución de comparación que aparece más abajo.)

Por qué TradingView sí tomó la misma operación

Este es el OHLC del par de barras en cuestión:

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 sonda dimensionó la orden al cierre de la señal: qty = round(985319.43 / 1566.66 * 1000) / 1000 = 628.93. El margen requerido calculado al cierre de la señal supera el equity disponible en solo cuatro centavos. El margen requerido calculado a la apertura de la barra siguiente lo supera en $18,91.

Precio usadoRequeridoEquityExceso
Cierre de la señal ($1566,66)$985.319,47$985.319,43+$0,04
Apertura del fill ($1566,69)$985.338,34$985.319,43+$18,91

Un movimiento de tres centavos en ETH, multiplicado por 628,93 contratos, añadió $18,87 de margen requerido, con lo que el exceso total llegó a $18,91. La comprobación de margen del motor se hacía en el momento del fill, con el precio del fill, y rechazaba la orden. El emulador de broker de TradingView, según creíamos ya, hacía la misma comprobación en el momento de la señal, con el cierre de la señal, y la aceptaba, porque cuatro centavos sobre una posición de 985 mil dólares quedan por debajo de la tolerancia de coma flotante, sea cual sea, que TV aplica en el límite.

Triangulación con tres sondas más

Para demostrar que no era una coincidencia de una sola operación, y que el bug tenía que ver específicamente con el límite de 1× equity, construimos tres sondas más que lo acotan:

SondaDimensionamientoPresión de margen
parity-probe-04-percent-of-equity-sizingdefault_qty_type=percent_of_equity, default_qty_value=99~99 % del equity
parity-probe-05-small-equity-fractionqty = round(equity / close * 100) / 1000~10 % del equity
parity-probe-06-edge-margin-sizingqty = round(equity * 0.5 / close * 1000) / 1000~50 % del equity

Para las tres sondas, comparamos la lista de operaciones del motor con la lista de operaciones 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

Cuando el dimensionamiento no estaba clavado en el límite de 1× margen, el motor y TV coincidían a la perfección en las 57 operaciones de cada sonda. El bug solo se manifestaba en el límite, donde el deslizamiento entre el cierre de la señal y la apertura del fill podía cambiar el resultado de la comprobación de margen.

La corrección

Mover la comprobación de margen de enter_market_from_flat (que se ejecuta en el momento del fill, con el precio del fill) a strategy_entry (que se ejecuta en el momento de la señal, con el cierre de la barra actual):

 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;
+            }
+        }
+    }
     ...

Alrededor de una docena de líneas en strategy_entry (el commit lleva un comentario más largo), más la eliminación correspondiente de ocho líneas en enter_market_from_flat. Nueva ejecución sobre 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 deriva del PnL bajó del 2,54 % al 0,78 %. IES pasó de moderate a excellent. En el resto del corpus de entonces: 165 de 168 estrategias en excellent, 2 en strong, 0 en moderate y la sonda 03 en weak (más abajo). Los 16 binarios de ctest pasaron, los 313 casos de pytest del codegen pasaron y no hubo regresiones en ninguna de las otras 161 estrategias.

El giro final

Después de la corrección, la propia parity-probe-03-equity-mirror seguía sin coincidir del todo con TV. El motor tomó 25 entradas, TV tomó 24 y solo 13 se solapaban. La sonda 03 está diseñada para vivir exactamente en el límite de 1× equity, así que cualquier diferencia de tolerancia entre las dos implementaciones aparece ahí antes que en ningún otro sitio.

Para cada uno de los 57 lunes de la ventana de comparación calculamos qty * signal_close - equity y anotamos si TV aceptaba o rechazaba la entrada. Estos son ocho de ellos:

LunesExceso al cierre de la señalAcción de TV
2025-04-07+$0,04TAKE
2025-04-14-$0,76TAKE
2025-04-21-$0,19TAKE
2025-04-28+$0,34REJECT
2025-05-12-$0,18REJECT (por debajo del equity, y aun así rechazada)
2025-05-26-$0,89REJECT (por debajo del equity, y aun así rechazada)
2025-08-18+$0,24REJECT
2025-11-10+$0,24TAKE (mismo exceso, resultado opuesto)

El 18 de agosto y el 10 de noviembre tienen el mismo exceso de +$0,24 y producen resultados opuestos. Ninguna regla pura de comprobación de margen (con cualquier umbral, con cualquier tolerancia) puede producir ese patrón. En ese límite, el emulador de broker de TV depende de algo que no es visible en ninguna variable documentada de Pine: el historial cargado en el gráfico, el orden en que las barras se volvieron visibles para la estrategia cuando el usuario la publicó o algún estado interno oculto que no tenemos forma de observar.

La lectura honesta es que se trata de un rincón no documentado del emulador de broker de TradingView que solo se manifiesta cuando el dimensionamiento está clavado exactamente en el límite de 1× equity. Las estrategias reales rara vez se quedan justo en el límite. community/IES es la que más se acerca: dimensiona cada operación a partir de un pequeño presupuesto de riesgo y de la distancia a su stop, así que algunas de sus órdenes usan casi todo el equity de la cuenta, y aun así alcanzó excellent tras la corrección. No esperamos que este rincón tenga mucho peso en el uso real. Decidimos mantener la corrección y documentar la sonda 03 como limitación conocida. La bajada cosmética de nivel en la sonda de diagnóstico es un precio justo por la mejora en IES.

Seis cosas que nos enseñó esta depuración

1. Las huellas asimétricas en las métricas diagnostican la clase de bug. Cuando el recuento, el precio de entrada y el precio de salida coinciden pero el PnL se desvía, estás ante un bug de dimensionamiento. Deberíamos haber mirado el código relacionado con el dimensionamiento antes de ponernos a auditar fórmulas de indicadores.

2. Las sondas de aislamiento escalan mejor que trazar estrategias grandes. Seis pequeñas sondas en Pine, cada una para probar una hipótesis, encontraron el bug. Trazar cada variable interna de un script de la comunidad de 700 líneas con cálculos realimentados por el equity habría llevado más tiempo y habría generado más ruido. Es la misma razón por la que escribimos tests unitarios en lugar de depurar solo a nivel de integración.

3. El parámetro qty= de TradingView tiene semántica de margen en el momento de la señal. La comprobación usa la barra en la que se llama a strategy.entry, no la barra del fill. Esto no está documentado en la referencia de Pine. Quien implemente un emulador de broker compatible con Pine debería replicarlo; la implementación natural pone la comprobación en el momento del fill (cuando ya se conoce el precio del fill) y falla en silencio.

4. La coma flotante en los límites siempre es el enemigo. La única operación que separó las dos trayectorias de equity de la sonda 03 fue un exceso de cuatro centavos sobre una posición de 985 mil dólares. Las estrategias en producción deberían dejar un colchón de margen del 1 al 5 % (un * 0.99 o un * 0.95 en la fórmula de dimensionamiento) para no vivir nunca en el límite.

5. El efecto compuesto amplifica una sola operación perdida. En la sonda 03, solo la operación perdida del 7 de abril supuso $1.345; hacia la operación 8, los tamaños de los dos lados ya diferían en un 7,76 % y así siguieron, porque cada operación perdida desplazaba la trayectoria del equity, lo que cambiaba el siguiente dimensionamiento, lo que a su vez cambiaba la siguiente decisión de aceptar o rechazar. En IES, la misma regla, a lo largo de 13 meses de operaciones, acabó sumando una diferencia de unos $29.000. Las estrategias con realimentación del equity no perdonan los huecos de ejecución aislados.

6. A veces el bug está del otro lado, y lo documentas con honestidad. El comportamiento de TV en el límite de 1× es un rincón real que no podemos corregir desde nuestro lado. Documentarlo con franqueza es mejor que perseguir en silencio una métrica imposible de igualar.

La metodología va más allá de este bug concreto. Las sondas de paridad complementan nuestro barrido de validación cruzada con PyneCore: PyneCore nos dice cuándo nuestro motor difiere de otro motor; las sondas de paridad nos dicen por qué difiere de TradingView. Cuando encontramos un hueco nuevo, el procedimiento ahora es: escribir el script Pine más pequeño que lo muestre, comparar las listas de operaciones, instrumentar el motor, corregir la discrepancia y documentar cualquier rincón de TV que no se pueda conciliar.

Por dónde seguir

  • Transpila y haz backtests desde Claude o Cursor: la herramienta transpile_pine del servidor MCP local devuelve el C++ que PineForge genera a partir de tu código Pine; la comprobación de margen en sí se ejecuta dentro del runtime del motor, no en ese código generado.
  • Explora la galería: las 312 estrategias actuales del corpus abierto, cada una comparada operación por operación con TradingView.
  • Cómo medimos la paridad: los resultados actuales y sus fuentes.