Domanda Marshalliana e Hicksiana con Python: simulare l’effetto reddito e l’effetto sostituzione

Quando un brand modifica il prezzo di un servizio o un algoritmo di dynamic pricing ritocca le tariffe, il comportamento degli utenti cambia per due ragioni distinte:

perché le alternative sono diventate economicamente più convenienti o perché quel cambio di prezzo ha alterato il loro potere d’acquisto reale.

Nella teoria del consumatore, questa scissione viene catturata da due pilastri matematici: la domanda marshalliana (o ordinaria) e la domanda hicksiana (o compensata). Se per molti studenti di economia queste restano astrazioni confinate nei manuali, per chi si occupa di data science, machine learning applicato al pricing o analisi causale, comprendere questa differenza è la chiave per non sbagliare le previsioni di elasticità.

In questo articolo colleghiamo la teoria con la pratica, costruendo un simulatore interattivo in Python capace di isolare visivamente l’effetto reddito e l’effetto sostituzione in tempo reale.

Perché servono due funzioni di domanda?

Immaginiamo che il prezzo di un bene aumenti. Per estrarre metriche utili dal mercato, possiamo interpellare i dati da due prospettive diverse:

L’approccio Marshalliano: Ci dice quanto prodotto acquisterà il consumatore mantenendo il suo reddito nominale rigorosamente invariato. Questo è ciò che osserviamo nei dati di vendita reali. Il cambio di prezzo modifica contemporaneamente i prezzi relativi dei beni e il potere d’acquisto del consumatore.

L’approccio Hicksiano: Ci dice quanto prodotto acquisterebbe il consumatore se venisse compensato economicamente per contrastare la perdita di potere d’acquisto, così da mantenere lo stesso livello di benessere (utilità) iniziale. Eliminando artificialmente l’effetto reddito, la domanda hicksiana isola l’effetto sostituzione.

 

Il Simulatore Interattivo: Obiettivi e Logica

Le equazioni sui manuali di economia hanno un grande limite: sono statiche. Guardare le formule della domanda marshalliana e hicksiana non restituisce l’impatto immediato di cosa accade sul mercato quando i prezzi fluttuano.

Questo simulatore interattivo nasce per colmare il divario tra l’astrazione matematica e l’intuizione visiva.

Sviluppato in Python sfruttando l’ecosistema ipywidgets e vettorizzazione NumPy, lo strumento si pone tre obiettivi fondamentali:

• Isolare i vettori della scomposizione di Slutsky: Invece di calcolare l’effetto reddito e l’effetto sostituzione solo a posteriori, l’interfaccia permette di visualizzare graficamente lo scarto tra le due curve associato a ogni singolo centesimo di variazione del prezzo.
• Fornire una Sandbox per scenari controfattuali: Il simulatore permette di rispondere visivamente alla domanda tipica dell’analisi causale: “Cosa farebbe il consumatore se il suo potere d’acquisto venisse artificialmente protetto (compensato) di fronte a uno shock di prezzo?”
• Abbinare l’efficienza computazionale alla chiarezza grafica: Il codice dimostra come gestire la manipolazione di array numerici in tempo reale senza cicli for, proiettando le coordinate direttamente sugli assi per ridurre al minimo il carico cognitivo di chi analizza il grafico.

Muovendo lo slider del prezzo [math]p_1[/math], l’intero sistema ricalcola istantaneamente l’equilibrio ottimale, trasformando la microeconomia in un oggetto dinamico da esplorare.

Le ipotesi del modello

Per tradurre questo scenario in codice, assumiamo una funzione di utilità Cobb-Douglas simmetrica:

[math]\displaystyle U(x_1, x_2) = \sqrt{x_1 x_2}[/math]

Fissiamo i parametri di partenza del nostro mercato simulato:

• Reddito nominale: [math]I = 100.0[/math]
• Prezzo del secondo bene (bene ancora): [math]p_2 = 1.0[/math]
• Livello di utilità target da garantire: [math]u_0 = 50.0[/math]

Perché una Cobb-Douglas simmetrica?

Assumere una funzione di utilità Cobb-Douglas simmetrica significa fare una scelta ben precisa sulle preferenze del consumatore. Nel nostro modello l’abbiamo scritta così:

[math]\displaystyle U(x_1, x_2) = \sqrt{x_1 x_2} = x_1^{0.5} x_2^{0.5}[/math]

La parola chiave qui è simmetrica: gli esponenti dei due beni sono identici ([math]\alpha = \beta = 0.5[/math]). Questa ipotesi non serve solo a semplificare i calcoli matematici nel codice, ma mappa un comportamento economico molto specifico con tre proprietà fondamentali.

1. La regola d’oro del 50/50 (Budget Share)
   Questa è la caratteristica più celebre della Cobb-Douglas simmetrica. Un consumatore con queste preferenze destinerà sempre esattamente il 50% del suo reddito a ciascun bene, indipendentemente da quali siano i prezzi di mercato.
   Se il tuo reddito [math]I[/math] è 100€, spenderai sistematicamente 50€ per il bene 1 e 50€ per il bene 2.
   Da questo comportamento rigido deriva direttamente la formula della domanda Marshalliana che abbiamo inserito nel simulatore:
   [math]\displaystyle p_1 x_1 = \frac{I}{2} \implies x_1^M = \frac{I}{2p_1}[/math]
2. Elasticità al prezzo pari a -1
   Poiché la quota di budget destinata al bene 1 è fissa (50€), se il prezzo [math]p_1[/math] raddoppia, la quantità acquistata [math]x_1[/math] deve esattamente dimezzarsi per mantenere la spesa costante a 50€.
   In termini tecnici, l’elasticità della domanda marshalliana rispetto al prezzo è rigidamente pari a [math]-1[/math]. La spesa totale per il bene non cambia mai al variare del prezzo.
3. I beni sono essenziali (Sostituzione imperfetta)
   La struttura moltiplicativa della funzione ([math]\sqrt{x_1 \cdot x_2}[/math]) implica che se il consumo di uno dei due beni scende a zero, l’utilità totale crolla a zero, a prescindere da quanto consumi dell’altro bene.
   I due prodotti non sono perfetti sostituti (come due marche diverse di acqua minerale), ma presentano curve di indifferenza convesse. Il consumatore ama la varietà e preferisce un paniere bilanciato piuttosto che consumare un solo bene.

Perché questa ipotesi è perfetta per il simulatore?

Scegliere questa funzione ci permette di mettere in evidenza il comportamento della domanda Hicksiana in modo cristallino.

Mentre nella Marshalliana il consumatore è vincolato dal portafoglio (e spende sempre 50€), nella Hicksiana il vincolo è il benessere ([math]u_0 = 50[/math]). Quando il prezzo [math]p_1[/math] sale, l’approccio Hicksiano dà al consumatore i soldi necessari (l’effetto reddito) per evitare che la sua utilità crolli. Il consumatore, protetto dal punto di vista economico, rimodula il suo paniere sostituendo il bene più costoso con quello rimasto invariato.

Se non avessimo usato una funzione simmetrica, le curve sarebbero state asimmetriche e più complesse da leggere visivamente, confondendo l’utente sul reale impatto della scomposizione tra effetto reddito ed effetto sostituzione.

 

Le funzioni di domanda

Nel codice vengono definite due funzioni.

Domanda Marshalliana

def domanda_marshalliana(p1):
    return I / (2 * p1)

Con una funzione Cobb-Douglas simmetrica, il consumatore destina sempre metà del reddito al bene 1.

La quantità ottimale diventa:

[math]\displaystyle x_1^M = \frac{I}{2p_1}[/math]

Osserviamo immediatamente una relazione inversa:

• se il prezzo raddoppia
• la quantità domandata si dimezza

Domanda Hicksiana

def domanda_hicksiana(p1):
    return u0 * np.sqrt(p2 / p1)

La domanda compensata nasce invece dalla minimizzazione della spesa necessaria per mantenere costante il livello di utilità.

La soluzione analitica è:

[math]\displaystyle x_1^H = u_0 \sqrt{\frac{p_2}{p_1}}[/math]

Qui il comportamento è differente.

L’obiettivo non è massimizzare l’utilità dato il reddito disponibile, ma minimizzare il costo mantenendo invariato il benessere.

