Quantenneuronales Netzwerk in MQL5 (Teil III): Ein virtueller Quantenprozessor auf Basis von Qubits

Im zweiten Teil unserer Forschung haben wir ein System entwickelt, das mathematische Analogien quantenmechanischer Effekte verwendet: Resonanz (Kosinus), Interferenz (Sinus), Dekohärenz (Exponentialfunktion). Dies blieb jedoch nur eine Nachahmung. Formal wirkte es elegant, aber im Wesentlichen war es nicht quantenmechanisch.

Mit der Zeit wurde deutlich, dass das Modell zwar elegant ist, aber nicht den Kern der Quantenverarbeitung erfasst – Superposition, Verschränkung und die Irreversibilität von Messungen. Wir arbeiteten mit Funktionen, nicht mit Prinzipien.

Klassische Ansätze bleiben begrenzt:

• LSTM erreicht eine Genauigkeit von bis zu 58 %
• Transformer sind anfällig für Rauschen
• ARIMA hat seine Relevanz verloren
• Modelle sind aufgrund von Overfitting instabil

Ein entscheidender Durchbruch ist der Übergang zu virtuellen Qubits

In der zweiten Version wird anstelle von Analogien ein vollwertiger Quantenprozessor verwendet: 3 Qubits, ein 8-dimensionaler Zustandsraum, Gatter und Messungen. Die Architektur wurde überarbeitet: Jetzt gehorcht jede Operation den Gesetzen der Quantenmechanik – Unitarität, Normalisierung, Verhalten bei Messungen.

Quantenprozessor-Architektur

Jedes Qubit wird als komplexer Vektor in einem zweidimensionalen Hilbertraum dargestellt.

struct ComplexVector {
    double real[STATE_DIM];
    double imag[STATE_DIM]; 
    int size;
    
    void Initialize(int dim) {
        size = dim;
        for(int i = 0; i < dim; i++) {
            real[i] = (i == 0) ? 1.0 : 0.0;  // Initial state |000⟩
            imag[i] = 0.0;
        }
    }
    
    double GetProbability(int index) {
        return real[index] * real[index] + imag[index] * imag[index];
    }
    
    void Normalize() {
        double norm = 0.0;
        for(int i = 0; i < size; i++) {
            norm += real[i] * real[i] + imag[i] * imag[i];
        }
        
        norm = MathSqrt(norm);
        if(norm > MATRIX_EPSILON) {
            for(int i = 0; i < size; i++) {
                real[i] /= norm;
                imag[i] /= norm;
            }
        }
    }
};

Dieser Code implementiert eine grundlegende Struktur zum Speichern eines Quantenzustands. Im Gegensatz zu klassischen Bits haben Quantenzustände komplexe Amplituden, die miteinander interferieren können. Die Funktion GetProbability berechnet die Wahrscheinlichkeit, ein System gemäß der Bornschen Regel in einem gegebenen Zustand zu messen.

Die Besonderheit der Implementierung besteht darin, dass wir nicht mit einzelnen Qubits arbeiten, sondern mit dem vollständigen Quantenzustand des gesamten Systems. Dies ist entscheidend für die korrekte Modellierung von Verschränkung und Quantenkorrelationen. Jeder Zustand in unserem 8-dimensionalen Raum entspricht einer spezifischen Kombination von drei Qubits: |000⟩, |001⟩, |010⟩, |011⟩, |100⟩, |101⟩, |110⟩, |111⟩.

Quantengatter: Von der Theorie zur Praxis

Rotationsgatter implementieren unitäre Transformationen, die es ermöglichen, den Qubit-Zustand auf der Bloch-Kugel stufenlos zu rotieren:

static void CreateRotationGate(int qubit, double angle, ComplexMatrix &gate) {
    gate.Initialize(STATE_DIM);
    double cos_half = MathCos(angle / 2.0);
    double sin_half = MathSin(angle / 2.0);
    
    for(int i = 0; i < STATE_DIM; i++) {
        for(int j = 0; j < STATE_DIM; j++) {
            gate.real[i][j] = 0.0;
            gate.imag[i][j] = 0.0;
            
            int bit_i = (i >> qubit) & 1;
            int bit_j = (j >> qubit) & 1;
            int other_bits_i = i & ~(1 << qubit);
            int other_bits_j = j & ~(1 << qubit);
            
            if(other_bits_i == other_bits_j) {
                if(bit_i == 0 && bit_j == 0) gate.real[i][j] = cos_half;
                else if(bit_i == 0 && bit_j == 1) gate.imag[i][j] = -sin_half;
                else if(bit_i == 1 && bit_j == 0) gate.imag[i][j] = -sin_half;
                else if(bit_i == 1 && bit_j == 1) gate.real[i][j] = cos_half;
            }
        }
    }
}

