Guida ai framework di sviluppo

Le piattaforme software

Una panoramica dei quantum computer disponibili e del software necessario per potersi connettere ad essi, è mostrato nella seguente immagine.

Al momento ci sono quattro piattaforme software che consentono di connettersi a tre differenti quantum computer, accessibili liberamente:

• un quantum computer da 8 qubit di Rigetti Computing accessibile utilizzando>pyQuil
• un quantum computer da 5 qubit di IBM accessibili con Qiskit e ProjectQ
• un quantum computer da 16 qubit di IBM accessibili con Qiskit e ProjectQ

Solo per i membri di IBM Q Network (un gruppo di aziende, università e enti di ricerca nazionali interessati ad investire nel mondo del quantum computing) è anche disponibile un quantum computer da 20 qubit,

Sempre IBM, possiede un altro quantum computer da 50 qubit, presentato alla fine dell’anno 2017, ma non ancora accessibile attraverso il servizio di cloud computing.

Per completezza d’informazione, sono da citare anche Google che ha annunciato un processore da 72 qubit (Bristlecone) e la Intel (con il suo partner QuTech in Olanda) che ha annunciato un processore da 49 qubit (Tangle Lake)

Le tecnologie con cui l’hardware quantistico viene realizzato si evolve continuamente, ed è molto probabile che nuove macchine saranno disponibili nei prossimi mesi. Quello che comunque resterà valido sarà il software utilizzato per connettersi a queste tecnologie. Sarà piuttosto semplice utilizzare i nuovi quantum computer, poiché basterà cambiare qualche riga di codice, senza dover modificare la sintassi utilizzata per generare ed eseguire un circuito quantistico.

Per esempio nel framework Qiskit potrebbe essere necessario modificare solo il nome del backend su cui viene eseguito il circuito quantistico:

execute(quantum.circuit, backend=”name”, …..)

Va comunque detto che dobbiamo tenere conto del probabile rilascio di nuove versioni dei framework che stiamo per approfondire, e che quindi, potrebbero essere necessarie delle modifiche minori alla sintassi dei comandi, che però non altereranno in modo significativo la funzionalità del software.

Nei prossimi paragrafi esamineremo nello specifico le varie piattaforme, analizzando i requisiti, le modalità di installazione, alcuni aspetti della sintassi dei linguaggi e dell’hardware reale e dei simulatori su cui eseguire gli esperimenti.

Il pyQuil

pyQuil è una libreria Python, open-source, sviluppata da Rigetti Computing per costruire, analizzare ed eseguire programmi quantistici. Questa libreria è costruita come astrazione del Quil, un linguaggio (open) che definisce le istruzioni quantistiche da inviare all’hardware. Il Quil è un quantum language, che svolge un ruolo analogo all’assembly dei computer classici, ed è stato progettato appositamente per le applicazioni dei quantum computer disponibili nel breve termine ed è basato su un modello di condivisione della memoria classica/quantistica. pyQuil è una delle librerie principali di Forest, la piattaforma generale per la gestione del software quantistico di Rigetti Computing.

Per installare pyQuil è necessario Python 2 o Python 3 (quest’ultimo è raccomandato poiché versioni future potrebbero supportare solo Python 3). Il modo più semplice per installare pyQuil è mediante pip, il package manager di Python:

pip install pyquil

pyQuil ha una eccellente documentazione disponibile online, che contiene informazioni generali sul quantum computing, semplici programmi, operazioni con porte quantistiche e sul simulatore (QVM, quantum virtual machine).

La sintassi di pyQuil è molto chiara ed efficace. L’elemento fondamentale per definire i circuiti quantistici è Program, che va importato dal package pyquil.quil. Le operazioni con le porte quantistiche sono in pyquil.gates. Mentre il modulo api consente l’esecuzione dei circuiti quantistici sulla macchina virtuale. Una funzionalità utile di pyQuil è che i registri dei qubit ed i registri dei bit non devono essere definiti a priori, ma possono essere allocati dinamicamente. Per riferirsi ai qubit allocati nel registro dei qubit si utilizza un indice (0, 1, 2, …), nello stesso modo ci si riferisce ai bit allocati nel registro classico.