Generazione delle curve

Per costruire il grafico vengono creati 400 punti:

prezzi = np.linspace(0.5, 5.0, 400)

che rappresentano i possibili valori del prezzo del bene 1.

Successivamente:

q_marshall_linea = domanda_marshalliana(prezzi)
q_hicks_linea = domanda_hicksiana(prezzi)

vengono calcolate le due curve.

Questo approccio è estremamente efficiente grazie alla vettorizzazione di NumPy.

Non utilizziamo cicli for.

L’intero array viene elaborato direttamente in memoria tramite operazioni SIMD ottimizzate.

Dal punto di vista della data science questo è il modo corretto di lavorare con grandi volumi di dati numerici.

La funzione di aggiornamento

Il cuore del simulatore è:

def aggiorna_simulatore(p1,
                        mostra_marshall,
                        mostra_hicks):

Questa funzione viene richiamata automaticamente ogni volta che:

• si muove lo slider
• si attiva una checkbox
• si disattiva una checkbox

L’utente non deve eseguire nuovamente il notebook.

L’interfaccia aggiorna il grafico in tempo reale.

Creazione della figura

fig, ax = plt.subplots(figsize=(9, 6))

Ad ogni aggiornamento viene creata una nuova figura.

Questo evita problemi di sovrapposizione grafica e mantiene il rendering pulito.

Evidenziare il prezzo corrente

ax.axhline(
    p1,
    color='gray',
    linestyle=':',
    alpha=0.7
)

La linea orizzontale indica il prezzo attualmente selezionato.

Si tratta di un accorgimento grafico molto utile perché permette di individuare immediatamente il punto della curva corrispondente al valore scelto.

Disegnare la domanda Marshalliana

Quando la checkbox è attiva:

if mostra_marshall:

viene eseguito:

ax.plot(
    q_marshall_linea,
    prezzi,
    'b-',
    label='Domanda Marshalliana'
)

La curva viene rappresentata in blu.

Successivamente:

q_m_corrente = domanda_marshalliana(p1)

calcola il punto corrente.

Infine:

ax.plot(
    [q_m_corrente],
    [p1],
    'bo'
)

disegna il marker.

Proiezione sull’asse delle quantità

Una delle parti più interessanti del codice è:

ax.vlines(
    q_m_corrente,
    0,
    p1,
    colors='blue',
    linestyles='--'
)

Questa linea tratteggiata permette di leggere immediatamente la quantità associata al prezzo selezionato.

Dal punto di vista della visualizzazione dati, si tratta di una tecnica molto efficace perché riduce il carico cognitivo dell’utente.

Disegnare la domanda Hicksiana

La logica è identica:

if mostra_hicks:

La curva viene visualizzata in rosso:

ax.plot(
    q_hicks_linea,
    prezzi,
    'r-'
)

e viene evidenziato il punto corrispondente al prezzo corrente.

La possibilità di attivare e disattivare le due curve rende immediata l’osservazione delle differenze.

Configurazione degli assi

ax.set_xlim(0, 110)
ax.set_ylim(0, 5.5)

Questi limiti sono stati scelti per mantenere il grafico leggibile lungo tutto l’intervallo dei prezzi.

Le etichette:

ax.set_xlabel(...)
ax.set_ylabel(...)

rendono esplicito il significato economico delle variabili.

L’interattività con ipywidgets

L’ultima parte del codice crea la dashboard.

