Algoritmo: logica, struttura, apprendimento
Origini e significato di algoritmo
Un algoritmo è una sequenza finita, ordinata e non ambigua di istruzioni che descrive come trasformare un insieme di dati in ingresso in un risultato definito. Non è un concetto esclusivo dell’informatica: ogni procedura riproducibile che porta a un risultato verificabile, dalla somma aritmetica alla diagnosi medica differenziale, è formalizzabile come processo algoritmico. La caratteristica essenziale che distingue questa struttura logica da qualsiasi altra forma di ragionamento è la sua eseguibilità meccanica: un esecutore privo di comprensione semantica può seguire i passi e ottenere comunque il risultato corretto.
Il termine deriva dal nome del matematico e astronomo persiano Al-Khwarizmi, vissuto nel a Baghdad. La sua opera Kitāb al-mukhtaṣar fī ḥisāb al-jabr wa-l-muqābala introdusse in Europa i metodi di calcolo posizionale che oggi costituiscono la base dell’aritmetica elementare. La latinizzazione del suo nome, Algoritmi, divenne il termine tecnico per indicare le regole di calcolo. Questa radice storica chiarisce perché il concetto sottenda non solo la programmazione contemporanea, ma l’intero edificio della matematica applicata: ogni dimostrazione costruttiva, ogni procedura di ottimizzazione numerica e ogni protocollo crittografico è, nella sua essenza, una sequenza di istruzioni a esecuzione garantita.
Dal punto di vista formale, una procedura si qualifica come algoritmicamente corretta solo se soddisfa quattro proprietà simultanee: finitezza, ovvero la certezza che l’esecuzione termini in un numero limitato di passi; definitezza, ovvero la non ambiguità di ogni singola istruzione; ingresso e uscita definiti, ovvero la presenza di dati iniziali ben specificati e di almeno un risultato producibile; ed efficacia, ovvero la possibilità concreta di eseguire ogni operazione con le risorse disponibili. La mancanza di anche una sola di queste proprietà non produce un algoritmo ma un’euristica, una procedura approssimata o un processo non terminante.
Comprendere questa distinzione è rilevante in tutti i contesti in cui la correttezza del risultato non è negoziabile: nei sistemi di controllo industriale, nei protocolli di sicurezza informatica, nei motori di calcolo finanziario. In questi ambiti, la differenza tra una sequenza di istruzioni formalmente corretta e una procedura approssimata determina la differenza tra un sistema affidabile e uno che produce errori sistematici.
Struttura interna e componenti logici
Qualunque procedura computazionale, indipendentemente dalla sua complessità, è costruita combinando tre sole strutture di controllo fondamentali: la sequenza, la selezione e l’iterazione. La sequenza è la forma più semplice: le istruzioni vengono eseguite nell’ordine in cui compaiono, una dopo l’altra, senza deviazioni. La selezione introduce un punto di biforcazione condizionale: in base al valore di una variabile o al risultato di un test logico, il flusso di esecuzione percorre uno tra due o più percorsi alternativi. L’iterazione consente la ripetizione di un blocco di istruzioni fino al verificarsi di una condizione di uscita.
Questo schema minimale, formalizzato nel da Böhm e Jacopini con il teorema sulla struttura dei programmi, dimostra che qualsiasi funzione computabile può essere espressa utilizzando solo queste tre costruzioni. La conseguenza pratica è che ogni sistema di elaborazione automatica, dalla calcolatrice tascabile a un modello di linguaggio di grandi dimensioni, è descrivibile come composizione di sequenze, condizioni e cicli.
Accanto alle strutture di controllo, la progettazione di procedure efficienti richiede la scelta delle strutture dati appropriate. Un array ordinato consente una ricerca binaria in tempo logaritmico; la stessa ricerca su una lista non ordinata richiede tempo lineare. Un grafo orientato rappresenta relazioni direzionali tra entità; un albero binario di ricerca garantisce inserimento, cancellazione e ricerca in tempo proporzionale al logaritmo del numero di elementi. La correttezza logica di una procedura è necessaria ma non sufficiente: la scelta errata della struttura dati può rendere un processo corretto ma inutilizzabile per la quantità di risorse che consuma.
Un ulteriore elemento strutturale è la ricorsione, ossia la capacità di una procedura di richiamare se stessa con un sottoproblema di dimensioni ridotte. La fattorizzazione di un numero, il calcolo di permutazioni, la navigazione di strutture ad albero e molti algoritmi di ordinamento si esprimono naturalmente in forma ricorsiva. La ricorsione e l’iterazione sono formalmente equivalenti, ma la leggibilità e la semplicità del codice ricorsivo ne giustificano l’uso in numerosi contesti applicativi.
Tipologie e criteri di classificazione
Le procedure di calcolo si classificano secondo criteri indipendenti che si sovrappongono e si combinano. La prima distinzione fondamentale riguarda il determinismo: una procedura deterministica produce sempre lo stesso output a parità di input, indipendentemente dall’ambiente di esecuzione o dal momento in cui viene avviata. Una procedura non deterministica, o probabilistica, può produrre output diversi anche con lo stesso input, perché incorpora scelte casuali o dipende da fattori stocastici. Gli algoritmi probabilistici sono ampiamente utilizzati nella crittografia, nella simulazione Monte Carlo e nei metodi di campionamento statistico come MCMC.
Una seconda classificazione riguarda la strategia di soluzione adottata. Gli approcci divide et impera suddividono il problema in sottoproblemi indipendenti, risolvono ciascuno separatamente e combinano le soluzioni. Merge sort e quicksort seguono questo schema. La programmazione dinamica, invece, riconosce che i sottoproblemi non sono indipendenti ma si sovrappongono, e memorizza i risultati parziali per evitarne il ricalcolo: è il principio alla base degli algoritmi per il calcolo delle distanze minime su grafi, come quello di Bellman-Ford, e per il calcolo della distanza di editing tra sequenze.
Gli approcci greedy costruiscono la soluzione passo dopo passo, scegliendo a ogni passo l’opzione localmente ottimale senza riesaminare le scelte precedenti. L’algoritmo di Dijkstra per i percorsi minimi e l’algoritmo di Kruskal per gli alberi di copertura minima sono esempi classici. Questi metodi non garantiscono sempre l’ottimo globale, ma in molti contesti producono soluzioni esatte o approssimazioni di qualità controllata con un costo computazionale significativamente inferiore rispetto all’enumerazione completa.
Una terza dimensione classificatoria è quella della complessità computazionale, che misura come crescono le risorse necessarie, tempo e memoria, al crescere della dimensione dell’input. La notazione O grande (Big-O) fornisce un linguaggio standard per confrontare l’efficienza di procedure diverse. Un processo con complessità O(log n) scala in modo eccellente su volumi di dati arbitrariamente grandi; uno con complessità O(n²) diventa rapidamente impraticabile. La distinzione tra problemi risolvibili in tempo polinomiale, classe P, e problemi per cui non è noto alcun algoritmo polinomiale, classe NP, è una delle questioni aperte più importanti della matematica e dell’informatica teorica.
Come i motori di ricerca usano procedure algoritmiche
I motori di ricerca su scala globale sono tra i sistemi più complessi che l’ingegneria del software abbia mai prodotto, e la loro funzione centrale, ordinare miliardi di documenti per rilevanza rispetto a una query, è interamente affidata a insiemi di regole computazionali che si aggiornano centinaia di volte ogni anno. Il modello concettuale alla base di questo processo è rimasto sostanzialmente invariato dal lavoro originale di Larry Page e Sergey Brin: si assegna a ogni pagina un punteggio che combina la rilevanza del contenuto rispetto alla query con l’autorevolezza inferita dalla struttura dei collegamenti ipertestuali.
PageRank, il meccanismo originale di ordinamento, modella il web come un grafo orientato e calcola per ogni nodo la probabilità stazionaria di un percorso casuale che segue i link. Un documento che riceve molti collegamenti da pagine già autorevoli acquisisce un punteggio elevato, indipendentemente dal suo contenuto. Questo approccio era rivoluzionario perché trasformava un segnale relazionale, la struttura dei link, in una misura quantitativa di autorevolezza. Nei sistemi attuali, il punteggio di posizionamento integra centinaia di fattori aggiuntivi: la velocità di caricamento della pagina, la struttura semantica del contenuto, il comportamento degli utenti successivo al clic, la coerenza tra query e testo visibile.
La componente di comprensione del linguaggio naturale si basa su architetture neurali addestrate su grandi corpora di testo. BERT (Bidirectional Encoder Representations from Transformers), integrato nella ricerca di Google a partire dal , consente di interpretare il contesto bidirezionale di ogni parola in una query: la parola “banca” in “riva di una banca” e in “sportello di una banca” attiva rappresentazioni vettoriali diverse, permettendo un abbinamento più preciso tra intenzione di ricerca e documento pertinente.
Per i professionisti del posizionamento organico, questa architettura ha conseguenze operative dirette: l’ottimizzazione non riguarda più la densità di una singola parola chiave ma la copertura semantica dell’intero campo concettuale associato a un argomento. Un documento che tratta in modo esaustivo le entità correlate, i concetti adiacenti e le domande implicite associate a un topic riceve segnali di qualità più forti rispetto a un testo che ottimizza meccanicamente la frequenza di un termine isolato.
Procedure di apprendimento automatico e intelligenza artificiale
La distinzione tra un programma tradizionale e un sistema di apprendimento automatico risiede nel modo in cui il comportamento viene specificato. In un programma convenzionale, le regole sono scritte esplicitamente dal programmatore: se la variabile X supera la soglia Y, esegui l’azione Z. In un sistema di apprendimento, invece, le regole vengono indotte dai dati: il sistema osserva migliaia o milioni di esempi etichettati e aggiusta automaticamente i propri parametri interni per minimizzare l’errore sugli esempi noti, acquisendo così la capacità di generalizzare su casi mai visti prima.
Le reti neurali artificiali sono la famiglia di modelli che ha dominato il campo nell’ultimo decennio. Composte da strati di unità computazionali interconnesse, apprendono rappresentazioni gerarchiche dei dati: i primi strati rilevano caratteristiche elementari come bordi in un’immagine o pattern fonetici in un segnale audio, mentre i livelli più profondi combinano queste caratteristiche in concetti di livello sempre più astratto. L’addestramento avviene tramite l’algoritmo di retropropagazione dell’errore (backpropagation), che calcola il gradiente della funzione di perdita rispetto a ogni parametro e aggiorna i pesi nella direzione che riduce l’errore.
I modelli transformer, introdotti nel da Google Brain con il lavoro Attention Is All You Need, hanno sostituito le architetture ricorrenti in quasi tutti i compiti di elaborazione del linguaggio naturale. Il meccanismo di attenzione consente a ogni elemento di una sequenza di pesare dinamicamente la propria relazione con tutti gli altri elementi, catturando dipendenze a lungo raggio senza le limitazioni dei modelli sequenziali. I grandi modelli linguistici (LLM) attuali, con parametri nell’ordine dei miliardi, sono versioni scalate di questa architettura addestrate su interi corpus testuali del web.
La differenza tra questi sistemi e un semplice programma basato su regole non è solo quantitativa ma qualitativa: un modello addestrato su dati sufficienti sviluppa rappresentazioni interne che catturano strutture statistiche del linguaggio non esplicitamente codificate da alcun programmatore. Questa capacità emergente è ciò che consente ai sistemi moderni di tradurre, riassumere, rispondere a domande e generare testo con una coerenza che fino a pochi anni fa era considerata irraggiungibile.
Differenza tra procedura astratta e programma eseguibile
La confusione tra il concetto di procedura computazionale e quello di programma informatico è comune anche tra i professionisti del settore, ma la distinzione è rilevante sia concettualmente sia praticamente. Una sequenza logica di istruzioni è un’entità astratta: descrive un processo in modo indipendente da qualsiasi linguaggio, piattaforma o architettura hardware. Può essere espressa in pseudocodice, in un diagramma di flusso, in prosa tecnica o in notazione matematica. Un programma, invece, è la traduzione concreta di quella logica in un linguaggio di programmazione specifico, con tutte le implicazioni che questo comporta.
Quando una procedura viene implementata in un programma, entrano in gioco vincoli che non esistono al livello astratto: la gestione della memoria disponibile, la rappresentazione finita dei numeri in virgola mobile che introduce errori di arrotondamento, la latenza di accesso al disco o alla rete, le limitazioni del sistema operativo. Due implementazioni della stessa procedura logica in linguaggi diversi, o anche sullo stesso linguaggio con librerie diverse, possono avere prestazioni radicalmente differenti su dati reali.
Questa distinzione ha implicazioni dirette per la verifica della correttezza. Una procedura astratta può essere dimostrata formalmente corretta attraverso tecniche di verifica matematica: si dimostrano l’invariante di ciclo, la terminazione garantita e la correttezza del risultato. Un programma concreto può contenere bug introdotti nella fase di implementazione che non esistono nella procedura originale: accessi a memoria fuori dai limiti, condizioni di gara in ambienti concorrenti, overflow aritmetici su input di dimensioni eccessive. La separazione concettuale tra i due livelli consente di affrontare la correttezza in modo modulare: si verifica prima la logica, poi l’implementazione.
Nel contesto dell’ingegneria del software moderna, questa distinzione è anche alla base delle pratiche di refactoring: migliorare la struttura del codice senza alterare il comportamento osservabile è possibile solo se si ha una rappresentazione chiara della logica sottostante, separata dai dettagli implementativi. I test automatici, che verificano il comportamento del programma su un insieme di casi noti, svolgono la funzione di ancorare l’implementazione alla specifica astratta durante le operazioni di modifica.
Efficienza e complessità computazionale
La correttezza è la condizione necessaria per qualificare una procedura come algoritmica, ma non è sufficiente per valutarne l’utilità pratica. Un processo che produce il risultato corretto dopo un milione di anni di calcolo o richiedendo più memoria di quella fisica disponibile su qualsiasi sistema è, di fatto, inutilizzabile. La teoria della complessità computazionale fornisce gli strumenti formali per misurare e confrontare l’efficienza di procedure diverse in modo indipendente dall’hardware su cui vengono eseguite.
La misura standard è la crescita asintotica delle risorse, tempo e memoria, al crescere della dimensione dell’input. La notazione Big-O descrive il comportamento nel caso peggiore: un processo con complessità O(n log n), come merge sort, richiede risorse proporzionali a n log n anche nel caso sfavorevole. Confrontando O(n log n) con O(n²) di insertion sort su un milione di elementi, la differenza è tra circa 20 milioni di operazioni e un trilione: la scelta della procedura giusta può rendere praticabile un processo altrimenti impossibile.
| Notazione | Nome | Esempio | n = 1.000.000 |
|---|---|---|---|
| O(1) | Costante | Accesso a array per indice | 1 operazione |
| O(log n) | Logaritmica | Ricerca binaria | ~20 operazioni |
| O(n) | Lineare | Scansione sequenziale | 1.000.000 operazioni |
| O(n log n) | Linearitmica | Merge sort | ~20.000.000 operazioni |
| O(n²) | Quadratica | Insertion sort | 10¹² operazioni |
La tabella mostra come la scelta della classe di complessità determini la praticabilità di un processo su input di grandi dimensioni.
La complessità spaziale, spesso trascurata rispetto a quella temporale, misura la memoria richiesta. Alcuni processi computazionali scambiano tempo con spazio: la programmazione dinamica memorizza risultati intermedi per evitare ricalcoli, consumando più memoria ma riducendo drasticamente il tempo. In ambienti con risorse di memoria limitate, come i sistemi embedded o i dispositivi mobili, questa scelta può essere vincolante. L’analisi congiunta di complessità temporale e spaziale è necessaria per selezionare la procedura più adatta a un contesto specifico.
Progettazione e verifica di procedure computazionali
La progettazione di una sequenza logica corretta ed efficiente non è un’attività intuitiva: richiede una metodologia strutturata che parte dalla specificazione formale del problema e procede attraverso fasi distinte di analisi, costruzione e verifica. La specifica formale definisce con precisione l’insieme degli input ammissibili, le proprietà che l’output deve soddisfare e i vincoli di risorse entro cui il processo deve operare. Senza una specifica rigorosa, la verifica della correttezza è impossibile: non si può dimostrare che un processo fa la cosa giusta se la cosa giusta non è definita in modo non ambiguo.
Una tecnica consolidata per la verifica della correttezza dei cicli è l’invariante di ciclo: una proprietà logica che è vera prima dell’inizio del ciclo, rimane vera dopo ogni iterazione e, quando il ciclo termina, garantisce la correttezza del risultato. Dimostrare formalmente un invariante richiede di identificare la proprietà rilevante, verificarne la validità iniziale, dimostrarne la conservazione a ogni passo e dedurre da essa la correttezza dell’output finale. Questo approccio, radicato nella logica di Floyd-Hoare, è alla base dei sistemi di verifica formale usati in settori critici come l’avionica e il controllo di reattori nucleari.
I test empirici, complementari alla verifica formale, selezionano un insieme rappresentativo di casi di input e verificano che l’output prodotto corrisponda a quello atteso. I casi limite, come input vuoto, input di dimensione unitaria, input con valori estremi o input già ordinati, sono i più rivelatori: la maggior parte dei bug si manifesta ai confini del dominio di input, non nel caso medio. Le tecniche di fuzzing, che generano input casuali o semiautomatici alla ricerca di comportamenti anomali, completano la copertura dei test manuali in scenari di sicurezza informatica.
La complessità della progettazione cresce in modo non lineare con le dimensioni del problema. Per problemi di grandi dimensioni, la decomposizione gerarchica in sottoproblemi indipendenti è l’unico approccio praticabile. Le librerie di strutture dati e gli algoritmi standard, come quelli inclusi nella STL del C++ o nel modulo collections di Python, codificano decenni di ricerca e ottimizzazione: riutilizzarli è quasi sempre preferibile rispetto a reimplementare da zero componenti già verificati.
Impatto delle procedure computazionali in settori non informatici
L’applicazione delle sequenze logiche strutturate si estende ben oltre i confini dell’informatica e della matematica, permeando settori che trattano dati complessi, decisioni ripetibili e processi ottimizzabili. In medicina, i sistemi di supporto alla decisione clinica utilizzano procedure di classificazione addestrate su dati epidemiologici per suggerire diagnosi differenziali, stratificare il rischio di complicanze e personalizzare i protocolli terapeutici. Il riconoscimento di pattern radiologici in immagini di risonanza magnetica o tomografia computerizzata tramite reti neurali convoluzionali ha raggiunto in alcuni domini una precisione paragonabile a quella di specialisti esperti.
In finanza, i sistemi di trading algoritmico eseguono ordini in frazioni di millisecondo basandosi su segnali di mercato elaborati in tempo reale. I modelli di valutazione del rischio di credito, costruiti su dati storici di insolvenza, permettono alle istituzioni finanziarie di prendere decisioni di prestito in modo sistematico e scalabile. La gestione di portafogli quantitativi si affida a procedure di ottimizzazione, come la massimizzazione del rapporto di Sharpe sotto vincoli di rischio, che sarebbero computazionalmente irrealizzabili senza le strutture algoritmiche appropriate.
Nella logistica e nella gestione delle catene di approvvigionamento, i problemi di ottimizzazione dei percorsi, come il TSP e le sue varianti con finestre temporali, sono affrontati con euristiche e metaeuristiche, come gli algoritmi genetici e la ricerca tabu, che producono soluzioni di qualità accettabile in tempi computazionalmente praticabili anche per istanze di grandi dimensioni. I risparmi operativi ottenuti attraverso l’ottimizzazione algoritmca dei percorsi di consegna si misurano, su scala globale, in miliardi di chilometri percorsi in meno ogni anno.
In biologia computazionale, l’allineamento di sequenze genomiche, la previsione della struttura tridimensionale delle proteine e l’analisi filogenetica sono interamente dipendenti da procedure computazionali specializzate. Il programma AlphaFold, sviluppato da DeepMind, ha risolto il problema del ripiegamento proteico con una precisione senza precedenti, aprendo prospettive radicalmente nuove per la scoperta di farmaci. Questo esempio illustra come l’avanzamento delle procedure di apprendimento automatico non sia confinato al dominio digitale ma produca impatti misurabili sulla ricerca scientifica e sulla salute umana.
Trasparenza e responsabilità nei sistemi decisionali automatizzati
Man mano che le procedure computazionali automatizzano decisioni che hanno conseguenze rilevanti sulla vita delle persone, come l’approvazione di un prestito, la selezione di un curriculum, la determinazione di una pena detentiva o l’assegnazione di un posto in una lista di attesa medica, emergono questioni di trasparenza, equità e responsabilità che vanno oltre il dominio tecnico. Il regolamento europeo sulla protezione dei dati, il GDPR, sancisce il diritto dell’interessato a non essere sottoposto a decisioni basate esclusivamente su trattamenti automatizzati che producano effetti giuridici o analoghi sulla sua persona, e impone l’obbligo di fornire spiegazioni comprensibili sulle logiche sottostanti.
Il problema dell’interpretabilità è particolarmente acuto per i modelli di apprendimento profondo, la cui struttura interna è distribuita su milioni di parametri in modo non direttamente leggibile da un analista umano. Il campo dell’XAI si occupa di sviluppare tecniche che producano spiegazioni locali o globali del comportamento di questi modelli: SHAP (SHapley Additive exPlanations) e LIME (Local Interpretable Model-agnostic Explanations) sono tra gli strumenti più diffusi per attribuire a ogni variabile di input il contributo che ha avuto nella determinazione di un output specifico.
Il bias algoritmico è un rischio concreto quando i dati di addestramento riflettono disuguaglianze storiche o strutturali. Un sistema addestrato su dati storici di selezione del personale che riflettono decenni di discriminazione di genere o etnica tenderà a replicare quelle discriminazioni nelle sue previsioni, a meno che non vengano adottate tecniche specifiche di debiasing. Il Regolamento europeo sull’intelligenza artificiale, approvato nel , classifica i sistemi di intelligenza artificiale per livello di rischio e impone requisiti di conformità progressivamente più stringenti, inclusi audit indipendenti e documentazione tecnica obbligatoria per i sistemi ad alto rischio.
La governance dei sistemi decisionali automatizzati richiede pertanto competenze che integrano il dominio tecnico con quello giuridico, etico e organizzativo. La sola correttezza matematica di una procedura non garantisce la sua legittimità in un contesto regolamentato: è necessaria anche la documentazione del processo di addestramento, la valutazione dell’impatto sui diritti fondamentali e la definizione di meccanismi di supervisione umana per i casi in cui il sistema produce output inattesi o contestati.
