Generative AI for Quantum Circuits and Quantum Code: A Technical Review and Taxonomy

Questa revisione tecnica del 2026 classifica tredici sistemi generativi e cinque dataset per la creazione di circuiti e codice quantistico, evidenziando che, sebbene la maggior parte garantisca validità sintattica e semantica, nessuno dei sistemi valutati ha ancora dimostrato l'esecuzione end-to-end su hardware quantistico reale, rivelando un divario critico tra generazione e deployment pratico.

L'essenziale

Immagina di essere un architetto che deve costruire case (i circuiti quantistici) per una città futuristica e molto complessa: il computer quantistico.

Fino a poco tempo fa, costruire queste case richiedeva ingegneri umani che calcolavano ogni singolo mattone a mano. Ora, abbiamo sviluppato dei "robot architetti" basati sull'Intelligenza Artificiale Generativa (come i famosi Chatbot, ma specializzati in fisica quantistica) che possono disegnare queste case da soli.

Questo articolo è una mappa e un'ispezione di tredici di questi robot architetti, fatta da un ricercatore di nome Juhani Merilehto. Ecco cosa ha scoperto, spiegato in modo semplice.

1. Il Problema: Costruire case su un terreno che non esiste ancora

I computer quantistici sono come terreni molto strani:

• Sono fragili: Se sbagli un mattone, la casa crolla (o meglio, il calcolo diventa sbagliato).
• Hanno regole strane: Non puoi mettere due muri vicini se sono troppo lontani nel "terreno" fisico (i qubit non sono tutti collegati tra loro).
• Sono costosi: Provare a costruire una casa reale su quel terreno costa tempo e denaro.

L'articolo dice che questi robot architetti sono bravissimi a disegnare la struttura della casa (la sintassi) e spesso anche a capire cosa deve fare la casa (la semantica, cioè se serve per calcolare la velocità di un'auto o per crittografare un messaggio).

MA c'è un grande buco: Nessuno di questi robot ha mai provato a costruire la casa su un terreno reale e a vedere se sta in piedi. Tutti si fermano alla fase del disegno su carta o alla simulazione al computer.

2. La Classificazione: Che tipo di robot sono?

L'autore ha diviso questi robot in due gruppi principali, incrociando cosa producono con come imparano:

• Cosa producono?

  • Codice Qiskit: Come scrivere istruzioni in Python per costruire la casa.
  • OpenQASM: Un linguaggio più grezzo, come i disegni tecnici puri.
  • Grafici: Disegni astratti che mostrano come i pezzi sono collegati.