Dieser Code konstruiert die Matrix eines Rotationsgatters, die auf ein bestimmtes Qubit wirkt. Der Rotationswinkel steht in direktem Zusammenhang mit Marktdaten – je stärker die Preisbewegung, desto größer der Rotationswinkel. Dies schafft eine direkte Verbindung zwischen Marktdynamik und dem Quantenzustand des Systems.

Der Algorithmus verwendet bitweise Operationen, um zu bestimmen, welche Matrixelemente gefüllt werden müssen. Für jedes Paar von Zuständen |i⟩ und |j⟩ prüfen wir, ob die Rotation eines bestimmten Qubits den Übergang zwischen ihnen beeinflusst. Wenn alle anderen Qubits im gleichen Zustand sind, wirkt die Rotation nur auf das Ziel-Qubit.

Kontrollierte Phasengatter erzeugen Quantenverschränkung zwischen Qubits:

static void CreateCPhaseGate(int control_qubit, int target_qubit, double phase, ComplexMatrix &gate) {
    gate.Initialize(STATE_DIM);
    
    for(int i = 0; i < STATE_DIM; i++) {
        int control_bit = (i >> control_qubit) & 1;
        int target_bit = (i >> target_qubit) & 1;
        
        if(control_bit == 1 && target_bit == 1) {
            gate.real[i][i] = MathCos(phase);
            gate.imag[i][i] = MathSin(phase);
        }
    }
}

Die Phase φ hängt von den Korrelationen zwischen Marktmerkmalen ab. Wenn zwei Marktfaktoren stark korreliert sind (z. B. Preis und Volumen), werden die entsprechenden Qubits verschränkt. Dies ermöglicht es dem System, komplexe Zusammenhänge in den Daten zu berücksichtigen.

Das kontrollierte Phasengatter wirkt nur dann, wenn sich beide Qubits im Zustand |1⟩ befinden. In diesem Fall fügt es den entsprechenden Zustandsamplituden den Phasenfaktor e^(iφ) hinzu. Dies ändert nichts an den Wahrscheinlichkeiten für die Messung einzelner Qubits, erzeugt jedoch Quantenkorrelationen zwischen ihnen.

Hadamard-Gatter versetzen Qubits in Superpositionszustände:

static void CreateHadamardGate(int qubit, ComplexMatrix &gate) {
    gate.Initialize(STATE_DIM);
    double inv_sqrt2 = 1.0 / MathSqrt(2.0);
    
    for(int i = 0; i < STATE_DIM; i++) {
        for(int j = 0; j < STATE_DIM; j++) {
            // ... Hadamard matrix construction code
            if(bit_i == 0 && bit_j == 0) gate.real[i][j] = inv_sqrt2;
            else if(bit_i == 0 && bit_j == 1) gate.real[i][j] = inv_sqrt2;
            else if(bit_i == 1 && bit_j == 0) gate.real[i][j] = inv_sqrt2;
            else if(bit_i == 1 && bit_j == 1) gate.real[i][j] = -inv_sqrt2;
        }
    }
}

Das Hadamard-Gatter erzeugt eine gleichgewichtete Superposition der Zustände |0⟩ und |1⟩. Im Kontext des Tradings bedeutet dies, dass das System gleichzeitig sowohl bullische als auch bärische Marktszenarien berücksichtigen kann, bevor die endgültige „Messung“ (die Handelsentscheidung) getroffen wird.

Dynamische Konstruktion von Quantenschaltkreisen

Die entscheidende Innovation besteht darin, einen Quantenschaltkreis dynamisch aufzubauen, basierend auf eingehenden Marktdaten. Jedes Marktmerkmal beeinflusst die Parameter der Quantengatter und erzeugt einen einzigartigen Quantenverarbeitungspfad für jede Marktsituation.

