Grade e martingale: o que são e como usá-los?

Introdução

Neste artigo, quero mostrar com a ajuda da matemática e da programação o que essas estratégias verdadeiramente são e se elas são realmente tão lucrativas quanto muitas pessoas pensam. Teremos uma parte matemática e outra prática. Na parte matemática, vou escrever fórmulas que podem ser usadas para calcular a expectância dessas estratégias e outros parâmetros importantes que, creio, muitos não levam em conta. Na parte prática, escreveremos a grade e o martingale mais simples, e confrontaremos o que nossas fórmulas dizem com a realidade. O artigo será especialmente útil para novatos, pois, basicamente, no início as pessoas se deparam com essas estratégias e passam a acreditar nelas, causando desapontamento e perda de tempo, como aconteceu comigo no meu tempo. Se eu não fosse amigo da matemática, talvez ainda continuasse acreditado nessas estratégias. Mas essas estratégias ainda têm um fundamento lógico, se nós as examinarmos corretamente. Vou tentar provar isso aqui.

O que essas duas estratégias têm em comum?

Para entender por que essas duas estratégias são tão populares, precisamos entender o que qualquer novato que opte pelo Forex quer. Entre os iniciantes, há sempre uma porcentagem bastante grande de matemáticos e sonhadores que pensam em enriquecer de maneira rápida e fácil graças ao seu intelecto. Eu fui uma dessas pessoas uma vez. Ambas as estratégias têm a aparência de uma negociação ganha-ganha, com gráficos que sobem o tempo todo no testador de estratégias. Elas podem ser testadas com base em muitas partes do histórico de cotações, mesmo sem usarmos filtros, pode parecer que são o Santo Graal. Em qualquer linha de atividade ou negócio existem momentos em que pessoas conhecedoras podem enganá-lo e se enriquecer à sua custa. E assim é aqui. No Forex isso acontece muito, e essas 2 estratégias são a prova mais clara e popular disso. A primeira vez que você usar essas estratégias, verá que funcionam com todos os pares de moedas com incríveis fatores de lucro e expectância e até mesmo que podem usar quaisquer spreads, o que faz parecer que esse algoritmo está fora do mercado. Isso ocorre porque elas são baseadas em matemática pura e não têm nenhuma lógica. Até eu, um desenvolvedor experiente, ainda gostaria de encontrar algoritmos que, independentemente da direção do preço, sempre são lucrativos. Na verdade, os matemáticos são pessoas estranhas, basta dar uma razão para eles inventarem e, ainda por cima, provarem com fórmulas, porém, no final, dizem "ah, mas está dando um erro aqui" 🙂. No geral, essas duas estratégias tiram proveito da ilusão de break-even para convencê-lo a usá-las. Ambas as estratégias funcionam com qualquer par de moedas e qualquer período, em outras palavras, criam uma ilusão de trabalho robusto, e convencem você da sua simplicidade e eficiência. Após entender tudo com essas estratégias, mais cedo ou mais tarde você acaba por perceber que não sabe de nada 🙂. Mas isso é necessário, porque só assim você vai começar a pensar racionalmente e a entender a verdadeira natureza do mercado e quais estratégias você realmente precisa usar.

A grade e suas fórmulas básicas

A grade de ordens foi inventada com o intuito de obter lucro em qualquer mercado, não importa se baixista ou altista. Segundo os criadores da grade: se houver um movimento pronunciado, a grade, através de um sistema inteligente de abertura de ordens, deverá abrir as ordens de forma que, de uma forma ou de outra, a soma dessas ordens em algum ponto acumulará lucro suficiente para fechá-las todas de uma vez. Vou ilustrar o que foi dito na imagem:

Aqui estão 2 opções para um mercado em alta e em queda, respectivamente. Independentemente da variante que obtivermos, ainda temos que lucrar com a ideia dos autores. Aqueles que usam a grade sempre dizem que usam ordens pendentes que são executadas ao melhor preço. Isso é verdade, mas acredito que as ordens a mercado não são piores, nem que seja pelo fato de que podemos controlar spreads e slippages no momento da entrada e, nesse caso, podemos esperar um pouco com a entrada, mas quanto a essa estratégia, as ordens limitadas são melhores. Temos um ponto de partida, em relação ao qual as ordens são feitas, tudo o que for mais alto é para compra com um passo "s", tudo abaixo é para venda, respectivamente. Se o preço chega até eles, eles se transformam em preços a mercado. Na figura, desenhei ordens já abertas com base numa situação específica de formação de preços. Não precisamos desenhar as ordens limite, já que estarão nos mesmos níveis - elas irão apenas subir e descer indefinidamente. Mas apenas ordens reais abertas são importantes, porque seus lucros ou perdas se somam ao lucro ou prejuízo total, respectivamente. Para garantir o lucro, é necessário que alguns pedidos sejam maiores que outros em "K" vezes. Isto é, devemos garantir K=a/d, onde K>=K0 . K0 é um coeficiente que, ao ser atingido, o lucro total de todas as ordens na grade ultrapassa o limite zero. Você também pode simplesmente calcular o lucro atual de uma posição ou ordens no caso do MetaTrader 4. Ou vamos ver que o preço se move imediatamente numa direção e fixamos o lucro ou que o preço ultrapassa "n" pontos para cima ou para baixo. Tecnicamente, este coeficiente pode ser calculado, mas geralmente é simplesmente selecionado manualmente sem problemas. Isso pode ser calculado assim:

• Nl=d/s - 1
• NP=(a+d)/s -1
• Pr=Soma(1,NP)(s*i)=(s+s*NP)*Np/2
• Ls=Soma(1,Nl)(s*j+ s*NP)=(s+s*Nl)*Nl/2+s*NP^2

Ao somar a perda ou lucro de todas as ordens, podemos ver que esses valores são progressões aritméticas - existe uma fórmula que descreve a soma de uma progressão aritmética (usando seu primeiro e último termos), que é aplicada aqui.

A partir da condição Pr-Ls=0, após resolver esta equação, podemos encontrar "a" e calcular K0=a/d. Além disso, com essas fórmulas podemos obter o fator de lucro e a expectância dos ciclos de negociação em que haverá posições abertas para compra e venda.

• Prf=Pr/Ls 
• M=(Pr-Ls)/(Np+Nl)

Essas fórmulas calculam o fator de lucro e a expectância de um ciclo de negociação específico, não o gráfico inteiro. Desde que nosso gráfico termine no ponto final do ciclo, nosso fator de lucro será positivo. Eu chamo uma única grade de ciclo. A grade é construída, ativada, as posições são fechadas, e então uma nova grade é construída e assim por diante, ad infinitum com um depósito infinito. É assim que fica a curva de equilíbrio:

Esta é uma representação simplificada do gráfico de equilíbrio de um robô gradador ao percorrer o histórico. Sempre há um certo número de ciclos que nosso depósito suporta, e o gráfico sobe, mas sempre há um ciclo em que o depósito não é suficiente e todo nosso lucro visível vai para a corretora. Do ponto de vista da matemática, isso é considerado um ciclo inacabado, que, por sua vez, é sempre não lucrativo, sobrepondo-se aos lucros obtidos em ciclos que funcionaram até o fim. Além disso, o ciclo pode não terminar ainda devido por não haver pedidos suficientes para continuar a grade. Na verdade, qualquer corretora tem um limite para o número de ordens abertas simultaneamente no terminal ou para um determinado par, o que nos obriga a levar em consideração essas características. Não podemos construir uma grade indefinidamente. Mesmo se assumirmos que podemos fazer isso por algum motivo mágico, ainda veremos o cenário que descrevi acima. No final do artigo, explicarei de forma muito simples e rápida matematicamente por que isso acontece, para que todos entendam e não haja mais perguntas.

Martingale e suas fórmulas básicas

Tal como a grade, o martingale foi projetado para vencer sem importar a direção do mercado, o tipo de posição e o sentido em que negociamos. Ele é baseado na mesma ilusão de lucro eterno. Se abrimos uma ordem e ela é lucrativa, simplesmente a fechamos e continuamos negociando. Assim que tivermos uma ordem perdedora, na próxima ordem aumentamos o lote "n" vezes em relação à posição perdedora; se nossa ordem for lucrativa, simplesmente a fechamos e redefinimos o lote para o valor inicial. Já se a ordem for novamente não lucrativa, repetimos o procedimento, só que agora aumentamos o lote "n" vezes em relação à soma dos lotes de todas as posições não lucrativas que estão neste ciclo, e assim por diante até conseguirmos uma transação lucrativa. A última transação no ciclo é sempre lucrativa e seu lucro sempre se sobrepõe a perda das transações não lucrativas, assim, nosso gráfico novamente começa a consistir em ciclos; e desde que o gráfico termine com o último ciclo, então obtemos uma expectância positiva e um fator de lucro. Não é tão importante como abrimos essas ordens e em que momento. É desejável que essas ordens tenham lucros e perdas fixos ou simplesmente fechem com base em stops fixos. É assim que o gráfico de equilíbrio do robô fica:

Como podemos ver, é muito semelhante ao gráfico de equilíbrio da grade, já que o martingale funciona em ciclos, assim como a grade. Só que ele sempre abre uma ordem por vez e, até que feche, ele não pode abrir outra. Como no caso da grade, um dia chega o momento em que o depósito não basta para encerrar o ciclo, ocorre o fechamento das ordens e, consequentemente, o depósito é zerado. Para garantir ciclos lucrativos, o lucro da última transação deve cobrir a perda das transações anteriores:

• Nl
• Np=1
• Pr=L[Nl+Np]*TP[Nl+Np]*TickSize
• Ls=Soma(1,Nl)(L[i]*SL[i])*TickSize

Aqui, o lucro não é calculado em pontos, mas nas unidades da moeda da sua conta, porque aqui são executadas manipulações de lote e é inconveniente calcular em pontos. Os lotes de uma ordem específica são calculados usando recursão:

• L[1]=StartLot
• for(2,Nl) L[i]=(K*Soma(1,i-1)(L[j]*SL[j]))/TP[i]

Onde "K" é o fator de lucro exigido do ciclo. Aqui, claro, não se levam em conta spreads, comissões e swaps, mas não acho que isso seja importante. Se for necessário, as fórmulas podem ser modificadas sem problemas, mas não vejo sentido nisso. Tentei fazer fórmulas, por analogia com a grade. SL e TP são a perda resultante ou o lucro desejado da ordem. Esta definição pode ser obtida resolvendo a equação simples: K=(L[i]* TP[i])/Soma(1,i-1)(L[j]*SL[j]).

Criando e testando uma grade simples

Para testar as suposições acima, juntos iremos escrever uma grade simples e um martingale simples em linguagem mql5, e então testá-los e ver o resultado. Vamos começar com a grade. Primeiro, vamos adicionar a nosso modelo algumas classes convenientes para trabalhar com posições:

#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
CPositionInfo  m_position=CPositionInfo();// trade position object
CTrade         m_trade=CTrade();          // trading object

Essas 2 bibliotecas estão sempre presentes no MetaTrader 5 por padrão, ninguém terá problemas com a compilação. 

A seguir, descrevemos todos os parâmetros de entrada de que precisamos:

///grid variables
input int MaxChannelSizePoints=500;//Max Of a+d
input int MinMoveToClose=100;//Mininum Move
input int GridStepPoints=20;//Grid Step In Points
input int BarsI=999;//Bars To Start Calculate
input double KClose=3.5;//Asymmetry
///

////////minimum trading implementation
input int SlippageMaxOpen=15; //Slippage For Open In Points
input double Lot=0.01;//Lot
input int MagicC=679034;//Magic
/////////

O primeiro bloco implementa os parâmetros de grade necessários, e o segundo implementa minimamente a possibilidade de negociação com um lote fixo.

Ao iniciar o Expert Advisor, precisamos verificar e restaurar os parâmetros da grade da sessão anterior, caso o trabalho tenha sido concluído incorretamente. Isso não é necessário, mas é melhor pensar sobre estes pontos com antecedência:

void DimensionAllMQL5Values()//////////////////////////////
   {
   ArrayResize(Time,BarsI,0);
   ArrayResize(High,BarsI,0);
   ArrayResize(Low,BarsI,0);
   }

void CalcAllMQL5Values()///////////////////////////////////
   {
   ArraySetAsSeries(High,false);                        
   ArraySetAsSeries(Low,false);                              
   ArraySetAsSeries(Time,false);                                                            
   CopyHigh(_Symbol,_Period,0,BarsI,High);
   CopyLow(_Symbol,_Period,0,BarsI,Low);
   CopyTime(_Symbol,_Period,0,BarsI,Time);
   ArraySetAsSeries(High,true);                        
   ArraySetAsSeries(Low,true);
   ArraySetAsSeries(Time,true);
   }

