Torna al Laboratorio
Ingegneria dei Sistemi & Ricerca OperativaOttobre 2026 • 6 min di lettura

Perché la ricerca operativa batte i Large Language Model: ottimizzazione spaziale e vincoli rigidi con Google OR-Tools

Nel contesto dell'allocazione spaziale e dei problemi NP-hard, i modelli generativi probabilistici falliscono sui vincoli fisici non negoziabili. Ecco perché i solver deterministici come Google OR-Tools CP-SAT rimangono lo standard d'eccellenza nell'ingegneria del software.

Autore: Giorgio Di Cristofalo•Software Engineer @ ENAV Group
Il principio chiave:I Large Language Model eccellono nella sintesi, nella traduzione e nell'interfaccia utente. Quando il problema richiede però il rispetto matematico di vincoli fisici (pescaggio fondale, tolleranze millimetriche, zero sovrapposizioni), la probabilità statistica deve cedere il passo alla correttezza deterministica.

1. L'illusione dell'intuizione spaziale negli LLM

I modelli di linguaggio basati su transformer generano token sequenziali attraverso stime di probabilità condizionate apprese durante il pre-training. Non hanno accesso a una griglia euclidea interna né a un motore di propagazione geometrica.

Affidare a un prompt l'allocazione di decine di imbarcazioni di lunghezza, larghezza e pescaggio eterogenei (il problema reale del progetto Harbor Manager) espone il sistema a tre criticità insostenibili in produzione:

  • Mancanza di garanzie sui vincoli rigidi (hard constraints): un LLM può produrre coordinate plausibili in JSON, ma non può garantire che due scafi non si tocchino per 10 centimetri o che il fondale sia sufficiente durante la bassa marea. In mare, una violazione su cento significa un incidente nautico o un danno economico.
  • Allucinazione combinatoria: man mano che il numero di barche o colli cresce, la complessità combinatoria esplode. I modelli dimenticano vincoli negativi o inventano coordinate di banchina fisicamente inesistenti.
  • Costo computazionale e non-determinismo: ogni inferenza LLM complessa richiede secondi preziosi, consuma budget API e fornisce output diversi a ogni esecuzione. Un solver matematico converge all'ottimo globale (o certifica l'inammissibilità) in frazioni di secondo a costo zero.

2. La formulazione formale: Constraint Programming & SAT

La Constraint Programming (programmazione a vincoli) inverte l'approccio: invece di indovinare una configurazione per tentativi statistici, definisce lo spazio degli stati ammissibili tramite variabili di decisione e vincoli algebrici. Il motore di ricerca esplora l'albero delle soluzioni potando intere combinazioni non ammissibili grazie alla propagazione logica.

// Modello 2D Bin Packing a vincoli disgiunti
• Coordinate spaziali: x_i (posizione su banchina), y_i (distanza dal canale)
• Finestre temporali: [t_start, t_end]
• Dimensioni fisiche: Lunghezza (L_i), Baglio (B_i) + Buffer di rispetto
• Vincolo batimetrico: Pescaggio_i ≤ Fondale(x_i, y_i) ∀ i
• Vincolo di non-sovrapposizione: Overlap(Barca_i, Barca_j) = 0 ∀ i ≠ j

3. Implementazione con Google OR-Tools (CP-SAT)

Google OR-Tools include CP-SAT, uno dei più performanti solver moderni al mondo. In Python, il vincolo critico di non-sovrapposizione bidimensionale viene risolto elegantemente con la funzione nativa AddNoOverlap2D:

berth_allocation_solver.pyPython 3.12 + OR-Tools CP-SAT
from ortools.sat.python import cp_model

def solve_berth_allocation(boats, dock_length, dock_depth):
    model = cp_model.CpModel()
    x_intervals, y_intervals = [], []
    assigned_vars = {}

    for boat in boats:
        # Variabili di decisione per la posizione (x, y) sul molo
        x_start = model.NewIntVar(0, dock_length - boat["length"], f"x_start_{boat['id']}")
        x_end = model.NewIntVar(0, dock_length, f"x_end_{boat['id']}")
        x_int = model.NewIntervalVar(x_start, boat["length"] + boat["buffer_x"], x_end, f"x_int_{boat['id']}")

        y_start = model.NewIntVar(0, dock_depth - boat["width"], f"y_start_{boat['id']}")
        y_end = model.NewIntVar(0, dock_depth, f"y_end_{boat['id']}")
        y_int = model.NewIntervalVar(y_start, boat["width"] + boat["buffer_y"], y_end, f"y_int_{boat['id']}")

        is_assigned = model.NewBoolVar(f"assigned_{boat['id']}")
        assigned_vars[boat['id']] = is_assigned

        x_intervals.append(x_int)
        y_intervals.append(y_int)

    # Garanzia matematica: nessuna intersezione geometrica nel piano 2D
    model.AddNoOverlap2D(x_intervals, y_intervals)

    # Obiettivo: massimizzare il gettito economico e i posti occupati
    model.Maximize(sum(assigned_vars[b['id']] * b['revenue'] for b in boats))

    solver = cp_model.CpSolver()
    solver.parameters.max_time_in_seconds = 5.0
    status = solver.Solve(model)

    if status in (cp_model.OPTIMAL, cp_model.FEASIBLE):
        return {
            b['id']: (solver.Value(model.GetIntVar(f"x_start_{b['id']}")),
                      solver.Value(model.GetIntVar(f"y_start_{b['id']}")))
            for b in boats if solver.Value(assigned_vars[b['id']]) == 1
        }
    return None

4. Risultati concreti: il caso Harbor Manager

Nel progetto di gestione portuale sviluppato da Giorgio, l'integrazione di Google OR-Tools in una pipeline asincrona con worker Celery ha prodotto risultati misurabili:

+22%Spazio recuperato rispetto alla gestione manuale
< 2.4sTempo di calcolo su banchina intera
0%Allucinazioni e violazioni sui vincoli di sicurezza

5. Il ruolo corretto dell'AI nei sistemi di produzione

La vera maturità ingegneristica non consiste nell'usare l'AI ovunque, ma nel sapere quale componente architetturale assegnare a ciascun problema:

Funzione del sistemaTecnologia adattaMotivazione ingegneristica
Comprensione linguaggio naturaleLLM (Gemini / Claude / GPT)Estrazione parametri da email, messaggi e richieste vocali non strutturate.
Ottimizzazione vincolata e fisicaGoogle OR-Tools (CP-SAT)Zero allucinazioni, rispetto algebrico di distanze, tempi e capienze.
Raccomandazioni rapide in-databasekNN Vettoriale in SQL (Postgres)Latenze <30ms senza overhead di rete o costi API per query.
Consegna streaming al clientCelery + Redis Pub/Sub + SSEDisaccoppiamento totale tra computazione asincrona e thread HTTP web.

Conclusioni

I modelli generativi sono una risorsa potente per interpretare l'ambiguità del linguaggio umano. Ma quando un errore di calcolo comporta costi materiali, inefficienze operative o rischi per la sicurezza, la matematica discreta e i solver di ricerca operativa rimangono insostituibili.

Caso Studio Correlato

Harbor Manager — Ottimizzazione Portuale con OR-Tools

Esplora l'architettura completa, i diagrammi del flusso dati PostGIS ➔ Celery ➔ Angular e le metriche di produzione.