Deep Blue batte Kasparov: il paradigma simbolico in vetrina pubblica

11 maggio 1997, Equitable Center di New York. Garry Kasparov gioca per diciannove mosse contro un armadio di processori, poi si alza, scuote la testa, e abbandona. Il match finisce 3.5-2.5 per la macchina. È la prima volta che un computer batte un campione del mondo in carica a scacchi, in un match a tempo standard. Mentre il deep learning matura sotto la superficie, la cultura generale registra una sola immagine: il paradigma simbolico ha vinto la partita pubblica.

Perché questo capitolo

Tra il 1985 e il 1997, una piccola squadra prima a Carnegie Mellon University e poi a IBM Research costruisce una linea di programmi scacchistici — ChipTest, Deep Thought, Deep Blue — che culminano nel match di sei partite a New York del maggio 1997 contro Garry Kasparov (scacchista russo-azero, 1963-, campione del mondo dal 1985 al 2000, all’epoca con un rating ELO di circa 2820, uno dei più alti mai raggiunti). Deep Blue vince il match 3.5-2.5. È la prima volta che una macchina batte un campione del mondo in carica a scacchi in un match a tempo standard di torneo. La notizia esce in prima pagina sui giornali generalisti del mondo intero, copertina di Newsweek, riferimenti in editoriali del New York Times, dibattiti televisivi che durano settimane.

Questo capitolo conta per tre ragioni distinte. La prima è culturale: l’evento entra nella memoria collettiva come “il giorno in cui il computer ha battuto l’uomo a scacchi”, una formula riduttiva ma efficace che plasma il modo in cui il grande pubblico immagina l’intelligenza artificiale per i decenni successivi. Per molti non addetti ai lavori, “AI” significa per anni “una macchina che gioca a scacchi”, esattamente come dopo il 2022 significherà “ChatGPT”. La seconda ragione è tecnica: Deep Blue è il punto di arrivo del paradigma simbolico-search applicato a un dominio combinatorio chiuso. Hardware specializzato, valutazione di posizione costruita da knowledge engineering pesante, ricerca alpha-beta minimax con estensioni sofisticate. Quasi nessun ingrediente è inedito al 1997; la novità è la combinazione e la scala. Capire bene Deep Blue significa capire fino a dove si poteva spingere il paradigma classico prima che la curva si appiattisse.

La terza ragione è contrastiva. Cinque anni prima, nello stesso ente di ricerca — IBM Watson Research Center a Yorktown Heights — Gerald Tesauro ha mostrato con TD-Gammon (vedi td-gammon-1992) che pure self-play con una rete neurale può battere i campioni di backgammon senza alcuna conoscenza programmata. Stesso laboratorio, stesso anno fiscale, due paradigmi opposti, due vittorie reali. Deep Blue cattura l’attenzione pubblica e diventa la metafora dominante. TD-Gammon resta noto solo nella comunità di reinforcement learning. La storia ufficiale che si sedimenta dopo il 1997 dice “il paradigma simbolico ha vinto”; la storia tecnica più accurata dice “due paradigmi diversi hanno avuto vittorie reali nello stesso periodo, su domini diversi, con metodi opposti”. Questo capitolo serve a tenere insieme entrambe le letture senza cancellare l’una con l’altra.

C’è anche una dimensione di tempistica che vale la pena fissare in apertura. Deep Blue arriva dentro il secondo-inverno-ai. Mentre l’industria dei sistemi esperti collassava, mentre il termine “AI” era da evitare nelle proposte di finanziamento, mentre i finanziamenti DARPA si riducevano, IBM stava costruendo in silenzio l’icona AI più visibile del decennio. La contraddizione apparente si scioglie osservando che Deep Blue era un’operazione di marketing corporate prima che un programma di ricerca AI: IBM aveva bisogno di un evento mediatico per rilanciare il brand del Research Center dopo gli anni difficili della ristrutturazione 1991-1993, e gli scacchi offrivano un palcoscenico pulito, comprensibile a chiunque, con una metrica di vittoria binaria. La scelta di IBM non fu “investiamo nell’AI”; fu “costruiamo un’icona pubblica di calcolo avanzato”. Il fatto che il dimostratore tecnico fosse riconducibile al paradigma simbolico è in parte conseguenza di questa scelta strategica.

Contesto

Da Shannon a Carnegie Mellon

Il filo storico arriva da lontano. Claude Shannon (matematico americano, 1916-2001, padre della teoria dell’informazione) pubblica nel 1950 sul Philosophical Magazine un articolo intitolato “Programming a Computer for Playing Chess”, in cui distingue due strategie di base per programmi scacchistici: type A, ricerca brute-force fino a una profondità fissa con valutazione semplice di tutte le posizioni terminali; type B, ricerca selettiva guidata da euristiche umane che esplora poche linee in profondità. Shannon stimava che type A fosse computazionalmente impraticabile e che il futuro stesse in type B. Cinquant’anni dopo, Deep Blue è il trionfo del type A portato al limite tecnologico: ricerca quasi-bruta su milioni di posizioni al secondo.

Tra Shannon 1950 e Deep Blue 1997 ci sono decenni di lavoro accademico. Alan Turing scrive nel 1948 un programma scacchistico che chiama Turochamp, eseguito a mano su carta. Alex Bernstein programma il primo programma scacchistico funzionante su un IBM 704 nel 1957. Nei decenni 60-70 gruppi al MIT, a Stanford, a Northwestern (programma Chess 4.x), e in Unione Sovietica (Kaissa) sviluppano motori scacchistici progressivamente migliori. Negli anni 80 il Computer Olympiad e i tornei dell’ICCA (International Computer Chess Association) sistematizzano la competizione. La performance dei motori cresce lentamente, di circa 50-70 punti ELO l’anno, in linea con la legge di Moore.

In questo paesaggio entra Feng-hsiung Hsu (informatico taiwanese-americano, 1959-, dottorando alla Carnegie Mellon University dal 1985 sotto Hans Berliner — lo stesso Berliner di BKG che incontriamo in td-gammon-1992). Hsu non vuole costruire un altro programma scacchistico in software. Vuole progettare chip VLSI custom che eseguano la generazione delle mosse e parte della valutazione direttamente in silicio, con throughput di ordini di grandezza superiori a un programma generale. La sua tesi di dottorato, completata nel 1989 e intitolata “Large Scale Parallelization of Alpha-Beta Search: An Algorithmic and Architectural Study with Computer Chess”, è centrata su questa idea.

Il primo prototipo, ChipTest, viene costruito tra il 1985 e il 1987. È una sola scheda con un chip move-generator custom, capace di valutare circa 50.000 posizioni al secondo. Non è ancora competitivo, ma valida il principio architetturale. Il secondo prototipo, Deep Thought, viene costruito tra il 1988 e il 1991 dalla squadra di Hsu più Murray Campbell (informatico canadese, 1959-, anch’egli dottorando di Berliner a CMU), Thomas Anantharaman, Andreas Nowatzyk e Mike Browne. Deep Thought è una macchina multi-chip che raggiunge circa 700.000 posizioni al secondo. Nel novembre 1988 Deep Thought batte Bent Larsen (Grandmaster danese, 1935-2010, uno dei migliori giocatori non-sovietici degli anni 60-70) al Software Toolworks Open di Long Beach, California, diventando il primo computer a vincere un torneo open contro un Grandmaster a tempo standard.

Nell’ottobre 1989 Deep Thought affronta Kasparov in due partite di esibizione a New York. Kasparov vince entrambe, 2-0, in modo netto. È un’esibizione, non un match formale, ma stabilisce la distanza: il miglior computer del 1989 è ancora chiaramente al di sotto del miglior umano. Kasparov dichiara dopo la partita che batterà i computer “per sempre”. È una dichiarazione che gli costerà cara otto anni dopo.

IBM entra in scena

Nel 1989 IBM assume Hsu, Campbell e Hoane dal gruppo Deep Thought di CMU. Il progetto si trasferisce al Watson Research Center a Yorktown Heights con il nome di Deep Blue (un gioco di parole tra “Deep Thought” e il soprannome corporate di IBM, “Big Blue”). L’obiettivo dichiarato è battere il campione del mondo entro la fine degli anni 90.

La squadra IBM è piccola: Hsu come architetto hardware principale, Campbell come responsabile software, A. Joseph Hoane Jr. come ingegnere software e di sistema, Jerry Brody come progettista hardware, Joel Benjamin (Grandmaster americano, 1964-, ex campione USA) come consulente scacchistico stipendiato, e Ken Thompson (informatico americano, 1943-, uno dei creatori di Unix, allora a Bell Labs) come consulente esterno per le endgame tablebases. Il budget non è enorme per gli standard IBM di quegli anni (alcuni milioni di dollari spalmati su otto anni) ma è cospicuo per un singolo progetto di ricerca.

Tra il 1991 e il 1995 il team produce diversi prototipi intermedi (Deep Blue prototype, Deep Blue Junior) che vengono testati in tornei di computer chess e in sfide contro giocatori di alto livello. La squadra impara, raffina i chip VLSI, espande la valutazione, costruisce un opening book sotto la guida di Benjamin.

I match Kasparov: 1996 e 1997

