Transfer Entropy: Which Way Does Information Flow Between Crypto Assets?

Questo blog ha già stabilito che le crypto sono vicine a un mercato a un fattore: la correlazione dei segnali tra coppie assegna a PC1 (il fattore BTC) il 65% della varianza e mostra che quattro fattori spiegano il 90%, quindi dieci coppie "diversificate" contengono l'informazione di tre o quattro coppie indipendenti. Ha anche stabilito che la struttura della dipendenza non è nemmeno costante: DCC-GARCH modella la matrice di correlazione come una serie temporale con regimi propri, e la sua sezione Limitazioni dice apertamente la parte scomoda — "la correlazione non è causalità e non è direzione".

È proprio quest'ultima clausola il divario affrontato da questo articolo. DCC dice quando la dipendenza si restringe. Non può dire verso quale direzione punti. La transfer entropy può farlo: è una misura senza modello e intrinsecamente asimmetrica di quanti bit il passato di una serie contribuisca a prevedere il futuro di un'altra, oltre a quanto il passato del target già spiega. Se ETH invia costantemente informazioni ad AAVE prima che AAVE si riprezzi, la transfer entropy vede l'asimmetria che nessuna matrice di correlazione può rappresentare.

Seguono la misura, il suo stimatore e — più importante della misura stessa — la calibrazione del nullo e l'analisi di sensibilità che determinano se una rete misurata di flussi informativi sia un segnale o semplice decorazione.

La rete misurata

Stato: non ancora eseguita. La pipeline seguente è implementata, ma non è ancora stata eseguita su dati reali per questo articolo. Finché non lo sarà, questo articolo è una descrizione del metodo, non un risultato. Lo standard del blog — vedi il risultato negativo onesto e Sharpe deflazionato e test multipli — è che una rete non calibrata sia rumore finché non si dimostra il contrario.

Qui devono essere riportate quattro cose, in quest'ordine, e nessuna può essere affermata sulla base della letteratura:

1. La matrice TE effettiva. Universo, exchange, intervallo di date, dimensione delle barre, TE effettiva in bit per ogni coppia ordinata, p-value per coppia e grafo diretto che supera il filtro di significatività. Questo sostituisce il solito vago discorso ("BTC è la fonte dominante, i token DeFi sono pozzi") con una tabella di forza in uscita, forza in entrata e flusso netto.
2. Il tasso di falsi positivi del test di significatività, misurato eseguendo l'intera pipeline su serie mescolate e su serie sintetiche indipendenti. Vedi Calibrazione del nullo più avanti.
3. Uno sweep di sensibilità sui due parametri liberi: n_bins in {3, 5} incrociato con k in {1, 2, 3, 5}. Se la graduatoria leader/follower vale solo in una cella di quella griglia, questa è la scoperta.
4. Stabilità nel tempo. La graduatoria misurata persiste fuori campione o si rimescola a ogni finestra? Nulla di ciò che viene dopo merita di essere scritto finché non si risponde a questa domanda.

La meccanica

Tre elementi costitutivi

L'entropia di Shannon misura l'incertezza di una variabile casuale $X$:

$H(X) = -\sum_{i=1}^{n} p(x_i) \log_2 p(x_i)$

Un lancio di moneta vale 1 bit; un dado equo vale $\log_2 6 \approx 2.58$ bit; una variabile deterministica vale 0.

L'entropia condizionata misura quanta incertezza su $Y$ rimane sapendo $X$:

$H(Y|X) = -\sum_{x,y} p(x,y) \log_2 \frac{p(x,y)}{p(x)}$

È 0 quando $X$ determina $Y$, ed è uguale a $H(Y)$ quando sono indipendenti.

L'informazione mutua è l'informazione condivisa tra le due variabili:

$I(X;Y) = H(Y) - H(Y|X) = H(X) - H(X|Y)$

È simmetrica — $I(X;Y) = I(Y;X)$ — e proprio questa simmetria deve essere spezzata.

Transfer entropy

La transfer entropy, introdotta da Schreiber (2000), spezza la simmetria condizionando sul passato del target. Misura quanto il passato della sorgente $X$ riduca l'incertezza sul futuro del target $Y$, oltre a ciò che il passato di $Y$ già spiega.

Sia $Y_t^{(k)}$ la storia di lunghezza $k$, $(Y_{t-1}, \dots, Y_{t-k})$, e $X_t^{(l)}$ la storia della sorgente di lunghezza $l$:

$T_{X \to Y} = \sum p(Y_{t+1}, Y_t^{(k)}, X_t^{(l)}) \log_2 \frac{p(Y_{t+1} \mid Y_t^{(k)}, X_t^{(l)})}{p(Y_{t+1} \mid Y_t^{(k)})}$

In modo equivalente, come differenza di entropie condizionate:

$T_{X \to Y} = H(Y_{t+1} \mid Y_t^{(k)}) - H(Y_{t+1} \mid Y_t^{(k)}, X_t^{(l)})$

Se il passato di $X$ non aiuta a prevedere $Y$ oltre il passato di $Y$, $T_{X \to Y} = 0$. Se lo fa, la grandezza è il numero di bit di informazione predittiva che fluisce.

Proprietà principali:

• Non negativa: $T_{X \to Y} \geq 0$.
• Asimmetrica: in generale $T_{X \to Y} \neq T_{Y \to X}$. È questo il punto.
• Non parametrica: nessuna ipotesi sul modello — cattura allo stesso modo dipendenze lineari e non lineari.
• Unità: bit con $\log_2$, nat con $\ln$.

La transfer entropy netta dà la direzione dominante:

$T_{X \to Y}^{\text{net}} = T_{X \to Y} - T_{Y \to X}$

Un valore positivo significa che $X$ è un mittente netto verso $Y$; un valore negativo significa che è $Y$ a guidare.

Transfer entropy e causalità di Granger a confronto

La causalità di Granger (GC) chiede se il passato di $X$ migliori una previsione autoregressiva lineare di $Y$. Non è il test di cointegrazione Engle-Granger trattato in arbitraggio statistico e pair trading — stesso cognome, concetto non correlato. Engle-Granger chiede se una combinazione lineare di due serie non stazionarie sia stazionaria; la causalità di Granger chiede se una serie aiuti a prevedere un'altra. I lettori di questo blog le confonderanno, quindi vale la pena dirlo chiaramente.

Equivalenza teorica per processi gaussiani

Barnett, Barrett e Seth (2009) hanno dimostrato che per processi congiuntamente gaussiani, causalità di Granger e transfer entropy sono equivalenti a meno di una trasformazione monotona:

$T_{X \to Y} = \frac{1}{2} \ln\left(1 + F_{X \to Y}\right)$

dove $F_{X \to Y}$ è la statistica di causalità di Granger (un rapporto di log-verosimiglianze). Per dati gaussiani lineari si recupera esattamente la stessa struttura causale con entrambi i metodi. La transfer entropy non è quindi tanto una rivale della GC quanto la sua generalizzazione non parametrica: si riduce alla GC proprio quando valgono le ipotesi della GC.

Dove divergono

Il divario conta in linea di principio per le crypto: i rendimenti hanno code pesanti, la volatilità si raggruppa e le relazioni dipendono dal regime, tutte caratteristiche che un VAR lineare appiattisce. Se il divario è abbastanza grande da cambiare la graduatoria dei leader su dati reali è una domanda empirica a cui questo articolo deve rispondere, non una cosa da presumere.

Dimpfl e Peter (2013) riferiscono che la transfer entropy rileva flussi che la causalità di Granger perde nelle serie finanziarie, soprattutto sotto stress; Keskin e Aste (2020) riferiscono una rete più ricca dalla TE non lineare nelle crypto. Entrambi sono citati qui come motivazione, non come prova per questo dataset.

Transfer entropy effettiva: la correzione del bias

Questa è la parte in cui è facile sbagliare. Le stime della TE grezza sono distorte verso l'alto nei campioni finiti: inserendo due serie indipendenti si stimerà comunque $T_{X \to Y} > 0$, soltanto per il rumore campionario nella distribuzione congiunta empirica. Il bias cresce con il numero di stati congiunti, che cresce esponenzialmente in $k + l$.

La transfer entropy effettiva sottrae quel bias:

$T_{X \to Y}^{\text{eff}} = T_{X \to Y} - \mathbb{E}\!\left[T_{X_{\text{surrogate}} \to Y}\right]$

dove il surrogato distrugge la struttura temporale di $X$ preservandone la distribuzione marginale. Nota cosa sia e cosa non sia: la media dei surrogati è una stima del bias dello stimatore stesso e noi la sottraiamo. Non è un intervallo di confidenza e la TE effettiva non è "TE con barre d'errore". Lo stesso insieme di surrogati svolge anche il ruolo di distribuzione nulla per un p-value, ma sottrazione e test sono usi distinti.