interact(
    aggiorna_simulatore,

Il componente principale è lo slider:

widgets.FloatSlider(
    value=1.0,
    min=0.5,
    max=5.0,
    step=0.1
)

che permette di modificare il prezzo del bene.

L’opzione:

continuous_update=True

garantisce un aggiornamento fluido durante il trascinamento.

Questo dettaglio migliora notevolmente l’esperienza utente.

Il Codice Completo

Copia e incolla questo blocco di codice in una cella di Colab ed eseguilo.

Vedrai comparire lo slider e i checkbox perfettamente funzionanti direttamente sotto il grafico:

import numpy as np
import matplotlib.pyplot as plt
import ipywidgets as widgets
from ipywidgets import interact

# --- PARAMETRI DEL MODELLO ---
I = 100.0      # Reddito Nominale
p2 = 1.0       # Prezzo del Bene 2 costante
u0 = 50.0      # Utilità target di partenza

# --- FUNZIONI DI DOMANDA ---
def domanda_marshalliana(p1):
    return I / (2 * p1)

def domanda_hicksiana(p1):
    return u0 * np.sqrt(p2 / p1)

# Preparazione curve di sfondo
prezzi = np.linspace(0.5, 5.0, 400)
q_marshall_linea = domanda_marshalliana(prezzi)
q_hicks_linea = domanda_hicksiana(prezzi)

# --- FUNZIONE DI AGGIORNAMENTO DINAMICO ---
def aggiorna_simulatore(p1, mostra_marshall, mostra_hicks):
    # Creiamo la figura a ogni movimento dello slider
    fig, ax = plt.subplots(figsize=(9, 6))
    
    # Linea tratteggiata del prezzo corrente
    ax.axhline(p1, color='gray', linestyle=':', alpha=0.7)
    
    # Gestione Domanda Marshalliana
    if mostra_marshall:
        ax.plot(q_marshall_linea, prezzi, 'b-', label='Domanda Marshalliana', linewidth=2)
        q_m_corrente = domanda_marshalliana(p1)
        ax.plot([q_m_corrente], [p1], 'bo', markersize=8)
        # Linea verticale di proiezione sull'asse X
        ax.vlines(q_m_corrente, 0, p1, colors='blue', linestyles='--', alpha=0.4)
        
    # Gestione Domanda Hicksiana
    if mostra_hicks:
        ax.plot(q_hicks_linea, prezzi, 'r-', label='Domanda Hicksiana ($u_0=50$)', linewidth=2)
        q_h_corrente = domanda_hicksiana(p1)
        ax.plot([q_h_corrente], [p1], 'ro', markersize=8)
        # Linea verticale di proiezione sull'asse X
        ax.vlines(q_h_corrente, 0, p1, colors='red', linestyles='--', alpha=0.4)

    # Configurazione assi grafico
    ax.set_xlim(0, 110)
    ax.set_ylim(0, 5.5)
    ax.set_xlabel('Quantità del Bene 1 ($x_1$)')
    ax.set_ylabel('Prezzo del Bene 1 ($p_1$)')
    ax.set_title('Simulatore Colab: Marshalliana vs Hicksiana')
    ax.grid(True, linestyle='--', alpha=0.5)
    ax.legend(loc='upper right')
    
    plt.show()

# --- CREAZIONE INTERFACCIA INTERATTIVA ---
interact(
    aggiorna_simulatore,
    p1=widgets.FloatSlider(
        value=1.0, 
        min=0.5, 
        max=5.0, 
        step=0.1, 
        description='Prezzo $p_1$ (€):',
        continuous_update=True  # Rende lo slider fluido in tempo reale
    ),
    mostra_marshall=widgets.Checkbox(value=True, description='Mostra Marshalliana'),
    mostra_hicks=widgets.Checkbox(value=True, description='Mostra Hicksiana')
);

Cosa osserviamo nel simulatore?

Quando aumentiamo il prezzo del bene:

• entrambe le domande diminuiscono
• le due curve non coincidono

La differenza tra le quantità rappresenta precisamente il contributo dell’effetto reddito.

La domanda hicksiana elimina infatti la perdita di potere d’acquisto attraverso una compensazione monetaria teorica.

La domanda marshalliana, invece, incorpora l’impatto reale dell’aumento di prezzo sul bilancio del consumatore.

Perché questo esempio interessa anche i data scientist?

A prima vista potrebbe sembrare un semplice esercizio di microeconomia.

In realtà il collegamento con la data science è molto più profondo.

Molti algoritmi moderni cercano di modellare comportamenti decisionali:

• dynamic pricing
• recommendation systems
• revenue management
• demand forecasting
• reinforcement learning economico

In tutti questi casi è fondamentale distinguere tra:

• variazioni dovute ai prezzi relativi
• variazioni dovute alla disponibilità economica

La decomposizione di Slutsky, da cui derivano Marshall e Hicks, è uno dei primi esempi storici di analisi causale applicata ai dati economici.

Cosa NON mostra questo modello: i limiti della “mappa pulita”

Nel data science e nell’economia quantitativa esiste una trappola sottile: innamorarsi della pulizia geometrica di una simulazione fino a confonderla con la realtà. Questo simulatore è uno strumento didattico eccellente, ma come diceva l’epistemologo Alfred Korzybski, “la mappa non è il territorio”.

La scelta della funzione Cobb-Douglas simmetrica ci ha permesso di scrivere un codice lineare ed elegante, ma ha anche nascosto  una serie di comportamenti umani e anomalie di mercato che chi analizza dati reali incontra ogni giorno.

Se provassi ad applicare questo identico modello matematico ai dati di vendita di un e-commerce o a un algoritmo di dynamic pricing in produzione, andresti incontro a fallimenti predittivi macroscopici.

Ecco tutto ciò che questo software non può mostrare:

1. L’illusione della spesa fissa (Preferenze non Cobb-Douglas)
   Il simulatore assume che il consumatore destini sempre, rigidamente, il 50% del suo budget al bene 1, a prescindere dal prezzo. Nella realtà non funziona così. Se il prezzo delle bollette della luce raddoppia, non dimezziamo i consumi per mantenere la spesa costante: tagliamo altre spese per coprire il nuovo costo. Le preferenze umane sono asimmetriche, risentono della saturazione e cambiano forma a seconda dei contesti di consumo.
2. Beni inferiori: quando la perdita di potere d’acquisto inverte le regole
   Nel nostro codice, se il prezzo sale, la quantità domandata scende sempre. Ma cosa succede se il bene analizzato è un servizio di trasporto pubblico economico o un alimento di sottomarca? Questi sono definiti beni inferiori.
   Quando il prezzo di un bene inferiore aumenta, il reddito reale del consumatore si riduce. Ma invece di consumarne meno, il consumatore potrebbe essere costretto a tagliare i beni premium (es. cene al ristorante) per comprare più beni di sottomarca. In questo scenario, l’effetto reddito si muove nella direzione opposta rispetto all’effetto sostituzione, un dinamismo che la nostra Cobb-Douglas cancella per costruzione.
3. Il paradosso estremo: i Beni di Giffen
   Un passo oltre i beni inferiori troviamo il caso limite dei beni di Giffen. Immagina un’economia di sussistenza dove il consumo principale è il pane. Se il prezzo del pane sale, la popolazione diventa così povera da non potersi più permettere carne o verdure. Risultato? Dovrà spendere tutto il budget rimasto per acquistare ancora più pane.
   Nello scenario di Giffen, la curva di domanda marshalliana assume un’inclinazione positiva: il prezzo sale e la quantità domandata aumenta. Il nostro simulatore, vincolato alla retta blu decrescente, non è matematicamente in grado di registrare questo paradosso.
4. Complementarità forti: beni che vivono o muoiono insieme
   La Cobb-Douglas presuppone che i beni siano parzialmente sostituibili: se il bene 1 costa troppo, riduco il consumo e compro un po’ più di bene 2. Ma cosa succede con i beni a complementarità rigida (preferenze Leontief)? Pensa a stampanti e cartucce d’inchiostro, o a smartphone e relativi caricabatterie.
   Nel simulatore: Se il prezzo del bene 1 tende a infinito, la domanda del bene 2 resta comunque stabile e ancorata a [math]\frac{I}{2p_2}[/math].
   Nella realtà: Se il prezzo delle stampanti dovesse schizzare a 10.000€, la domanda di cartucce d’inchiostro crollerebbe istantaneamente a zero. I beni complementari distruggono la fluidità delle curve simmetriche.

⚠️Ridurre l’elasticità di un mercato a una curva simmetrica significa assumere che il mondo sia privo di attriti, di beni di prima necessità e di legami di complementarità. Questo simulatore descrive le forze vettoriali teoriche della scomposizione di Slutsky; usarlo per fare previsioni di ricavo senza calibrare questi limiti significa scambiare un esercizio di stile per un modello predittivo.

Ogni modello è un’ipotesi sul mondo. Capire cosa lascia fuori è spesso più importante di ciò che include.

Pubblicità