Nel febbraio 1996, a Philadelphia, Deep Blue (versione 1996, talvolta chiamata “Deep Blue I”) affronta Kasparov in un match formale di sei partite a tempo standard di torneo (40 mosse in 2 ore). Kasparov vince la prima partita ma perde la seconda; le successive sono divise tra patte e una vittoria umana. Il match finisce 4-2 per Kasparov. È un risultato significativo per IBM: per la prima volta un computer ha battuto Kasparov in una partita singola a tempo standard. Ma il match è perso, e la stampa generalista ne parla con relativo distacco.

Tra il 1996 e il 1997 il team riprogetta sostanzialmente l’hardware (più del doppio di chip, throughput quintuplicato), espande l’opening book con il contributo continuo di Benjamin, riscrive parti dell’algoritmo di ricerca con nuove estensioni euristiche. La versione 1997, talvolta chiamata “Deep Blue II”, è una macchina sostanzialmente diversa.

Il match di rivincita si tiene dal 3 all’11 maggio 1997 all’Equitable Center, midtown Manhattan, New York. Premio di 1.1 milioni di dollari, di cui 700.000 al vincitore. Sei partite, tempo standard, condizioni torneo. Cinque grandmaster come arbitri tecnici. La copertura è massiccia: trasmissione in diretta su internet (cosa rara per il 1997), conferenze stampa quotidiane, tre milioni di visite al sito IBM dedicato.

Inquadramento nella mappa

Questo capitolo si colloca nel filone “giochi come laboratorio AI” della Parte I della wiki. Il capitolo immediatamente precedente, td-gammon-1992, copre l’altra grande vittoria nello stesso quinquennio, con paradigma opposto. Il filone si chiude — provvisoriamente — con alphago-2016 (in preparazione) che riconcilia learning e search. Il paradigma simbolico di knowledge engineering che culmina in Deep Blue è lo stesso paradigma che incontriamo in sistemi-esperti: regole costruite a mano, valutazioni esplicite, ingegneria della conoscenza. Il secondo-inverno-ai è il contesto di sfondo: Deep Blue arriva nel mezzo di un raffreddamento dei finanziamenti AI, ed è in parte un’operazione di marketing IBM, non un programma di ricerca AI mainstream.

L’intuizione

Angolo algoritmico: alpha-beta minimax come ricetta che scala con l’hardware

L’idea base degli scacchi computazionali è semplice e antica. Una posizione ha un valore (misura quanto è buona per il giocatore di turno). Per giocare bene, basta esplorare l’albero delle mosse possibili fino a una certa profondità, valutare le posizioni terminali con una funzione statica, e propagare i valori all’indietro verso la radice scegliendo, a ogni livello, la mossa che massimizza il proprio valore (e che l’avversario, simmetricamente, minimizzerà). Questo è il minimax classico, formulato in teoria dei giochi da John von Neumann negli anni 20 e applicato agli scacchi da Shannon.

Il problema del minimax puro è esplosivo. Una posizione di scacchi tipica ha circa 35 mosse legali. Esplorare 6 ply significa visitare $35^6 \approx 1.8$ miliardi di posizioni. Esplorare 8 ply significa quasi 2.300 miliardi. Anche con 200 milioni di posizioni al secondo (la velocità di Deep Blue 1997), 8 ply puri richiedono ore.

L’alpha-beta pruning è la cura. Pubblicato in forma matura da John McCarthy e collaboratori nei primi anni 60, formalizzato in forma generale da Donald Knuth e Ronald Moore in un paper del 1975 su Artificial Intelligence Journal intitolato “An Analysis of Alpha-Beta Pruning”, l’algoritmo riconosce che molte sotto-linee dell’albero di ricerca non possono influenzare la decisione finale e possono essere troncate senza esplorarle. In pratica, alpha-beta riduce il branching factor effettivo da 35 a circa $\sqrt{35} \approx 6$ . Il costo per esplorare a profondità $d$ scende da $b^d$ a $b^{d/2}$ . Su 8 ply, il numero di posizioni esplorate diventa dell’ordine di milioni, non miliardi. Profondità 10-12 diventa raggiungibile.

L’intuizione operativa è questa: alpha-beta minimax con una buona funzione di valutazione e ordinamento intelligente delle mosse è una ricetta che scala quasi linearmente con l’hardware. Raddoppi la velocità del calcolatore, vai un mezzo-ply più in profondità (in media). Ogni mezzo-ply in più vale empiricamente circa 50-70 punti ELO. Da Bernstein 1957 (profondità ~2 ply, ELO ~1000) a Deep Blue 1997 (profondità tipica 6-8 ply brute, fino a 20+ ply lungo linee tattiche con estensioni, ELO ~2700+), il progresso è stato in larga misura una funzione del compute disponibile, applicato a un algoritmo essenzialmente fissato. Questa è la ragione profonda per cui hardware specializzato come quello di Hsu poteva competere: ogni fattore 10 di throughput in più si traduceva, ruvidamente, in 100-200 punti ELO in più.

Angolo strategico-AI: knowledge engineering vince ancora in domini con regole esplicite e ramificazione gestibile

L’altro angolo è più filosofico-storico. Nel 1997, il dibattito su come costruire intelligenza artificiale è aperto. Da un lato il paradigma simbolico, erede di ai-simbolica-anni-60 e sistemi-esperti: rappresentazione esplicita della conoscenza, regole, ricerca strutturata. Dall’altro il paradigma connessionista, in piena traversata silenziosa (vedi reti-neurali-80-90), che otterrà i suoi primi grandi successi pubblici solo nel 2012 con AlexNet (vedi imagenet-alexnet-2012). Nel mezzo, il paradigma statistico (vedi rinascita-statistica-90) che sta prendendo piede in machine learning accademico.

Deep Blue è una vittoria pulita del paradigma simbolico. Tutto in Deep Blue è esplicito: le regole degli scacchi, le mosse legali, le funzioni di valutazione (otto migliaia di feature pesate a mano), gli opening book costruiti da maestri umani, le endgame tablebases pre-calcolate, le estensioni euristiche scelte per ragioni note. Non c’è learning. La rete neurale di Deep Blue è zero. I pesi della valutazione sono ottimizzati con regressione lineare su database di partite GM, ma il framework è interamente progettato a mano.

L’intuizione strategica è questa: in domini con regole esplicite e branching gestibile, il knowledge engineering pesante combinato con search massiva è ancora competitivo nel 1997. Gli scacchi soddisfano entrambe le condizioni: regole completamente formalizzate (32 pezzi, 64 case, ~400 pagine di regole in totale incluso enroque, en passant, promozione), branching factor di circa 35 (basso rispetto al Go con ~250). Il dominio è perfettamente adatto a un attacco simbolico-search. Per dominio dove le regole non sono esplicite (riconoscimento di immagini, comprensione del linguaggio naturale), questo approccio non funziona. Per dominio dove il branching factor è troppo alto (Go), neanche.

Vale la pena marcare la classe di affermazione: dire “Deep Blue è la vittoria del paradigma simbolico” è una filiazione metodologica corretta — Deep Blue eredita tecniche e visione da decenni di lavoro nel filone simbolico. Dire “Deep Blue dimostra che la strada giusta verso l’AI è simbolica” è un’equivalenza indebita: dimostra solo che, in un dominio specifico con proprietà particolari, il simbolico vince. Questa sfumatura sarà cruciale per leggere correttamente il decennio successivo.

Angolo cognitivo: cosa NON è il “pensare scacchistico” di Deep Blue

Un terzo angolo aiuta a evitare fraintendimenti che il successo mediatico ha alimentato. Quando un Grandmaster umano gioca a scacchi, le evidenze degli studi di Adriaan de Groot (psicologo olandese, 1914-2006, autore di Thought and Choice in Chess del 1965) e di Herbert Simon (premio Nobel per l’economia 1978, vedi ai-simbolica-anni-60) suggeriscono un processo radicalmente diverso. Il GM riconosce pattern memorizzati (decine di migliaia di configurazioni tipiche), genera poche mosse candidate (4-5, non 35), valuta in profondità su quelle poche linee. È un processo di chunking e search selettiva guidata da intuizione esperta — molto più vicino al “type B” di Shannon che al “type A”.

Deep Blue fa l’opposto. Genera quasi tutte le mosse legali a ogni nodo, valuta milioni di posizioni al secondo, va in profondità senza guida umana sulla scelta di cosa esplorare. Il risultato in termini di mosse giocate può somigliare a quello umano, ma il processo è incommensurabile. Questa è una analogia debole, non una filiazione né un’equivalenza: Deep Blue gioca a scacchi, ma non gioca come un umano gioca. Confondere i due livelli ha alimentato per decenni un equivoco filosofico, raccolto poi nel dibattito sulla “comprensione” delle macchine che attraversa la Parte II della wiki (vedi stanza-cinese-searle, in preparazione).

La meccanica

Il problema scacchi

Gli scacchi sono un gioco a informazione perfetta, deterministico, a somma zero, con un albero di gioco gigantesco ma finito. Il numero totale di posizioni di scacchi legali è stato stimato attorno a $10^{43}$ - $10^{50}$ (Shannon stimava $10^{43}$ nel 1950, stime più recenti basate su simulazioni Monte Carlo lo collocano attorno a $10^{45}$ ). Il numero di partite distinte di scacchi è ancora più grande, dell’ordine di $10^{120}$ (il famoso “numero di Shannon”). Tutti questi numeri sono molto più grandi del numero di particelle nell’universo osservabile (~ $10^{80}$ ). Una soluzione per enumerazione completa è e resterà sempre fuori portata.

