C’è una differenza enorme tra accumulare investimenti e costruire un portafoglio.

Eppure, la maggior parte delle persone fa esattamente la prima cosa: acquista un titolo tecnologico perché negli ultimi anni è salito, aggiunge un’obbligazione per bilanciare, e magari un ETF globale.

Tutto nella speranza che, alla fine, la somma dei guadagni superi quella delle perdite.

Piazzare i propri risparmi un po’ qua e un po’ là, incrociando le dita, non è una strategia.

È, nel migliore dei casi, ottimismo.

Quando negli anni ’50 Harry Markowitz ha formalizzato la Teoria Moderna di Portafoglio (vincendo poi il Premio Nobel per l’Economia), ha dimostrato matematicamente un fatto controintuitivo:

non conta solo il rendimento dei singoli asset, ma il modo in cui si muovono l’uno rispetto all’altro.

Inserire in portafoglio un titolo estremamente volatile può, paradossalmente, abbassare il rischio complessivo dell’investimento se i suoi movimenti sono opposti a quelli degli altri asset.

Oggi non serve una lavagna per calcolarlo. Con poche righe di codice Python possiamo simulare decine di migliaia di combinazioni e chiedere a un algoritmo di isolare l’esatta allocazione che massimizza il rendimento per ogni livello di rischio che siamo disposti a sopportare.

1. Il Cuore della Teoria: Il Ruolo della Covarianza

Per capire la matematica di Markowitz, occorre superare l’idea che il rischio di un portafoglio sia la semplice media ponderata del rischio dei singoli titoli.

Se indichiamo con [math]w_i[/math] il peso dell’asset [math]i[/math] nel portafoglio e con [math]R_i[/math] il suo rendimento atteso, il rendimento totale del portafoglio [math]R_p[/math] è lineare:

[math]\displaystyle R_p = \sum_{i=1}^{n} w_i R_i = \mathbf{w}^T \mathbf{R}[/math]

La svolta di Markowitz riguarda la varianza del portafoglio ([math]\sigma_p^2[/math]).

A differenza del rendimento, il rischio include la matrice di covarianza [math]\mathbf{\Sigma}[/math]:

[math]\displaystyle \sigma_p^2 = \mathbf{w}^T \mathbf{\Sigma} \mathbf{w} = \sum_{i=1}^{n} \sum_{j=1}^{n} w_i w_j \sigma_{ij}[/math]

Dove [math]\sigma_{ij}[/math] rappresenta la covarianza tra l’asset [math]i[/math] e l’asset [math]j[/math].

• Se due titoli hanno covarianza positiva ed elevata ([math]\sigma_{ij} > 0[/math]), si muoveranno nella stessa direzione. Quando uno crolla, anche l’altro tende a scendere.
• Se due titoli hanno covarianza negativa ([math]\sigma_{ij} < 0[/math]), i movimenti opposti si annullano a vicenda. Il termine incrociato [math]w_i w_j \sigma_{ij}[/math] diventa negativo, riducendo la varianza totale del portafoglio.

Questa intuizione algebrica è il motivo per cui la diversificazione reale abbatte il rischio senza necessariamente sacrificare il rendimento atteso.

2. Simulazione Monte Carlo e Ottimizzazione SLSQP in Python

Di seguito è riportato lo script Python completo per simulare 10.000 portafogli casuali e calcolare analiticamente la Frontiera Efficiente.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import scipy.optimize as sco

# 1. Setup e Generazione Dati Sintetici (4 asset)
np.random.seed(42)
num_assets = 4
num_portfolios = 10000

# Simulazione di rendimenti giornalieri (1000 giorni di trading)
returns = pd.DataFrame(np.random.randn(1000, num_assets) / 100 + 0.0005)
mean_returns = returns.mean() * 252  # Rendimenti annualizzati (252 giorni di trading)
cov_matrix = returns.cov() * 252     # Matrice di Covarianza annualizzata

