Discussão do artigo "De Python para MQL5: Uma Jornada em Sistemas de Trading Inspirados na Computação Quântica"
Não use a Configuração nº 2 (deixei a otimização em execução e foi uma estratégia perdedora). Faça otimizações e procure o melhor ajuste (e termine o EA).
Não entendo muito do assunto de computação quântica, mas há muito tempo tenho interesse nele.
Enviei uma pergunta à IA sobre essa implementação específica — não para criticar, mas porque tenho a ideia de experimentá-la na prática — e recebi uma resposta detalhada e bem fundamentada, com análise dos erros e uma implementação corrigida/aprimorada. Anexo a conversa (em russo) no arquivo, bem como a versão final do código-fonte (há várias opções dentro do arquivo — à sua escolha).
double SimulatePureQuantumCircuit(double &features[]) { const int num_states = (int)MathPow(2.0, (double)NUM_QUBITS); // 1. Criamos e inicializamos o vetor de estado (evolução determinística) double state[]; ArrayResize(state, num_states); ArrayInitialize(state, 0.0); state[0] = 1.0; // Estado |000...0> double next_state[]; ArrayResize(next_state, num_states); // --- [Evolução: Válvulas rotativas Ry] --- for(int qubit = 0; qubit < NUM_QUBITS; qubit++) { const int feature_idx = qubit % ArraySize(features); const double angle = MathMax(MathMin(features[feature_idx] * M_PI, M_PI), -M_PI); const double cos_a = MathCos(angle / 2.0); const double sin_a = MathSin(angle / 2.0); ArrayCopy(next_state, state); for(int i = 0; i < num_states; i++) { if((i & (1 << qubit)) == 0) { const int i1 = i | (1 << qubit); next_state[i] = cos_a * state[i] - sin_a * state[i1]; next_state[i1] = sin_a * state[i] + cos_a * state[i1]; } } ArrayCopy(state, next_state); } // --- [Evolução: Confusão CZ] --- for(int i = 0; i < NUM_QUBITS - 1; i++) { for(int j = i + 1; j < NUM_QUBITS; j++) { const double phase = M_PI / 2.0 * (features[i] * features[j]); if(MathAbs(phase) > M_PI / 4.0) { for(int k = 0; k < num_states; k++) { if(((k & (1 << i)) != 0) && ((k & (1 << j)) != 0)) state[k] = -state[k]; } } } } // --- [Cálculo das probabilidades reais] --- double exact_probs[]; ArrayResize(exact_probs, num_states); for(int i = 0; i < num_states; i++) { // O quadrado da amplitude é a probabilidade puramente teórica segundo a lei de Born exact_probs[i] = state[i] * state[i]; } // 2. Passamos imediatamente as probabilidades ideais para a ponderação dos votos const double prediction = GetWeightedVote(exact_probs); return prediction; }
Não fiz nenhuma verificação dos novos códigos-fonte e não contestei os argumentos da IA.
Talvez alguém mais versado no assunto possa avaliar?
Arquivos anexados:
quantum-mql5-safe.zip
841 kb
Como complemento, uma versão mais “abrangente”, que leva em conta a interdependência dos atributos — eles devem ser transmitidos em pares — e, por isso, os divide em duas partes distintas (real e imaginária) de um qubit.
// Configurações globais (adapte-as ao seu sistema de negociação) #define NUM_QUBITS 3 // Número de qubits (tamanho do vetor de estados = 2^NUM_QUBITS) #define MIN_CONFIDENCE 0.1 // Limite mínimo de confiança para a filtragem do flat //+------------------------------------------------------------------+ //| Cálculo rápido dos bits ativos (Método de Brian Kernighan) | //+------------------------------------------------------------------+ int CountBits(int n) { int count = 0; while(n > 0) { n &= (n - 1); count++; } return count; } //+------------------------------------------------------------------+ //| Cálculo da esperança matemática (Expectation Value) | //+------------------------------------------------------------------+ double GetWeightedVote(const double &state_probs[]) { double expected_value = 0.0; double total_weight = 0.0; const int size = ArraySize(state_probs); for(int i = 0; i < size; i++) { const double vote_weight = state_probs[i]; if(vote_weight <= 0.000001) continue; const int num_ones = CountBits(i); const double state_value = (2.0 * (double)num_ones / (double)NUM_QUBITS) - 1.0; expected_value += state_value * vote_weight; total_weight += vote_weight; } if(total_weight <= 0.0001) return 0.0; double final_prediction = expected_value / total_weight; if(final_prediction > 1.0) final_prediction = 1.0; if(final_prediction < -1.0) final_prediction = -1.0; return final_prediction; } //+------------------------------------------------------------------+ //| Simulador de circuito quântico complexo determinístico | //| features[][0] - parâmetro de amplitude, features[][1] - parâmetro de fase | //+------------------------------------------------------------------+ double SimulateQuantumCircuitComplex(double &features_matrix[][]) { const int num_states = (int)MathPow(2.0, (double)NUM_QUBITS); const int num_features = ArrayRange(features_matrix, 0); if(num_features == 0) { Print("Erro: matriz de atributos vazia!"); return 0.0; } // Vetor de estados quânticos baseado no tipo embutido complex complex state[]; ArrayResize(state, num_states); // Inicialização do sistema no estado rígido |000...0> for(int i = 0; i < num_states; i++) { state[i].real = 0.0; state[i].imag = 0.0; } state[0].real = 1.0; // A amplitude do estado fundamental é igual a 1 // Buffer temporário para atualização atômica (simultânea) do vetor complex next_state[]; ArrayResize(next_state, num_states); // --- 1. Codificação complexa de características (U-Gate: Ry + Rz) --- for(int qubit = 0; qubit < NUM_QUBITS; qubit++) { const int feat_idx = qubit % num_features; // Limitamos os ângulos de entrada ao intervalo [-PI; PI] const double theta = MathMax(MathMin(features_matrix[feat_idx][0] * M_PI, M_PI), -M_PI); // Para Ry const double phi = MathMax(MathMin(features_matrix[feat_idx][1] * M_PI, M_PI), -M_PI); // Para Rz const double cos_t = MathCos(theta / 2.0); const double sin_t = MathSin(theta / 2.0); // Exponencial de Euler para o deslocamento de fase: e^(i*phi) = cos(phi) + i*sin(phi) complex e_phase; e_phase.real = MathCos(phi); e_phase.imag = MathSin(phi); ArrayCopy(next_state, state); for(int i = 0; i < num_states; i++) { if((i & (1 << qubit)) == 0) { const int i1 = i | (1 << qubit); // Matriz complexa do vetor de rotação U(theta, phi): // [ cos(theta/2) , -sin(theta/2) ] // [ sin(theta/2)*e^(i*phi), cos(theta/2)*e^(i*phi) ] // Cálculo para o bit de destino = 0 next_state[i].real = cos_t * state[i].real - sin_t * state[i1].real; next_state[i].imag = cos_t * state[i].imag - sin_t * state[i1].imag; // Cálculo para o bit de destino = 1 (levando em conta o deslocamento de fase e^i*phi) complex temp_i1; temp_i1.real = sin_t * state[i].real + cos_t * state[i1].real; temp_i1.imag = sin_t * state[i].imag + cos_t * state[i1].imag; // Aplicamos o deslocamento de fase por meio da multiplicação complexa nativa do MQL5 next_state[i1] = temp_i1 * e_phase; } } ArrayCopy(state, next_state); } // --- 2. Entrelaciamento quântico complexo honesto (Controlled-Phase Gate) --- for(int i = 0; i < NUM_QUBITS - 1; i++) { for(int j = i + 1; j < NUM_QUBITS; j++) { const int idx_i = i % num_features; const int idx_j = j % num_features; // Confundimos as fases complexas de dois parâmetros inter-relacionados const double cross_phase = M_PI / 2.0 * (features_matrix[idx_i][0] * features_matrix[idx_j][1]); complex cz_gate; cz_gate.real = MathCos(cross_phase); cz_gate.imag = MathSin(cross_phase); for(int k = 0; k < num_states; k++) { // Se ambos os qubits estiverem no estado 1, giramos gradualmente sua fase complexa comum if(((k & (1 << i)) != 0) && ((k & (1 << j)) != 0)) { state[k] = state[k] * cz_gate; } } } } // --- 3. Cálculo das probabilidades teóricas exatas (etapa determinística) --- double exact_probs[]; ArrayResize(exact_probs, num_states); for(int i = 0; i < num_states; i++) { // De acordo com a lei de Born, a probabilidade P = |psi|² = real² + imag² exact_probs[i] = (state[i].real * state[i].real) + (state[i].imag * state[i].imag); } // --- 4. Obtenção da previsão final --- const double prediction = GetWeightedVote(exact_probs); const double confidence = MathAbs(prediction); if(confidence < MIN_CONFIDENCE) { return 0.0; // O mercado está em fase de estagnação/indecisão do ponto de vista da cadeia quântica } return prediction; }
A maneira mais prática de transmitir parâmetros interligados é por meio da matriz features[][] com a segunda dimensão igual a 2, onde:
- features[i][0] — característica de amplitude (define o ângulo de rotação real (Ry)).
- features[i][1] — característica de fase (define o ângulo de rotação complexa (Rz)).
Por exemplo, o código chamador pode transmitir pares como: [Variação de preço; Variação de volume] ou [Posição do RSI; Volatilidade atual do ATR].
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Novo artigo De Python para MQL5: Uma Jornada em Sistemas de Trading Inspirados na Computação Quântica foi publicado:
Faremos uma viagem que conecta ideias teóricas da computação quântica com aplicações reais de trading nesta investigação completa de sistemas de trading inspirados na computação quântica. Começando com ideias básicas de computação quântica e terminando com uma implementação real em MQL5, este tutorial foi projetado para guiá-lo por todo o processo de desenvolvimento. Discutiremos como o trading pode se beneficiar do uso de conceitos quânticos, descreveremos nossa abordagem de desenvolvimento do protótipo em Python até a integração em MQL5 e apresentaremos dados reais de performance e implementações de código.
Este artigo explora a aplicação de conceitos inspirados na computação quântica em sistemas de trading, fazendo a ponte entre a teoria da computação quântica e a implementação prática em MQL5. Apresentaremos princípios quânticos essenciais e guiaremos você do protótipo em Python até a integração em MQL5, com dados reais de performance.
Ao contrário do trading tradicional, que depende de tomadas de decisão binárias, os modelos de trading inspirados na quântica aproveitam comportamentos de mercado semelhantes a fenômenos quânticos — múltiplos estados simultâneos, interconexões e mudanças abruptas de estado. Ao usar simuladores quânticos como o Qiskit, podemos aplicar algoritmos inspirados na quântica em computadores clássicos para lidar com a incerteza do mercado e gerar insights preditivos.
Autor: Javier Santiago Gaston De Iriarte Cabrera