Esse código é necessário para implementar as matrizes predefinidas para que a análise inicial possa ser feita. Depois, não precisaremos delas, só as usaremos para o cálculo inicial.

Faremos a restauração assim:

void RestoreGrid()//recover the grid if the robot is restarted
   {
   DimensionAllMQL5Values();
   CalcAllMQL5Values(); 
   bool ord=PositionSelect(Symbol());
   if ( ord && int(PositionGetInteger(POSITION_MAGIC)) == MagicC )
      {
      GridStartTime=datetime(PositionGetInteger(POSITION_TIME));
      GridStartPrice=double(PositionGetDouble(POSITION_PRICE_OPEN));
      GridUpPrice=GridStartPrice;
      GridDownPrice=GridStartPrice;      
      
      for(int i=0;i<BarsI;i++)
         {
         if ( High[i] > GridUpPrice ) GridUpPrice=High[i];
         if ( Low[i] < GridDownPrice ) GridDownPrice=Low[i];
         if ( Time[i] < GridStartTime ) break;         
         }
      bCanUpdate=true;
      bTryedAlready=false;         
      }
   }

Para rastrear o estado atual da rede, precisamos de variáveis auxiliares que exibam os preços superior e inferior durante a existência da grade, bem como o preço inicial da grade e o tempo em que foi colocada.

datetime GridStartTime;//grid construction time
double GridStartPrice;//grid starting price
double GridUpPrice;//upper price within the corridor
double GridDownPrice;//lower price within the corridor

E mais 2 booleanos para acompanhar ou atualizar as variáveis da grade durante o movimento do preço, bem como para tentativas adicionais de fechamento da grade se a primeira tentativa falhar.

bool bCanUpdate;//whether it is possible to update the grid
bool bTryedAlready;//whether there was an attempt to close a position

A criação e atualização dos parâmetros de grade durante o desenvolvimento serão assim:

void CreateNewGrid()//create a new grid
   {
   SymbolInfoTick(Symbol(),LastTick);  
   GridStartTime=TimeCurrent();
   GridStartPrice=LastTick.bid;
   GridUpPrice=GridStartPrice;
   GridDownPrice=GridStartPrice;
    
   double SummUp=LastTick.ask+double(GridStepPoints)*_Point;
   double SummDown=LastTick.bid-double(GridStepPoints)*_Point;
   
   while ( SummUp <= LastTick.ask+double(MaxChannelSizePoints)*_Point )
      {
      m_trade.BuyStop(Lot,SummUp,Symbol());
      SummUp+=double(GridStepPoints)*_Point;
      }
     
   while ( SummDown >= LastTick.bid-double(MaxChannelSizePoints)*_Point )
      {
      m_trade.SellStop(Lot,SummDown,Symbol());
      SummDown-=double(GridStepPoints)*_Point;
      }
   }

void UpdateGrid()//update the grid parameters
   {
   SymbolInfoTick(Symbol(),LastTick);
   if ( LastTick.bid > GridUpPrice ) GridUpPrice=LastTick.bid;
   if ( LastTick.bid < GridDownPrice ) GridDownPrice=LastTick.bid;
   }

Funções para fechar posições, limpar as restantes ordens limitadas e uma função-predicado que detecta a condição para fechar a grade:

void ClosePosition()//close a position by a symbol
   {
   bool ord;
   ord=PositionSelect(Symbol());
   if ( ord && int(PositionGetInteger(POSITION_MAGIC)) == MagicC  )
      {
      if(m_position.SelectByIndex(0)) m_trade.PositionClose(m_position.Ticket());          
      }
   }

void CleanLimitOrders()//clear limit orders
   {
   int orders=OrdersTotal();
   for(int i=0;i<orders;i++)
      {
      ulong ticket=OrderGetTicket(i);
      if(ticket!=0)
         {
         m_trade.OrderDelete(ticket);
         }
      }
   }