Un circuito per la generazione di numeri casuali può essere scritto in questo modo:

# random number generator circuit in pyQuil
from pyquil.quil import Program
import pyquil.gates as gates
from pyquil import api
qprog = Program()
qprog += [gates.H(0), gates.MEASURE(0,0)]
qvm = api.QVMConnection()
print(qvm.run(qprog))

Nelle prime righe di codice importiamo tutto quello che ci serve per poter dichiarare un circuito/programma quantistico (riga 2), per eseguire le operazioni quantistiche sui qubit (riga 3) e per mandare in esecuzione il programma (riga 4). Alla riga 6 istanziamo il programma quantistico e alle righe 7-8 forniamo una lista di istruzioni: prima applichiamo una porta Hadamard (H) al qubit con indice 0, e poi eseguiamo una misurazione dello stesso qubit e mettiamo il risultato nel bit con indice 0 del registro classico.

Alla riga 10 stabiliamo una connessione con la QVM (quantum virtual machine) ed infine alle riga 11 lanciamo il programma e mostriamo l’output del circuito sul display. Il programma stamperà un output standard di pyQuil, costituito da una lista di array di interi: nel nostro caso [[0]] oppure [[1]]. In generale, il numero di elementi contenuti nell’array di output corrisponde al numero di tentativi eseguiti ed i valori interi contenuti nella lista interna sono i risultati delle misurazioni finali salvate nei registri classici. Nel nostro caso abbiamo un solo elemento nella lista interna perchè, senza specificarlo esplicitamente, il numero di tentativi (e di misurazioni) è uno solo (ad esempio, se avessimo imposto un numero di tentativi uguale a 5, avremmo ottenuto un output simile a questo: [[0], [1], [0], [1], [0]]). Il numero di tentativi da eseguire può essere specificato come parametro del metodo run (vedi documentazione).

Come abbiamo accennato sopra, Quil è il quantum language di Rigetti Computing che fornisce le istruzioni di basso livello per comandare l’hardware del quantum computer. Esso è concettualmente analogo all’assembly dei computer tradizionali. La sintassi generale di Quil è: GATE index dove GATE rappresenta la porta quantistica che deve essere applicata al qubit con il valore di indice specificato (0, 1, 2, …).

pyQuil ha la possibilità di generare il codice Quil corrispondente ad un determinato programma. Ad esempio, se al nostro programma di generazione di numeri casuali aggiungiamo la riga:

print(qprog)

al termine dell’esecuzione avremo stampato il codice Quil per quel circuito:

H 0
MEASURE 0 [0]

Per poter eseguire i programmi quantistici, con Rigetti Computing abbiamo due possibilità. La prima è quella di richiedere l’accesso al vero hardware quantistico: bisogno inoltrare una richiesta sul sito web, fornendo nome, email, nome dell’organizzazione e descrizione del motivo della richiesta di accesso al processore quantistico. In caso di accettazione verrà assegnato un tempo per poter utilizzare il QPU (processore quantistico). L’alternativa è quella di utilizzare il simulatore (QVM) che può essere scaricato ed installato seguendo le istruzioni che si trova nella documentazione. In questo modo si potranno eseguire sul proprio computer i programmi scritti in pyQuil (esiste comunque la possibilità di utilizzare il simulatore di Rigetti come servizio cloud).

Qiskit

Il Quantum Information Science Kit, o Qiskit, è una piattaforma completa per lo sviluppo di software quantistico, da utilizzare a vari livelli, con i quantum computer di IBM.

Il Qiskit è costituito da un framework fondamentale (di basso livello), Qiskit Terra, che consente di lavorare direttamente con i circuiti quantistici. Basati su Terra, sono poi stati costruiti altri framework, di più alto livello e maggiormente specializzati:

• Qiskit Aqua: nato per rendere più semplice la ricerca nell’ambito della chimica, dell’ottimizzazione e dell’intelligenza artificiale; consente di utilizzare gli algoritmi quantistici senza preoccuparsi dei dettagli implementativi di basso livello
• Qiskit Ignis: è il framework dedicato alla riduzione degli errori e del rumore nelle porte quantistiche; è un framework specialistico per coloro che si concentrano sulla progettazione di nuovi algoritmi di correzione d’errore o che desiderano studiare modi per caratterizzare gli errori attraverso metodi come la tomografia
• Qiskit Aer: è il framework di IBM dedicato allo sviluppo di simulatori, emulatori e debugger ad alte prestazioni; lo scopo di Aer è quello di aiutare a capire quali sono i limiti dei processori classici nell’ambito della simulazione dei processori quantistici e verificare la correttezza del funzionamento dei processori quantistici attuali e futuri

dotQuantum.io | Gli elementi di Qiskit

In questa trattazione, la nostra attenzione si concentra su Qiskit Terra, un SDK (Software Development Kit) open-source per lavorare con il quantum language OpenQASM e con IBM Quantum Experience. Qiskit Terra è disponibile in Python, JavaScript e Swift. Qui useremo la versione per Python.

Qiskit Terra è disponibile per macOS, Windows e Linux. Per installare Terra è richiesto Python 3.5+. Anche se non indispensabile, si può anche installare Jupyter  per visionare i numerosi tutorial e Anaconda, una distribuzione di Python con tutte le dipendenze necessarie pre-installate.

Il modo più semplice di installare Qiskit Terra è attraverso pip, il package manager di Python. A riga di comando possiamo procedere all’installazione digitando:

pip install qiskit

In questo modo verranno installate automaticamente tutte le dipendenze necessarie all’uso di qiskit-terra (gli utenti che sono interessati a contribuire al progetto open-source possono installare il codice sorgente direttamente da github).

La documentazione di Qiskit Terra si trova online all’indirizzo https://qiskit.org/documentation/. Qui si possono trovare le istruzioni dettagliate per l’installazione ed il setup, programmi di esempio, documentazione di sviluppo e modalità di connessione ai dispositivi reali. Sono inoltre disponibili anche informazioni di base per coloro che si affacciano per la prima volta nel mondo del quantum computing. Sui notebook Jupyter sono disponibili esempi documentati di alcuni algoritmi quantistici standard come Deutsch-Josza, l’algoritmo di Grover, phase estimation e la trasformata quantistica di Fourier, oltre ad un insieme di algoritmi più complessi.

All’interno di IBM Quantum Experience è possibile utilizzare anche lo strumento grafico Composer, in cui l’utente può costruire con dei semplici drag&drop il circuito quantistico; si tratta di uno strumento utile per imparare le basi del funzionamento dei circuiti quantistici prima di procedere alla programmazione con qiskit-terra.

Come abbiamo fatto con pyQuil, proviamo ora a scrivere un breve programma per la generazione di numeri casuali usando qiskit-terra:

# random number generator circuit in QISKit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute
qreg = QuantumRegister(1)
creg = ClassicalRegister(1)
qcircuit = QuantumCircuit(qreg,creg)
qcircuit.h(qreg[0])
qcircuit.measure(qreg[0],creg[0])
result = execute(qcircuit, 'local_qasm_simulator’).result()
print(result.get_counts())

Commentiamo le righe di codice per comprendere meglio il funzionamento di Qiskit.

Alla riga 2 importiamo gli strumenti per creare i registri classici e quantistici, un circuito quantistico ed una funzione per eseguire quel circuito. Alla riga 4 creiamo un registro quantistico con un qubit, ed alla riga 5 un registro classico con un bit. Alla riga 6 creiamo invece un circuito quantistico inizializzato con i due registri creati in precedenza. Ora che il circuito è pronto, possiamo fornire le istruzioni da eseguire: alla riga 8 facciamo una porta Hadamard sul qubit di indice 0 che si trova nel registro quantistico (l’unico qubit presente nel registro); alla riga 9 misuriamo il qubit e mettiamo il risultato della misurazione nel bit di indice 0 del registro classico (l’unico bit presente nel registro classico). Alla riga 11 procediamo con l’esecuzione del circuito e stampiamo i risultati alla riga 12.

Stampando il valore di result.get_counts(), stampiamo il contenuto del dizionario che con i valori di output e quante volte quei valori sono stati ricevuti come risultato.

Nel nostro caso, i due possibili risultati sono 0 e 1, ed un esempio di output del programma è {‘0’:532, ‘1’:492} che significa che abbiamo avuto 532 volte il risultato 0 e 492 volte il risultato 1 (in Qiskit, il numero di volte in cui un circuito viene eseguito ha come valore di default 1024).

OpenQASM (open quantum assembly language) è il quantum language che fornisce le istruzioni al dispositivo quantistico reale (come abbiamo già detto, analogo all’assembly dei computer classici). La sintassi del QASM è: gate qubit dove il parametro gate serve a specificare un’operazione quantistica e qubit definisce il qubit destinatario dell’operazione.

Qiskit ha una funzionalità per generare il codice QASM dalla definizione del circuito. Se aggiungiamo all’esempio precedente la riga di codice:

print(qcircuit.qasm())

al termine dell’esecuzione otterremo il codice QASM relativo al circuito:

OPENQASM 2.0;
include "qelib1.inc";
qreg q0[1];
creg c0[1];
h q0[0];
measure q0[0] -> c0[0];

Le prime due righe sono incluse in ogni file QASM. Le righe 3 e 4 creano il registro quantistico e classico, e le righe 5 e 6 forniscono le istruzioni del circuito. Per piccoli circuiti è possibile scrivere direttamente il codice in QASM, ma per circuiti più complessi è molto meglio scrivere il codice in Python con Qiskit.

E’ disponibile molta documentazione relativa ai vari backend che consentono di usare l’hardware per l’esecuzione dei programmi quantistici. E’ possibile eseguire un circuito su un chip reale mediante la IBM Q experience (QX) cloud platform ed attualmente sono disponibili due alternative:

• ibmqx4: 5-qubit backend
• ibmq_16_melbourne: 16-qubit backend

Le informazioni specifiche su come configurare il codice per l’esecuzione sull’hardware sono disponibili nella documentazione

IBM fornisce inoltre diversi simulatori che possono essere usati sia localmente che nel servizio cloud.

ProjectQ

ProjectQ è un framework open source per il quantum computing con la possibilità di connettersi ai backend di IBM e di utilizzare un simulatore di quantum computing ad elevate prestazioni, ha inoltre molti plugin da utilizzare per lo sviluppo.

La prima versione di ProjectQ fu sviluppata da Thomas Häner e Damien S. Steiger nel gruppo di Matthias Troyer all’ETH di Zurigo, e da allora ha ricevuto molti contributi.

Per l’installazione è richiesto Python 3.5+, la documentazione contiene informazioni dettagliate sulle modalità di installazione. Al solito, il modo più semplice di eseguire l’installazione è attraverso pip, il package manager di Python:

python -m pip install --user projectq

Per poter iniziare è utile consultare i tutorial online in cui sono esposti alcuni esempi di programmi (generazione di numeri casuali, teletrasporto ed algoritmo di Shor).

La sintassi di ProjectQ è chiara ed efficace, anche se è necessario un pò di tempo per abituarsi. Non c’è nessun quantum assembly language, poiché non esiste alcun backend specifico di ProjectQ, ma il linguaggio è un po un ibrido tra classico e quantistico.

Di seguito possiamo vedere un esempio di programma per la generazione di numeri casuali:

from projectq import MainEngine #import the main compiler engine
from projectq.ops import H, Measure #import the operations we want to perform (Hadamard and measurement)
eng = MainEngine() #create a default compiler (the back-end is a simulator)
qubit = eng.allocate_qubit() #allocate 1 qubit
H | qubit #apply a Hadamard gate
Measure | qubit #measure the qubit
eng.flush() #flush all gates (and execute measurements)
print(“Measured {}“.format(int(qubit))) #output measurement result

Dopo aver importato il modulo principale (MainEngine) e le operazioni quantistiche che vogliamo eseguire, viene allocato il MainEngine. Si procede quindi con l’allocazione del registro da un qubit e poi si forniscono le operazioni da eseguire: la porta Hadamard sul qubit allocato in precedenza e la misurazione (notiamo l’utilizzo di questa particolare sintassi che in qualche modo ricorda la notazione di Dirac). A questo punto si esegue il circuito e si stampa l’output della misurazione.

Poiché ProjectQ non ha un suo hardware dedicato, è possibile quindi utilizzarlo su IBM Q, ed in tal caso il codice verrà convertito in OpenQASM.

ProjectQ è fornito di un simulatore molto veloce scritto in C++ che viene automaticamente installato durante il setup, le cui capacità di calcolo sono limitate dall’hardware su cui si fa girare.

Quantum Development Kit

A differenza di IBM e Rigetti Computing, che hanno scelto di utilizzare la tecnologia superconduttiva dei transmon qubit, Microsoft sta scommettendo molto sulla possibilità di realizzare un computer quantistico topologico basato sui fermioni di Majorana, che sembrano promettere grande stabilità ed insensibilità al rumore. Microsoft è, quindi,  in una fase di ricerca sperimentale e non ha a disposizione nessun hardware quantistico, ma, dal gennaio 2018, ha rilasciato il suo Quantum Development Kit con un linguaggio di programmazione, il Q#, ed un simulatore su cui provare gli algoritmi quantistici.

Il linguaggio Q# nasce con una forte integrazione con Microsoft Visual Studio e Visual Studio Code, e può simulare fino a 30 qubit localmente.

L’installazione è semplice, ed è ben spiegata nella documentazione. Dopo aver installato il .NET Core SDK 2.0, si può procedere all’installazione da riga di comando del Quantum Development Kit:

dotnet new -i "Microsoft.Quantum.ProjectTemplates::0.3.1810.2508-preview"

Nella documentazione si può trovare moltissimo materiale interessante (anche per coloro che muovono i primi passi nel mondo del quantum computing), e tanti esempi per testare i primi programmi quantistici. Come per gli altri framework, vediamo un programma di esempio per la generazione di numeri casuali in Q#:

// random number generator circuit in QDK
operation random (count : Int, initial: Result) : (Int, Int)
{
  body
  {
      mutable numOnes = 0;
      using (qubits = Qubit[1])
      {
          for (test in 1..count)
         {
             Set(initial, qubits[0]);
             H(qubits[0]);
             let res = M(qubits[0]);
             // count the number of ones
             if (res == One)
             {
                 set numOnes = numOnes+1;
             }
         }
         Set(Zero, qubits[0]);
     }
     // return statistics
     return (count - numOnes, numOnes);
  }
}

La sintassi del Q# è molto differente dagli altri linguaggi che abbiamo visto negli altri framework. E’ sicuramente più familiare agli sviluppatori che conoscono il C#, ed è molto più verboso del Python. I file che contengono codice Q# hanno estensione .qs. Può essere conveniente utilizzare come editor di codice per il Q#, il Microsoft Visual Studio Code che è un editor multi piattaforma (macOS, Linux e Windows).

E’ interessante notare come il QDK fornisca un livello di astrazione dall’hardware molto elevato: consente allo sviluppatore di concentrarsi esclusivamente sugli algoritmi quantistici, ignorando totalmente i dettagli di basso livello.

Oltre al simulatore locale, è anche possibile una simulazione di più di 40 qubit utilizzando una sottoscrizione ai servizi di Microsoft Azure.

Conclusioni

Arrivati a questo punto, penso di aver fornito abbastanza materiale per iniziare un approfondimento in ciascuna delle piattaforme, provando a scaricare ed installare i framework ed iniziando a scrivere il codice. In breve tempo si riuscirà ad eseguire i primi programmi quantistici su dispositivi reali come quelli di IBM e Rigetti Computing, ma anche a testare i propri esperimenti nei vari simulatori disponibili.

Come consiglio finale, mi sento di dire che, per coloro che hanno il quantum computing come obiettivo principale del loro studio, l’utilizzo di Qiskit (e ProjectQ) o di pyQuil sono le scelte consigliate.