🤖 AI

Automated Proof Generation for Rust Code via Self-Evolution

Il paper introduce SAFE, un framework che supera la carenza di dati di verifica formale per il codice Rust attraverso un ciclo di auto-evoluzione che combina sintesi dati e fine-tuning, permettendo ai modelli open-source di generare e correggere automaticamente prove formali con una precisione del 52,52%, nettamente superiore a quella di GPT-4o.

Autori originali: Tianyu Chen, Shuai Lu, Shan Lu, Yeyun Gong, Chenyuan Yang, Xuheng Li, Md Rakib Hossain Misu, Hao Yu, Nan Duan, Peng Cheng, Fan Yang, Shuvendu K Lahiri, Tao Xie, Lidong Zhou

Pubblicato 2026-02-17

📖 4 min di lettura☕ Lettura da pausa caffè

CC BY 4.0

Autori originali: Tianyu Chen, Shuai Lu, Shan Lu, Yeyun Gong, Chenyuan Yang, Xuheng Li, Md Rakib Hossain Misu, Hao Yu, Nan Duan, Peng Cheng, Fan Yang, Shuvendu K Lahiri, Tao Xie, Lidong Zhou

Articolo originale sotto licenza CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Questa è una spiegazione generata dall'IA dell'articolo qui sotto. Non è stata scritta né approvata dagli autori. Per precisione tecnica, consulta l'articolo originale. Leggi il disclaimer completo

🛠️ Il Problema: Costruire una casa senza le istruzioni

Immagina di voler costruire una casa (il codice software) e vuoi essere assolutamente sicuro che non crollerà mai, nemmeno durante un terremoto. Per farlo, non basta guardare la casa: devi avere un manuale di istruzioni matematico (la prova formale) che dimostri, con certezza assoluta, che ogni muro è solido.

Il problema è che scrivere questi manuali è difficilissimo. Richiede esperti che parlano una lingua molto complessa (come il Rust con il suo strumento di verifica Verus). È come se dovessimo scrivere un'enciclopedia di matematica per ogni singola casa che costruiamo.

Il risultato? Ci sono milioni di case (codice), ma pochissimi manuali (prove). Senza manuali, non possiamo insegnare ai robot (le Intelligenze Artificiali) a scrivere le prove da soli.

🚀 La Soluzione: SAFE (Il Robot che Impara da Solo)

Gli autori hanno creato SAFE (Self-evolving Automated prooF gEneration). È un sistema che insegna a un'IA a scrivere questi manuali matematici senza bisogno di un umano che glieli scriva.

Ecco come funziona, usando un'analogia culinaria:

1. Il Cuoco e il Ricettario (Generazione del Codice)

