Com programar un ordinador quàntic - 2a part

Naus de guerra amb mesures quàntiques

IBM Research https://www.flickr.com/photos/ibm_research_zurich/33072160062/

Aquest article té la part 2 del títol per una bona raó. Hi va haver una primera part, en què es va analitzar la base de l'escriptura i la realització de programes quàntics.

Suposo que heu llegit almenys la primera meitat abans d’arribar aquí.

La majoria dels coneixements de codificació reals necessaris per a aquest tutorial es van cobrir l'última vegada. Aquest article es centrarà principalment en algunes de les coses que podem fer amb aquestes ordres.

Com mirar els codis

Als programes tenim variables. En algun moment haurem de mirar-los.

Això podria ser al final del programa quan obtinguem el resultat. També podria ser durant el programa quan utilitzem la variable com a part d’una sentència condicional. De qualsevol forma, passa molt. I quan es programen variables no quàntiques, es tracta d’un procés força poc marcable.

Això és degut a que les variables que no són quàntiques tenen valors definits. Mirar-los només ens indica, o altres parts del programa, quin és el valor. Res sobre la variable en si canviarà.

Això no és cert amb les variables quàntiques, que poden tenir valors indefinits. Poden estar en una anomenada superposició quàntica, que els permet mantenir diversos valors contradictoris alhora.

Quan els mirem, han de renunciar a tota aquesta estranya. Es veuen obligats a prendre un valor definit i, a continuació, ens diuen què és aquest valor. Com que no es tracta només d’un procés passiu, cal tenir una consideració acurada. I necessita un nom. L’anomenem mesura.

En aquest article explorarem algunes de les propietats de la mesura. També l’utilitzarem com a base d’un mecànic de jocs i veurem exactament com programar-lo en un ordinador quàntic. Al final, tindrem una nova versió de Battleships.

Cartografiar el món d'un qubit

Abans de començar a mesurar qubits, hauríem d’intentar comprendre una mica més el seu món. La millor manera de visualitzar un qubit és usant una esfera. Qualsevol estat de qubit possible correspon a un punt de la superfície d’aquesta esfera.

Els estats 0 i 1 són completament diferents, completament disjunts. Són els oposats els uns dels altres. Per tant, viuran en els costats oposats de l'esfera. Solem escollir posar 0 al pol nord i 1 al sud.

Triem un punt equidistant entre els dos, en algun lloc al llarg de l'equador. Pot ser a qualsevol lloc que vulgueu. L’anomenarem +. Per què +? Perquè no?

L’estat + també té un contrari, tan diferent com el que és 0 a 1. Això viu al costat oposat, que també serà un punt al llarg de l’equador. Anomenarem aquest estat -.

Amb els punts 0, 1, + i - ara definits, un altre parell de punts demanen la nostra atenció. Aquests són els equidistants entre 0 i 1, i també equidistants entre + i -. Els anomenarem ↻ i ↺. Per què? Perquè una vegada vaig veure un tipus que no va escriure The Da Vinci Code fent-ho, i em va agradar.

Ara hem mapejat el món del qubit amb sis punts. Aquests no són els únics que utilitzarem mai. Simplement són les fites per on navegarem.

Mesura d'un qubit

Qualsevol mesura és simplement nosaltres demanant un qubit que triï entre dos punts oposats de l’esfera.

L’exemple clàssic és per al nostre parell d’estats oposats preferits: 0 i 1. Demanem al qubit que triï entre tots dos. Si ja es trobava a l'estat 0, es procedirà per 0. Un qubit a l'estat 1 donarà el resultat de manera similar 1. Per a qualsevol altre estat, el resultat serà aleatori, sent l'opció més propera la més probable.

A l'equador, és 50/50 l'oportunitat de qualsevol manera. De manera que si el nostre estat era + o - i ens preguntem si és 0 o 1, haurà d’escollir un o l’altre amb igual probabilitat.

