Linguaggi di programmazione per il Quantum Computing: un viaggio tra Qiskit, Cirq, Q#, ed altri meno famosi.

texservice13
7 apr
Tempo di lettura: 3 min

Il post che segue esplora come diversi linguaggi di programmazione per il quantum computing affrontano lo stesso problema — l’implementazione della Quantum Fourier Transform (QFT) — con approcci differenti sia a livello sintattico che filosofico.

La scelta del linguaggio quantistico da adottare dipende da diversi fattori: le esigenze specifiche del progetto, il livello di astrazione desiderato, il tipo di hardware target e la familiarità con l’ecosistema di riferimento.

Partendo dal mio post precedente sulla QFT, mi concentro qui sull’implementazione minimalista di questo algoritmo, così da evidenziare le differenze tra i linguaggi più utilizzati.

Prima, però, una nota importante: le “porte logiche” nel quantum computing sono astrazioni di complesse interazioni fisiche che manipolano lo stato dei qubit — interazioni che coinvolgono laser, microonde, campi magnetici, temperature criogeniche, ecc. In questo contesto, la QFT rappresenta un algoritmo fondamentale e altamente simbolico, ideale per confrontare gli approcci dei vari framework quantistici.

📌 Struttura comune degli esempi:

Creazione di uno stato indeterminato (Hadamard)
Applicazione della QFT
Misurazione (collasso della funzione d’onda)

Gli esempi sono volutamente semplici per mettere in risalto le differenze strutturali tra i linguaggi, più che le performance o le funzionalità avanzate.

🔹 1. Qiskit (by IBM)

Qiskit è probabilmente il framework più diffuso. Basato su Python e sviluppato da IBM, permette di costruire, simulare ed eseguire circuiti quantistici sia in simulazione che su hardware reale IBM Quantum. È modulare: consente di lavorare a basso livello, ma offre anche strumenti avanzati per quantum machine learning e chimica quantistica.

📌 Punto di forza: Ottima documentazione e una community molto attiva📌 Ideale per: Sviluppatori Python, studenti, ricercatori accademici

from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit.library import QFT

qc = QuantumCircuit(3, 3)
qc.h([0, 1, 2])
qc.append(QFT(3), [0, 1, 2])
qc.measure([0, 1, 2], [0, 1, 2])

sim = Aer.get_backend('qasm_simulator')
result = execute(qc, sim, shots=1024).result()
print(result.get_counts())

🔸 2. Cirq (by Google)

Cirq, sviluppato da Google, è anch’esso basato su Python ma con un focus più marcato sull’esecuzione di algoritmi su dispositivi NISQ (Noisy Intermediate-Scale Quantum). È molto vicino all’hardware e offre grande controllo sulle operazioni quantistiche.

📌 Punto di forza: Controllo granulare sui circuiti📌 Ideale per: Ricercatori, sviluppatori orientati agli esperimenti su hardware reale

import cirq
import numpy as np

qubits = [cirq.LineQubit(i) for i in range(3)]
circuit = cirq.Circuit()
circuit.append(cirq.H.on_each(*qubits))

def qft_cirq(qs):
    n = len(qs)
    c = cirq.Circuit()
    for i in range(n):
        c.append(cirq.H(qs[i]))
        for j in range(i+1, n):
            angle = np.pi / (2 ** (j - i))
            c.append(cirq.CZ(qs[j], qs[i])**(angle / np.pi))
    return c

circuit += qft_cirq(qubits)
circuit.append(cirq.measure(*qubits, key='result'))

sim = cirq.Simulator()
result = sim.run(circuit, repetitions=1000)
print(result.histogram(key='result'))

🔹 3. Q# (by Microsoft)

Q# è un linguaggio quantistico standalone, parte del Quantum Development Kit di Microsoft. Non è un’estensione di un linguaggio classico, ma è progettato specificamente per la programmazione quantistica, con un forte sistema di tipi e supporto integrato per concetti come entanglement e misurazioni.

📌 Punto di forza: Linguaggio nativo quantistico, tipizzazione forte📌 Ideale per: Sviluppatori .NET, team enterprise, integrazione con Azure Quantum

operation QFTExample() : Result[] {
    use q = Qubit[3];
    ApplyToEach(H, q);
    QFT(q);
    mutable results = new Result[3];
    for (i in 0..2) {
        set results w/= i <- M(q[i]);
    }
    ResetAll(q);
    return results;
}

🔸 4. Ocean (by D-Wave)

Ocean è un insieme di tool progettati per lavorare con i computer quantistici ad annealing di D-Wave, focalizzati su problemi di ottimizzazione combinatoria. Non usa porte logiche né implementa direttamente algoritmi come la QFT, ma possiamo costruire esempi concettualmente affini.

📌 Punto di forza: Eccellente per problemi di ottimizzazione📌 Ideale per: Aziende e casi d’uso industriali

from dwave.system import DWaveSampler, EmbeddingComposite
from dimod import BinaryQuadraticModel

bqm = BinaryQuadraticModel({}, {('a', 'b'): -1}, 0.0, 'BINARY')
sampler = EmbeddingComposite(DWaveSampler())
sampleset = sampler.sample(bqm, num_reads=1000)
print(sampleset.aggregate())

🔹 5. PennyLane (by Xanadu)

PennyLane è un framework orientato all’apprendimento automatico quantistico e agli algoritmi ibridi quantum-classical. Supporta back-end multipli come Qiskit, Cirq, Braket, ecc. e consente di costruire modelli differenziabili.

📌 Punto di forza: Focus su quantum machine learning📌 Ideale per: Ricercatori in AI quantistica, sviluppatori ibridi

import pennylane as qml
from pennylane import numpy as np

dev = qml.device("default.qubit", wires=3, shots=1000)

@qml.qnode(dev)
def circuit():
    for i in range(3):
        qml.Hadamard(wires=i)
    qml.templates.QFT(wires=[0, 1, 2])
    return qml.sample(qml.PauliZ(0)), qml.sample(qml.PauliZ(1)), qml.sample(qml.PauliZ(2))

res = circuit()
print(res)

⚙️ Altri strumenti emergenti

Amazon Braket: piattaforma che consente di utilizzare diversi linguaggi e back-end tramite AWS.
QuTiP: potente toolkit per la simulazione di sistemi quantistici aperti, molto usato in ambito accademico.

#quantistica #divulgatoreinformatico