void BuildQuantumCircuit(const vector &features) {
    num_gates = 0;
    quantum_state.Initialize(STATE_DIM);
    
    // Rotation gates based on market features
    for(int qubit = 0; qubit < NUM_QUBITS && num_gates < MAX_GATES; qubit++) {
        if(qubit < features.Size()) {
            double angle = features[qubit] * M_PI / 2.0;
            CMatrixOps::CreateRotationGate(qubit, angle, circuit_gates[num_gates]);
            num_gates++;
        }
    }
    
    // Entangling gates between pairs of qubits
    for(int i = 0; i < NUM_QUBITS - 1 && num_gates < MAX_GATES; i++) {
        for(int j = i + 1; j < NUM_QUBITS && num_gates < MAX_GATES; j++) {
            double correlation = CalculateFeatureCorrelation(features[i], features[j]);
            double phase = correlation * features[i] * features[j] * M_PI * entanglement_factor;
            
            if(MathAbs(phase) > MIN_PHASE_THRESHOLD) {
                CMatrixOps::CreateCPhaseGate(i, j, phase, circuit_gates[num_gates]);
                num_gates++;
            }
        }
    }
    
    // Adaptive superposition gates
    double market_uncertainty = CalculateMarketUncertainty(features);
    for(int qubit = 0; qubit < NUM_QUBITS && num_gates < MAX_GATES; qubit++) {
        double superposition_probability = coherence * market_uncertainty;
        if(GetRandomDouble() < superposition_probability) {
            CMatrixOps::CreateHadamardGate(qubit, circuit_gates[num_gates]);
            num_gates++;
        }
    }
}

Dieser Algorithmus zeigt, wie Marktdaten direkt die Architektur eines Quantenschaltkreises bestimmen. Im Gegensatz zu statischen neuronalen Netzwerken passt unser System seine interne Struktur an jede Marktsituation an. Eine hohe Korrelation zwischen Merkmalen erzeugt stärker verschränkte Zustände, und Marktunsicherheit erhöht die Wahrscheinlichkeit von Superpositionsoperationen.

Das einzigartige Merkmal unseres Ansatzes ist, dass wir nicht einfach eine feste Abfolge von Gattern anwenden. Stattdessen wird die Struktur adaptiv aufgebaut: Wenn die Korrelation zwischen Merkmalen schwach ist, werden die entsprechenden Verschränkungsgatter nicht erstellt. Wenn die Marktunsicherheit gering ist, werden Superpositionsgatter selten verwendet. Dies ermöglicht es dem System, Rechenressourcen zu sparen und sich auf die relevantesten Quanteneffekte zu konzentrieren.

Quantenevolution und Dekohärenz

Nach dem Aufbau des Schaltkreises fährt das System mit der Quantenevolution fort – der sukzessiven Anwendung unitärer Operatoren auf den Anfangszustand |000⟩:

void ExecuteQuantumCircuit() {
    // Initialize the state
    double state[STATE_DIM];
    ArrayInitialize(state, 0.0);
    state[0] = 1.0;  // Initial state |000⟩
    
    // Apply each gate in the circuit
    for(int gate_idx = 0; gate_idx < num_gates; gate_idx++) {
        ApplyGateToState(state, gate_idx);
    }
    
    // Normalize the state
    double norm = 0.0;
    for(int i = 0; i < STATE_DIM; i++) {
        norm += state[i] * state[i];
    }
    
    norm = MathSqrt(norm);
    if(norm > MATRIX_EPSILON) {
        for(int i = 0; i < STATE_DIM; i++) {
            quantum_state.real[i] = state[i] / norm;
            quantum_state.imag[i] = 0.0;
        }
    }
}

Die Reihenfolge, in der die Operatoren angewendet werden, ist entscheidend, da Quantengatter nicht kommutieren. Dies bedeutet, dass die Abfolge von Marktereignissen den Endzustand des Systems beeinflusst, genau wie in realen Märkten die Reihenfolge des Dateneingangs die Preise beeinflusst.

Simulation der Marktdekohärenz

In realen Finanzsystemen existieren Quanteneffekte in einer „verrauschten“ Umgebung. Der ständige Nachrichtenfluss, die emotionalen Reaktionen der Teilnehmer und makroökonomische Ereignisse erzeugen Dekohärenz:

