Matrices, tenseurs et algèbre tropicale : l'algèbre linéaire pour la détection d'arbitrage

Partie 4 de la série "Chaînes d'arbitrage complexes entre futures et spot"

Imaginez une immense salle où des centaines de traders échangent des devises simultanément. Chacun a ses propres taux, frais et particularités. Vous êtes au centre avec un carnet, essayant de trouver un circuit d'échange qui rapporte un profit : dollars vers euros, euros vers yens, yens de retour vers dollars—et repartir avec plus que ce avec quoi vous avez commencé. Il est facile de s'y perdre. Mais si vous inscrivez tous les taux dans un tableau—une matrice—le chaos gagne soudain en structure. Les valeurs propres de cette matrice vous diront s'il existe un arbitrage. L'algèbre tropicale trouvera le circuit optimal. Et les décompositions tensorielles révéleront des motifs invisibles à l'œil nu.

Dans cet article, nous partirons d'un simple tableau de taux de change pour aller vers des méthodes d'analyse multidimensionnelles avancées—et chaque étape sera étayée par une implémentation en Rust.

Visualisation de la matrice des taux de change entre cryptomonnaies : les arêtes du graphe représentent des paires de trading, et le cycle mis en évidence représente une opportunité d'arbitrage détectée.

1. La matrice des taux de change : les fondations

1.1 Du chaos au tableau

Supposons que nous ayons n actifs : BTC, ETH, USDT, SOL, etc. Chaque paire peut être échangée à un certain taux. La Matrice des Taux de Change R est un tableau n × n où l'élément R[i][j] indique combien d'unités de l'actif j nous obtenons pour une unité de l'actif i.

Propriétés d'une matrice bien formée :

• Diagonale : R[i][i] = 1—échanger un actif contre lui-même ne change rien.
• Positivité : R[i][j] > 0 pour toutes les paires.
• Réciprocité (dans un marché idéal) : R[i][j] * R[j][i] = 1.

En Rust, nous pouvons représenter cela avec 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 La condition d'absence d'arbitrage

Voici le théorème clé sur lequel tout le reste repose.

Théorème. Un marché est exempt d'arbitrage si et seulement si, pour tout cycle d'actifs (i₁, i₂, ..., iₖ, i₁), le produit des taux de change le long du cycle est égal à un :

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

Formulation équivalente : une matrice R est exempte d'arbitrage si et seulement si son rang est 1 (au sens multiplicatif). Cela signifie qu'il existe un vecteur de prix p = (p₁, p₂, ..., pₙ) tel que :

R[i][j] = pj / pi   pour tout i, j

La matrice R se décompose comme un produit extérieur R = (1/p) * pᵀ—et il s'agit d'une matrice de rang 1. Si la matrice réelle s'écarte du rang 1—une opportunité d'arbitrage se cache quelque part.

2. La méthode des valeurs propres : arbitrage en O(n³)

2.1 Le théorème de Ming Ma

L'une des approches les plus élégantes de la détection d'arbitrage a été proposée par Ming Ma en 2007. L'idée est d'une simplicité remarquable.

Théorème (Ming Ma). Soit R une matrice de taux de change n × n. Si le marché est exempt d'arbitrage, alors :

1. La plus grande valeur propre λ_max = n.
2. Toutes les autres valeurs propres sont égales à zéro.
3. Le vecteur propre correspondant v représente les prix d'équilibre.

Pourquoi cela fonctionne-t-il ? Une matrice exempte d'arbitrage a un rang de 1, et sa trace (la somme des éléments diagonaux) est égale à n (car chaque R[i][i] = 1). Pour une matrice de rang 1, la seule valeur propre non nulle est égale à la trace. Par conséquent, λ_max = n.

Critère d'arbitrage : l'arbitrage existe si et seulement si λ_max > n. L'écart δ = λ_max - n estime quantitativement l'ampleur de l'opportunité d'arbitrage.

3. Algèbre tropicale (max-plus) : la méthode la plus élégante

3.1 Quand l'addition devient un maximum

C'est peut-être la plus belle découverte de notre étude. L'algèbre tropicale est un système algébrique où les opérations familières sont redéfinies :

• « Addition » : a ⊕ b = max(a, b)
• « Multiplication » : a ⊗ b = a + b

La multiplication matricielle dans cette algèbre recherche automatiquement le chemin dont la somme des poids est maximale. C'est exactement ce qu'il faut pour trouver le cycle d'arbitrage le plus rentable.

3.2 Valeur propre tropicale et arbitrage

Prenons la matrice logarithmique des taux L[i][j] = ln(R[i][j]). Calculons la valeur propre tropicale λ de la matrice L.

Théorème. λ > 0 si et seulement si un arbitrage existe. De plus, exp(λ) est le multiplicateur de profit du meilleur cycle.

/// 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. ACP et modèles factoriels : arbitrage statistique

Nous passons de l'arbitrage déterministe (écarts de prix directs) à l'arbitrage statistique—la recherche d'écarts systématiques par rapport à un modèle factoriel.

L'Analyse en Composantes Principales (ACP) décompose les rendements des actifs en facteurs systématiques et résidus idiosyncratiques :

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

où Fk(t) est le k-ième facteur, βik est la charge (loading), et εi(t) est le résidu—le signal d'arbitrage.

4.1 Théorie des matrices aléatoires (RMT)

Question clé : combien de facteurs faut-il conserver ? La distribution de Marchenko-Pastur décrit le spectre des valeurs propres d'une matrice de covariance aléatoire. Les valeurs propres au-dessus de la borne supérieure $λ_+$ portent des signaux réels, tandis que celles situées à l'intérieur de la borne sont du bruit.

5. Méthodes tensorielles : la troisième dimension de l'arbitrage

L'arbitrage des cryptomonnaies implique plusieurs dimensions simultanément. La matrice des taux n'est qu'une coupe 2D. L'image réelle est un Tenseur :

T(a, e, i) = prix/taux pour l'actif a sur l'exchange e pour l'instrument i

Dimensions :

• Mode 1 (Actifs) : BTC, ETH, SOL, ...
• Mode 2 (Exchanges) : Binance, Kraken, Coinbase, ...
• Mode 3 (Instruments) : Spot, Perpetual, Futures, ...

La décomposition CP (CANDECOMP/PARAFAC) factorise le tenseur en une somme de tenseurs de rang 1. Les résidus T - T_approx révèlent des anomalies où des combinaisons spécifiques actif/exchange/instrument sont mal valorisées par rapport à la structure factorielle globale du marché.

Conclusion

Des simples tableaux aux tenseurs multidimensionnels, l'algèbre linéaire fournit un langage formel pour le marché des cryptomonnaies. Rust nous permet d'exécuter ces modèles complexes avec la vitesse requise pour le HFT.

Dans la prochaine partie, nous explorerons les GNN, Transformers et RL pour l'arbitrage, en examinant comment les réseaux de neurones apprennent à trader.

Vous traitez des signaux à haute dimensionnalité ? Découvrez notre moteur de trading basé sur les tenseurs sur GitHub.