Il surrogato viene generato con un block bootstrap, così l'autocorrelazione di $X$ all'interno di un blocco sopravvive —la meccanica generale e la motivazione del ricampionamento a blocchi sono trattate in Monte Carlo e bootstrap per backtest.

Implementazione

Dati: rendimenti logaritmici orari per un universo fisso di principali perpetui USDT su un singolo exchange, in un intervallo di date contiguo e dichiarato. Il recupero standard di OHLCV e la costruzione dei rendimenti logaritmici sono boilerplate trattato in arbitraggio statistico e pair trading e non vengono ripetuti.

Discretizzazione — e avviso sulla leakage

La transfer entropy richiede stati discreti. Il binning per quantili è la scelta abituale, ed è anche il luogo abituale in cui si introduce il futuro.

import numpy as np
import pandas as pd

def discretize_trailing(series, n_bins=3, warmup=500):
    """Discretize using bin edges estimated on a TRAILING window only.

    Computing quantile edges over the full sample is whole-series
    normalization leakage: every bar's label depends on the entire
    future distribution. See the look-ahead bias taxonomy.
    """
    x = np.asarray(series, dtype=float)
    out = np.full(len(x), -1, dtype=int)
    qs = np.linspace(0, 1, n_bins + 1)[1:-1]
    for t in range(warmup, len(x)):
        edges = np.quantile(x[:t], qs)      # strictly past data
        out[t] = np.digitize(x[t], edges)
    return out

La versione ingenua su tutto il campione va bene per un'affermazione descrittiva — "in questo periodo l'informazione è fluita in questa direzione" — ma è contaminata per qualsiasi affermazione tradabile. Questa distinzione è l'intero argomento della tassonomia del look-ahead bias. Se usi bordi calcolati sull'intero campione, dichiaralo e fermati prima della parola "segnale".

Transfer entropy da zero

from collections import Counter

def transfer_entropy(source, target, k=1, l=1):
    """Transfer entropy T_{source -> target} in bits.

    source, target : 1-D integer arrays of discrete states
    k : history length for the target
    l : history length for the source
    """
    source = np.asarray(source)
    target = np.asarray(target)
    n = len(target)
    max_lag = max(k, l)

    y_future = target[max_lag:]
    y_past = np.column_stack([target[max_lag - i - 1:n - i - 1] for i in range(k)])
    x_past = np.column_stack([source[max_lag - i - 1:n - i - 1] for i in range(l)])
    N = len(y_future)

    yf = y_future.tolist()
    yp = [tuple(row) for row in y_past]
    xp = [tuple(row) for row in x_past]

    c_yf_yp_xp = Counter(zip(yf, yp, xp))
    c_yp_xp = Counter(zip(yp, xp))
    c_yf_yp = Counter(zip(yf, yp))
    c_yp = Counter(yp)

    te = 0.0
    for (yf_val, yp_val, xp_val), count in c_yf_yp_xp.items():
        p_joint = count / N
        p_yf_given_yp_xp = count / c_yp_xp[(yp_val, xp_val)]
        p_yf_given_yp = c_yf_yp[(yf_val, yp_val)] / c_yp[yp_val]
        if p_yf_given_yp > 0 and p_yf_given_yp_xp > 0:
            te += p_joint * np.log2(p_yf_given_yp_xp / p_yf_given_yp)

    return te

TE effettiva con un nullo block-bootstrap

def effective_transfer_entropy(source, target, k=1, l=1,
                               n_shuffles=200, block_size=5, rng=None):
    """Effective TE plus a surrogate p-value.

    Returns dict: te, ete, p_value, null_mean, null_std
    """
    rng = rng or np.random.default_rng(0)
    te_observed = transfer_entropy(source, target, k, l)

    n = len(source)
    n_blocks = int(np.ceil(n / block_size))
    null_tes = np.empty(n_shuffles)

    for b in range(n_shuffles):
        starts = rng.integers(0, n, size=n_blocks)
        shuffled = np.concatenate(
            [np.take(source, range(s, s + block_size), mode='wrap')
             for s in starts]
        )[:n]
        null_tes[b] = transfer_entropy(shuffled, target, k, l)

    null_mean = null_tes.mean()
    return {
        'te': te_observed,
        'ete': max(te_observed - null_mean, 0.0),
        'p_value': (np.sum(null_tes >= te_observed) + 1) / (n_shuffles + 1),
        'null_mean': null_mean,
        'null_std': null_tes.std(),
    }

