Copula Models for Joint Risk Modeling in Crypto Portfolios

Correlation is the first tool most portfolio managers reach for when assessing diversification. But in crypto markets, correlation is dangerously misleading. Two tokens might show a Pearson correlation of 0.3 during calm markets, then spike to 0.95 during a crash. Linear correlation assumes elliptical distributions — an assumption that collapses under the heavy tails and asymmetric dependence structures endemic to cryptocurrency returns.

Copula models solve this by separating marginal behavior (how each asset behaves individually) from dependence structure (how assets move together). This separation, rooted in Sklar's theorem, gives us a flexible framework for modeling the full joint distribution of portfolio returns — including the tails where risk actually lives.

Why Linear Correlation Fails for Crypto

Consider a portfolio of BTC, ETH, SOL, and AVAX. During the Terra/Luna collapse in May 2022, correlations between these assets converged toward 1.0, exactly when diversification was needed most. A mean-variance optimizer that assumed stable correlations would have dramatically underestimated portfolio risk.

The core problems with Pearson correlation for crypto:

1. Non-elliptical distributions. Crypto returns exhibit significant skewness and kurtosis. BTC daily returns regularly show kurtosis values above 10 (normal distribution: 3).
2. Asymmetric dependence. Assets tend to be more correlated during downturns than during rallies. This "correlation breakdown" phenomenon is well-documented in equity markets and is even more pronounced in crypto.
3. Tail dependence. The probability that two assets simultaneously experience extreme losses is not captured by linear correlation. You can have two assets with identical correlation but vastly different tail dependence.

Sklar's Theorem: The Foundation

Sklar's theorem (1959) states that any multivariate joint distribution $F(x_1, x_2, \ldots, x_d)$ can be decomposed into:

$F(x_1, x_2, \ldots, x_d) = C\bigl(F_1(x_1), F_2(x_2), \ldots, F_d(x_d)\bigr)$

where $F_i$ are the marginal distribution functions and $C: [0,1]^d \to [0,1]$ is the copula — a function that encodes the entire dependence structure between variables.

Conversely, if the marginals are continuous, the copula $C$ is unique.

This decomposition is powerful because it lets us:

• Model each asset's marginal distribution separately (using GARCH, EVT, or any distribution that fits)
• Model the dependence structure independently via the copula
• Combine them to get the full joint distribution

The density of the joint distribution factors as:

$f(x_1, \ldots, x_d) = c\bigl(F_1(x_1), \ldots, F_d(x_d)\bigr) \cdot \prod_{i=1}^{d} f_i(x_i)$

where $c$ is the copula density and $f_i$ are the marginal densities.

Copula Families and Their Properties

Gaussian Copula

The Gaussian copula is parameterized by a correlation matrix $\Sigma$:

$C_{\Sigma}^{\text{Gauss}}(u_1, \ldots, u_d) = \Phi_{\Sigma}\bigl(\Phi^{-1}(u_1), \ldots, \Phi^{-1}(u_d)\bigr)$

where $\Phi_{\Sigma}$ is the multivariate normal CDF and $\Phi^{-1}$ is the univariate normal quantile function.

Tail dependence: $\lambda_L = \lambda_U = 0$ (for $\rho < 1$).

The Gaussian copula has zero tail dependence — it systematically underestimates the probability of joint extreme events. This was a key factor in the mispricing of CDOs before 2008, and it is equally dangerous for crypto risk modeling.

Student's t-Copula

The t-copula introduces symmetric tail dependence via a degrees-of-freedom parameter $\nu$:

$C_{\nu, \Sigma}^{t}(u_1, \ldots, u_d) = t_{\nu, \Sigma}\bigl(t_{\nu}^{-1}(u_1), \ldots, t_{\nu}^{-1}(u_d)\bigr)$

Tail dependence:

$\lambda_L = \lambda_U = 2 \cdot t_{\nu+1}\left(-\sqrt{\frac{(\nu+1)(1-\rho)}{1+\rho}}\right)$

For $\nu = 4$ and $\rho = 0.5$, this gives $\lambda \approx 0.18$ — an 18% probability that both assets are in their worst quantile simultaneously. Lower $\nu$ (heavier tails) increases this probability. Crypto markets, with their fat-tailed returns, typically require $\nu$ in the range of 3-8.