bool bCanClose()//closure condition
   {
   if ( GridStartPrice == GridUpPrice && (GridStartPrice-GridDownPrice)/_Point >= MinMoveToClose ) return true;
   if ( GridStartPrice == GridDownPrice && (GridUpPrice-GridStartPrice)/_Point >= MinMoveToClose ) return true;
   
   if ( GridStartPrice != GridUpPrice && GridStartPrice != GridDownPrice 
   && (GridStartPrice-GridDownPrice)/(GridUpPrice-GridStartPrice) >= KClose 
   && (GridStartPrice-GridDownPrice)/_Point >= MinMoveToClose ) return true;
   if ( GridStartPrice != GridDownPrice && GridStartPrice != GridUpPrice 
   && (GridUpPrice-GridStartPrice)/(GridStartPrice-GridDownPrice) >= KClose
   && (GridUpPrice-GridStartPrice)/_Point >= MinMoveToClose ) return true;
   
   /*
   if ( GridUpPrice >= GridStartPrice+MaxChannelSizePoints*_Point 
   //|| GridDownPrice <= GridStartPrice-MaxChannelSizePoints*_Point ) return true;
   */
   return false;
   }

Comentei a última condição da função-predicado, ela fecha a grade caso o preço saia da grade, você pode usar à vontade, não muda a essência. Resta escrever a função principal para negociação:

void Trade()//the main function where all actions are performed
   {
   bool ord=PositionSelect(Symbol());
   
   if ( bCanUpdate ) UpdateGrid();
   
   if ( ord && bCanClose() )//if there is a position and the closing condition is met
       {
       ClosePosition();
       CleanLimitOrders();
       bCanUpdate=false;
       bTryedAlready=true;
       }
   if ( bTryedAlready ) ClosePosition();
          
   if ( !bCanUpdate && !ord )
       {
       CleanLimitOrders();
       CreateNewGrid();
       bCanUpdate=true;
       bTryedAlready=false;
       }
   }

 Bem, vamos definir as chamadas e o que faremos ao inicializar o Expert Advisor:

int OnInit()
  {
  m_trade.SetExpertMagicNumber(MagicC);//set the magic number for positions
  RestoreGrid();//restore the grid if present
   return(INIT_SUCCEEDED);
  }

void OnTick()
  {
  Trade();
  }

Isso completa a montagem do gradador, agora vamos testá-lo e ver como se comporta, e tirar conclusões a partir disso:

Como você pode ver, as premissas sobre o ciclo não lucrativo foram confirmadas. No início, ele funciona muito bem, mas chega um momento em que a grade não é suficiente e ocorre um ciclo de prejuízo, que reduz todos os lucros. Em áreas onde há um bom movimento de tendência, você não verá tais situações, mas onde o componente lateral domina, você verá perda após perda. Você pode testar sozinho e notar que, em geral, terá perdas, pois ainda temos spread.

Construindo e testando o martingale mais simples

Agora que vimos a grade, podemos continuar com o martingale. Seu código será muito mais simples. Para trabalhar com posições, vamos usar também as bibliotecas que usamos na grade, não adianta dar esse código uma segunda vez. Vamos começar imediatamente com os parâmetros de entrada:

input int SLE=100;//Stop Loss Points
input int TPE=300;//Take Profit Points
input int SlippageMaxOpen=15; //Slippage For Open In Points
input double Lot=0.01;//Start Lot
input int MagicC=679034;//Magic
input int HistoryDaysLoadI=10;//History Deals Window Days

Para simplificar, escolhi um esquema em que as posições são fechadas estritamente por stop-loss ou take-profit; só direi que a última variável é necessária para não carregar todo o histórico de ordens todas as vezes, mas apenas alguma janela necessária (puramente para otimização); o resto das variáveis parecem esclarecidas para todos.

Nosso Expert Advisor terá apenas 2 funções:

double CalcLot()//calculate the lot
   {
   bool ord;
   double TotalLot=0;
   HistorySelect(TimeCurrent()-HistoryDaysLoadI*86400,TimeCurrent());
   for ( int i=HistoryDealsTotal()-1; i>=0; i-- )
      {
      ulong ticket=HistoryDealGetTicket(i);
      ord=HistoryDealSelect(ticket);
      if ( ord && HistoryDealGetString(ticket,DEAL_SYMBOL) == _Symbol 
      && HistoryDealGetInteger(ticket,DEAL_MAGIC) == MagicC 
      && HistoryDealGetInteger(ticket,DEAL_ENTRY) == DEAL_ENTRY_OUT )
         {
         if ( HistoryDealGetDouble(ticket,DEAL_PROFIT) < 0 )
            {
            TotalLot+=HistoryDealGetDouble(ticket,DEAL_VOLUME);
            }
         else
            {
            break;
            }
         }
      } 
   return TotalLot == 0 ? Lot: TotalLot;
   }