La matrice a coppie

def compute_te_matrix(disc_returns, k=1, n_shuffles=200):
    cols = list(disc_returns.columns)
    m = len(cols)
    te_matrix = np.zeros((m, m))
    pval_matrix = np.ones((m, m))

    for i in range(m):
        for j in range(m):
            if i == j:
                continue
            r = effective_transfer_entropy(
                disc_returns[cols[i]].values,
                disc_returns[cols[j]].values,
                k=k, n_shuffles=n_shuffles,
            )
            te_matrix[i, j] = r['ete']
            pval_matrix[i, j] = r['p_value']

    return (pd.DataFrame(te_matrix, index=cols, columns=cols),
            pd.DataFrame(pval_matrix, index=cols, columns=cols))

Il percorso rapido

pyinform racchiude un'implementazione C ottimizzata:

from pyinform.transferentropy import transfer_entropy as te_pyinform

te_btc_to_eth = te_pyinform(btc_disc, eth_disc, k=2)
te_eth_to_btc = te_pyinform(eth_disc, btc_disc, k=2)

Calibrazione del nullo

Questa è la parte di maggior valore dell'analisi e quella che viene saltata più spesso. Prima di credere a qualsiasi arco nella rete misurata, esegui l'intera pipeline — discretizzazione, TE effettiva, test surrogato e filtro di significatività — su dati in cui la risposta vera è nota essere zero:

1. Rendimenti reali mescolati. Distruggi la sincronizzazione temporale tra le serie mantenendo la distribuzione marginale di ciascuna.
2. Serie sintetiche indipendenti. Simula $M$ processi indipendenti con code pesanti e volatilità raggruppata, senza dipendenza incrociata per costruzione.

Poi riporta la frazione di coppie ordinate che il test segnala con $\alpha = 0.05$. Se tale frazione non è vicina a 0.05, il test è mal calibrato e ogni arco nella rete reale è sospetto.

I test multipli aggravano il problema. Un universo di 8 asset comporta $8 \times 7 = 56$ test a coppie ordinate; 20 asset ne comportano 380. Le correzioni — Bonferroni, Holm e FDR di Benjamini-Yekutieli — sono derivate integralmente in Sharpe deflazionato e test multipli, insieme allo studio di calibrazione in cui la FDR del test ingenuo è 1.000 contro 0.007 per BHY.

Ma non fermarti a un Bonferroni grezzo, perché questi 56 test non sono 56 osservazioni indipendenti. Gli asset crypto sono fortemente correlati tra loro — questo blog ha misurato PC1 al 65% della varianza —, proprio il modo di fallimento della griglia correlata documentato nell'Atto 5 di quell'articolo: trattare il conteggio grezzo delle celle di una griglia correlata come numero di prove porta a una sovra-deflazione e rifiuta falsamente un arco genuino. Il risultato consegnato lì era una banda di stime delle prove effettive, non un punto: la formula basata sulla correlazione media $N_{\text{eff}} = N/(1 + (N-1)\bar\rho)$ all'estremo più morbido, e gli stimatori basati sugli autovalori (participation ratio, PCA-95%, Kaiser) nel mezzo difendibile. Riporta la banda di $N$ effettivo per la griglia TE e verifica se gli archi sopravvissuti sono stabili lungo tutta la banda.

Sensibilità: i due parametri liberi

Entrambi i parametri vengono di solito impostati per regola empirica e poi mai più riesaminati. Devono invece essere sottoposti a sweep, riportando la graduatoria leader/follower in ogni cella.

Lunghezza della storia $k$

$k$ controlla quanto del passato del target viene condizionato. Se è troppo piccolo, attribuisci alla sorgente l'autocorrelazione propria del target; se è troppo grande, la distribuzione congiunta diventa troppo sparsa per essere stimata — il numero di stati congiunti è $|\mathcal{A}|^{k+l+1}$, quindi con 3 bin, $k=2$ e $l=1$ hai $3^4 = 81$ stati, mentre $k=5$ porta a $3^7 = 2187$ contro poche migliaia di osservazioni.