# 2. Simulazione Monte Carlo (Approccio Euristico)
results = np.zeros((3, num_portfolios))
for i in range(num_portfolios):
    # Generazione di pesi casuali normalizzati a 1 (Long-Only)
    weights = np.random.random(num_assets)
    weights /= np.sum(weights)
    
    # Algebra Matriciale per Rischio e Rendimento
    portfolio_return = np.sum(mean_returns * weights)
    portfolio_std_dev = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
    
    results[0, i] = portfolio_std_dev
    results[1, i] = portfolio_return
    # Indice di Sharpe (assumendo Risk-Free Rate = 2%)
    results[2, i] = (portfolio_return - 0.02) / portfolio_std_dev 

# 3. Calcolo Analitico della Frontiera Efficiente tramite Ottimizzazione
def portfolio_performance(weights, mean_returns, cov_matrix):
    ret = np.sum(mean_returns * weights)
    std = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
    return std, ret

def minimize_volatility(weights, mean_returns, cov_matrix):
    return portfolio_performance(weights, mean_returns, cov_matrix)[0]

# Definizione dei target di rendimento lungo l'asse Y
target_returns = np.linspace(results[1].min(), results[1].max(), 50)
efficient_volatilities = []

# Ciclo di ottimizzazione vincolata
for target in target_returns:
    # Vincolo 1: Il rendimento deve eguagliare il target (assegnazione esplicita per late binding)
    # Vincolo 2: La somma dei pesi deve essere pari a 1 (100% del capitale allocato)
    constraints = (
        {'type': 'eq', 'fun': lambda x, t=target: portfolio_performance(x, mean_returns, cov_matrix)[1] - t},
        {'type': 'eq', 'fun': lambda x: np.sum(x) - 1}
    )
    bounds = tuple((0, 1) for _ in range(num_assets))
    
    # Solver SLSQP (Sequential Least Squares Programming)
    res = sco.minimize(
        minimize_volatility, 
        num_assets * [1. / num_assets], 
        args=(mean_returns, cov_matrix), 
        method='SLSQP', 
        bounds=bounds, 
        constraints=constraints
    )
    efficient_volatilities.append(res['fun'])

# 4. Visualizzazione Grafica
plt.figure(figsize=(12, 7))

# Nuvola di portafogli casuali (colore = Indice di Sharpe)
plt.scatter(results[0, :], results[1, :], c=results[2, :], cmap='viridis', marker='o', s=10, alpha=0.5)
plt.colorbar(label='Indice di Sharpe')

# Curva della Frontiera Efficiente ottimizzata
plt.plot(efficient_volatilities, target_returns, 'r-', linewidth=3, label='Frontiera Efficiente')

# Portafoglio Tangente (Massimo Sharpe Ratio)
max_sharpe_idx = np.argmax(results[2])
plt.scatter(results[0, max_sharpe_idx], results[1, max_sharpe_idx], marker='*', color='red', s=400, label='Portafoglio Tangente')

plt.title('Simulazione Monte Carlo & Frontiera Efficiente di Markowitz', fontsize=14)
plt.xlabel('Rischio (Deviazione Standard Annualizzata)', fontsize=12)
plt.ylabel('Rendimento Atteso Annualizzato', fontsize=12)
plt.legend(loc='upper left')
plt.grid(True, linestyle='--', alpha=0.6)
plt.tight_layout()
plt.show()

3. Analisi Applicativa: Esplorazione vs. Estrazione

Da una prospettiva di Data Science e Finanza Quantitativa, questo script mostra il funzionamento e la transizione tra due diversi paradigmi computazionali:

+-----------------------------------------------------------------------------------+
|                            SPAZIO DELLE SOLUZIONI                                 |
|                                                                                   |
|    [ Simulazione Monte Carlo ]               [ Ottimizzazione SLSQP ]             |
|    - Euristico / Stocastico                  - Deterministico / Gradiente         |
|    - Mappa il dominio possibile              - Isola il bordo convesso            |
|    - Evidenzia l'inefficienza del caso       - Trova l'allocazione paretiana      |
+-----------------------------------------------------------------------------------+