void ApplyEnvironmentalDecoherence(ComplexVector &state, int evolution_step) {
    // Adaptive assessment of market noise
    double market_volatility = CalculateRecentVolatility();
    double information_flow = CalculateInformationIntensity();
    double decoherence_strength = base_decoherence_rate * 
                                 (1.0 + 0.5 * market_volatility + 0.3 * information_flow);
    
    // Phase decoherence (loss of quantum interference)
    for(int i = 0; i < STATE_DIM; i++) {
        if(state.GetProbability(i) > DECOHERENCE_THRESHOLD) {
            double phase_noise = GenerateGaussianNoise(0.0, decoherence_strength);
            
            // Rotation in the complex plane
            double cos_phase = MathCos(phase_noise);
            double sin_phase = MathSin(phase_noise);
            
            double new_real = state.real[i] * cos_phase - state.imag[i] * sin_phase;
            double new_imag = state.real[i] * sin_phase + state.imag[i] * cos_phase;
            
            state.real[i] = new_real;
            state.imag[i] = new_imag;
        }
    }
    
    state.Normalize();
}

Dieser Code modelliert realistische Dekohärenz, wobei die Intensität von den Marktbedingungen abhängt. In ruhigen Phasen halten Quanteneffekte länger an, während das System bei Marktturbulenzen schnell in ein klassisches Verhalten wechselt.

Dekohärenz ist nicht nur ein technisches Artefakt, sondern ein wichtiger Bestandteil des Modells. Sie spiegelt die Tatsache wider, dass Finanzmärkte die Quantenkohärenz nicht unbegrenzt aufrechterhalten können. Neue Informationen, Händlerentscheidungen und Stimmungsänderungen wirken alle als „Messungen“, die Quantensuperpositionen stören.

Quantenmessungen und Informationsgewinnung

Die Gewinnung von Informationen aus einem Quantenzustand erfordert spezielle Messprotokolle:

vector MeasureQuantumState() {
    vector measurements = vector::Zeros(NUM_QUBITS);
    
    // Compute the probability of measuring each qubit
    for(int qubit = 0; qubit < NUM_QUBITS; qubit++) {
        double prob_1 = 0.0;
        
        for(int i = 0; i < STATE_DIM; i++) {
            if((i >> qubit) & 1) {  // If the qubit is in state |1⟩
                prob_1 += quantum_state.GetProbability(i);
            }
        }
        
        measurements[qubit] = prob_1;  // Probability to measure |1⟩
    }
    
    return measurements;
}

Z-Messungen repräsentieren klassische Handelssignale – die Wahrscheinlichkeit eines Kursanstiegs oder -rückgangs. X-Messungen enthüllen Superpositionseffekte und zeigen Momente maximaler Marktunsicherheit. Zwei-Qubit-Korrelationen enthüllen verborgene Beziehungen zwischen verschiedenen Marktfaktoren.

Ein wichtiges Merkmal unserer Implementierung ist, dass wir zerstörungsfreie Messungen durchführen. Im Gegensatz zu realen Quantensystemen, bei denen die Messung die Wellenfunktion kollabieren lässt, extrahieren wir statistische Informationen, ohne den Quantenzustand zu stören. Dies ermöglicht es, mehrere Messungen durchzuführen und umfassende Informationen über das System zu erhalten.

Hybridarchitektur: Das Beste aus beiden Welten

Die wichtigste Errungenschaft ist eine elegante Integration der Quantenverarbeitung mit klassischen Methoden. Der Quantenprozessor ergänzt und verbessert die klassische Analyse:

double Predict(const vector &input_features, double &confidence, bool is_training = false) {
    // Apply the quantum processor to the input data
    matrix input_matrix(1, input_features.Size());
    input_matrix.Row(input_features, 0);
    
    // Create a base context for the quantum processor
    matrix basic_context = matrix::Zeros(1, input_features.Size());
    for(ulong i = 0; i < input_features.Size(); i++) {
        basic_context[0][i] = MathSin(input_features[i] * M_PI / 4.0);
    }
    
    // Apply quantum effects
    matrix quantum_enhanced_input = input_quantum_proc.ApplyQuantumEffects(input_matrix, basic_context);
    vector quantum_features = quantum_enhanced_input.Row(0);
    
    // Market state classification with quantum-enhanced data
    double price_change = quantum_features[0];
    double volatility = quantum_features[1];
    double volume_ratio = quantum_features[2];
    int state = markov_chain.ClassifyMarketState(price_change, volatility, volume_ratio);

    // Get state embedding
    matrix state_embedding = markov_chain.Forward(state);
    
    // Further processing via classical components...
    matrix ssm_output = ssm.ProcessSequence(quantum_input_matrix);
    matrix contextualized = context_analyzer.ProcessWithContext(combined);
    
    // Transformer layers with quantum attention
    matrix hidden = contextualized;
    for(int i = 0; i < TRANSFORMER_LAYERS; i++) {
        hidden = transformer_layers[i].Forward(hidden, is_training);
    }
    
    // Final forecast
    double prediction = Sigmoid(output_result[0][0] + output_bias[0]);
    confidence = meta_model.Forward(quantum_features, prediction, error_metrics);
    
    return prediction;
}