I punti di partenza convenzionali sono $k \in \{1, 2\}$ per i dati orari e $k \in \{1, \dots, 5\}$ per quelli giornalieri, eventualmente verificati con AIC/BIC sul lag VAR equivalente. Trattali come la griglia da sottoporre a sweep, non come la risposta.

Discretizzazione

• 3 bin (giù / piatto / su): robusti, funzionano con dati limitati e catturano solo la struttura direzionale.
• 5 bin: catturano la magnitudine, ma richiedono molti più dati.
• Bordi dei quantili: occupazione approssimativamente uguale, nessun bin vuoto — ma vedi l'avvertenza sulla leakage sopra.
• Codifica ordinale/simbolica: in stile entropia di permutazione, robusta alle trasformazioni monotone.

La TE continua basata su kernel evita completamente la perdita dovuta alla discretizzazione, al costo della selezione della bandwidth e di un calcolo molto più pesante.

Lo sweep

for n_bins in (3, 5):
    for k in (1, 2, 3, 5):
        disc = discretize_all(returns, n_bins=n_bins)
        te_df, p_df = compute_te_matrix(disc, k=k)
        rank = net_flow_ranking(te_df, p_df)
        report(n_bins, k, rank)

La domanda non è "qual è la graduatoria?", ma "la graduatoria è la stessa in ogni cella?" Se un asset è un mittente netto solo a $k=2$, $n_{\text{bins}}=3$, questa instabilità è il risultato e va riportata come tale.

Confondimento: transfer entropy condizionata

Se sia $X$ sia $Y$ sono guidati da un fattore latente $Z$, la TE a coppie segnalerà un flusso tra loro che è interamente un artefatto del driver comune. In un mercato a un fattore non è un caso limite; è l'aspettativa predefinita. La transfer entropy condizionata lo elimina condizionando su di esso:

$T_{X \to Y | Z} = H(Y_{t+1} \mid Y_t^{(k)}, Z_t^{(l)}) - H(Y_{t+1} \mid Y_t^{(k)}, X_t^{(l)}, Z_t^{(l)})$

Qualsiasi affermazione secondo cui SOL invia informazioni ad AVAX va verificata di nuovo condizionando su BTC. Se il flusso scompare, il risultato a coppie era il fattore di mercato travestito.

te_sol_avax_given_btc = te_pyinform(sol_disc, avax_disc, k=2,
                                    condition=btc_disc)

Condizionare non è gratuito: ogni variabile di condizionamento moltiplica lo spazio degli stati congiunti per $|\mathcal{A}|^{l}$, quindi la TE condizionata richiede molti più dati della versione a coppie allo stesso $k$.

Stabilità e possibilità di tradare qualcosa di tutto questo

Il flusso informativo non è statico — e in questo mercato non lo è nient'altro, premessa iniziale della rilevazione dei regimi con HMM e motivo per cui ogni stima qui deve essere calcolata su finestre anziché adattata una sola volta. La versione su finestra mobile di questa analisi, però, eredita un risultato noto invece di scoprirne uno. Che la dipendenza crypto si restringa durante una crisi è già pubblicato con numeri: la correlazione dei segnali tra coppie tabula una correlazione media dei segnali dallo 0.15 nei mercati laterali allo 0.90 nel panico, con $N_{\text{eff}}$ che crolla da 4.2 a 1.1, e DCC-GARCH, nell'Applicazione 3, trasforma la correlazione media a coppie in un segnale di regime risk-off con un flag a quantile mobile e l'esplicita avvertenza "questo è un segnale di rischio, non un segnale alpha".

La centralizzazione di Freeman della forza in uscita della TE è uno scalare diverso su una matrice diversa, ma è la stessa mossa: ridurre un oggetto di dipendenza $d \times d$ a un numero e osservarlo crescere. Quindi il criterio non è "la centralizzazione aumenta prima dei drawdown?", ma supera la correlazione media a coppie come segnale risk-off?, misurata testa a testa, sulle stesse finestre e contro gli stessi drawdown.

def network_centralization(G):
    """Freeman centralization of out-strength. High = one dominant source."""
    if G.number_of_nodes() < 2:
        return 0.0
    s = [sum(d['weight'] for _, _, d in G.out_edges(v, data=True)) for v in G.nodes()]
    total = sum(s)
    if total == 0:
        return 0.0
    n = len(s)
    return sum(max(s) - x for x in s) / ((n - 1) * total)

Prima di poter scrivere qualsiasi applicazione successiva bisogna rispondere a due domande:

1. La graduatoria dei leader persiste fuori campione? Adatta la rete sulla finestra $t$ e controlla la graduatoria sulla finestra $t+1$. Riporta la correlazione dei ranghi tra le finestre. Una graduatoria che si rimescola ogni settimana descrive rumore.
2. Il filtro TE aggiunge qualcosa a un trade lead-lag? L'esperimento corretto è un singolo confronto controllato: la stessa logica di entrata/uscita con z-score mobile descritta in arbitraggio statistico e pair trading e l'approccio della distanza, eseguita due volte, con la presenza del filtro di significatività TE come unica differenza e includendo le commissioni.

Nessuno dei due è stato eseguito per questo articolo. Nessun backtest lead-lag, nessun portafoglio information-momentum, nessun confronto di rilevazione dei regimi. La meccanica di costruzione dei pesi per un ipotetico comparto information-momentum è descritta in algoritmi di ottimizzazione di portafoglio a confronto — ma nota che una softmax sulla forza netta grezza in bit è arbitraria per scala e richiederebbe un argomento di normalizzazione prima di avere un significato. Qui non viene distribuito codice strategico non testato.

Costo

La TE è $O(N)$ per coppia, ma la costante è determinata dal numero di stati congiunti $|\mathcal{A}|^{k+l+1}$ e dal numero di surrogati. Per $M$ asset e $B$ repliche bootstrap servono $M(M-1)B$ valutazioni TE — con 50 asset e 200 surrogati sono 490.000. Il costo per valutazione dipende interamente dall'hardware, dalla versione di pyinform e da $N$; misuralo sulla tua macchina invece di fidarti di una cifra citata. Tre leve se è troppo lento:

• Parallelizza. Ogni coppia è indipendente — joblib o multiprocessing.
• Pre-seleziona. Calcola prima la TE grezza; esegui i surrogati solo sulle coppie sopra una soglia. (Nota che così il test di significatività diventa condizionato al superamento dello screening, cosa che richiede un'adeguata correzione.)
• Riduci l'universo. Fai prima il clustering, poi calcola la TE tra i rappresentanti dei cluster.

Riepilogo

La transfer entropy è una misura fondata e senza modello del flusso informativo diretto e colma una lacuna reale nel kit di strumenti di questo blog: DCC-GARCH dice quando la dipendenza si restringe, la TE dice verso quale direzione punta. Per i processi gaussiani collassa esattamente sulla causalità di Granger tramite $T = \tfrac{1}{2}\ln(1 + F)$, il che la rende una generalizzazione e non una rivale.

Ciò che ancora non è, però, è un risultato. La pipeline è implementata e i modi di fallimento sono elencati — bias da campione finito corretto con surrogati, binning dell'intera serie come leakage look-ahead, una griglia correlata di 56 test che rompe le correzioni ingenue dei test multipli, confondimento da driver comune in un mercato a un fattore e parametri liberi che potrebbero determinare la risposta. Ognuno di questi è un motivo per diffidare di una rete TE non calibrata. Pubblicare la rete senza calibrazione del nullo, sweep di sensibilità e controllo della stabilità fuori campione significherebbe pubblicare i modi di fallimento come se fossero risultati.

Riferimenti

• Schreiber, T. (2000). "Measuring Information Transfer." Physical Review Letters, 85(2), 461-464.
• Barnett, L., Barrett, A.B., Seth, A.K. (2009). "Granger Causality and Transfer Entropy Are Equivalent for Gaussian Variables." Physical Review Letters, 103(23), 238701.
• Marschinski, R., Kantz, H. (2002). "Analysing the information flow between financial time series." European Physical Journal B, 30(2), 275-281.
• Dimpfl, T., Peter, F.J. (2013). "Using Transfer Entropy to Measure Information Flows Between Financial Markets." Studies in Nonlinear Dynamics & Econometrics, 17(1), 85-102.
• Keskin, Z., Aste, T. (2020). "Information-theoretic measures for nonlinear causality detection: application to social media sentiment and cryptocurrency prices." Royal Society Open Science, 7(9), 200863.
• Jang, S.M. et al. (2022). "Using transfer entropy to measure information flows between cryptocurrencies." Physica A, 586, 126476.
• Nicola, G. et al. (2020). "Network Analysis of Multivariate Transfer Entropy of Cryptocurrencies in Times of Turbulence." Entropy, 22(7), 760.