L’Approccio Euristico-Stocastico (Monte Carlo)
Lanciando 10.000 combinazioni casuali di pesi, mappiamo l’intero spazio delle soluzioni possibili. Questo passaggio visualizza la densità della probabilità: la stragrande maggioranza delle combinazioni generate a caso finisce all’interno della “pancia” della nuvola. Questi portafogli sono dominati e inefficienti: a parità di rischio, esistono altre combinazioni in grado di offrire rendimenti nettamente superiori.
La simulazione Monte Carlo serve proprio a dimostrare l’irrazionalità delle scelte causali: selezionare casualmente gli asset porta quasi sempre a un’allocazione subottimale.

L’Approccio Deterministico (SLSQP)
Il solver Sequential Least Squares Programming non tenta combinazioni a caso. Calcola le derivate parziali (il gradiente) della funzione obiettivo del rischio e scende lungo la curva. Per ogni livello di rendimento target ([math]R_{target}[/math]), trova l’esatto vettore di pesi [math]\mathbf{w}[/math] che minimizza la varianza [math]\mathbf{w}^T \mathbf{\Sigma} \mathbf{w}[/math].
Il risultato di questa ottimizzazione è la Frontiera Efficiente (la linea rossa). Tutti i punti al di sotto di questa curva sono matematicamente inefficienti.

Il Portafoglio Tangente
Il punto contrassegnato dalla stella rossa rappresenta il portafoglio che massimizza l’Indice di Sharpe:[math]\displaystyle \text{Sharpe Ratio} = \frac{R_p – R_f}{\sigma_p}[/math]

Nel modello di Markowitz (e successivamente nel CAPM di Tobin), il Portafoglio Tangente individua la combinazione ottimale di asset rischiosi, a prescindere dalla propensione al rischio del singolo investitore. L’investitore dovrà poi unicamente decidere come distribuire il proprio capitale tra questo portafoglio tangente e l’asset privo di rischio ([math]R_f[/math]).

4. Estensione Dinamica: Google Colab e Widget Interattivi

I parametri accademici fissi (come un tasso risk-free costante al 2%) non riflettono le dinamiche reali dei mercati finanziari.

Attraverso questo codice per Google Colab, introduciamo due elementi di analisi reale:

• Fetch in tempo reale del Tasso Risk-Free: Collegamento via yfinance ai rendimenti dei Titoli di Stato americani a 10 anni (^TNX).
• Short Selling (Vendita allo scoperto): Sblocco dei vincoli sui pesi [math]w_i \in [0, 1][/math]. Consentendo pesi negativi ([math]w_i \in [-1, 1][/math]), l’algoritmo può vendere allo scoperto gli asset meno efficienti per finanziare posizioni a leva sui titoli più promettenti.

# Installa yfinance per l'importazione dati
!pip install yfinance -q

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import scipy.optimize as sco
import yfinance as yf
import ipywidgets as widgets
from IPython.display import display

# Setup dati fittizi
np.random.seed(42)
num_assets = 4
num_portfolios = 5000
returns = pd.DataFrame(np.random.randn(1000, num_assets) / 100 + 0.0005)
mean_returns = returns.mean() * 252
cov_matrix = returns.cov() * 252

# Recupero dinamico del tasso Risk-Free (US 10Y Treasury)
def fetch_real_risk_free():
    try:
        tnx_data = yf.download("^TNX", period="1d", progress=False)
        return float(tnx_data['Close'].iloc[-1].item()) / 100.0 
    except Exception:
        return 0.035 # Fallback al 3.5%

live_rf = fetch_real_risk_free()