The t-copula is a significant improvement over Gaussian, but it enforces symmetric tail dependence ($\lambda_L = \lambda_U$). In practice, crypto assets often exhibit stronger lower-tail dependence (crash together) than upper-tail dependence (rally together).

Clayton Copula

The Clayton copula captures lower tail dependence — exactly the kind of asymmetric crash-clustering behavior we see in crypto:

$C_{\theta}^{\text{Clayton}}(u_1, u_2) = \left(u_1^{-\theta} + u_2^{-\theta} - 1\right)^{-1/\theta}, \quad \theta > 0$

Tail dependence: $\lambda_L = 2^{-1/\theta}$, $\lambda_U = 0$.

As $\theta$ increases, lower tail dependence strengthens. For $\theta = 2$, $\lambda_L \approx 0.71$ — a very high probability of joint extreme losses.

Gumbel Copula

The Gumbel copula is the mirror image — it captures upper tail dependence:

$C_{\theta}^{\text{Gumbel}}(u_1, u_2) = \exp\left(-\left[(-\ln u_1)^{\theta} + (-\ln u_2)^{\theta}\right]^{1/\theta}\right), \quad \theta \geq 1$

Tail dependence: $\lambda_L = 0$, $\lambda_U = 2 - 2^{1/\theta}$.

Frank Copula

The Frank copula has zero tail dependence in both tails ($\lambda_L = \lambda_U = 0$), making it suitable for modeling dependence in the body of the distribution without tail effects:

$C_{\theta}^{\text{Frank}}(u_1, u_2) = -\frac{1}{\theta}\ln\left(1 + \frac{(e^{-\theta u_1}-1)(e^{-\theta u_2}-1)}{e^{-\theta}-1}\right)$

Choosing the Right Copula for Crypto

For crypto portfolios, the empirical evidence points to:

• Clayton or rotated Gumbel (survival Gumbel) for lower tail dependence — capturing crash contagion
• t-copula as a robust general-purpose choice when symmetric tail dependence is acceptable
• Joe copula for capturing strong upper tail dependence in rally phases

Research by Bruhn and Jeleskovic (2024) found that GARCH-copula models, particularly those using Student's t marginals with t-copulas, consistently outperformed mean-variance and historical CVaR approaches across downturn (2022), recovery (2023), and stability (2024) market conditions in crypto.

The Curse of Dimensionality: Enter Vine Copulas

Standard multivariate copulas (Gaussian, t-copula) scale to high dimensions but impose restrictive assumptions. Archimedean copulas (Clayton, Gumbel, Frank) are naturally bivariate — extending them to $d > 2$ dimensions requires that all pairs share the same dependence parameter, which is unrealistic.

Vine copulas solve this by decomposing a $d$-dimensional copula into a cascade of bivariate copulas arranged in a tree structure. Each pair of variables (conditional on others) gets its own bivariate copula family and parameter.

The Pair-Copula Construction

For a $d$-dimensional density, the vine copula factorization is:

$f(x_1, \ldots, x_d) = \prod_{i=1}^{d} f_i(x_i) \cdot \prod_{j=1}^{d-1}\prod_{i=1}^{d-j} c_{i,i+j|i+1,\ldots,i+j-1}$

where $c_{i,j|S}$ is a bivariate copula density for variables $i$ and $j$ conditional on the set $S$.

A $d$-dimensional vine copula requires $\binom{d}{2} = d(d-1)/2$ bivariate copulas. For a 10-asset crypto portfolio, that is 45 pair copulas — each potentially from a different family.

Vine Structures: C-Vine, D-Vine, R-Vine

C-vine (Canonical vine): Each tree has a single root node connected to all other nodes. Best when one variable dominates — e.g., BTC as the market driver.

Tree 1:    BTC --- ETH
           BTC --- SOL
           BTC --- AVAX
           BTC --- DOT

Tree 2:    ETH|BTC --- SOL|BTC
           ETH|BTC --- AVAX|BTC
           ETH|BTC --- DOT|BTC

D-vine (Drawable vine): A sequential path structure. Best when variables have a natural ordering (e.g., by market cap or sector).

R-vine (Regular vine): The most general structure — any valid tree sequence. R-vines subsume both C-vines and D-vines.

Research on cryptocurrency portfolios suggests that D-vine structures often produce superior VaR forecasts compared to C-vine and R-vine for crypto assets, though this depends on the specific portfolio composition.

