Matrices, tensoren en tropische algebra: lineaire algebra voor arbitragedetectie

Deel 4 van de reeks "Complexe arbitrageketens tussen futures en spot"

Stel je een enorme zaal voor waarin honderden traders gelijktijdig valuta's wisselen. Iedereen heeft zijn eigen koersen, kosten en eigenaardigheden. Jij staat in het midden met een notitieboekje en probeert een wisselroute te vinden die winst oplevert: dollars naar euro's, euro's naar yen, yen terug naar dollars—en met meer naar buiten stappen dan waarmee je begon. Het is makkelijk om de weg kwijt te raken. Maar als je alle koersen in een tabel—een matrix—zet, krijgt de chaos plotseling structuur. De eigenwaarden van deze matrix vertellen je of er arbitrage bestaat. Tropische algebra vindt de optimale route. En tensor-decomposities onthullen patronen die voor het blote oog onzichtbaar zijn.

In dit artikel reizen we van een eenvoudige wisselkoerstabel naar geavanceerde meerdimensionale analysemethoden—en elke stap wordt ondersteund door een implementatie in Rust.

Visualisatie van de wisselkoersmatrix tussen cryptovaluta's: de randen van de graaf vertegenwoordigen handelsparen, en de gemarkeerde cyclus toont een gedetecteerde arbitragekans.

1. De wisselkoersmatrix: de basis

1.1 Van chaos naar tabel

Stel dat we n activa hebben: BTC, ETH, USDT, SOL, enzovoort. Elk paar kan tegen een bepaalde koers worden gewisseld. De Wisselkoersmatrix R is een n × n-tabel waarin element R[i][j] aangeeft hoeveel eenheden van activum j we krijgen voor één eenheid van activum i.

Eigenschappen van een goed gevormde matrix:

• Diagonaal: R[i][i] = 1—een activum ruilen voor zichzelf verandert niets.
• Positiviteit: R[i][j] > 0 voor alle paren.
• Reciprociteit (in een ideale markt): R[i][j] * R[j][i] = 1.

In Rust kunnen we dit weergeven met nalgebra:

use nalgebra::DMatrix;

/// Builds an exchange rate matrix from a set of trading pairs
fn build_exchange_rate_matrix(
    assets: &[&str],
    rates: &[((usize, usize), f64)],
) -> DMatrix<f64> {
    let n = assets.len();
    let mut matrix = DMatrix::from_element(n, n, 0.0);

    // Diagonal: exchange for self = 1
    for i in 0..n {
        matrix[(i, i)] = 1.0;
    }

    // Fill known rates
    for &((i, j), rate) in rates {
        matrix[(i, j)] = rate;
        // Reciprocal rate (if there is no direct one)
        if matrix[(j, i)] == 0.0 {
            matrix[(j, i)] = 1.0 / rate;
        }
    }

    matrix
}

1.2 De no-arbitrage-voorwaarde

Dit is de sleutelstelling waarop al het overige is gebouwd.

Stelling. Een markt is vrij van arbitrage dan en slechts dan als voor elke cyclus van activa (i₁, i₂, ..., iₖ, i₁) het product van de wisselkoersen langs de cyclus gelijk is aan één:

R[i₁][i₂] * R[i₂][i₃] * ... * R[iₖ][i₁] = 1

Equivalente formulering: een matrix R is arbitragevrij dan en slechts dan als de rang gelijk is aan 1 (in multiplicatieve zin). Dit betekent dat er een prijsvector p = (p₁, p₂, ..., pₙ) bestaat zodat:

R[i][j] = pj / pi   voor alle i, j

De matrix R valt uiteen als een uitwendig product R = (1/p) * pᵀ—en dit is een matrix van rang 1. Als de werkelijke matrix afwijkt van rang 1—schuilt er ergens een arbitragekans.

2. De eigenwaardemethode: arbitrage in O(n³)

2.1 De stelling van Ming Ma

Een van de meest elegante benaderingen voor arbitragedetectie werd in 2007 voorgesteld door Ming Ma. Het idee is briljant eenvoudig.

Stelling (Ming Ma). Laat R een n × n-wisselkoersmatrix zijn. Als de markt arbitragevrij is, dan geldt:

1. De grootste eigenwaarde λ_max = n.
2. Alle andere eigenwaarden zijn gelijk aan nul.
3. De bijbehorende eigenvector v vertegenwoordigt de evenwichtsprijzen.