La branching factor media è circa 35 mosse legali per posizione, come accennato. Le partite di scacchi durano in media circa 40 mosse a giocatore (80 ply totali). Una partita generica, quindi, vive in un sotto-albero con $35^{80} \approx 10^{123}$ foglie. Il punto chiave non è “esplorare tutto”, che è impossibile, ma “esplorare abbastanza da decidere bene”.

Deep Blue al 1997 esplorava in modo brute fino a profondità tipica 6-8 ply, e in modo selettivo (lungo linee tattiche con estensioni) fino a 20-40 ply su singole linee. Questa profondità si è dimostrata sufficiente, in pratica, per giocare al livello dei top GM umani.

Hardware Deep Blue 1997

Deep Blue 1997 è un sistema massivamente parallelo con architettura ibrida. La macchina occupa due rack da 1.4 metri di altezza nella sala server IBM e pesa circa una tonnellata totale. La sua specifica:

30 nodi di calcolo basati su IBM RS/6000 SP2, una linea di server enterprise IBM degli anni 90. Ogni nodo ha un processore POWER2 a 120 MHz e diversi MB di memoria RAM.
480 chip VLSI custom per scacchi, distribuiti 16 per nodo. Ogni chip è progettato dalla squadra di Hsu e fabbricato da IBM Microelectronics. Il chip è specializzato per due compiti: generazione delle mosse legali (un compito che, in software generale, è uno dei colli di bottiglia di un motore scacchistico), e valutazione di posizione hardware (una versione semplificata della funzione di valutazione, eseguita direttamente in silicio per nodi vicini alle foglie dell’albero).
Throughput aggregato: circa 200 milioni di posizioni al secondo in regime sostenuto, con picchi fino a 330 milioni in posizioni tattiche favorevoli al hardware.
Interconnect: i nodi RS/6000 sono connessi via High Performance Switch IBM, una rete ad alta velocità che permette al nodo master di distribuire sotto-alberi ai nodi worker e raccogliere i risultati.

L’architettura è concepita per alpha-beta parallelo, un problema notoriamente difficile perché la stessa natura di alpha-beta (i valori alpha e beta dipendono dall’ordine di esplorazione e tagliano sotto-alberi) limita la parallelizzabilità ideale. Il team Deep Blue usa una variante di young brothers wait concept (YBWC), in cui ogni nodo esplora il primo figlio in modo seriale e poi distribuisce i fratelli successivi ai worker. La efficienza parallela non è 1.0 ma circa 0.5-0.7 sui 30 nodi: meglio di metà del massimo teorico, ma con molto spreco rispetto a un’architettura puramente seriale ipotetica.

I chip custom sono il cuore dell’architettura. Ogni chip valuta circa 2-2.5 milioni di posizioni al secondo: 480 chip moltiplicato per questa cifra dà appunto il throughput aggregato. Il chip implementa in hardware:

Move generator: data una posizione codificata, produce in qualche ciclo di clock la lista di tutte le mosse legali, includendo casi speciali (en passant, arrocco, promozione).
Static evaluator: una versione semplificata della valutazione completa (solo material balance, alcune feature di pawn structure e king safety), usata per le foglie dell’albero quando il nodo software passa la palla all’hardware.
Repetition detection: riconosce posizioni visitate in precedenza nella stessa linea di ricerca.

I nodi software (RS/6000) gestiscono i livelli alti dell’albero, dove la valutazione completa è più importante e la velocità conta meno; passano i sotto-alberi vicini alle foglie ai chip hardware, che eseguono la ricerca rimanente in modo veloce ma con valutazione semplificata. Questa architettura ibrida è una scelta di compromesso: i top livelli dell’albero hanno valutazioni complete e accurate, le foglie hanno valutazioni veloci e approssimate.

Algoritmo: alpha-beta minimax con estensioni

L’ossatura algoritmica è alpha-beta minimax classico, ma arricchito da un insieme di estensioni (search extensions) che ampliano la profondità lungo linee specifiche dove la valutazione statica al nodo terminale sarebbe inaffidabile. Le estensioni più importanti:

Singular extension (estensione singolare): se a un nodo c’è una mossa nettamente migliore di tutte le altre (di un margine prefissato), la profondità di ricerca su quella mossa viene estesa di un ply. L’idea: una mossa “obbligata” merita di essere esplorata più a fondo, perché la valutazione del sotto-albero è di fatto la valutazione di tutta la posizione.
Recapture extension: se un pezzo viene catturato e c’è una ricattura immediata, si estende la ricerca per evitare l’horizon effect (l’effetto di “non vedere oltre l’orizzonte” dovuto a una profondità fissa: una catastrofe a profondità $d+1$ è invisibile a un motore che cerca a profondità $d$ ).
Threat extension: se una mossa minaccia immediatamente uno scacco matto o una grande perdita di materiale, la ricerca lungo quella linea si estende.
Check extension: se un nodo è in scacco, la profondità di ricerca su tutte le mosse di risposta si estende di 1 ply.

Oltre alle estensioni, Deep Blue usa diverse tecniche standard di ottimizzazione di alpha-beta:

Null-move pruning: trucco potente che si basa sull’osservazione “se la posizione è così buona che potrei passare il turno (mossa nulla) e essere ancora in vantaggio, allora il sotto-albero è probabilmente un beta cutoff”. La mossa nulla è esplorata a profondità ridotta; se restituisce un valore $\geq \beta$ , il nodo viene troncato.
Transposition table: una hash table che memorizza posizioni già esplorate con il loro valore, profondità di ricerca a cui sono state esplorate, e tipo di nodo (alpha, beta, exact). Quando una posizione viene re-incontrata (per trasposizione di mosse), si riusa il valore memorizzato anziché ri-esplorare. Deep Blue usa una transposition table di centinaia di MB.
Iterative deepening: la ricerca parte da profondità 1 e aumenta di 1 ply per volta. A ogni iterazione, la transposition table accumula informazioni che accelerano l’iterazione successiva. Inoltre, iterative deepening permette gestione del tempo: se il tempo si esaurisce, l’ultima profondità completata fornisce comunque una mossa.
Move ordering: alpha-beta è massimamente efficace quando le mosse migliori vengono esplorate per prime (massimo cutoff). Deep Blue ordina le mosse a ogni nodo in base a euristiche: mosse di cattura prima (specialmente cattura di pezzi più valuti con pezzi meno valuti, MVV-LVA), mosse trovate buone in iterazioni precedenti dell’iterative deepening, mosse “killer” (mosse che hanno prodotto cutoff in posizioni simili).

In pseudocodice, il cuore della ricerca è una funzione ricorsiva che possiamo abbozzare così:

funzione alphabeta(posizione, profondita, alpha, beta, nodo_max):
    se profondita == 0 o posizione_terminale(posizione):
        ritorna evaluate(posizione)

    se nodo_max:
        valore = -infinito
        per ogni mossa in genera_mosse_ordinate(posizione):
            nuova_pos = applica(posizione, mossa)
            valore = max(valore, alphabeta(nuova_pos, profondita-1, alpha, beta, falso))
            alpha = max(alpha, valore)
            se alpha >= beta:
                rompi  # beta cutoff
        ritorna valore
    altrimenti:
        valore = +infinito
        per ogni mossa in genera_mosse_ordinate(posizione):
            nuova_pos = applica(posizione, mossa)
            valore = min(valore, alphabeta(nuova_pos, profondita-1, alpha, beta, vero))
            beta = min(beta, valore)
            se alpha >= beta:
                rompi  # alpha cutoff
        ritorna valore

Questo è lo scheletro. La versione reale di Deep Blue ha decine di migliaia di righe di codice C distribuite tra il software dei nodi RS/6000 e i micro-codici dei chip VLSI, con tutte le estensioni e le ottimizzazioni discusse sopra. Il punto è che l’idea è semplice; la complessità è nei dettagli e nella scala di esecuzione.

Funzione di valutazione

La funzione di valutazione di Deep Blue è il pezzo dove più knowledge engineering è stato investito. Quando la ricerca raggiunge un nodo foglia (a profondità terminale, oppure in posizioni “quiete” dove la quiescence search è terminata), questa funzione produce un numero che stima quanto la posizione è buona per il bianco. Numero positivo: il bianco è in vantaggio. Numero zero: posizione bilanciata. Numero negativo: il nero è in vantaggio.

La struttura della funzione è una somma pesata di feature. Approssimativamente $V(s) = \sum_i w_i \cdot f_i(s)$ , dove $f_i$ è la $i$ -esima feature (un numero estratto dalla posizione) e $w_i$ è il suo peso. Deep Blue ha circa 8000 feature distinte. Le categorie principali, in ordine approssimativo di importanza:

Material balance (bilanciamento materiale): pedone vale circa 1, cavallo 3, alfiere 3.25, torre 5, donna 9, re infinito (perdita = sconfitta). La somma ponderata dei pezzi rimasti è la feature dominante. Da sola spiega circa il 60% della varianza nelle valutazioni.
Pawn structure: feature che descrivono la disposizione dei pedoni. Pedoni doppiati (due pedoni sulla stessa colonna), isolati (senza pedoni amici sulle colonne adiacenti), passati (senza pedoni nemici davanti che possano fermare la promozione), arretrati, in catena. Ogni configurazione ha un peso. Approssimativamente 15% del peso totale.
King safety: misura la sicurezza del re. File aperte vicino al re, pezzi nemici che attaccano la zona del re, pezzi amici a difesa, possibilità di scacco rapido. Critica nel mediogioco, meno in finale. Approssimativamente 12%.
Mobility: numero di mosse legali per ogni pezzo. Più mobilità è meglio. Pezzi bloccati (cavalli su orlo, alfieri ostacolati da pedoni propri) penalizzati. Approssimativamente 8%.
Tempo, control of squares, threats, varie: il rimanente 5% è distribuito tra molte feature minori — controllo del centro, possesso di file aperte da torri, coppia di alfieri, presenza di outpost (case avanzate sicure per cavalli), e così via.

I pesi delle feature sono determinati con un mix di tre metodi:

Esperienza umana: i pesi base (valori dei pezzi, penalità per pedoni doppiati, e così via) sono inizializzati su valori che la teoria scacchistica conosce da decenni.
Tuning su database: i pesi vengono raffinati con regressione su grandi database di partite GM (centinaia di migliaia di posizioni etichettate con la valutazione di esperti o con l’esito della partita). La regressione cerca i pesi che massimizzano la coerenza tra valutazione automatica e giudizio esperto.
Tuning manuale: alcuni pesi (estensioni, threshold per singular extension, parametri di null-move) sono tuneati a mano dal team in base ai test su posizioni note.

La fragilità di questo approccio è evidente. 8000 feature manuali significano migliaia di scelte di design, ognuna delle quali può essere sbagliata o sub-ottimale. Il tuning fa quello che può, ma il framework sottostante è progettato a mano. Una sola feature mal pesata può produrre comportamenti scacchisticamente strani in classi di posizioni rare. Joel Benjamin, il GM consulente, passa una frazione del suo tempo a identificare pattern dove Deep Blue valuta male e a proporre nuove feature o aggiustamenti. È knowledge engineering nello stile dei sistemi esperti, applicato agli scacchi.

Opening book ed endgame tablebases

Il libro delle aperture (opening book) è una collezione di posizioni iniziali con la mossa raccomandata pre-calcolata. Deep Blue ne ha circa 4000, costruite e curate da Joel Benjamin nei mesi precedenti il match. Quando la posizione corrente è nel libro, la mossa viene scelta dal libro senza alcuna ricerca, risparmiando tempo e garantendo un’apertura giocata bene contro le linee teoricamente più forti.

La curazione dell’opening book per il match 1997 è strategica. Benjamin studia le partite di Kasparov, identifica le aperture che Kasparov gioca abitualmente, e prepara linee specifiche per quelle. Il libro è anche bilanciato per evitare che Deep Blue cada in linee dove la sua valutazione (essenzialmente tattica e a corto raggio) sia debole; in caso di posizioni strategiche di lungo respiro, il libro raccomanda mosse che evitano le situazioni dove Deep Blue è più debole.

Le endgame tablebases sono una struttura dati pre-calcolata che, per ogni posizione di finale con pochi pezzi, contiene la valutazione esatta (vittoria, patta, sconfitta) e il numero di mosse al matto con gioco ottimo. Ken Thompson ha pionierizzato il concetto negli anni 70-80 con tablebase per finali a 4 pezzi. Al 1997 sono disponibili tablebase complete per tutti i finali a 3, 4 e 5 pezzi (totalizzando alcuni GB di dati pre-calcolati). Deep Blue ha le tablebase a 5 pezzi caricate, e durante la ricerca, quando un nodo raggiunge una posizione coperta dalla tablebase, il valore esatto viene letto direttamente.

Le tablebase risolvono completamente i finali coperti: nessuna ricerca, valutazione perfetta. Sono uno strumento potentissimo nelle posizioni che vi rientrano, e la loro estensione progressiva (al 2018 sono complete fino a 7 pezzi, generate dal team Lomonosov) ha gradualmente “risolto” porzioni sempre più ampie del finale di scacchi. Il loro contributo al successo di Deep Blue è significativo ma non determinante: la maggior parte delle partite del match 1997 si è decisa nel mediogioco, fuori dalla copertura delle tablebase.

Il match 1996 e cosa imparò IBM

Il match di Philadelphia del febbraio 1996 si gioca su sei partite. Risultati partita per partita:

Partita 1 (10 febbraio): Deep Blue (bianco) batte Kasparov. Sensazione mondiale: per la prima volta un computer batte il campione mondiale a tempo standard.
Partita 2 (11 febbraio): Kasparov (bianco) batte Deep Blue.
Partita 3 (13 febbraio): patta.
Partita 4 (14 febbraio): patta.
Partita 5 (16 febbraio): Kasparov (bianco) batte Deep Blue.
Partita 6 (17 febbraio): Kasparov (nero) batte Deep Blue.
Risultato finale: Kasparov 4 - Deep Blue 2.

Cosa imparò IBM dal match 1996? Tre lezioni operative principali:

Primo, profondità di ricerca insufficiente in posizioni strategiche. Kasparov nelle partite vinte aveva spesso giocato linee posizionali a lungo respiro, dove Deep Blue 1996 (con i suoi ~100 milioni di nps) non vedeva abbastanza in profondità per coglierne le conseguenze. La risposta fu hardware: raddoppiare il numero di chip e quintuplicare il throughput.

Secondo, opening book inadeguato. Kasparov aveva facilmente trovato linee fuori dal libro di Deep Blue 1996 dove poteva giocare con preparazione domestica, mettendo il computer in posizioni dove la search da sola non bastava. La risposta fu Joel Benjamin che lavorò per un anno intero a costruire un opening book molto più ricco e specificamente calibrato contro Kasparov.

Terzo, comprensione strategica troppo debole. Le valutazioni di Deep Blue 1996 in posizioni strategiche (dove conta il piano a lungo termine, non la tattica immediata) erano percepite da Kasparov come ingenue. La risposta fu un raffinamento estensivo della funzione di valutazione, con nuove feature aggiunte per concetti posizionali (controllo di colonne aperte, debolezza del re a lungo termine, struttura dei pedoni dinamica).

C’è anche una dimensione psicologica nelle lezioni IBM. Kasparov nel 1996 era visibilmente teso solo nella prima partita persa; nelle successive aveva ritrovato fiducia e dominato. Per il 1997, IBM voleva un Deep Blue in grado di disturbare Kasparov psicologicamente, mantenendolo in tensione lungo tutto il match.

Il match 1997: cronaca e svolta

Il match di rivincita inizia il 3 maggio 1997 a New York. Kasparov gioca con il bianco la prima partita in base al sorteggio.

Partita 1, 3 maggio: Kasparov vince con il bianco. Apertura inglese, Kasparov gioca solidamente, Deep Blue commette qualche imprecisione nel mediogioco, Kasparov sfrutta. Risultato 1-0 Kasparov. Tutto sembra andare come nel 1996.

Partita 2, 4 maggio: la partita che cambia il match. Deep Blue gioca con il bianco. Apertura Ruy Lopez (apertura spagnola), una linea classica. Kasparov gioca un set-up posizionale con cui ha avuto successo molte volte. Nel mediogioco, alla mossa 36, Deep Blue gioca 36.axb5, una cattura di pedone non immediatamente decisiva ma posizionalmente forte: rinuncia a una possibile attivita immediata in favore di un vantaggio posizionale a lungo termine. La mossa turba profondamente Kasparov. Lui si aspettava da Deep Blue una mossa più tattica, più “computeresca”; questa mossa assomiglia a quella che farebbe un GM umano con ottima comprensione strategica. Kasparov perde fiducia, gioca le mosse successive in modo sub-ottimale, e si arrende alla mossa 45. Deep Blue vince, 1-1.

C’è una nota tecnicamente importante. Successivamente, l’analisi post-match con software più potenti ha mostrato che la posizione finale era in realtà patta: Kasparov aveva una linea di salvataggio (un tema di scacco perpetuo) che non vide. Lui si era arreso in una posizione tecnicamente patta. Questo aggiungerà sale alla polemica successiva.

Partita 3, 6 maggio: patta. Apertura Caro-Kann, gioco prudente da entrambe le parti.

Partita 4, 7 maggio: patta. Game di mediogioco prolungato senza vincitori chiari.

Partita 5, 10 maggio: patta. Match in equilibrio, 2.5-2.5.

Partita 6, 11 maggio: la partita decisiva. Kasparov gioca con il nero. Sceglie l’apertura Caro-Kann, una difesa solida ma passiva. Deep Blue (bianco) gioca 7.Nxe6! un sacrificio di cavallo classico contro questa difesa, ben noto alla teoria — IBM con Joel Benjamin lo aveva esplicitamente preparato nel libro delle aperture. Kasparov, che probabilmente aveva sottovalutato il fatto che la macchina avrebbe accettato di giocare un sacrificio “umano” così classico, si trova in una posizione concreta dove deve difendere accuratamente. Gioca alcune mosse imprecise, si arrende alla mossa 19 in posizione persa.

Risultato finale: Deep Blue 3.5 - Kasparov 2.5. Per la prima volta nella storia, un campione del mondo in carica perde un match a tempo standard contro una macchina.

L’incident della partita 2

La polemica esplode subito dopo il match. Kasparov, in conferenza stampa nei giorni seguenti, accusa pubblicamente IBM di intervento umano durante la partita 2. La sua tesi: la mossa 36.axb5 era “troppo umana” per essere stata trovata da una macchina puramente algoritmica; doveva esserci stato un Grandmaster che, in qualche modo, aveva influenzato la scelta.