• Come imparano?

  • Studio noioso (Supervised Fine-Tuning): Gli mostrano migliaia di esempi di case perfette e dicono: "Guarda, fai così".
  • Prova ed errore con un supervisore (RL): Disegnano una casa, un simulatore dice "Brutto, crolla", e loro correggono.
  • Diffusione (come l'arte): Partono da un caos di punti e li "puliscono" fino a formare una casa.
  • Agenti intelligenti: Un robot che usa altri strumenti (come un simulatore) per controllare il proprio lavoro mentre lo fa.

3. La "Regola dei Tre Livelli" (La scala della verità)

Per capire se un robot è bravo, l'autore usa una scala di tre livelli, come un esame di guida:

1. Livello 1: La Grammatica (Sintassi).

   • Domanda: Il disegno è leggibile? Il computer capisce le istruzioni?
   • Risultato: Tutti i robot superano questo livello. Sanno scrivere frasi grammaticalmente corrette.

2. Livello 2: Il Significato (Semantica).

   • Domanda: La casa fa quello che deve fare? Se chiedo "calcola la radice quadrata", la casa calcola davvero la radice quadrata?
   • Risultato: Molti robot ci arrivano. Usano simulazioni al computer per verificare se il risultato è corretto.

3. Livello 3: La Realtà (Hardware).

   • Domanda: Se portiamo i piani di costruzione in cantiere (il vero computer quantistico), la casa viene costruita senza crollare?
   • Risultato: NESSUNO. Questo è il punto cruciale dell'articolo.
   • Perché? Perché i computer quantistici reali sono rari, costosi e rumorosi. I robot disegnano case perfette sulla carta, ma quando proviamo a costruirle nella realtà, i "muri" (i gate quantistici) non si adattano bene al "terreno" (i cavi e le connessioni fisiche).

4. L'Analogia del "Traduttore"

Immagina che questi robot scrivano ricette per cucinare un piatto gourmet (il circuito quantistico).

• I robot sono bravissimi a scrivere la ricetta in italiano perfetto (OpenQASM).
• Sono anche bravissimi a dire che il piatto sarà gustoso (Simulazione).
• Ma il problema è: La cucina reale (il computer quantistico) ha fornelli diversi, pentole diverse e non ha il sale che la ricetta richiede.
• Prima di cucinare, serve un "traduttore" (il transpiler) che adatta la ricetta alla cucina reale.
• Il problema attuale: I robot scrivono ricette pensando di avere una cucina ideale. Quando un umano prova a tradurle per la cucina reale, la ricetta si rompe o diventa troppo lunga e complessa.

5. Cosa manca e cosa serve?

L'articolo conclude con un messaggio forte: Dobbiamo smettere di guardare solo i disegni e iniziare a costruire.

Per fare un passo avanti, i ricercatori devono:

1. Insegnare ai robot le regole del terreno reale: Far loro disegnare circuiti che tengano conto dei limiti fisici dei computer quantistici mentre li disegnano, non dopo.
2. Creare un esame finale reale: Non basta dire "ho simulato il risultato". Bisogna dire "ho eseguito questo circuito su un vero computer quantistico e ho ottenuto il risultato".
3. Standardizzare i test: Oggi ogni robot viene valutato con un metro diverso (uno conta i passi, l'altro la velocità). Servirebbe un'unica "prova del nove" per tutti.

In sintesi

Questo articolo è come un ispettore edilizio che dice: "Guardate, abbiamo 13 architetti robot fantastici che disegnano case incredibili. Sanno scrivere bene e sanno cosa devono fare le case. Ma nessuno di loro ha mai provato a costruire una di queste case su un terreno reale. Finché non lo faremo, queste case rimarranno solo bellissimi disegni su carta, e non case vere in cui vivere."

È un invito a passare dalla teoria alla pratica, colmando il divario tra l'Intelligenza Artificiale che "pensa" e il computer quantistico che "agisce".

Sommario tecnico

1. Il Problema

Il campo dell'Intelligenza Artificiale Generativa per il software quantistico si è diversificato rapidamente, passando da semplici assistenti per il codice a sistemi capaci di sintetizzare artefatti quantistici a diversi livelli di astrazione. Tuttavia, il panorama è frammentato e manca di standardizzazione. Le principali sfide identificate sono:

• Definizione di Correttezza Semantica: A differenza della generazione di codice classico (dove i test unitari sono sufficienti), verificare l'equivalenza semantica di circuiti quantistici (cioè se due circuiti implementano la stessa unitaria) è computazionalmente costoso ($O(2^n)$ o $O(4^n)$) e non esiste un verificatore di equivalenza polinomiale generale.
• Divario tra Sintassi ed Esecuzione: Molti sistemi garantiscono che il codice sia sintatticamente valido, ma pochi verificano la correttezza semantica e nessuno valuta l'esecuzione su hardware reale.
• Eterogeneità degli Output: I sistemi generano artefatti diversi (codice Qiskit, programmi OpenQASM 2.0/3.0, grafi di circuiti), rendendo difficile il confronto diretto.
• Vincoli Hardware: La generazione di circuiti deve tenere conto di vincoli reali come la connettività dei qubit, l'insieme di gate nativi e i tempi di coerenza, aspetti spesso ignorati dai modelli attuali.

2. Metodologia

L'autore ha condotto una revisione di ambito (scoping review) strutturata seguendo le linee guida PRISMA-ScR, effettuata tra gennaio e febbraio 2026.

• Fonti di Ricerca: Hugging Face (ricerca di modelli), arXiv (carte scientifiche) e tracciamento della provenienza (GitHub, citazioni).
• Criteri di Selezione: Sono stati inclusi solo sistemi che pubblicano almeno due dei seguenti: architettura del modello, fonte e scala dei dati di addestramento, o metriche di valutazione quantitative.
• Campionamento: Su 228 candidati iniziali, sono stati selezionati 13 sistemi generativi e 5 dataset di supporto dopo un processo di screening in due fasi.
• Terminologia: Il termine "codice quantistico" si riferisce a QASM e Qiskit, escludendo la generazione di codici di correzione d'errore quantistici (QEC).

3. Contributi Chiave

A. Una Nuova Tassonomia

Il paper organizza i sistemi esistenti lungo due assi principali:

1. Tipo di Artefatto: Codice Qiskit, programmi OpenQASM (2.0 o 3.0), o grafi di circuiti (DAG).
2. Regime di Addestramento:
   • Assistenti per codice Qiskit: LLM generalisti adattati alle API Qiskit.
   • Generatori OpenQASM (SFT statico): Modelli linguistici addestrati supervisionatamente.
   • Piccoli LLM specialisti: Modelli piccoli (es. 100M parametri) per coppie testo-QASM.
   • Allineamento con Verificatore in Loop (RL): Uso di reward basati su simulatori quantistici (es. GRPO).
   • Generatori basati su Grafi e Diffusione: Modelli che operano su strutture di circuiti o token discreti.
   • Sistemi Agentic: Agenti multi-step che usano strumenti esterni (simulatori, compilatori) per il miglioramento iterativo.

B. Framework di Valutazione a Tre Livelli

L'autore propone un framework sistematico per valutare la correttezza:

1. Livello 1 (Sintassi): Validità del parsing o compilazione sotto la grammatica target.
2. Livello 2 (Semantica): Correttezza dell'implementazione dell'obiettivo (test unitari, fedeltà di processo, allineamento di distribuzione, ecc.).
3. Livello 3 (Hardware/Esecuzione):
   • 3a (Compilabilità): Trasformazione in gate nativi e rispetto della connettività.
   • 3b (Esecuzione Empirica): Esecuzione su QPU reale e confronto delle distribuzioni di output.

C. Analisi dei Dataset e Benchmark

Vengono esaminati dataset chiave come QASMBench, QCircuitBench e dataset sintetici (es. quantum-circuits-8k), evidenziando come le differenze tra OpenQASM 2.0 e 3.0 (controllo di flusso classico, variabili tipizzate) aumentino la complessità della generazione e della verifica.

4. Risultati Principali

• Assenza di Valutazione su Hardware Reale: Il risultato centrale è che nessuno dei 13 sistemi esaminati riporta una valutazione end-to-end su hardware quantistico (Livello 3b). Esiste un divario significativo tra i circuiti generati e il loro dispiegamento pratico.
• Copertura della Valutazione:
  • Tutti i sistemi affrontano la sintassi (Livello 1).
  • La maggior parte affronta la semantica (Livello 2) in modi diversi a seconda della famiglia (test unitari per Qiskit, fedeltà di processo per la compilazione, allineamento di distribuzione per l'ottimizzazione).
  • Solo un sistema (AltGraph) affronta parzialmente il Livello 3a (metriche post-trasformazione), ma nessuno chiude il ciclo fino all'esecuzione fisica.
• Limiti della Verifica Classica: La verifica semantica su simulatori classici diventa intrattabile oltre i 30-50 qubit a causa della memoria esponenziale richiesta ($O(2^n)$), limitando l'efficacia dei metodi "verifier-in-the-loop" su larga scala.
• Differenze tra OpenQASM 2.0 e 3.0: I modelli che generano OpenQASM 3.0 affrontano una spaziatura grammaticale più ampia e comportamenti dipendenti dal percorso (controllo di flusso classico), rendendo la verifica semantica più complessa rispetto alla semplice sequenza di gate dell'OpenQASM 2.0.

5. Significato e Implicazioni Future

• Gap Pratico: La ricerca attuale è focalizzata sulla generazione di circuiti logicamente corretti, ma trascura i vincoli hardware reali (connessione, rumore, set di gate nativi). Questo limita l'applicabilità immediata dei modelli generativi.
• Necessità di Standardizzazione: È urgente sviluppare protocolli di valutazione standardizzati che separino sintassi, semantica e realismo hardware, poiché le metriche attuali (es. pass@k vs fedeltà) non sono intercambiabili e possono portare a valutazioni ingannevoli.
• Direzioni Future:
  • Adozione di protocolli di valutazione che includano la trasformazione (transpilation) e l'esecuzione su QPU.
  • Sviluppo di metodi di generazione "consapevoli della trasposizione" (che considerano la connettività del dispositivo durante la generazione).
  • Miglioramento della provenienza dei dataset e dell'interoperabilità tra versioni OpenQASM.
  • Creazione di metodi di verifica scalabili che vadano oltre la simulazione di stati completi.

In conclusione, il paper fornisce una mappa strutturata di un campo in rapida evoluzione, evidenziando che, sebbene i modelli generativi abbiano fatto progressi nella sintassi e in alcune forme di semantica, la vera sfida per il dispiegamento pratico risiede nella chiusura del divario tra generazione software ed esecuzione hardware reale.