Waarom werkt dit? Een arbitragevrije matrix heeft rang 1, en het spoor (de som van de diagonale elementen) is gelijk aan n (omdat elke R[i][i] = 1). Voor een matrix van rang 1 is de enige eigenwaarde die niet nul is gelijk aan het spoor. Daarom geldt λ_max = n.

Arbitragecriterium: arbitrage bestaat dan en slechts dan als λ_max > n. De afwijking δ = λ_max - n schat kwantitatief de omvang van de arbitragekans.

3. Tropische (max-plus) algebra: de meest elegante methode

3.1 Wanneer optellen een maximum wordt

Dit is misschien wel de mooiste vondst van ons onderzoek. Tropische algebra is een algebraïsch systeem waarin vertrouwde bewerkingen opnieuw worden gedefinieerd:

• "Optelling": a ⊕ b = max(a, b)
• "Vermenigvuldiging": a ⊗ b = a + b

Matrixvermenigvuldiging in deze algebra zoekt automatisch naar het pad met de maximale som van gewichten. Dit is precies wat nodig is om de meest winstgevende arbitragecyclus te vinden.

3.2 Tropische eigenwaarde en arbitrage

Neem de log-matrix van de koersen L[i][j] = ln(R[i][j]). Bereken de tropische eigenwaarde λ van matrix L.

Stelling. λ > 0 dan en slechts dan als er arbitrage bestaat. Bovendien is exp(λ) de winstvermenigvuldiger van de beste cyclus.

/// Tropical (max-plus) matrix multiplication
fn tropical_matmul(a: &DMatrix<f64>, b: &DMatrix<f64>) -> DMatrix<f64> {
    let n = a.nrows();
    let m = b.ncols();
    let k = a.ncols();
    let mut result = DMatrix::from_element(n, m, f64::NEG_INFINITY);

    for i in 0..n {
        for j in 0..m {
            for l in 0..k {
                // Tropical multiplication: max instead of sum, + instead of *
                let val = a[(i, l)] + b[(l, j)];
                if val > result[(i, j)] {
                    result[(i, j)] = val;
                }
            }
        }
    }
    result
}

4. PCA en factormodellen: statistische arbitrage

We gaan van deterministische arbitrage (directe prijsverschillen) naar statistische arbitrage—het opsporen van systematische afwijkingen van een factormodel.

Principale Componentenanalyse (PCA) ontleedt rendementen van activa in systematische factoren en idiosyncratische residuen:

ri(t) = αi + Σk βik * Fk(t) + εi(t)

waarbij Fk(t) de k-de factor is, βik de loading, en εi(t) het residu—het arbitragesignaal.

4.1 Random Matrix Theory (RMT)

Kernvraag: hoeveel factoren moet je behouden? De Marchenko-Pastur-verdeling beschrijft het spectrum van eigenwaarden voor een willekeurige covariantiematrix. Eigenwaarden boven de bovengrens $λ_+$ dragen echte signalen, terwijl die binnen de grens ruis zijn.

5. Tensor-methoden: de derde dimensie van arbitrage

Crypto-arbitrage omvat meerdere dimensies tegelijk. De koersmatrix is slechts een 2D-doorsnede. Het werkelijke beeld is een Tensor:

T(a, e, i) = prijs/koers voor activum a op exchange e voor instrument i

Dimensies:

• Modus 1 (Activa): BTC, ETH, SOL, ...
• Modus 2 (Exchanges): Binance, Kraken, Coinbase, ...
• Modus 3 (Instrumenten): Spot, Perpetual, Futures, ...

CP-decompositie (CANDECOMP/PARAFAC) factoriseert de tensor in een som van rang-1-tensoren. Residuen T - T_approx onthullen anomalieën waar specifieke combinaties van activum/exchange/instrument verkeerd geprijsd zijn ten opzichte van de algehele factorstructuur van de markt.

Conclusie

Van eenvoudige tabellen tot meerdimensionale tensoren, lineaire algebra biedt een formele taal voor de cryptomarkt. Rust stelt ons in staat om deze complexe modellen uit te voeren met de snelheid die vereist is voor HFT.

In het volgende deel verkennen we GNN's, Transformers en RL voor arbitrage, en kijken we hoe neurale netwerken leren handelen.

Verwerk je hoogdimensionale signalen? Bekijk onze Tensor-gebaseerde Trading Engine op GitHub.