L’accusa è scivolosa. Da un lato, è scacchisticamente plausibile che 36.axb5 fosse trovabile da Deep Blue: con le horizon extensions attive, e con valutazioni che premiano vantaggi posizionali a lungo termine, il motore poteva vedere che la posizione risultante era favorevole pur senza guadagno tattico immediato. Dall’altro lato, IBM ha rifiutato di rilasciare i log dei calcoli durante il match, alimentando il sospetto. La posizione di IBM era: i log sono proprietà industriale, non dobbiamo nulla al pubblico; quella di Kasparov: senza i log, non posso verificare cosa ha fatto la macchina.

Anni dopo (in particolare nel documentario Game Over: Kasparov and the Machine di Vikram Jayanti del 2003, e in interviste successive), Kasparov ha parzialmente ritrattato l’accusa di cheating, ammettendo che la mossa era plausibile per Deep Blue e che la sua reazione emotiva al momento aveva forse esagerato. Ma ha mantenuto la critica all’opacità di IBM: il rifiuto di rilasciare i log e di concedere una rivincita formale (Kasparov chiese pubblicamente una rivincita per anni; IBM rifiutò sistematicamente, smantellando Deep Blue poco dopo il match) lascia un’ombra sul significato definitivo del risultato.

L’incident della partita 2 è importante perché mostra una proprietà operativa dell’AI in vetrina pubblica: quando un sistema AI vince in un evento di alto profilo contro un esperto umano, la trasparenza dei log diventa una questione che esce dal tecnico ed entra nel politico. Senza trasparenza, accuse di trucco sono inevitabili. Con trasparenza, la vittoria è verificabile. La lezione è stata raccolta da DeepMind nel 2016 con AlphaGo, dove i log delle partite contro Lee Sedol furono pubblicati interamente.

Cosa fece Deep Blue, cosa NON fece

Vale la pena fissare in chiusura del corpo storico cosa Deep Blue fece e cosa non fece, per evitare letture esagerate.

Fece:

Cercare con velocità senza precedenti, fino a 200 milioni di posizioni al secondo, nodi tattici esplorati in profondità a 16-20 ply.
Valutare posizioni con una funzione di valutazione complessa multi-feature, calibrata su decenni di teoria scacchistica.
Giocare un’apertura solida grazie all’opening book curato da un GM umano.
Giocare finali coperti dalle tablebase con qualità di gioco perfetto.
Vincere un match a tempo standard contro il campione del mondo.

Non fece:

Imparare durante il match. Deep Blue 1997 al termine del match è esattamente il sistema che era all’inizio; nessuna parte dei suoi pesi o del suo libro si è aggiornata.
Generalizzare. Deep Blue gioca a scacchi e basta. Non può essere ri-applicato a dama, Go, backgammon, o qualsiasi altro gioco senza ridisegnarne hardware, valutazione, opening book.
“Capire” gli scacchi nel senso umano. Non c’è rappresentazione interna di concetti scacchistici di alto livello (un piano, una strategia, un principio); c’è una somma pesata di feature numeriche.
Sopravvivere come sistema produttivo. IBM ha smantellato Deep Blue poco dopo il match. Un nodo è stato donato allo Smithsonian Institution, un altro al Computer History Museum, il resto disassemblato. Non c’era follow-up commerciale: Deep Blue era marketing, non prodotto.

Esempi

Esempio 1: la cattura critica della partita 6 (Nxe6)

L’apertura Caro-Kann classica si gioca per le prime mosse:

1. e4 c6
2. d4 d5
3. Nc3 dxe4
4. Nxe4 Nd7
5. Ng5 Ngf6
6. Bd3 e6

A questo punto, posizione standard di Caro-Kann moderna. Il cavallo bianco in g5 è poi mosso indietro in f3 (mossa “normale”), oppure si gioca il sacrificio classico 7.N1f3 h6 8.Nxe6 dove il cavallo si “suicida” sulla casa e6 per esporre il re nero. Nella partita 6 Deep Blue gioca proprio questa idea (con sequenza leggermente variata: 7.Nxe6 direttamente, dopo aver indotto Kasparov in una linea sub-ottimale).

Il sacrificio 7.Nxe6 è teorico, noto da decenni. Un GM umano lo conosce come opzione contro la Caro-Kann, e di solito il Nero risponde con una difesa accurata che annulla il sacrificio. Kasparov, tuttavia, gioca 7…Qe7, una mossa imprecisa (la teoria suggerisce 7…Kxe6 o 7…fxe6 con difese specifiche). La precisione di Deep Blue nella parte tattica successiva è schiacciante: ogni mossa successiva di Kasparov è obbligata o quasi, ogni risposta di Deep Blue massimizza la pressione. Alla mossa 19 il bianco ha matto in poche mosse forzate, e Kasparov si arrende.

Cosa fece Deep Blue in questa partita? Eseguì un opening book ben preparato. Joel Benjamin aveva esplicitamente codificato la linea del sacrificio Nxe6 contro la Caro-Kann nel libro, anticipando che Kasparov potesse scegliere proprio quella difesa. Per le prime 7-8 mosse, Deep Blue non sta neppure cercando: sta semplicemente leggendo dal libro le mosse pre-calcolate. Solo dalla mossa 9-10 in poi entra in gioco la search.

Lezione: una parte significativa del vantaggio di Deep Blue in posizioni di apertura non viene dalla sua intelligenza algoritmica, ma dalla preparazione umana codificata nel libro. È un’osservazione che vale anche oggi per i motori scacchistici moderni.

Esempio 2: alpha-beta su un albero giocattolo

Per intuire come alpha-beta tagli sotto-alberi senza esplorarli, consideriamo un mini-albero a profondità 3 con branching factor 2 (8 foglie totali), valori tutti già pre-calcolati. Numeriamo le foglie da sinistra a destra:

                  ROOT (max)
                  /        \
            A (min)        B (min)
            /    \          /    \
        A1 (max) A2 (max) B1 (max) B2 (max)
        /   \    /  \      /  \    /  \
       3    8  5    7    2    9   1    4

Esecuzione alpha-beta con $\alpha = -\infty$ , $\beta = +\infty$ iniziali:

Esplora A → A1 → 3, 8 → A1 = max(3,8) = 8.
A2 → 5, 7 → A2 = 7. A = min(8, 7) = 7. Aggiorna $\alpha = 7$ alla radice (è il valore minimo che ROOT può garantire scegliendo A).
Esplora B → B1 → 2, 9 → B1 = 9. Ora a B (nodo min), il valore corrente è 9. Ma ROOT (max) ha già $\alpha = 7$ , quindi se B può restituire qualcosa $\leq 7$ , ROOT preferirà A. Per ora $\beta_B = 9$ .
Esplora B2 → 1. A questo punto B2 (nodo max) ha visto 1 e potrebbe migliorare con la prossima foglia. Ma B (min) sta cercando un valore basso, e se B2 alza oltre 7, B sceglierà B1=9 comunque. Cutoff condizionale: la struttura alpha-beta dipende dall’ordine di esplorazione. In questo esempio specifico:

Riformulando con cutoff esplicito: dopo aver visto B2 = max(1, …) ≥ 1, il nodo B (min) confronta 1 con B1=9 e prende min, quindi B ≤ 1. Ora ROOT con $\alpha = 7$ e B ≤ 1 sa che B non migliora la sua posizione: non serve esplorare la seconda foglia di B2 perché qualunque valore essa abbia, B2 ≥ 1 (visto già) ma B = min(B1, B2), e B ≤ 1 < 7 = $\alpha$ , quindi ROOT preferirà comunque A. La seconda foglia di B2 (valore 4) viene tagliata.

Su 8 foglie totali, alpha-beta ne ha esplorate 7, risparmiando 1. Su alberi più profondi e larghi, il risparmio è esponenziale: profondità 6 brute equivale a profondità ~12 con alpha-beta, a parità di nodi esplorati.

Il punto importante: l’efficacia di alpha-beta dipende criticamente dall’ordine di esplorazione. Esplorare la mossa migliore per prima massimizza i cutoff. Per questo Deep Blue investe pesantemente in move ordering: se ordini bene, alpha-beta è quasi ottimale; se ordini male, degenera verso il minimax puro.

Esempio 3: valutazione Deep Blue vs valutazione umana — stessa mossa, ragioni diverse

Consideriamo una posizione tipica di mediogioco, diciamo dopo la mossa 25 di una partita Karpov-Kasparov del 1985 (esempio costruito a fini illustrativi). Bianco ha re in g1, donna in d2, torri in e1 e a1, alfieri in b3 e c3, pedoni in a2-b2-d4-e3-f2-g2-h2. Nero ha re in g8, donna in d8, torri in e8 e a8, cavalli in c6 e f6, pedoni in a7-b6-c7-d6-e6-f7-g7-h7. Posizione equilibrata.

Mossa migliore secondo entrambi: Bxf6 gxf6, sacrificio dell’alfiere per rovinare la struttura pedonale del nero attorno al re.