Immagina di avere un cuoco (l'IA) che sa cucinare piatti semplici, ma non conosce le ricette "sicure" per evitare intossicazioni alimentari.

Il problema: Non abbiamo un libro di ricette "sicure" (proofs) per il Rust.
La soluzione SAFE: Prendiamo migliaia di ricette semplici (codice Python o Rust generico) e le traduciamo in un formato che il "controllore di sicurezza" (Verus) può leggere. Se il controllo fallisce, buttiamo via la ricetta. Se passa, teniamola. Ora abbiamo una pila di piatti potenzialmente sicuri.

2. L'Assaggio Critico (Generazione delle Specifiche)

Ora, per ogni piatto, dobbiamo scrivere una lista di ingredienti e condizioni (le specifiche).

Il trucco: Invece di chiedere a un umano di scrivere la lista, chiediamo all'IA di inventarla.
Il filtro: Usiamo un "gusto robotico" (un algoritmo matematico) per assaggiare la lista. Se la lista dice "il piatto è sicuro" ma in realtà c'è un veleno, la scartiamo. Se la lista è ragionevole (anche se non perfetta), la teniamo.
L'evoluzione: L'IA scrive le liste, le scarta quelle brutte, e si allena su quelle buone. Diventa sempre più brava a scrivere liste accurate.

3. Il Cuoco che Impara a Correggere i Errori (Sintesi delle Prove)

Ora abbiamo i piatti e le liste. Dobbiamo scrivere la prova che il piatto è sicuro.

Il primo tentativo: L'IA prova a scrivere la prova. Spesso sbaglia.
Il grande segreto di SAFE: Qui entra in gioco la parte geniale. Quando l'IA sbaglia, il sistema di controllo (Verus) non dice solo "Sbagliato". Dice: "Hai dimenticato di controllare che il sale non sia troppo salato!".
L'allenamento: SAFE prende l'errore, la correzione e la spiegazione del controllo, e crea un nuovo esercizio di allenamento. Invece di buttare via gli errori, li usa per insegnare all'IA a correggersi da sola (Self-Debugging).
- Analogia: È come un bambino che impara a andare in bicicletta. Se cade, non smette di imparare; impara dove ha perso l'equilibrio e come correggere la posizione la prossima volta.

🏆 I Risultati: Da Principiante a Campione

All'inizio, l'IA (un modello open-source come DeepSeekCoder) non sapeva nulla di queste prove matematiche. Era come un principiante assoluto.

Prima di SAFE: Se chiedevi a un'IA potente (come GPT-4o) di scrivere queste prove, falliva nel 85-90% dei casi.
Dopo SAFE: Grazie a questo ciclo di "prova, sbaglia, correggi, impara", l'IA ha imparato da sola.
- Su un test fatto da esperti umani, la precisione è passata dal 14% (GPT-4o) al 52% (SAFE).
- Se permettiamo all'IA di "ripensarci" e correggere i suoi errori (Self-Debugging), la precisione sale fino al 70%.

💡 In Sintesi

SAFE è come un allenatore sportivo per l'Intelligenza Artificiale.
Invece di avere un allenatore umano che scrive ogni singolo esercizio (cosa impossibile perché ci sono troppi esercizi da fare), SAFE crea i propri esercizi, fa fare all'IA le prove, guarda dove sbaglia, e usa quegli errori per creare esercizi ancora migliori per il giorno dopo.

Grazie a questo metodo, siamo riusciti a insegnare a un'IA a scrivere certificati di sicurezza matematica per il codice informatico, un compito che prima richiedeva anni di studio umano e che ora può essere automatizzato. È un passo enorme per rendere il software che usiamo ogni giorno più sicuro e affidabile.

1. Il Problema: Scarsità di Dati per la Verifica Formale

La generazione di codice affidabile richiede la verifica formale per garantire che un programma soddisfi determinate proprietà sotto tutti i possibili input. Tuttavia, l'adozione della verifica formale è ostacolata da due fattori principali:

Alto sforzo umano: Scrivere specifiche formali e prove (proofs) richiede competenze specializzate e tempo.
Carenza critica di dati: A differenza del codice generico, esistono pochissimi esempi di prove formali scritte da umani per addestrare i Large Language Models (LLM). In particolare, per Verus, lo strumento di verifica più avanzato per il linguaggio Rust, esistono meno di 500 file verificati su GitHub, una quantità insufficiente per il fine-tuning dei modelli.

Le soluzioni esistenti si basano su prompt engineering (limitata generalizzazione) o sul fine-tuning su dataset esistenti (impossibile per Verus a causa della mancanza di dati).

2. Metodologia: Il Framework SAFE

Gli autori propongono SAFE (Self-evolving Automated prooF gEneration), un framework che supera la scarsità di dati creando un ciclo di auto-evoluzione che combina sintesi dei dati e fine-tuning del modello. SAFE sfrutta la capacità del verificatore simbolico (Verus) di distinguere in modo definitivo e automatico tra prove corrette e incorrette.

Il processo si articola in tre fasi principali:

Fase 1: Generazione di Codice Compatibile con Verus

Poiché Verus non supporta tutte le funzionalità di Rust (es. iteratori, HashMap), SAFE utilizza GPT-4o per "tradurre" migliaia di piccoli programmi Python e Rust (da dataset come MBPP e CodeNet) in sintassi Rust compatibile con Verus. Solo il codice che compila viene mantenuto.

Fase 2: Sintesi Auto-Evolvente delle Specifiche

Per ogni funzione Rust, è necessaria una specifica formale (pre-condizioni e post-condizioni).

Bootstrapping: GPT-4o genera specifiche iniziali basate su docstring naturali.
Ciclo di Evoluzione: Un modello LLM open-source viene addestrato sulle specifiche di alta qualità generate nelle iterazioni precedenti per produrne di nuove.
Filtraggio Quantitativo: Le specifiche vengono valutate non tramite ispezione umana, ma tramite metriche quantitative di Correttezza (quanti test case corretti accetta) e Completezza (quanti test case mutati/errati rifiuta). Solo le specifiche che superano una soglia (es. 80% correttezza, 60% completezza) vengono mantenute per l'addestramento successivo.

Fase 3: Sintesi Auto-Evolvente delle Prove e Self-Debugging

Questa è la fase centrale per la generazione delle prove.

Sintesi: Il modello tenta di generare annotazioni di prova (invarianti di ciclo, asserzioni) affinché Verus verifichi la funzione.
Selezione: Verus agisce come "giudice" assoluto. Se la prova passa la verifica, viene conservata; se fallisce, viene scartata.
Self-Debugging (Punto Chiave): SAFE sfrutta le prove errate generate durante il processo. Per ogni prova corretta finale ( $P_{\checkmark}$ $P_{✓}$ ), il sistema crea una tripletta di addestramento composta da:
1. Una prova errata precedente ( $P_X$ ).
2. Il messaggio di errore di Verus relativo a $P_X$ .
3. La prova corretta finale ( $P_{\checkmark}$ ).
  Questo insegna al modello non solo a generare prove da zero, ma anche a debuggare e riparare prove esistenti basandosi sui feedback del verificatore.

3. Contributi Chiave

Framework di Auto-Evoluzione: Dimostrazione che è possibile costruire dataset di addestramento massicci per la verifica formale partendo da zero, senza dati umani iniziali, sfruttando un ciclo di generazione-filtraggio-addestramento.
Meccanismo di Self-Debugging: L'uso innovativo delle prove fallite e dei messaggi di errore di Verus per addestrare i modelli a correggere i propri errori, migliorando drasticamente il tasso di successo.
Dataset Sintetico su Scala: Creazione del più grande dataset sintetico per Verus a oggi, contenente 19.017 specifiche formali e 9.706 funzioni Rust verificate, derivato da 45.395 programmi originali.
Indipendenza dai Prompt: Il modello fine-tuned non richiede prompt complessi durante l'inferenza, a differenza dei modelli base che necessitano di ingegneria dei prompt intensiva.

4. Risultati Sperimentali

Il framework è stato valutato su due benchmark: VerusBench (creato da esperti umani) e CodeNet-Test (sintetico e più ampio).

Prestazioni Superiori: SAFE ha superato significativamente GPT-4o.
- Su VerusBench, SAFE ha raggiunto un'accuratezza del 52,52% (con self-debugging e 100 tentativi), contro il 14,39% di GPT-4o.
- Su CodeNet-Test, SAFE ha raggiunto il 48,43%, contro lo 0,28% di GPT-4o.
Efficacia del Self-Debugging: L'uso del meccanismo di debug ha portato a miglioramenti sostanziali. Ad esempio, su VerusBench, l'accuratezza è passata dal 43,17% (generazione diretta) al 52,52% (con debug).
Scalabilità: Il framework ha funzionato efficacemente anche con modelli open-source più piccoli (es. DeepSeekCoder-33B e persino 1.3B), dimostrando che l'auto-evoluzione compensa la mancanza di dati umani.
Qualità delle Specifiche: Esperimenti hanno mostrato che l'uso di specifiche di bassa qualità (non filtrate) degrada drasticamente le prestazioni, confermando l'importanza del filtro quantitativo.

5. Significato e Impatto

Questo lavoro rappresenta un passo avanti fondamentale nell'automazione della verifica del software:

Democratizzazione della Verifica Formale: Rende possibile l'uso di LLM per la verifica formale in contesti (come Rust/Verus) dove i dati umani sono scarsi o inesistenti.
Nuovo Paradigma di Addestramento: Introduce un approccio "data-centric" che non dipende dalla raccolta manuale di dati, ma dalla generazione e filtraggio automatico guidato da strumenti di verifica simbolica.
Affidabilità del Codice: Offre una via praticabile per generare codice Rust corretto per definizione, riducendo i bug critici in sistemi di produzione.
Risorsa Open Source: Il dataset sintetico prodotto è stato reso disponibile su HuggingFace, facilitando la ricerca futura nel campo della verifica formale assistita da AI.

In sintesi, SAFE dimostra che combinando la potenza dei LLM con la rigore dei verificatori simbolici in un ciclo di auto-miglioramento, è possibile superare la barriera della scarsità di dati e automatizzare la generazione di prove formali complesse.