La mesura basada en 0 i 1 té uns quants noms. Podem anomenar-la mesura 0/1, per raons òbvies. També s’anomena mesura de base Z, a causa de la relació especial que els estats 0 i 1 tenen amb una operació anomenada z. Més informació sobre aquesta història una altra vegada.

El següent tipus de mesurament més popular és el de + i -. Anomenaré a això una mesura +/-, però també podeu veure que es diu una mesura de base X. Funciona de la mateixa manera que abans, però només per a + i - en lloc de 0 i 1. Així que si comenceu amb un qubit a l'estat + i feu aquesta mesura, obtindreu el resultat +. Però si comenceu amb 0 i feu la mateixa pregunta, escollireu de forma aleatòria.

També tenim una mesura per a les coses estranyes de la fletxa. A això s’anomena mesura de base Y. A ningú li agraden les mesures de base Y.

Una mica és només una mica, fins i tot quan és quàntic

La mesura d'objectes no quàntics és un procés passiu. Et diu què està fent l'objecte, però no el canvia de cap manera. Mesurar les coses quàntiques és molt diferent. Les mesures quàntiques no canvien només el nostre coneixement sobre les variables. Canvien les variables ells mateixos.

Suposem que teniu un qubit a l'estat + i, a continuació, pregunteu-lo si és 0 o 1. Quan us dóna un resultat aleatori, no us voleu deixar de banda. No us diu res de tonteries perquè us heu fet una pregunta errònia. Un cop us doni un resultat, s’hi enganxarà. El seu valor canviarà per reflectir la resposta. Si us indica 0, serà 0 per sempre (o fins que torneu a embolicar-lo amb, almenys). S'oblidarà que sempre va ser +.

Això significa que un qubit només pot estar segur del seu resultat a una única mesura. Si sap definitivament si és 0 o 1, no és completament insegur si és + o -, i també és completament insegur si és it o ↺. Un qubit només té una quantitat limitada de certesa, limitada pel principi d’incertesa de Heisenberg.

Això vol dir que només aconseguim un cop d’obtenir informació des d’un qubit. Un cop extret un únic resultat binari, s’oblida tot el qubit que s’havia sabut abans de la mesura. Només recorda el resultat que ens va donar. Per tant, malgrat el nombre infinit d’estats de qubit possibles, només podem extreure un sol tros d’informació. És per això que la pensem com la versió quàntica d’un bit, més que no pas un vector float quàntic o quantum 3, etc.

El mecànic de joc

Anem a fer una variant de cuirassats en què hi haurà dos tipus d’atac: bombes i torpedes. Només caldrà un atac amb èxit per enfonsar un vaixell, però no sempre és tan fàcil aconseguir un atac amb èxit. Alguns vaixells tenen una defensa tan gran contra els avions que mai cap bomba s'aproparà a ells. Altres són fantàstics en repel·lir torpedes.

Per implementar-ho en un ordinador normal, podríem definir dues variables booleanes per a cada vaixell. Un ens diria si el vaixell és immune a les bombes i l’altre als torpedes. A continuació, es poden comprovar durant els atacs per veure si el vaixell s’enfonsa o no.

Si aquesta fos la implementació que utilitzem, en teoria podria ser que un vaixell sigui immune als dos tipus d’atac. Això seria un disseny de joc deficient, ja que fa impossible guanyar un jugador. Una bona implementació caldria evitar que hi hagi vaixells indestructibles.

Una forma d’evitar fer aquests vaixells és amb algunes simples línies de codi. No és realment el nostre estil. En canvi, ho solucionarem amb la mecànica quàntica.

Concretament, intentarem esprémer aquests dos booleans en un sol qubit. Com que no s’ajustaran prou, tindrem un comportament quàntic interessant. Això permetrà afegir una jugabilitat interessant al joc, a més d’evitar que qualsevol vaixell sigui indestructible.