# Funzione per aggiornamento grafico interattivo
def ottimizza_portafoglio(allow_short_selling, risk_free_rate):
    results = np.zeros((3, num_portfolios))
    
    # 1. Simulazione Monte Carlo
    for i in range(num_portfolios):
        if allow_short_selling:
            # Pesi estratti da distribuzione normale (ammette valori negativi)
            weights = np.random.randn(num_assets)
        else:
            # Pesi estratti da distribuzione uniforme (solo valori positivi)
            weights = np.random.random(num_assets)
            
        weights /= np.sum(weights) # Normalizzazione: la somma dei pesi deve essere 1
        
        portfolio_return = np.sum(mean_returns * weights)
        portfolio_std_dev = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
        
        results[0, i] = portfolio_std_dev
        results[1, i] = portfolio_return
        results[2, i] = (portfolio_return - risk_free_rate) / portfolio_std_dev 

    # 2. Ottimizzazione analitica
    def portfolio_performance(w, m_ret, cov_mat):
        ret = np.sum(m_ret * w)
        std = np.sqrt(np.dot(w.T, np.dot(cov_mat, w)))
        return std, ret

    def minimize_volatility(w, m_ret, cov_mat):
        return portfolio_performance(w, m_ret, cov_mat)[0]

    target_returns = np.linspace(results[1].min(), results[1].max(), 50)
    efficient_volatilities = []

    # Vincoli sui pesi (Bounds)
    bounds = tuple((-1.0, 1.0) if allow_short_selling else (0.0, 1.0) for _ in range(num_assets))

    for target in target_returns:
        constraints = (
            {'type': 'eq', 'fun': lambda x, t=target: portfolio_performance(x, mean_returns, cov_matrix)[1] - t},
            {'type': 'eq', 'fun': lambda x: np.sum(x) - 1}
        )
        res = sco.minimize(
            minimize_volatility, 
            num_assets * [1. / num_assets], 
            args=(mean_returns, cov_matrix), 
            method='SLSQP', 
            bounds=bounds, 
            constraints=constraints
        )
        efficient_volatilities.append(res['fun'])

    # 3. Output grafico
    plt.figure(figsize=(10, 6))
    plt.scatter(results[0, :], results[1, :], c=results[2, :], cmap='viridis', marker='o', s=10, alpha=0.5)
    plt.colorbar(label=f'Indice di Sharpe (RF = {risk_free_rate:.2%})')
    
    plt.plot(efficient_volatilities, target_returns, 'r-', linewidth=3, label='Frontiera Efficiente')
    
    max_sharpe_idx = np.argmax(results[2])
    plt.scatter(results[0, max_sharpe_idx], results[1, max_sharpe_idx], marker='*', color='red', s=350, label='Portafoglio Tangente')
    
    plt.title(f'Frontiera di Markowitz {"(Con Short Selling)" if allow_short_selling else "(Long-Only)"}', fontsize=14)
    plt.xlabel('Rischio (Volatilità Annualizzata)', fontsize=12)
    plt.ylabel('Rendimento Atteso', fontsize=12)
    plt.legend(loc='upper left')
    plt.grid(True, linestyle='--', alpha=0.6)
    plt.tight_layout()
    plt.show()

# Interfaccia Widget
style = {'description_width': 'initial'}

short_checkbox = widgets.Checkbox(
    value=False,
    description='Consenti Short Selling (Pesi Negativi)',
    style=style
)

rf_slider = widgets.FloatSlider(
    value=live_rf,
    min=0.0,
    max=0.10,
    step=0.0025,
    description='Tasso Risk-Free (BTP/Treasury):',
    readout_format='.2%',
    style=style,
    layout=widgets.Layout(width='480px')
)

interact_plot = widgets.interactive(
    ottimizza_portafoglio, 
    allow_short_selling=short_checkbox, 
    risk_free_rate=rf_slider
)

display(interact_plot)

Conclusione

I mercati finanziari restano un ecosistema dominato dall’emotività, dai crolli improvvisi e da euforie spesso irrazionali. Ma il nostro modo di affrontarli non deve per forza esserlo.

Un principio matematico formalizzato settant’anni fa, unito alla potenza di calcolo del Python moderno, ci permette di tracciare una linea netta tra il puro azzardo e una strategia strutturata. L’ottimizzazione di portafoglio non elimina il rischio — la volatilità fa parte delle regole del gioco — ma insegna a misurarlo, a dargli un prezzo e a valutare, con i dati alla mano, se vale la pena assumerlo.

In un contesto in cui notizie e opportunità estemporanee generano costantemente rumore di fondo, la differenza tra una gestione inefficiente e una strategia rigorosa risiede nella capacità di scartare le alternative subottimali. I dati non servono a prevedere il futuro, ma a costruire difese matematiche contro l’incertezza.