Why Vine Copulas Matter for Crypto

A portfolio of 8 crypto assets modeled with a single Clayton copula forces all 28 pairs to share the same $\theta$. But BTC-ETH might have $\theta_{\text{Clayton}} = 3.5$ (strong crash dependence) while SOL-AVAX might have $\theta = 1.2$ (moderate). Vine copulas let each pair express its own dependence structure:

• BTC-ETH: t-copula ($\nu=4$, $\rho=0.72$)
• BTC-SOL: Clayton ($\theta=2.1$)
• ETH-AVAX: Frank ($\theta=5.3$)
• SOL-DOT | BTC: Gumbel ($\theta=1.8$)

This flexibility is critical for accurate portfolio risk estimation.

Modeling the Marginals: GARCH-EVT

Before fitting the copula, we need to transform each asset's return series into uniform $[0,1]$ variables (the "probability integral transform"). The standard pipeline:

1. Fit a GARCH model to each asset's return series to capture time-varying volatility
2. Extract standardized residuals $z_t = (r_t - \mu_t) / \sigma_t$
3. Fit the tails using Extreme Value Theory (EVT) — specifically, the Generalized Pareto Distribution (GPD) for the upper and lower tails beyond a threshold (typically the 5th and 95th percentiles)
4. Use the empirical CDF for the body of the distribution
5. Apply the probability integral transform to get pseudo-uniform observations $u_{i,t} = \hat{F}_i(z_{i,t})$

This GARCH-EVT approach is often called the "semi-parametric" method. It properly captures:

• Volatility clustering (GARCH)
• Heavy tails (GPD from EVT)
• The overall shape of the distribution (empirical CDF for the body)

For crypto assets, an EGARCH(1,1) or GJR-GARCH(1,1) model with Student's t innovations tends to work well, as it captures the asymmetric volatility response (bad news increases volatility more than good news).

Portfolio VaR and CVaR with Copulas

Value-at-Risk (VaR)

Portfolio VaR at confidence level $\alpha$ is:

$\text{VaR}_\alpha = \inf\{ l : P(L \leq l) \geq \alpha \}$

where $L$ is the portfolio loss. With copulas, we estimate VaR via Monte Carlo:

1. Simulate $N$ samples from the fitted vine copula (in uniform space)
2. Transform back to return space using the inverse marginal CDFs
3. Compute portfolio returns: $r_p = \sum_i w_i \cdot r_i$
4. VaR is the $\alpha$-quantile of the simulated portfolio loss distribution

Conditional Value-at-Risk (CVaR / Expected Shortfall)

CVaR is the expected loss given that the loss exceeds VaR:

$\text{CVaR}_\alpha = E[L \mid L \geq \text{VaR}_\alpha] = \frac{1}{1-\alpha}\int_{\alpha}^{1}\text{VaR}_u\, du$

CVaR is coherent (satisfies subadditivity), making it superior to VaR for portfolio optimization. Monte Carlo estimation is straightforward — average the losses that exceed VaR.

Why Copula-Based Risk Beats Correlation-Based Risk

Consider two portfolios with identical pairwise correlations of 0.5:

• Portfolio A: Gaussian copula dependence (no tail dependence)
• Portfolio B: Clayton copula dependence ($\theta = 2$, $\lambda_L = 0.71$)

At the 99% confidence level, Portfolio B will have a significantly higher VaR and CVaR because the Clayton copula correctly models the tendency of assets to crash together. The Gaussian copula underestimates this risk by assuming that extreme co-movements are vanishingly rare.

In empirical studies on crypto portfolios, the difference in 99% CVaR between Gaussian and vine copula models can exceed 30-40%, meaning correlation-based models may underestimate tail risk by a third or more.

Implementation: Python with pyvinecopulib

Here is a complete pipeline for fitting a vine copula to crypto returns and estimating portfolio VaR/CVaR.

Step 1: Data Preparation and Marginal Fitting

import numpy as np
import pandas as pd
from arch import arch_model
from scipy import stats
import pyvinecopulib as pv

def fetch_crypto_returns(symbols, start="2023-01-01", end="2025-12-31"):
    """
    Fetch daily returns for a list of crypto symbols.
    Replace with your data source (ccxt, yfinance, etc.)
    """
    import yfinance as yf
    prices = yf.download(
        [f"{s}-USD" for s in symbols],
        start=start, end=end
    )["Close"]
    prices.columns = symbols
    returns = np.log(prices / prices.shift(1)).dropna()
    return returns