Ho implementarem associant un atac amb una bomba a 0/1. Si obtenim el resultat 1, diem que el vaixell s’ha enfonsat. Per a 0 deduïm que la nau és immune als atacs amb bombes. En el cas dels torpedes, fem una mesura de +/-, implicant destrucció i + implicant immunitat.

Aquest mètode fa impossible que un vaixell sigui definitivament immune als dos tipus d’atac. Si ens assabentem que un vaixell enemic és immune a les bombes (és a dir, el seu estat és 0), sabem que ha d’ésser completament incert sobre els torpedes (el resultat d’una mesura +/-). Com que un atac amb bomba certament fallaria, hauríem d’atacar amb torpedes al costat.

Aleshores, pot resultar que l’atac de la torpeda falla (l’estat es converteix en + després de la mesura +/-). El vaixell decidiria que definitivament és immune a ells, i qualsevol altre atac de torpedes fallaria. Però no es perd tota esperança. En prendre certesa sobre els torpedes, s'ha tornat insegur sobre les bombes. Atacar amb ells (fer una mesura de 0/1) podria donar lloc a la victòria.

Si l’atac amb bomba no té èxit, tornem als torpedes, etc. La millor tàctica és seguir canviant entre tots dos fins que finalment la nau s’enfonsa.

Començarem les naus com a insegurs sobre la seva immunitat als dos atacs. Això es pot fer inicialitzant el qubit en un dels estats de base Y. Anem per ↻. En realitat, és un estat que vam trobar a la primera part, és a dir, u3 (0,5 * pi, 0,0) 0, per la qual cosa ja sabem com fer-ho.

Fer front a qubits de curta durada

Implementar el joc en un processador quàntic no serà tan fàcil com podríem esperar. Farem una ullada a tots els problemes que es plantejaran en el nostre camí i veurem com evitar-los.

Suposem que un vaixell és atacat per una bomba i sobreviu. A la següent ronda és atropellat per un torpedo.

Si el joc es pogués executar en un ordinador normal i es simulés amb bits normals, la seva implementació seria molt senzilla. El vaixell s’inicialitzaria quan s’iniciés el joc i, després, s’esperava a la memòria fins que el jugador decideixi què fer amb ell. Un cop el jugador envia una bomba, s’aplicarien les operacions corresponents per veure si es destrueix. Si sobreviu, torna a esperar fins al següent atac.

Això no servirà per a nosaltres. Els Qubits no poden seure-hi a l’espera d’esperar calendaris humans. Uns segons són un temps més que suficient per a que caiguin i es cremin, almenys amb la tecnologia actual.

L’alternativa és executar un nou procés quàntic cada cop que es faci un atac. El primer treball s’inicialitzarà amb l’estat ↻, de manera que els resultats seran aleatoris tant per a una mesura 0/1 (atac de bomba) com per a una mesura de +/- (atac de torpedes). El resultat de la mesura es guarda i es guarda a la memòria a l'ordinador normal. Quan es produeix el següent atac, es crea un altre treball per veure què passa. S’inicialitzarà amb el resultat de l’última mesura, i així continua.

Feu una mesura +/-

Fins ara he escrit un munt de paraules, però no una sola línia de codi. Comencem recordant com s’implementa una mesura 0/1 en codi QASM.

mesura q [0] -> c [0];

El paper de c [0] aquí és important revisar. És la sortida del procés de mesurament. És el bit normal on es guarda el resultat de la mesura. Per a una mesura 0/1, el resultat és 0 o 1.

Tot això és bastant senzill per a una mesura de 0/1. Però ara estem analitzant les mesures +/-. Com obtenim la informació d’una d’elles?

Encara voldrem emmagatzemar el resultat en un bit normal c [0]. Com que és un bit normal, no té coneixement dels estats estranys + i -. Només coneix el binari normal. Per tant, optem per informar del resultat + com c [0] = 0, i - com c [0] = 1. El fet que semblin iguals als resultats d’una mesura 0/1 no serà cap problema. Com en qualsevol programa informàtic, hauríem de saber què hem programat i, per tant, hauríem de saber interpretar els resultats.