Dieser Code zeigt, wie Quantenverarbeitung in die gesamte Pipeline integriert wird. Die Rohdaten werden zuerst durch einen Quantenprozessor geleitet, der verborgene Korrelationen aufdeckt und eine angereicherte Repräsentation erstellt. Die quantenangereicherten Daten werden dann von den klassischen Systemkomponenten verarbeitet.

Ein wichtiges Detail der Architektur ist, dass wir klassische Methoden nicht durch Quantenmethoden ersetzen, sondern eine Symbiose schaffen. Der Quantenprozessor fungiert als „Präprozessor“, der die Eingabedaten mit zusätzlichen Informationen über verborgene Korrelationen und nichtlineare Abhängigkeiten anreichert. Klassische Komponenten nutzen diese angereicherten Informationen dann, um genauere Entscheidungen zu treffen.

Die Integration von Quanteneffekten in die Aufmerksamkeitsmechanismen von Transformern verdient besondere Aufmerksamkeit:

matrix Forward(const matrix &input_data, bool is_training) {
    last_input_data = input_data;
    matrix Q = input_data.MatMul(W_q);
    matrix K = input_data.MatMul(W_k);
    matrix V = input_data.MatMul(W_v);
    
    // Apply dropout in training mode
    if (is_training) {
        Q = ApplyDropoutMask(Q, dropout_mask_q, 1.0 / (1.0 - DROPOUT_RATE));
        K = ApplyDropoutMask(K, dropout_mask_k, 1.0 / (1.0 - DROPOUT_RATE));
        V = ApplyDropoutMask(V, dropout_mask_v, 1.0 / (1.0 - DROPOUT_RATE));
    }
    
    // KEY INNOVATION: Quantum processing of Query and Key
    Q = quantum_proc.ApplyQuantumEffects(Q, input_data);
    K = quantum_proc.ApplyQuantumEffects(K, input_data);
    
    // Calculate attention scores with quantum correlations
    matrix scores = Q.MatMul(K.Transpose()) / MathSqrt((double)d_model);
    
    // Use softmax to obtain attention weights
    matrix scores_softmax = matrix::Zeros(scores.Rows(), scores.Cols());
    for(ulong i = 0; i < scores.Rows(); i++) {
        vector row = scores.Row(i);
        double max_val = row.Max();
        for(ulong j = 0; j < row.Size(); j++)
            row[j] = MathExp(row[j] - max_val);
        double sum = row.Sum();
        if (sum == 0.0) sum = 1e-9;
        row = row / sum;
        scores_softmax.Row(row, i);
    }
    
    matrix attention_output = scores_softmax.MatMul(V);
    return attention_output.MatMul(W_o);
}

Die Quantenverarbeitung von Query- und Key-Matrizen ermöglicht es dem Aufmerksamkeitsmechanismus, nicht nur lineare Beziehungen zwischen Merkmalen, sondern auch deren Quantenkorrelationen zu berücksichtigen. Dies ist besonders effizient für die Identifizierung schwacher Signale in verrauschten Finanzdaten.

Das gesamte System wurde als Trading-EA für MetaTrader 5 implementiert und vollständig in MQL5 ohne externe Abhängigkeiten geschrieben. Die Architektur umfasst die folgenden Schlüsselkomponenten:

struct QuantumContextAnalyzer {
    matrix short_memory, medium_memory, long_memory, episodic_memory, pattern_memory;
    
    matrix ProcessWithContext(const matrix &input_data) {
        // Adaptive weighting of memory types
        double input_volatility = CalculateVolatility(input_data);
        double short_weight = 0.4 + 0.4 * input_volatility;
        double medium_weight = 0.3 + 0.2 * (1.0 - input_volatility);
        double long_weight = 0.2 + 0.3 * (1.0 - input_volatility);
        
        // Apply quantum effects to contextual information
        matrix quantum_result = quantum_proc.ApplyQuantumEffects(input_matrix, context_matrix);
        
        return quantum_result;
    }
};