symbols = ["BTC", "ETH", "SOL", "AVAX", "DOT", "LINK", "MATIC", "ATOM"]
returns = fetch_crypto_returns(symbols)

def fit_garch_marginal(series, dist="t"):
    """
    Fit GJR-GARCH(1,1) with Student-t innovations.
    Returns standardized residuals and the fitted model.
    """
    model = arch_model(
        series * 100,  # scale for numerical stability
        vol="GARCH",
        p=1, o=1, q=1,  # GJR-GARCH
        dist=dist,
        mean="AR",
        lags=1
    )
    result = model.fit(disp="off")
    std_resid = result.std_resid.dropna()
    return std_resid, result

residuals = {}
garch_models = {}
for sym in symbols:
    std_resid, model = fit_garch_marginal(returns[sym])
    residuals[sym] = std_resid
    garch_models[sym] = model

residuals_df = pd.DataFrame(residuals).dropna()

Step 2: Probability Integral Transform

def semi_parametric_pit(residuals, tail_threshold=0.05):
    """
    Semi-parametric probability integral transform:
    - GPD for tails beyond threshold
    - Empirical CDF for the body
    Returns pseudo-uniform observations in [0, 1].
    """
    n = len(residuals)
    u = np.zeros(n)
    sorted_resid = np.sort(residuals)

    lower_thresh = np.quantile(residuals, tail_threshold)
    upper_thresh = np.quantile(residuals, 1 - tail_threshold)

    for i, x in enumerate(residuals):
        if x <= lower_thresh:
            lower_exceedances = -(residuals[residuals <= lower_thresh] - lower_thresh)
            shape, _, scale = stats.genpareto.fit(lower_exceedances, floc=0)
            u[i] = tail_threshold * (
                1 - stats.genpareto.cdf(-(x - lower_thresh), shape, scale=scale)
            )
        elif x >= upper_thresh:
            upper_exceedances = residuals[residuals >= upper_thresh] - upper_thresh
            shape, _, scale = stats.genpareto.fit(upper_exceedances, floc=0)
            u[i] = 1 - tail_threshold * (
                1 - stats.genpareto.cdf(x - upper_thresh, shape, scale=scale)
            )
        else:
            u[i] = np.mean(residuals <= x)

    u = np.clip(u, 1e-6, 1 - 1e-6)
    return u

U = np.column_stack([
    semi_parametric_pit(residuals_df[sym].values)
    for sym in symbols
])

Step 3: Fit the Vine Copula

controls = pv.FitControlsVinecop(
    family_set=[
        pv.BicopFamily.student,
        pv.BicopFamily.clayton,
        pv.BicopFamily.gumbel,
        pv.BicopFamily.frank,
        pv.BicopFamily.joe,
        pv.BicopFamily.bb1,       # Clayton-Gumbel mixture
        pv.BicopFamily.bb7,       # Joe-Clayton mixture
        pv.BicopFamily.gaussian,
    ],
    selection_criterion="bic",    # BIC for model selection
    tree_criterion="tau",          # Kendall's tau for tree structure
    nonparametric_method="constant",
    trunc_lvl=5,                   # Truncate after 5 trees
)

vine = pv.Vinecop(U, controls=controls)

print(f"Log-likelihood: {vine.loglik(U):.2f}")
print(f"AIC: {vine.aic(U):.2f}")
print(f"BIC: {vine.bic(U):.2f}")

for i in range(vine.order.shape[0] - 1):
    pair = vine.get_pair_copula(0, i)
    print(f"Tree 1, Edge {i}: {pair.family} "
          f"(params: {pair.parameters})")

Step 4: Monte Carlo VaR and CVaR

