Circuits Quàntics
En aquest tutorial, cobrirem els fonaments dels circuits quàntics, que són els blocs de construcció fonamentals de la computació quàntica. També mostrarem com fer servir QiliSDK per construir i simular un circuit quàntic simple.
Què és un Circuit Quàntic?
En la computació clàssica, tenim portes lògiques que operen sobre bits per realitzar càlculs. Podríem començar amb tots els nostres bits en l’estat 0, i llavors apliquem una sèrie de portes lògiques (p. ex. AND, OR, NOT) per manipular aquests bits i realitzar algun càlcul. En la computació quàntica, en canvi tenim portes quàntiques que operen sobre qubits per realitzar càlculs.
La majoria dels circuits quàntics tenen un aspecte similar al següent:
En aquest cas particular, tenim un circuit quàntic amb 2 qubits: \(q_0\) i \(q_1\). Les línies horitzontals representen els qubits, i les caixes i altres símbols representen les portes quàntiques que operen sobre aquests qubits.
La primera porta que apliquem és una porta Hadamard (H) sobre \(q_0\), que la posa en una superposició d’estats. Llavors apliquem una porta CNOT, que entrellaça \(q_0\) i \(q_1\). Finalment, mesurem ambdós qubits.
Què Són les Portes Quàntiques?
Llavors, què fan exactament aquestes portes? Una manera de representar tals operacions quàntiques és a través de la seva representació matricial. En convertir l’estat dels nostres qubits en un vector, podem representar les portes quàntiques com a matrius que actuen sobre aquests vectors per produir nous estats. Per convertir el nostre estat en un vector, podem fer servir la base computacional, on \(|0⟩\) es representa com el vector \(\begin{pmatrix} 1 \\ 0 \end{pmatrix}\) i \(|1⟩\) es representa com el vector \(\begin{pmatrix} 0 \\ 1 \end{pmatrix}\).
Quan tenim múltiples qubits, podem fer servir el producte tensorial com es va mencionar al tutorial anterior per representar l’estat del sistema com un vector en un espai de dimensió superior. Per tant, si tenim dos qubits, podem representar l’estat inicial \(|00⟩\) com el vector:
La nostra porta Hadamard (H) es pot representar com la matriu:
Ara volem fer l’operació \(H|00⟩\), però observeu que la nostra porta Hadamard és una matriu 2x2, mentre que el nostre estat és un vector de 4 dimensions. Per aplicar la porta Hadamard al nostre estat de dos qubits, primer hem de prendre el producte tensorial de la porta Hadamard amb la matriu identitat per crear una matriu 4x4 que pugui operar sobre el nostre vector d’estat de 4 dimensions. La matriu identitat és:
Per tant, podem representar l’operació d’aplicar la porta Hadamard al primer qubit com:
Si finalment realitzem l’operació \((H \otimes I)|00⟩\), obtenim:
Això és exactament el que esperaríem, ja que la porta Hadamard posa el primer qubit en una superposició d’estats, mentre deixa el segon qubit sense canvis.
Es pot realitzar un procés similar per a totes les diferents portes i combinacions de portes, i és així com podem entendre i simular el que cada porta farà al nostre estat quàntic.
Observeu que amb un únic qubit teníem un vector de dimensió 2, mentre que amb dos qubits tenim un vector de dimensió 4. En general, la mida del nostre vector d’estat creix exponencialment amb el nombre de qubits, de manera que si tinguéssim 20 qubits necessitaríem vectors de mida 1.048.576, per la qual cosa hauria de quedar clar per què simular circuits quàntics en ordinadors clàssics pot tornar-se difícil ràpidament.
Què Fa Cada Porta Quàntica?
Acabem de veure com es comporta la porta Hadamard, però quines altres portes podem fer servir en circuits quàntics? Aquí llistem totes les portes quàntiques més comunes, el seu comportament i les seves representacions matricials.
Nota
No us preocupeu per memoritzar res aquí, però és bo tenir una idea vaga d’alguns dels noms i comportaments.
Nom/s de la Porta |
Descripció |
Representació Matricial |
|---|---|---|
X |
Inverteix l’estat d’un qubit: \(|0⟩\) a \(|1⟩\) i \(|1⟩\) a \(|0⟩\) |
\(\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\) |
Y |
Inverteix l’estat d’un qubit i aplica un desplaçament de fase: \(|0⟩\) a \(i|1⟩\) i \(|1⟩\) a \(-i|0⟩\) |
\(\begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix}\) |
Z |
Aplica un desplaçament de fase de -1 a l’estat \(|1⟩\), deixant l’estat \(|0⟩\) sense canvis |
\(\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}\) |
H, Hadamard |
Crea superposicions: \(|0⟩\) a \(\frac{1}{\sqrt{2}}(|0⟩ + |1⟩)\) i \(|1⟩\) a \(\frac{1}{\sqrt{2}}(|0⟩ - |1⟩)\) |
\(\frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}\) |
S |
Aplica un desplaçament de fase de \(i\) a l’estat \(|1⟩\), deixant l’estat \(|0⟩\) sense canvis |
\(\begin{pmatrix} 1 & 0 \\ 0 & i \end{pmatrix}\) |
T |
Aplica un desplaçament de fase de \(e^{i\pi/4}\) a l’estat \(|1⟩\), deixant l’estat \(|0⟩\) sense canvis |
\(\begin{pmatrix} 1 & 0 \\ 0 & e^{i\pi/4} \end{pmatrix}\) |
RX |
Una rotació d’un sol qubit al voltant de l’eix X de l’esfera de Bloch per un angle \(θ\) |
\(\begin{pmatrix} \cos(\frac{θ}{2}) & -i\sin(\frac{θ}{2}) \\ -i\sin(\frac{θ}{2}) & \cos(\frac{θ}{2}) \end{pmatrix}\) |
RY |
Una rotació d’un sol qubit al voltant de l’eix Y de l’esfera de Bloch per un angle \(θ\) |
\(\begin{pmatrix} \cos(\frac{θ}{2}) & -\sin(\frac{θ}{2}) \\ \sin(\frac{θ}{2}) & \cos(\frac{θ}{2}) \end{pmatrix}\) |
RZ |
Una rotació d’un sol qubit al voltant de l’eix Z de l’esfera de Bloch per un angle \(θ\) |
\(\begin{pmatrix} e^{-i\frac{θ}{2}} & 0 \\ 0 & e^{i\frac{θ}{2}} \end{pmatrix}\) |
CNOT, CX |
Una porta de dos qubits que inverteix el segon qubit si el primer qubit és \(|1⟩\) |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}\) |
CZ |
Una porta de dos qubits que aplica un desplaçament de fase de -1 a l’estat \(|11⟩\), deixant els altres estats sense canvis |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & -1 \end{pmatrix}\) |
SWAP |
Una porta de dos qubits que intercanvia els estats dels dos qubits |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{pmatrix}\) |
Portes Controlades Genèriques |
Una versió controlada d’una porta genèrica U, de manera que U actua sobre el segon qubit únicament si el primer qubit és \(|1⟩\) |
\(\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & U_{00} & U_{01} \\ 0 & 0 & U_{10} & U_{11} \end{pmatrix}\) |
Toffoli |
Una porta de tres qubits que inverteix el tercer qubit si els dos primers qubits són ambdós \(|1⟩\) |
\(\begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \end{pmatrix}\) |
Com Podem Simular Aquests Circuits?
Nota
Si no teniu QiliSDK instal·lat i voleu executar els exemples següents vosaltres mateixos, podeu seguir les instruccions de la guia d’instal·lació.
Ara que entenem què són els circuits quàntics i què fan les portes quàntiques, podem fer servir QiliSDK per construir i simular els nostres propis circuits quàntics. Per crear un circuit quàntic a QiliSDK, podem fer servir la classe Circuit:
from qilisdk.digital import Circuit
circuit = Circuit(2)
Això crea un circuit quàntic amb 2 qubits. Llavors podem afegir portes al nostre circuit:
from qilisdk.digital import H, CNOT
circuit.add(H(0))
circuit.add(CNOT(0, 1))
I finalment també hauríem d’afegir algunes mesures:
from qilisdk.digital import M
circuit.add(M(0))
circuit.add(M(1))
Això dóna com a resultat el circuit que vam mostrar al principi d’aquest tutorial, que crea una superposició en el primer qubit, l’entrellaça amb el segon qubit i llavors mesura ambdós qubits.
If we want to simulate this circuit, we can use the QiliSim backend. To tell the simulator that we want to simulate a circuit we use the the DigitalPropagation class and then use the Readout class to specify how we want to read out our results:
from qilisdk.backends import QiliSim
from qilisdk.functionals import DigitalPropagation
from qilisdk.readout import Readout
backend = QiliSim()
result = backend.execute(DigitalPropagation(circuit), Readout().with_sampling(nshots=100))
print(result.get_samples())
Això executarà el nostre circuit al simulador QiliSim, com si haguéssim executat el nostre circuit quàntic 100 vegades i registrat totes les nostres mesures. La sortida d’això serà un diccionari de mostres, on cada clau és una cadena que representa els resultats de mesura per a cada qubit, i cada valor és el nombre de vegades que aquell resultat va ser observat:
{
'00': 49,
'11': 51
}
Com podeu veure, obtenim nombres aproximadament iguals de resultats “00” i “11”, que és el que esperaríem del nostre circuit. Observeu que no és exactament 50/50 ja que estem mostrejant d’una distribució aleatòria, però a mesura que augmentem el nombre de mostres hauríem de veure com s’aproxima cada vegada més a 50/50.
Aquí hem fet servir un simulador per executar el nostre circuit, però també podríem executar-lo en un ordinador quàntic real. Per fer-ho, podeu fer servir SpeQtrum, el sistema per accedir al maquinari quàntic de Qilimanjaro, que està disponible a través de QiliSDK. Podeu trobar més informació sobre com fer-ho a la guia del mòdul SpeQtrum.