Ragionamento di un GM umano: “Sacrificio Bxf6 gxf6 indebolisce in modo permanente la struttura del re nero. Il pedone in f6 doppiato e isolato sarà cronicamente debole. La diagonale h2-b8 si apre per la mia donna. Anche senza un attacco immediato decisivo, ho creato un vantaggio strutturale a lungo termine che si tradurrà in pressione costante per le prossime 20-30 mosse. Vale la pena dare l’alfiere per questo.” Riconoscimento di pattern strategico, valutazione qualitativa, intuizione esperta.

Ragionamento di Deep Blue (semplificato): dopo Bxf6 gxf6, valuta la posizione risultante con la sua funzione $V(s)$ . Material balance: -3.25 (alfiere perso) + 0 (pedoni invariati in numero) = -3.25. Pawn structure: pedone f6 doppiato (-0.20), pedone f7 isolato dal lato (-0.10), pedoni g7-h7 isolati dalla colonna g (-0.30) → -0.60 totale. King safety: file g aperta verso il re nero (+0.40), pezzi bianchi che possono attaccare la zona del re (+0.30), pedone g7 come scudo perso (+0.25) → +0.95 totale. Mobility: leggermente a favore del bianco (+0.15). Bilancio: -3.25 + 0.60 + 0.95 + 0.15 = -1.55 (in unità pedone, dal punto di vista del bianco).

Adesso Deep Blue cerca alla profondità di 8-10 ply oltre. Troverà che, con gioco accurato, dopo Bxf6 gxf6 il bianco recupera materiale (non per cattura immediata, ma per pressione progressiva sull’avversario indebolito) o crea minacce di attacco al re che obbligano il nero a concedere materiale per difendersi. Il valore della posizione, propagato all’indietro tramite alpha-beta minimax, sale a -0.20 o -0.30 (quasi pareggio in termini materiali, ma con vantaggio dinamico).

Confronto: la mossa Bxf6 alternative non sacrificate hanno valutazione propagata tipicamente +0.10 (pari o leggermente positiva). Bxf6 ha valutazione propagata -0.30. Però, Bxf6 costringe il nero a giocare in posizione di estrema difensiva, e il numero di errori probabili lungo le 30 mosse successive è molto alto. La funzione di valutazione di Deep Blue cattura parte di questo (con feature di king safety e mobility), ma non tutto. Il rischio: se il nero gioca difesa perfetta, Bxf6 è leggermente peggio. Se il nero commette un errore, Bxf6 vince.

Deep Blue al 1997 sceglie spesso la mossa “umana” — il sacrificio per debolezza strutturale persistente — ma per ragioni quantitative diverse: somma pesata di feature, propagata via search, non riconoscimento di pattern strategico. Il risultato è simile, il processo è diverso. Questa convergenza di output a partire da processi diversi è la ragione per cui un GM umano poteva, in molti momenti, non distinguere se la sua controparte fosse una macchina o un altro umano. Era il test di Turing scacchistico, superato implicitamente nel 1997.

Eredità oggi

[DATATO 2026-04] Le sezioni che seguono guardano cosa è rimasto di Deep Blue e cosa no, dal punto di vista del 2026. La storia si aggiorna continuamente; queste righe vanno lette come snapshot, non come versione definitiva.

Stockfish e la tradizione classical chess engine

Il filone diretto di Deep Blue è continuato come classical chess engine open source. Il programma di riferimento contemporaneo è Stockfish (prima release nel novembre 2008, derivato dal precedente Glaurung di Tord Romstad). Stockfish è scritto in C++, multi-piattaforma, sviluppato da una comunità open source guidata storicamente da Romstad, Marco Costalba, Joona Kiiski e oggi da una squadra distribuita di decine di contributori.

Architettonicamente, Stockfish è un discendente diretto di Deep Blue: alpha-beta minimax con estensioni sofisticate (singular extension, late move reduction, futility pruning), valutazione di posizione hand-crafted con centinaia di feature, opening book esterno, endgame tablebases (oggi Syzygy, fino a 7 pezzi). Differenze rispetto a Deep Blue: nessun hardware custom (gira su CPU x86 standard, beneficia di SIMD), valutazione raffinata su decenni di tuning automatico tramite SPSA (Simultaneous Perturbation Stochastic Approximation) e successivamente tramite framework collaborativi come Fishtest, throughput su singolo PC consumer di alcuni milioni di nps (10x meno di Deep Blue del 1997 in termini puri, ma con valutazione molto più accurata e ricerca molto più selettiva).

Al 2017, Stockfish 8 aveva un rating ELO stimato di circa 3400 (rating CCRL su tempo standard), molto al di sopra del Kasparov del 1997 (~2820) e di qualsiasi giocatore umano vivente. La distanza Deep Blue 1997 - Stockfish 2017 in termini di forza di gioco è di circa 600-700 punti ELO, ottenuta in vent’anni di hardware progress (legge di Moore) e di tuning algoritmico continuo. Il miglioramento è stato lineare, prevedibile, conservativo nello stile.

AlphaZero e la chiusura del cerchio

Nel dicembre 2017, DeepMind pubblica AlphaZero, un sistema che batte Stockfish 8 con una serie di partite a tempo standard. AlphaZero è il punto di chiusura concettuale di un cerchio iniziato da TD-Gammon nel 1992: pure self-play + deep neural network + Monte Carlo Tree Search, senza alcuna conoscenza scacchistica codificata oltre alle regole del gioco. AlphaZero impara a giocare a scacchi in 9 ore di training su 5000 TPU di prima generazione, partendo da zero (mosse casuali) e arrivando a battere Stockfish.

Vale la pena marcare con cura le classi di affermazioni sulla relazione AlphaZero - Deep Blue:

Filiazione tecnica diretta: nessuna. AlphaZero non eredita componenti algoritmici, software, o intellettuali da Deep Blue. La sua tradizione è quella di TD-Gammon (Tesauro) e DQN (Mnih), passando per AlphaGo (Silver et al. 2016). Tutto il filone è connessionista-RL, separato dal filone simbolico-search di Deep Blue.
Filiazione del problema: AlphaZero affronta lo stesso problema di Deep Blue (giocare a scacchi al massimo livello) e lo risolve in modo confrontabile o superiore. Conoscere l’esistenza del problema, e la consapevolezza che il problema era stato “vinto” da Deep Blue nel 1997, è una motivazione storica per AlphaZero. In questo senso debole c’è continuità.
Sostituzione paradigmatica: AlphaZero dimostra che, nel 2017 con compute adeguato, il paradigma simbolico non è più necessario neanche nei domini classici dove era considerato dominante. Il paradigma connessionista, vittorioso in vision (AlexNet 2012) e in Go (AlphaGo 2016), conquista anche gli scacchi.

In estrema sintesi: dal lato algoritmico, Deep Blue e AlphaZero sono linee di ricerca diverse, parallele ma non sovrapposte, che convergono sullo stesso problema con metodi opposti. Il “ponte” tra loro è il problema stesso, non la tecnica.

NNUE e l’ibridazione

C’è poi un terzo capitolo di evoluzione, recente. Nel 2018 il programmatore giapponese Yu Nasu pubblica un paper su NNUE (Efficient Updatable Neural Networks), un’idea di valutazione neurale incrementalmente aggiornabile, originariamente sviluppata per il software di shogi YaneuraOu. L’innovazione di NNUE è architetturale: una piccola rete neurale (poche decine di migliaia di pesi) calcolabile efficientemente a ogni nodo della ricerca alpha-beta, con un trick di update incrementale che evita di ricalcolare l’intera rete dopo ogni mossa.

Nel 2020, Stockfish 12 integra NNUE come funzione di valutazione, sostituendo (in parte) la valutazione hand-crafted classica. Il guadagno è di circa 80-100 punti ELO. Nel 2021-2022, Stockfish 14-15 estende l’uso di NNUE rendendolo dominante. Al 2024, la valutazione di Stockfish è essenzialmente neurale (NNUE), pur mantenendo la struttura di ricerca alpha-beta classica.

Questo è un esempio concreto di ibridazione: Stockfish moderno è una sintesi parziale di Deep Blue (search, alpha-beta minimax, ricerca selettiva con estensioni) e di AlphaZero (rete neurale come valutazione). NNUE non è AlphaZero, ma è un’iniezione di tecnica neurale nel framework simbolico-search. Il risultato è un sistema più forte di entrambi i puristi: più forte di un Stockfish pre-NNUE (paradigma simbolico puro), competitivo con AlphaZero su singoli match (paradigma neurale puro), con un costo computazionale per inferenza molto più basso di AlphaZero.

La lezione operativa: i paradigmi puri spesso si dimostrano sub-ottimali rispetto a sintesi pragmatiche. Nel 2026, lo stato dell’arte dei chess engine è ibrido. Il futuro probabilmente lo sarà ancora di più.

Cosa NON è rimasto

Alcuni elementi di Deep Blue sono spariti completamente:

Hardware custom per giochi specifici: morto. Deep Blue era basato su chip VLSI scacchi-specifici, una scelta che richiedeva milioni di dollari di investimento e anni di progettazione. Le GPU general-purpose, dagli anni 2010 in poi, hanno reso obsoleto questo approccio: un singolo GPU consumer da poche centinaia di dollari supera abbondantemente Deep Blue 1997 in throughput grezzo, e chiunque può accedervi. L’idea di chip dedicati a un singolo gioco non è più economicamente sensata.
Knowledge engineering manuale di 8000 feature: ridimensionato. La valutazione hand-crafted di Stockfish pre-NNUE era già più snella di quella di Deep Blue (centinaia di feature, non migliaia). NNUE l’ha quasi azzerata: la rete impara feature implicite dai dati, senza bisogno che un team di programmatori e GM le definiscano a mano. Il knowledge engineering scacchistico classico — l’arte di codificare intuizioni di Grandmaster in formule numeriche — è diventato un’arte per archeologi.
Match singoli ad alto profilo come metrica: ridimensionato. Dopo il 1997, la valutazione della forza di un motore scacchistico si è spostata dalla logica del “match singolo contro un campione” alla logica del rating statistico su migliaia di partite contro altri motori. Il sito CCRL (Computer Chess Rating Lists) e i tornei come TCEC (Top Chess Engine Championship) producono rating con basso errore standard, sostituendo la spettacolarità del singolo evento con il rigore statistico. Nessun motore moderno gioca pubblicamente contro campioni umani — la differenza è troppo grande, sarebbe un evento privo di interesse competitivo.

Tablebases: l’eccezione che sopravvive

Le endgame tablebases, introdotte da Ken Thompson negli anni 70 e usate da Deep Blue, sono rimaste e sono state estese. Al 2018 sono state pubblicate le tablebase a 7 pezzi (Lomonosov), che occupano circa 140 TB di dati pre-calcolati. Sono accessibili online via servizi come Syzygy e Lichess. Coprono tutti i finali di scacchi con al massimo 7 pezzi totali sulla scacchiera (incluso i due re).

Le tablebase sono un caso interessante perché sono conoscenza esatta che nessun algoritmo neurale può migliorare: sono soluzioni del gioco per le sotto-posizioni coperte, calcolate per enumerazione completa retrograda. Stockfish e AlphaZero le usano entrambi quando la posizione vi rientra. Sono un complemento, non un sostituto, della ricerca: nessuno cerca di rimpiazzarle con reti neurali, perché non c’è spazio per migliorare la perfezione.

Le tablebase sono l’unica componente di Deep Blue che è sopravvissuta non come tradizione metodologica ma come artefatto computazionale concreto ancora in uso oggi. Anche i motori più moderni le caricano dalla stessa famiglia di file di Thompson e successori. È un caso di permanenza tecnica raro nella storia dell’AI.

Dove si rompe

I limiti di Deep Blue, e i fraintendimenti tipici che il suo successo ha alimentato, meritano una sezione ampia. Vediamoli.

Deep Blue NON era AI generale. Era un sistema scacchi-specifico, costruito per giocare a scacchi e basta. Non poteva essere ri-applicato a dama, Go, backgammon, o qualsiasi altro problema senza ridisegnare hardware, valutazione, opening book. Non c’era trasferimento. Non c’era apprendimento durante il gioco. Una conseguenza pratica: dopo il match 1997, IBM ha smantellato il sistema e nessun altro lavoro di ricerca AI ne è derivato direttamente. Il valore di Deep Blue era nella dimostrazione pubblica, non in un programma di ricerca riutilizzabile.

Knowledge engineering manuale era costoso e fragile. Costruire 8000 feature pesate a mano richiede anni di lavoro di un team specializzato (programmatori + GM consulenti). Ogni nuova feature è una scelta di design che può essere giusta o sbagliata. Le interazioni tra feature sono difficili da prevedere: aggiungere una feature in un punto può degradare la performance in un altro. Il tuning richiede iterazioni continue di test, regressione, aggiustamento. Per gli scacchi, dove la teoria umana è enorme e ben documentata, l’investimento è recuperabile. Per altri domini, è proibitivo. Questa fragilità è una delle ragioni per cui il paradigma simbolico ha gradualmente perso terreno: scala male nei domini dove la conoscenza esperta è scarsa, ambigua o costosa da estrarre.

L’incident della partita 2 e l’opacità IBM. Il rifiuto di IBM di rilasciare i log dei calcoli durante il match 1997 è un esempio importante di come l’opacità di un sistema AI in vetrina pubblica generi sospetto, anche quando il sistema è probabilmente onesto. Kasparov non aveva torto a chiedere i log: senza, il match restava verificabile solo sulla parola di IBM. La lezione è stata raccolta da DeepMind nel 2016 con AlphaGo (log pubblicati) e dovrebbe essere uno standard per qualsiasi sistema AI competitivo che opera in pubblico. Nel 2026 è una questione ricorrente per modelli LLM in benchmark contestati: chi non rilascia logs e prompt, chiede di essere creduto sulla parola.

Il mito “Deep Blue capisce gli scacchi” è falso. Deep Blue non ha rappresentazione interna di concetti scacchistici di alto livello. Non sa cosa sia un piano, una strategia, un’idea posizionale. Ha una somma pesata di feature numeriche e una procedura di ricerca. Le scelte che fa coincidono spesso con quelle di un GM umano per ragioni numeriche convergenti, ma il processo è incommensurabile. Dire “Deep Blue capisce” è una metafora utile per la divulgazione ma non ha contenuto tecnico verificabile. Lo stesso fraintendimento ricorre oggi con i modelli LLM: dire che “GPT-4 capisce” è altrettanto carico filosoficamente, e lo stesso tipo di obiezione si applica.

Il mito “ha sconfitto Kasparov in modo definitivo” è troppo netto. Il match 1997 era un singolo match di sei partite, vinto 3.5-2.5 — un margine sottile. La partita 2 (vinta da Deep Blue) era tecnicamente patta, come l’analisi successiva ha mostrato; Kasparov si era arreso in posizione tenibile. La partita 6 (decisiva) Kasparov la perse per scelta di apertura imprudente, non per superiorità tecnica generale. Inoltre, non c’è mai stata rivincita formale: Kasparov chiese pubblicamente per anni una rivincita, IBM rifiutò sistematicamente e smantellò il sistema. Senza rivincita, il risultato 1997 resta non confutato ma anche non confermato. La superiorità definitiva delle macchine sugli umani agli scacchi è solo statisticamente confermata sui motori successivi (Stockfish, Komodo, Houdini) che a partire dal 2005-2006 hanno superato chiaramente i top GM umani. Ma quella è un’affermazione su una classe di sistemi, non su Deep Blue specificamente.

Il mito “alpha-beta è eternamente la ricetta giusta”. Per gli scacchi sì, almeno fino all’avvento di AlphaZero che ha mostrato che MCTS + deep network può essere competitivo o superiore. Per altri domini, no. Il Go (con branching factor ~250) ha resistito ad alpha-beta per decenni e ha richiesto MCTS più reti neurali per essere risolto. Per problemi non-game-tree (visione, NLP, controllo robotico), alpha-beta non si applica nemmeno concettualmente. La generalizzazione “ricerca + valutazione = AI” è limitata ai domini con regole esplicite, branching gestibile, esito ben definito — esattamente gli stessi limiti del paradigma simbolico classico.

Il problema dell’horizon effect non è scomparso. Anche con estensioni sofisticate, una ricerca a profondità fissa ha sempre un orizzonte oltre il quale non vede. Tattiche profonde (combinazioni che si svolgono in 15-20 mosse) sono al limite della profondità tipica di Deep Blue (6-8 ply brute, 16-20 ply estese su singole linee). In posizioni dove la decisione corretta richiede di vedere molto più lontano, il motore può sbagliare. Stockfish moderno ha ridotto questo problema con extensioni più aggressive e con NNUE (che cattura pattern strategici a lungo termine in modo implicito), ma non lo ha eliminato. È una fragilità strutturale del paradigma search-based, non risolvibile completamente con compute aggiuntivo.

L’efficienza energetica era pessima. Deep Blue 1997 consumava decine di kilowatt durante una partita: due rack pieni di processori potenti che giravano a pieno carico. Per giocare a scacchi al livello di un singolo umano. Confronto: il cervello umano consuma circa 20 watt e gioca a scacchi (anche se al livello di Kasparov solo per un soggetto su miliardi). Il rapporto efficienza è di tre-quattro ordini di grandezza a favore del cervello umano, almeno per questa specifica task. Il paradigma simbolico-search è computazionalmente costoso in modi che non si riconciliano facilmente con la natura biologica dell’intelligenza. Questa è un’osservazione retrospettiva, non un’obiezione che si poneva al 1997, ma è rilevante per inquadrare correttamente la portata del risultato.

Il successo non si tradusse in revival del paradigma simbolico. Una conseguenza inattesa, retrospettivamente curiosa. Il 1997 sembrava il trionfo della scuola simbolica: hardware specializzato + knowledge engineering + ricerca strutturata avevano battuto il paradigma “soft” delle reti neurali su un dominio classico. Eppure, nei dieci anni successivi, il paradigma simbolico continuò a perdere terreno mentre il paradigma neurale (silenziosamente, fino a 2012) si rafforzava. Deep Blue non causò un revival simbolico nell’AI mainstream. Era una vittoria di nicchia — gli scacchi erano un dominio molto specifico, le tecniche non si trasferivano. La narrazione pubblica di “il computer ha battuto l’uomo” non si traduceva in agenda di ricerca riproducibile.

Confondere Deep Blue con AlphaGo. Errore comune nelle ricostruzioni divulgative. Le due famiglie sono tecnicamente disgiunte. Deep Blue è alpha-beta minimax + valutazione hand-crafted + chip VLSI custom. AlphaGo è MCTS + deep CNN + reinforcement learning + TPU general-purpose. Condividono solo il problema (battere campioni umani in un gioco classico). Trattarli come “stessa famiglia di tecniche con dominio diverso” è un’incomprensione storiografica.