def estimate_var_cvar(vine, garch_models, symbols, weights,
                       n_sim=50_000, alpha=0.99, seed=42):
    """
    Estimate portfolio VaR and CVaR using Monte Carlo simulation
    from the fitted vine copula.
    """
    U_sim = vine.simulate(n=n_sim, seeds=[seed])

    returns_sim = np.zeros((n_sim, len(symbols)))
    for j, sym in enumerate(symbols):
        model = garch_models[sym]
        forecasts = model.forecast(horizon=1)
        mu = forecasts.mean.iloc[-1, 0] / 100  # unscale
        sigma = np.sqrt(forecasts.variance.iloc[-1, 0]) / 100

        nu = model.params.get("nu", 5)
        z_sim = stats.t.ppf(U_sim[:, j], df=nu)
        returns_sim[:, j] = mu + sigma * z_sim

    weights = np.array(weights)
    portfolio_returns = returns_sim @ weights

    losses = -portfolio_returns

    var = np.quantile(losses, alpha)

    cvar = np.mean(losses[losses >= var])

    return var, cvar, portfolio_returns

weights = [1.0 / len(symbols)] * len(symbols)

var_99, cvar_99, sim_returns = estimate_var_cvar(
    vine, garch_models, symbols, weights,
    n_sim=100_000, alpha=0.99
)

print(f"1-day 99% VaR:  {var_99*100:.2f}%")
print(f"1-day 99% CVaR: {cvar_99*100:.2f}%")

from scipy.stats import norm
mu_p = sim_returns.mean()
sigma_p = sim_returns.std()
var_gauss = -(mu_p + sigma_p * norm.ppf(0.01))
print(f"\nGaussian VaR:   {var_gauss*100:.2f}%")
print(f"Copula/Gaussian ratio: {var_99/var_gauss:.2f}x")

Step 5: Tail Dependence Analysis

def compute_tail_dependence(vine, symbols):
    """
    Extract lower and upper tail dependence coefficients
    from the first tree of the vine copula.
    """
    results = []
    order = vine.order
    n_edges = order.shape[0] - 1

    for i in range(n_edges):
        pair = vine.get_pair_copula(0, i)
        u_pair = pair.simulate(n=100_000, seeds=[42])
        q = 0.01  # 1st percentile

        mask_lower = (u_pair[:, 0] <= q)
        lambda_L = np.mean(u_pair[mask_lower, 1] <= q) if mask_lower.sum() > 0 else 0

        mask_upper = (u_pair[:, 0] >= 1 - q)
        lambda_U = np.mean(u_pair[mask_upper, 1] >= 1 - q) if mask_upper.sum() > 0 else 0

        i_idx = order[0]
        j_idx = order[i + 1]
        results.append({
            "pair": f"{symbols[i_idx]}-{symbols[j_idx]}",
            "family": str(pair.family),
            "lambda_L": round(lambda_L, 4),
            "lambda_U": round(lambda_U, 4),
        })

    return pd.DataFrame(results)

tail_dep = compute_tail_dependence(vine, symbols)
print(tail_dep.to_string(index=False))

Typical output for a crypto portfolio might look like:

Notice how each pair can have a completely different dependence structure. BTC-SOL shows strong lower tail dependence (Clayton) with zero upper tail dependence — they crash together but do not necessarily rally together. BTC-MATIC shows no tail dependence at all (Frank), suggesting some diversification benefit even in extremes.

Backtesting the Copula VaR Model

A VaR model is only useful if it is well-calibrated. The standard backtest computes VaR violations — days when the actual loss exceeded the predicted VaR — and tests whether the violation rate matches the expected rate.

def backtest_var(returns, symbols, weights, window=500,
                 alpha=0.99, n_sim=20_000):
    """
    Rolling-window VaR backtest using vine copula.
    """
    violations = []
    var_series = []
    T = len(returns)

    for t in range(window, T):
        window_returns = returns.iloc[t-window:t]

        U_window = np.zeros((window, len(symbols)))
        models_t = {}
        for j, sym in enumerate(symbols):
            std_resid, model = fit_garch_marginal(window_returns[sym])
            models_t[sym] = model
            u = pv.to_pseudo_obs(std_resid.values.reshape(-1, 1))
            U_window[:len(u), j] = u.ravel()

        U_clean = U_window[~np.any(U_window == 0, axis=1)]
        vine_t = pv.Vinecop(U_clean, controls=controls)

        var_t, _, _ = estimate_var_cvar(
            vine_t, models_t, symbols, weights,
            n_sim=n_sim, alpha=alpha
        )
        var_series.append(var_t)

        actual_return = (returns.iloc[t][symbols].values
                         * np.array(weights)).sum()
        violations.append(-actual_return > var_t)

    violation_rate = np.mean(violations)
    expected_rate = 1 - alpha
    print(f"Expected violation rate: {expected_rate:.4f}")
    print(f"Actual violation rate:   {violation_rate:.4f}")
    print(f"Number of violations:    {sum(violations)} / {len(violations)}")

    return violations, var_series