void Trade()//the main function where all actions are performed
   {
   bool ord=PositionSelect(Symbol());
   SymbolInfoTick(Symbol(),LastTick);
   if ( !ord )
      {
      if ( MathRand() > 32767.0/2.0 )
         {
         m_trade.Buy(CalcLot(),_Symbol,LastTick.ask,LastTick.bid-double(SLE)*_Point,LastTick.ask+double(TPE)*_Point);
         }
      else
         {
         m_trade.Sell(CalcLot(),_Symbol,LastTick.ask,LastTick.ask+double(SLE)*_Point,LastTick.bid-double(TPE)*_Point);
         }
      }
   }

A primeira é necessária para calcular o lote final com o qual abriremos uma posição, após observar o histórico de transações. Se a última transação não for lucrativa, o próximo lote será igual à soma dos lotes das transações anteriores não lucrativas, até a primeira lucrativa. Se a última transação for lucrativa, restauraremos o lote para o seu valor original. Na função principal, simplesmente abriremos ordens aleatoriamente em diferentes direções com stops fixos, os volumes serão calculados pela primeira função. Para que tudo isso funcione corretamente, no inicializador precisamos atribuir um magic ao EA e chamar a função principal no manipulador OnTick, assim como na grade.

Assim concluímos a montagem de um martingale simples, agora vamos testá-lo e ver o resultado:

Esta situação é muito parecida com a da grade, você pode selecionar os ciclos e ver como funcionam por um tempo; depois começa um ciclo não lucrativo em que a margem já não é suficiente para abrir a próxima posição, e inevitavelmente ocorre uma perda. Da mesma forma que com a grade, às vezes funcionará, mas no final você terá novamente uma perda, de qualquer forma. Agora que revisamos ambas as estratégias e as testamos na prática, podemos ir além e tirar conclusões matemáticas que nos levam a respostas mais importantes do que apenas compreendê-las.

Matemática geral da grade e do martingale

Por que a matemática geral da grade e do martingale é tão importante na minha opinião? Basicamente, porque, após compreender e absorver toda sua essência, você vai se despedir de toda uma série de ideias que nunca vão dar lucro, embora você queira acreditar nelas, ou, pelo menos, compreender que condições podem contribuir para melhorar o desempenho destas estratégias. Também, você vai entender de uma vez por todas por que razão o martingale e a grade são estratégias de perda, e por isso digo isso com tanta confiança.

Imaginemos qualquer estratégia consistindo em inúmeras estratégias simples e que quando qualquer ordem é aberta, qualquer uma delas é ativada. Assumiremos que essas ordens são fechadas com perda ou lucro fixo. Vamos colocá-las em correspondência com as matrizes C[i], Lot[i], onde o tamanho dessas matrizes é igual e tende ao infinito. Acreditamos que o lote utilizado por cada estratégia é sempre diferente. Também apresentaremos a probabilidade de ativação de qualquer uma dessas estratégias. PC[i], é claro que esses eventos formam um grupo completo de modo que Soma(0,n)( PC[i] ) = 1. Todos os resultados desses eventos formam novos espaços de eventos S[i], T[i], que representam, respectivamente, as ativações com base no prejuízo e no lucro. Esses eventos têm suas próprias probabilidades condicionais PS[i], PT[i], que, é claro, também formam um grupo completo. Abaixo está uma representação gráfica do que foi dito:

Agora analisaremos qualquer estratégia retirada separadamente desta lista e calcularemos sua expectância.

• M[i]=(PT[i]*TP-PS[i]*SL)*Lot[i]*TickSize.

Quando não sabemos que direção vai ter o preço no pontos onde a posição é aberta, podemos dizer que M[i]=0. Onde M[i] é uma matriz de expectância de estratégias específicas. Em outras palavras, se não sabemos a direção do preço, não importa como nós operemos, teremos "0" quando o número de transações tende ao infinito.