Ara sabem com treure els resultats d’una mesura +/-. Però encara no hem sabut com fer-ne un. Això és degut a què hem de ser esperpèntics. Hem de piratejar el procés que fa les mesures 0/1 i fer-lo fer un +/- al seu lloc.

La clau del nostre hack és una operació anomenada Hadamard. Aplicant això a un qubit q [0] en codi QASM s’assembla així.

hq [0];

La comanda que fem servir a Python per afegir aquesta línia a un fitxer QASM anomenat gridScript és

gridScript.h (q [0])

L’efecte de l’Adamamard és canviar els estats de base Z amb els de base X i viceversa. És una rotació de l’Esfera que mou els gires un estat de qubit 0 a a +, i + a 0. De la mateixa manera, 1 es gira a - i viceversa.

Això significa que la història que podem explicar sobre un qubit en termes de 0 i 1 abans de l’Adamamard, hem d’explicar amb + i - després d’ella. I qualsevol història de + i - esdevé un de 0 i 1.

Això és exactament el que necessitem. Significa que es pot fer una mesura +/- en un qubit q [0] mitjançant el següent codi QASM.

hq [0]; mesura q [0] -> c [0]; hq [0];

Per veure per què funciona això, anem a través d’uns quants exemples. El qubit q [0] es començarà a declarar recentment en cadascun, i també serà el valor inicial predeterminat de 0.

Exemple Zero:

mesura q [0] -> c [0];

El qubit comença a l'estat 0. Es pregunta si és 0 o 1 i indica a c [0] la resposta. El resultat sempre serà c [0] = 0.

Exemple 1:

xq [0];
mesura q [0] -> c [0];

El qubit s’inicia a l’estat 0 i després es torna a girar a 1. Es demana si és 0 o 1. Sempre contesta 1.

Exemple +:

hq [0];
mesura q [0] -> c [0];

El qubit s'inicia a l'estat 0 i es gira immediatament a +. Aleshores, es pregunta si el seu estat és 0 o 1. Es tria aleatòriament un o un altre, i el seu estat s’actualitza amb la resposta.

Ara hem fet uns quants exemples trivials, fem una cosa més complexa.

Exemple ++:

hq [0];
hq [0]; mesura q [0] -> c [0]; hq [0];

El qubit s'inicia a l'estat 0 i després es gira a +. Després d’això, hi ha dues maneres equivalents de poder continuar la història.

Una és dir que les tres línies finals fan col·lectivament una mesura +/-. Pregunten al qubit si és + o -. Per a + retornen el resultat c [0] = 0, i per a - tornen c [0] = 1. Com que el qubit entra en la mesura amb estat + en aquest exemple, sempre es mesura com a +. Per tant, surt de la mesura encara en aquest estat.

Per a l’altra història, mirem els efectes de les línies d’una en una. El segon Hadamard anul·la l'efecte del primer, de manera que gira el qubit cap a l'estat 0. A continuació, se li demana si el seu estat és 0 o 1, i així sempre respon 0. Un altre Hadamard el torna a girar cap a +.

Ambdues històries coincideixen en els efectes observables. Acorden que la sortida c [0] sempre serà 0, i estan d’acord que l’estat de qubit al final serà +. Simplement estan en desacord sobre com va passar. Les dues interpretacions són igualment vàlides.

Si voleu que algun argot expliqui coses a la Viquipèdia, aquests són exemples de les imatges de Schrödinger i Heisenberg sobre mecànica quàntica.

Exemple +1:

xq [0];
hq [0]; mesura q [0] -> c [0]; hq [0];

Aquí hi ha un altre exemple per al qual tenim dues històries equivalents. Podem dir que q [0] comença com a 0 i es torna a girar a 1. Tot seguit es gira a t0 abans de passar per una mesura 0/1. Decideix aleatòriament un o altre, dóna la sortida c [0] = 0 o c [0] = 1 i té el seu estat actualitzat en conseqüència. Si ho decidís 0, l'Adamard final el converteix a +. En cas contrari, acabarà com -.