A well-calibrated 99% VaR model should have a violation rate close to 1%. If the rate is significantly higher, the model underestimates risk. If significantly lower, it is too conservative.

Practical Considerations

Computational Cost

Vine copula fitting is $O(d^2 \cdot n)$ per tree level. For a 10-asset portfolio with 500-day rolling windows, a full backtest with 50,000 Monte Carlo simulations per step can take hours. Strategies to manage this:

• Truncated vines: Set trunc_lvl=3 or trunc_lvl=4 — higher trees capture weaker conditional dependencies that contribute less to risk
• Reduced simulation count: 10,000-20,000 simulations often suffice for 99% VaR
• Parallel computation: The GARCH fits for each asset are independent and can be parallelized
• Model caching: Refit the copula weekly rather than daily, updating only the GARCH forecasts

Regime Awareness

Crypto markets exhibit distinct regimes (bull, bear, sideways, high-volatility events). A single vine copula fitted over the entire sample may not capture regime-dependent dependence. Consider:

• Rolling windows of 250-500 days
• Regime-switching copulas where the copula parameters depend on a hidden Markov state
• Exponentially-weighted observations that give more weight to recent data

Common Pitfalls

1. Forgetting the PIT. Feeding raw returns directly into the copula instead of pseudo-uniform observations will produce meaningless results. Always transform to uniform margins first.
2. Overfitting with too many families. Including every possible bivariate family in the selection set can lead to overfitting, especially with short samples. Use BIC for model selection and consider restricting to 4-5 families.
3. Ignoring serial dependence. Copulas model cross-sectional dependence at a single time point. If you skip the GARCH step and feed autocorrelated returns into the copula, the estimated dependence will be contaminated by serial effects.
4. Static copulas in dynamic markets. A copula fitted on 2021 bull market data will be poorly calibrated for a 2022 crash. Always use rolling or expanding windows.

Conclusion

Copula models — particularly vine copulas — provide a mathematically rigorous framework for modeling the joint risk of crypto portfolios that goes far beyond what linear correlation can capture. The key advantages:

• Separate marginal and dependence modeling via Sklar's theorem
• Flexible tail dependence through appropriate copula family selection (Clayton for crash contagion, Gumbel for rally co-movement, t-copula for symmetric tails)
• High-dimensional scalability through vine copula decomposition, where each pair of assets gets its own bivariate copula
• Accurate VaR/CVaR estimation that accounts for non-linear, asymmetric dependence — critical for risk management in a market where "everything crashes together" is the norm, not the exception

The GARCH-EVT-Copula pipeline is now the standard approach at quantitative hedge funds and crypto-focused risk desks. With libraries like pyvinecopulib, the implementation barrier is low enough that any systematic trader can integrate copula-based risk modeling into their portfolio management workflow.

The code in this article provides a working starting point. For production use, you would add proper cross-validation for the GARCH order selection, more sophisticated marginal models (e.g., EGARCH with leverage effects, or realized volatility measures using intraday data), and stress testing under hypothetical copula parameters calibrated to historical crisis episodes.

References

• Sklar, A. (1959). Fonctions de repartition a n dimensions et leurs marges. Publications de l'Institut de Statistique de l'Universite de Paris, 8, 229-231.
• Joe, H. (2014). Dependence Modeling with Copulas. Chapman and Hall/CRC.
• Aas, K., Czado, C., Frigessi, A., & Bakken, H. (2009). Pair-copula constructions of multiple dependence. Insurance: Mathematics and Economics, 44(2), 182-198.
• Jeleskovic, V. & Bruhn, L. (2024). Cryptocurrency portfolio optimization: Utilizing a GARCH-Copula model within the Markowitz framework. Journal of Corporate Accounting & Finance.
• Nagler, T. & Vatter, T. (2023). pyvinecopulib: A Python library for vine copula models. GitHub.
• Tiwari, A. K., et al. (2020). Modeling risk dependence and portfolio VaR forecast through vine copula for cryptocurrencies. PLOS ONE, 15(1), e0242102.