Das System wählt je nach Marktbedingungen dynamisch den relevantesten Gedächtnistyp aus. In Zeiten hoher Volatilität wird das Kurzzeitgedächtnis stärker gewichtet, während in ruhigen Zeiten das Langzeitgedächtnis stärker gewichtet wird.

double Forward(const vector &original_features, double prediction, const vector &error_metrics) {
    vector meta_input = vector::Zeros(original_features.Size() + 1 + error_metrics.Size());
    
    // Combine the original features, forecast, and error metrics
    for(ulong i = 0; i < original_features.Size(); i++)
        meta_input[i] = original_features[i];
    meta_input[original_features.Size()] = prediction;
    for(ulong i = 0; i < error_metrics.Size(); i++)
        meta_input[original_features.Size() + 1 + i] = error_metrics[i];
    
    // Confidence prediction via a two-layer network
    matrix hidden = input_matrix.MatMul(meta_weights);
    for(ulong i = 0; i < hidden.Cols(); i++) 
        hidden[0][i] = Tanh(hidden[0][i] + meta_bias[i]);
    
    matrix output_result = hidden.MatMul(output_weights);
    return Sigmoid(output_result[0][0] + output_bias_meta[0]);
}

Das Metamodell analysiert nicht nur die aktuelle Prognose, sondern auch die Systemfehlerhistorie und schätzt die Konfidenz für den jeweiligen Einzelfall adaptiv ab.

Besonderes Augenmerk wurde auf die Integration in das Risikomanagementsystem für die Arbeit mit Prop-Firmen gelegt. Moderne Prop-Firmen haben strenge Anforderungen an maximale Drawdowns, tägliche Verlustlimits und Gewinnziele.

Live-Handelsergebnisse: Theorie trifft auf Realität

Der wichtigste Test für jedes Handelssystem sind seine Ergebnisse unter realen Marktbedingungen. Für 2024–2025 zeigte das Quantensystem:

Finanzergebnisse:

• Jahresrendite: +13,3 %
• Maximaler Drawdown: 2,39 %
• Gewinnrate: 87 %
• Sharpe Ratio: 2,48
• Durchschnittliche Haltedauer: 4,2 Stunden

Systemanpassungsfähigkeit: Besonders wichtig ist, dass das System unter verschiedenen Marktbedingungen stabile Ergebnisse gezeigt hat. In Zeiten hoher Volatilität reduzierte es automatisch die Positionsgrößen und agierte konservativer. Im Gegensatz dazu verhielt es sich in ruhigen Phasen aggressiver und nutzte Quanteneffekte, um nach schwachen, aber stabilen Signalen zu suchen.

Trotz der beeindruckenden Ergebnisse hat das System noch nicht alle seine Ziele erreicht:

Aktuelle Einschränkungen:

• Die Sharpe-Ratio von 2,48 liegt noch unter dem Zielwert von 3,5+
• Die Rechenkomplexität eines Quantensimulators erfordert erhebliche Ressourcen
• Die Hyperparameter-Optimierung bleibt eine Herausforderung
• Das System erfordert eine sorgfältige Kalibrierung für jedes Handelsinstrument

Schlussfolgerung

Die Zukunft quantenbasierter Ansätze eröffnet eine neue Welt im algorithmischen Handel. Der Übergang zu virtuellen Qubits brachte einen erheblichen Vorteil gegenüber klassischen Methoden und verbesserte Vorhersagen und Ergebnisse. Unser System, das auf den Prinzipien der Quantenmechanik basiert, bewältigt auf natürliche Weise Marktunsicherheiten und komplexe Korrelationen, was für klassische Modelle weiterhin eine Herausforderung darstellt. Die Schaffung des ersten vollwertigen Quantensimulators, die adaptive Architektur und die Integration von Quanten- und klassischen Methoden in einem Hybridsystem unterstreichen unsere Erfolge.

In Zukunft werden wir uns auf die Optimierung des Systems und das Erreichen einer Ziel-Sharpe-Ratio von über 3,5 konzentrieren und das Quanten-Handelsökosystem weiterentwickeln. Die vollständige Implementierung ist als Trading-EA für MetaTrader 5 verfügbar und für den Echtzeiteinsatz bereit.