Agora vamos escrever a fórmula geral para a expectância:

• M0=Soma(0,n)(PC[i]*M[i])

Sabemos que como n tende ao infinito, todos os M[i] tendem a zero, o que significa que todos os termos da nossa soma, com um número finito de estratégias assim, tendem a "0", mas com um número infinito de transações. Isso, por sua vez, significa que a expectância total M0 ainda é igual a "0". Se pensamos mais sobre isso, iremos ver que um conjunto infinito de conjuntos finitos de estratégias desse tipo também será igual a zero, já que somar um número infinito de zeros dará "0". No caso de uma grade, o tamanho do lote é o mesmo em todos os lugares, já no caso de um martingale é diferente, mas essas diferenças não afetam a expectância final de forma alguma. Nós podemos descrever ambas as estratégias com esta fórmula geral e não nos dar ao trabalho de lidar com combinatória, fechamento e abertura. Tudo é muito simples e claro.

Porém, visto que essas estratégias podem ser descritas por esta fórmula, qualquer estratégia também pode sê-lo e, portanto, chegamos a uma conclusão indiscutível, que muitos não quererão aceitar, tenho certeza, mas isso é do seu interesse, acredite. A conclusão é que todas as estratégias que utilizam variação e manipulação de volumes de transações, bem como um sistema arbitrariamente "xamânico" de abertura e fechamento de ordens, sem conhecer a direção aproximada do movimento no momento da abertura e fechamento das transações, ou pelo menos alguns parâmetros auxiliares de mercado, são insustentáveis por definição. Ou seja, sem uma previsão correta, todas as suas danças com pandeiros são uma perda de tempo e de dinheiro.

Como usar a grade e o martingale corretamente

Vamos começar com a grade. É melhor usar a grade quando se sabe que o mercado está prestes a se movimentar numa direção ou quando a probabilidade de dado evento aumenta muito, e, além disso, há risco de ter um gap. Os gaps e as grades são péssimos amigos. Isso ocorre porque as ordens são colocadas com determinado passo, e pode acontecer que o próximo tick passe perto de todas as ordens e apareça muito além da grade. Claro, isso acontecerá muito raramente, mas inevitavelmente reduzirá o desempenho do sistema. O tamanho da grade deve ser definido igual ou ligeiramente menor do que o movimento previsto, além disso, não precisamos saber a direção do movimento, mas apenas seu valor aproximado. Seu gráfico de equilíbrio, no caso de um algoritmo de detecção de tendência bem-sucedido, será semelhante a este:

A tendência está longe de ser determinada com precisão antecipadamente, portanto, ciclos não lucrativos ocorrerão com bastante frequência, na figura ele é vermelho, e o rebaixamento também será bastante grande. Aqueles que têm métodos para detectar grandes movimentos podem usar a grade com sucesso, construindo uma de acordo com seu sinal. Eu não tive de resolver esse problema ainda, se alguém tiver bons algoritmos para detectar essas coisas, eu ficaria feliz em ver.

A seguir, determinaremos quando o martingale pode ser usado. Se tivermos algum sinal com expectância igual a "0", mas sabemos que a sequência de perdas é tal que a probabilidade de uma negociação lucrativa é próxima de um para um certo número de perdas consecutivas, então esse sinal pode ser usado para martingale. Nosso gráfico de equilíbrio será assim:

Mas acho que é perigoso usar martingale em qualquer caso. Acredito que seja quase impossível atingir as condições que descrevi, mas com a grade parece-me tudo mais fácil e, o mais importante, mais claro.

Fim do artigo

Neste artigo, tentei dizer com clareza que são essas duas estratégias, o que elas têm em comum e, o mais importante, o que têm de bom. O material é o mais simples e compreensível possível, mesmo para um iniciante. Este artigo é mais para novatos, mas as conclusões são muito mais importantes do que uma simples avaliação das estratégias e dos limites de sua aplicação. Tiramos conclusões matemáticas gerais que permitirão aos iniciantes, e acho que não apenas a eles, usar seu tempo da forma mais produtiva possível ao desenvolver seus próprios sistemas de negociação. O artigo em si não traz nada de novo para compreender fisicamente o mercado, mas acho que esfriará a cabeça daqueles que ainda estão tentando tirar vantagem precipitadamente desses princípios.