“Deep Blue era AI”. Affermazione filosoficamente carica e contestata. John McCarthy (uno dei padri fondatori dell’AI, vedi dartmouth-1956) commentò nel 1997 a IJCAI: “chess has been the Drosophila of AI” — utile per il progresso del campo, ma non rappresentativa di intelligenza nel senso forte. L’opinione di McCarthy era che Deep Blue fosse un dimostratore tecnico impressionante ma non un sistema AI nel senso pieno: mancava di apprendimento, di trasferimento, di flessibilità, di comprensione. Questa critica anticipa, in molti modi, le obiezioni che si pongono oggi ai sistemi AI moderni: capacità impressionanti su compiti specifici, dubbi sulla “vera” intelligenza generale.

“Chess è risolto”. Falso. Risolvere un gioco significa calcolare la strategia ottimale per ogni posizione raggiungibile. Il backgammon non è risolto (vedi td-gammon-1992), il Go non è risolto, e nemmeno gli scacchi lo sono. Stockfish + tablebase a 7 pezzi sono una soluzione pratica: vincono o pareggiano contro qualsiasi giocatore umano e contro la maggior parte degli altri motori. Ma in molte posizioni la valutazione resta approssimata, non esatta. La soluzione formale degli scacchi, se mai sarà raggiunta, richiederà ordini di grandezza più compute di quanto disponibile oggi.

Collegamenti

td-gammon-1992 — il paradigma opposto, vincente nello stesso quinquennio. TD-Gammon (1992-1995, Tesauro a IBM Watson) usa pure self-play con rete neurale e batte i campioni di backgammon. Stesso laboratorio di Deep Blue, due paradigmi diametralmente opposti, due vittorie reali. Confronto centrale di questo capitolo.
sistemi-esperti — il paradigma di knowledge engineering che culmina anche in Deep Blue. MYCIN, XCON, e gli altri expert system degli anni 70-80 codificavano regole esperte in formato esplicito; Deep Blue codifica conoscenza scacchistica esperta in 8000 feature pesate. Stessa logica metodologica, dominio diverso.
secondo-inverno-ai — il contesto in cui Deep Blue arriva. Mentre il termine “AI” era da evitare nei finanziamenti, IBM costruiva l’icona AI più visibile del decennio. Il paradosso si scioglie ricordando che Deep Blue era marketing corporate, non programma di ricerca AI mainstream.
reti-neurali-80-90 — il filone alternativo, in traversata silenziosa proprio negli anni di Deep Blue. La narrazione “il simbolico ha vinto” del 1997 era prematura: il filone neurale stava maturando sotto la superficie e sarebbe esploso quindici anni dopo.
ai-simbolica-anni-60 — la radice storica del paradigma a cui Deep Blue appartiene. Da Logic Theorist e GPS a Deep Blue, c’è una linea metodologica continua di ricerca strutturata + rappresentazione esplicita.
imagenet-alexnet-2012 — il rilancio del paradigma neurale che porterà in pochi anni alla sostituzione del paradigma simbolico anche nei suoi domini storici. Deep Blue è l’apice del paradigma simbolico in vetrina; AlexNet è l’inizio della sostituzione.
alphago-2016 (in preparazione) — la chiusura del cerchio. Pure self-play + deep CNN + MCTS sul Go. Eredita da TD-Gammon e DQN, non da Deep Blue. Mostra che il paradigma neurale-RL può conquistare anche i domini classici dove il simbolico era considerato dominante.
dqn-atari-2013 (in preparazione) — il ponte tra TD-Gammon e AlphaGo. DQN combina deep CNN, Q-learning, experience replay per giocare a videogame Atari. Riapre la stagione del deep RL dopo il lungo silenzio post-TD-Gammon.
search-bfs-dfs (Parte VI, in preparazione) — i fondamenti algoritmici di ricerca su grafi. Il minimax di Deep Blue è una variante specializzata di DFS con backup di valori. Capire BFS/DFS è prerequisito per capire alpha-beta.
monte-carlo-tree-search (Parte VI, in preparazione) — l’alternativa moderna a alpha-beta, dominante nei sistemi neurali post-AlphaGo. MCTS bilancia esplorazione e sfruttamento via UCT, complementa la valutazione neurale anziché ricorrere a search esaustiva.
search-problems-formal (Parte VII, in preparazione) — la formalizzazione del problema di ricerca come (stato, azioni, transizioni, goal). Inquadramento generale di cui scacchi e alpha-beta sono un caso particolare.
planning-strips (Parte VII, in preparazione) — il filone planning dell’AI classica. Diverso dal game-playing di Deep Blue ma sotto-paradigma simbolico-search. STRIPS, PDDL, HTN sono cugini metodologici.
bayesian-networks (Parte VII, in preparazione) — il paradigma probabilistico-statistico che emerge negli stessi anni di Deep Blue. Bayesian networks di Pearl 1988 e Deep Blue 1997 sono entrambi esempi di sistemi che ragionano in modi formalmente specificati, ma con framework diversi.

Per andare oltre

Hsu, F.-h. (2002). Behind Deep Blue: Building the Computer that Defeated the World Chess Champion. Princeton University Press. Memoir tecnico-personale di Hsu, l’architetto hardware di Deep Blue. Da leggere per capire le scelte di design dei chip VLSI e la dinamica interna del team IBM. Riferimento primario imprescindibile.
Campbell, M., Hoane, A.J., Hsu, F.-h. (2002). “Deep Blue”. Artificial Intelligence Journal, 134, pp. 57-83. Il paper accademico ufficiale del team Deep Blue, pubblicato cinque anni dopo il match. Documenta architettura, algoritmi, valutazione, opening book. Riferimento primario per i dettagli tecnici.
Hsu, F.-h., Anantharaman, T., Campbell, M., Nowatzyk, A. (1990). “A Grandmaster Chess Machine”. Scientific American, 263(4), pp. 44-50. Articolo divulgativo su Deep Thought, il predecessore di Deep Blue. Da leggere per il contesto pre-IBM e per capire la fase CMU del progetto.
Kasparov, G. (2017). Deep Thinking: Where Machine Intelligence Ends and Human Creativity Begins. PublicAffairs. Riflessione di Kasparov a vent’anni dal match, sull’evento e sull’AI in generale. Perspettiva del giocatore, importante per capire la ricezione umana dell’evento e la sua evoluzione nel tempo. Include retrazione parziale dell’accusa di cheating.
Newborn, M. (1997). Kasparov versus Deep Blue: Computer Chess Comes of Age. Springer. Cronaca tecnica del match 1997 da parte di un esperto di computer chess (Newborn era presidente dell’ICCA per anni). Include analisi delle partite e contesto storico del computer chess.
Jayanti, V. (regia) (2003). Game Over: Kasparov and the Machine. Documentario. Disponibile su piattaforme streaming e DVD. Ricostruzione narrativa del match con interviste a Kasparov, Hsu, Campbell, Benjamin. Buon punto di ingresso non-tecnico, anche se con un’inclinazione narrativa che enfatizza il sospetto di Kasparov.
Knuth, D.E., Moore, R.W. (1975). “An Analysis of Alpha-Beta Pruning”. Artificial Intelligence Journal, 6(4), pp. 293-326. Il paper classico che formalizza l’analisi di alpha-beta. Tecnico ma essenziale per capire perché alpha-beta scala come $b^{d/2}$ e non $b^d$ .
Shannon, C.E. (1950). “Programming a Computer for Playing Chess”. Philosophical Magazine, 41(314), pp. 256-275. Il paper foundational che introduce le strategie type A e type B. Cinquant’anni prima di Deep Blue, il programma concettuale era già delineato.

[DATATO 2026-04] Una nota sul rapporto tra Deep Blue e i sistemi AI contemporanei. Nel 2026, l’eredita più visibile del paradigma simbolico-search di Deep Blue non sta negli LLM (che sono pieno paradigma neurale) ma nei sistemi di reasoning con search esplicita che stanno emergendo: reasoning models (o1, o3, DeepSeek-R1) che combinano LLM con search esplicita su tracce di ragionamento, MCTS su token sequences, sistemi di tool use con planning espliciti. La logica “esplora, valuta, propaga, decidi” è ricomparsa, con la differenza che la valutazione è oggi neurale anziché hand-crafted. È una sintesi più sottile della contrapposizione semplice “simbolico vs neurale” che il 1997 sembrava sancire.

Una nota sul lettore. Questo capitolo è denso di nomi, date, dettagli tecnici. Non è necessario memorizzare ogni dettaglio per usare la wiki: i collegamenti incrociati con i capitoli su td-gammon-1992, alphago-2016, monte-carlo-tree-search, search-bfs-dfs permettono di ricostruire la mappa concettuale più volte da angolazioni diverse. La cosa importante è il principio: nel 1997, all’Equitable Center di New York, è stato dimostrato per la prima volta che hardware specializzato + knowledge engineering pesante + ricerca alpha-beta massiva sono sufficienti per battere il campione del mondo a scacchi. Era una vittoria reale, in un dominio specifico, con metodi che non si trasferivano. Cinque anni prima, in un altro angolo dello stesso laboratorio, era stata dimostrata l’altra strada (TD-Gammon). La storia che si è raccontata dopo, fino ad AlphaZero e oltre, è la lenta riconciliazione di queste due strade.