Alternativament, podríem dir que després de girar a 1, el qubit passa per una mesura +/-. Decideix de forma aleatòria entre aquestes dues opcions, donant la sortida c [0] = 0 per a + i c [0] = 0 per a -. L'estat s'actualitza en conseqüència, acabant en l'estat + o -.

De nou, aquestes dues històries són igualment vàlides i coincideixen en tots els efectes observables. Si volem pensar en les tres línies

hq [0]; mesura q [0] -> c [0]; hq [0];

com a mesura de +/-, som lliures. Si volem pensar-ho com un Hadamard seguit d’una mesura de 0/1 seguida d’un Hadamard, també està bé.

Hi ha una cosa important a tenir en compte abans de seguir endavant. L’API d’IBM actualment no ens permet fer res a un qubit després d’haver-lo mesurat. Aquesta no és una regla general per als ordinadors quàntics. Normalment esperem poder seguir mesurant i manipulant qubits durant el temps que desitgem. Però de moment no ho podem fer.

Això no ens planteja cap problema. Com que els quits no es poden asseure mentre els jugadors decideixen de totes maneres, ja hem de recrear completament l'estat després de cada ronda de mesurament. El segon Hadamard apareixerà eficaçment en el proper treball, actuant sobre la versió reencarnada de l'estat.

Totes les altres mesures possibles es poden aconseguir amb hacks similars. Només hem de fer algunes operacions prèviament per detectar la mesura alternativa, i després (si l'API ho permet) fer les operacions contràries just després.

Fer front als errors

La tecnologia quàntica actual no és perfecta. Els codis no sempre fan el que haurien. Si el vostre qubit és 0 i feu una mesura 0/1, el resultat sempre ha de ser 0. Sempre. Però amb els dispositius quàntics actuals, hi ha una probabilitat que sigui 1. Podria ser perquè una operació x s’enredés mentre no estàvem buscant. Pot ser perquè la mesura ens menteix. Es poden produir fets com aquests, però succeeixen.

Hi ha dues maneres de tractar els errors. Un és ignorar-los. Els podem escriure a la narració del joc. Hi ha grans tempestes sobre el mar. De vegades, aquests aconsegueixen que un vaixell sigui destruït per un atac, encara que sigui immune. O sobreviure a un atac que l'hauria d'haver destruït.

La segona manera de fer front als errors és intentar eliminar els seus efectes. Si hi hagués molts codis disponibles, podríem fer-ho amb la correcció quàntica d'errors. Malauradament, encara queden uns quants anys.

En canvi, farem algunes estadístiques. Per això necessitem probabilitats, les quals aconseguim executant cada treball moltes vegades i veiem amb quina freqüència es produeix cada resultat possible.

En el cas silenciós, les probabilitats serien del 0%, 100% o 50%. Un resultat és o bé impossible (com obtenir un 1 si l'estat és 0), cert (com obtenir un + si l'estat és +) o completament aleatori (com obtenir un 0 quan l'estat és +).

El soroll ens embolicarà una mica. Quan fem una mesura 0/1 de 0, podríem trobar que el resultat 0 es produeix només el 98% del temps, i el 2% passaria per 1. Per corregir això farem alguna cosa bastant arbitrari. Decidirem que qualsevol cosa amb menys d’un 5% de probabilitat no hauria d’haver passat mai. Qualsevol cosa amb més d’un 95% de probabilitat hauria d’haver estat segura.

Posant-ho tot junt

Aquest article ha tractat els grans passos del mecànic del joc per a aquesta versió de Battleships, i com implementar-lo amb un ordinador quàntic. En lloc de recórrer tots els detalls aquí, el deixo per als comentaris del codi font real.

Si creieu que necessiteu més informació, no dubteu en comunicar-me.