Compilazione automatica di circuiti quantistici

Una domanda recente qui ha chiesto come compilare il gate CCCZ a 4 qubit (controllato-controllato-controllato-Z) in semplici porte da 1 qubit e 2 qubit, e l'unica risposta data finora richiede 63 porte !

Il primo passo è stato quello di utilizzare la costruzione C n U di Nielsen & Chuang:$^n$

Con $n=3$ ciò significa 4 porte CCNOT e 3 porte semplici (1 CNOT e 2 Hadamards sono sufficienti per eseguire il CZ finale sul qubit target e l'ultimo qubit di lavoro).

Il teorema 1 di questo articolo , afferma che in generale il CCNOT richiede 9 porte da un qubit e 6 porte da due qubit (15 in totale):

Questo significa:

(4 CCNOT) x (15 gate per CCNOT) + (1 CNOT) + (2 Hadamards) = 63 gate totali .

In un commento , è stato suggerito che le 63 porte possano essere ulteriormente compilate usando una "procedura automatica", ad esempio dalla teoria dei gruppi automatici .

Come si può fare questa "compilazione automatica", e quanto ridurrebbe il numero di porte da 1 qubit e 2 qubit in questo caso?

Sia $g_1 \cdots g_M$ le porte di base che è consentito utilizzare. Ai fini del presente $\operatorname{CNOT}_{12}$ e $\operatorname{CNOT}_{13}$ ecc. Sono trattati separatamente. Quindi $M$ è polinomialmente dipendente da $n$ , il numero di qubit. La dipendenza precisa coinvolge i dettagli del tipo di gate che usi e di quanto siano $k$ -local. Ad esempio, se ci sono $x$ porte single qubit e $y$ porte 2-qubit che non dipendono da un ordine come $CZ$ allora .$M = xn+\binom{n}{2}y$

Un circuito è quindi un prodotto di quei generatori in un certo ordine. Ma ci sono più circuiti che non fanno nulla. Come . Quindi quelli danno relazioni sul gruppo. È una presentazione di gruppo cui vi sono molte relazioni che non conosciamo.$\operatorname{CNOT}_{12} \operatorname{CNOT}_{12} = \mathrm{Id}$ ⟨ g 1 ⋯ g M | R 1 ⋯ ⟩ $\langle g_1 \cdots g_M \mid R_1 \cdots \rangle$

Il problema che desideriamo risolvere è dato una parola in questo gruppo, qual è la parola più breve che rappresenta lo stesso elemento. Per presentazioni di gruppo generali, questo è senza speranza. Il tipo di presentazione di gruppo in cui è accessibile questo problema è chiamato automatico.

Ma possiamo considerare un problema più semplice. Se della , le parole di prima diventano della forma dove ciascuna delle sono parole solo nelle lettere rimanenti. Se siamo riusciti a renderli più brevi usando le relazioni che non coinvolgono , allora avremo ridotto l'intero circuito. Questo è simile all'ottimizzazione dei CNOT da soli realizzati nell'altra risposta.$g_i$$w_1 g_{i_1} w_2 g_{i_2} \cdots w_k$$w_i$$g_i$

Ad esempio, se ci sono tre generatori e la parola è , ma non vogliamo avere a che fare con , accorceremo invece e a e . Quindi li rimettiamo insieme come e questo è un accorciamento della parola originale.$aababbacbbaba$$c$$w_1=aababba$$w_2=bbaba$w 1 w 2 w 1 c w 2$\hat{w}_1$$\hat{w}_2$$\hat{w}_1 c \hat{w}_2$

Quindi WLOG (senza perdita di generalità), supponiamo di essere già in quel problema dove ora usiamo tutte le porte specificate. Ancora una volta questo probabilmente non è un gruppo automatico. Ma cosa succede se eliminiamo alcune delle relazioni. Quindi avremo un altro gruppo che ha una mappa quoziente fino a quella che vogliamo davvero.$\langle g_1 \cdots g_M \mid R_1 \cdots \rangle$

Il gruppo nessuna relazione è un gruppo libero , ma se metti come relazione, otterrai il prodotto gratuito e c'è una mappa quoziente dalla prima alla successiva che riduce il numero di in ciascun segmento modulo .$\langle g_1 g_2 \mid - \rangle$$g_1^2=\mathrm{id}$ $\mathbb{Z}_2 \star \mathbb{Z}$$g_1$$2$

Le relazioni che lanceremo saranno tali che quella al piano superiore (la fonte della mappa del quoziente) sarà automatica in base alla progettazione. Se usiamo solo le relazioni che rimangono e accorciano la parola, allora sarà comunque una parola più breve per il gruppo di quozienti. Semplicemente non sarà ottimale per il gruppo quoziente (la destinazione della mappa quoziente), ma avrà la lunghezza alla lunghezza con cui è iniziato.$\leq$

Questa era l'idea generale, come possiamo trasformarla in un algoritmo specifico?

Come scegliamo e le relazioni da eliminare per ottenere un gruppo automatico? È qui che entra in gioco la conoscenza dei tipi di cancelli elementari che usiamo di solito. Ci sono molte involuzioni, quindi mantieni solo quelle. Fai attenzione al fatto che queste sono solo le involuzioni elementari, quindi se il tuo hardware ha difficoltà a scambiare qubit che sono ampiamente separati sul tuo chip, questo li sta scrivendo solo in quelli che puoi fare facilmente e riducendo quella parola a essere il più corto possibile.$g_i$

Ad esempio, supponiamo di avere la configurazione IBM . Quindi sono le porte consentite. Se si desidera effettuare una permutazione generale, scomporla in fattori . Questa è una parola nel gruppo che vogliamo abbreviare .$s_{01},s_{02},s_{12},s_{23},s_{24},s_{34}$$s_{i,i+1}$$\langle s_{01},s_{02},s_{12},s_{23},s_{24},s_{34} \mid R_1 \cdots \rangle$

Si noti che queste non devono essere le involuzioni standard. Puoi aggiungere oltre a per esempio. Pensa al teorema di Gottesman-Knill , ma in modo astratto ciò significa che sarà più facile generalizzare. Come usare la proprietà che in sequenze esatte brevi, se si dispone di sistemi di riscrittura completi finiti per le due parti, si ottiene una per il gruppo centrale. Questo commento non è necessario per il resto della risposta, ma mostra come è possibile creare esempi più ampi e generali da quelli in questa risposta.$R(\theta) X R(\theta)^{-1}$$X$

Le relazioni che vengono mantenute sono solo quelle del modulo . Questo dà un gruppo Coxeter ed è automatico. In effetti, non dobbiamo nemmeno ricominciare da zero per codificare l'algoritmo per questa struttura automatica. È già implementato in Sage (basato su Python) in generale. Tutto quello che devi fare è specificare e l'implementazione rimanente è già stata eseguita. Potresti anche fare alcune accelerazioni.$(g_i g_j)^{m_{ij}} = 1$$m_{ij}$

$m_{ij}$ è davvero facile da calcolare a causa delle proprietà della località delle porte. Se le porte sono al massimo -local, allora il calcolo di può essere fatto su uno spazio di Hilbert dimensionale . Questo perché se gli indici non si sovrappongono, allora sai che . è per quando e pendolari. Devi anche calcolare solo meno della metà delle voci. Questo perché la matrice è simmetrica, ha sulla diagonale ( ). Inoltre, la maggior parte delle voci sta semplicemente rinominando i qubit coinvolti, quindi se conosci l'ordine di$k$$m_{ij}$$2^{2k-1}$$m_{ij}=2$$m_{ij}=2$$g_i$$g_j$$m_{ij}$$1$$(g_i g_i)^1 = 1$$(\operatorname{CNOT}_{12} H_1)$ , conosci l'ordine di senza il calcolo.$\operatorname{CNOT}_{37} H_3$

Ciò si è preso cura di tutte le relazioni che riguardavano solo due porte distinte (prova: esercizio). Le relazioni che coinvolgono o più sono state eliminate. Ora li rimettiamo dentro. Diciamo che ce l'abbiamo, quindi si può eseguire l'algoritmo goloso di Dehn usando nuove relazioni. Se c'è stato un cambiamento, lo facciamo tornare indietro per correre di nuovo attraverso il gruppo Coxeter. Questo si ripete fino a quando non ci sono cambiamenti.$3$

Ogni volta che la parola si accorcia o si mantiene la stessa lunghezza e stiamo usando solo algoritmi con comportamento lineare o quadratico. Questa è una procedura piuttosto economica, quindi potresti anche farlo e assicurarti di non aver fatto nulla di stupido.

Se vuoi provarlo tu stesso, indica il numero di generatori come , la lunghezza della parola casuale che stai provando e la matrice di Coxeter come .$N$$K$$m$

edge_list=[]
for i1 in range(N):
    for j1 in range(i):
        edge_list.append((j1+1,i1+1,m[i1,j1]))
G3 = Graph(edge_list)
W3 = CoxeterGroup(G3)
s3 = W3.simple_reflections()
word=[choice(list([1,..,N])) for k in range(K)]
print(word)
wTesting=s3[word[0]]
for o in word[1:]:
    wTesting=wTesting*s3[o]
word=wTesting.coset_representative([]).reduced_word()
print(word)

Un esempio con N=28e K=20, le prime due righe sono la parola non ridotta di input, le due successive sono la parola ridotta. Spero di non aver fatto un refuso quando si entra nella matrice .$m$

[26, 10, 13, 16, 15, 16, 20, 22, 21, 25, 11, 22, 25, 13, 8, 20, 19, 19, 14, 28]

['CNOT_23', 'Y_1', 'Y_4', 'Z_2', 'Z_1', 'Z_2', 'H_1', 'H_3', 'H_2', 'CNOT_12', 'Y_2', 'H_3', 'CNOT_12', 'Y_4', 'X_4', 'H_1', 'Z_5', 'Z_5', 'Y_5', 'CNOT_45']

[14, 8, 28, 26, 21, 10, 15, 20, 25, 11, 25, 20]

['Y_5', 'X_4', 'CNOT_45', 'CNOT_23', 'H_2', 'Y_1', 'Z_1', 'H_1', 'CNOT_12', 'Y_2', 'CNOT_12', 'H_1']

Riportando indietro quei generatori come ripristiniamo solo le relazioni come e che commuta con porte che non implicano qubit . Questo ci consente di effettuare la decomposizione prima di avere la più a lungo possibile. Vogliamo evitare situazioni come . (In Cliff + T si cerca spesso di minimizzare il conteggio T). Per questa parte, il grafico aciclico diretto che mostra la dipendenza è cruciale. Questo è un problema nel trovare un buon tipo topologico del DAG. Ciò avviene cambiando la precedenza quando si ha la scelta di quale vertice usare successivamente. (Non perderei tempo a ottimizzare questa parte troppo difficile.)$T_i$$T_i^n = 1$$T_i$$i$$w_1 g_{i_1} w_2 g_{i_2} \cdots w_k$$w_i$$X_1 T_2 X_1 T_2 X_1 T_2 X_1$

Se la parola è già vicina alla lunghezza ottimale, non c'è molto da fare e questa procedura non sarà di aiuto. Ma come esempio più basilare di ciò che trova è se hai più unità e hai dimenticato che c'era un alla fine di uno e un all'inizio del successivo, si sbarazzerà di quella coppia. Ciò significa che puoi eseguire il black box delle routine comuni con maggiore sicurezza che quando le metterai insieme, verranno eliminate tutte quelle ovvie cancellazioni. Fa altri che non sono così ovvi; quelli usano quando .$H_i$$H_i$$m_{ij} \neq 1,2$

Usando la procedura descritta in https://arxiv.org/abs/quant-ph/0303063 ¹ , qualsiasi porta diagonale - qualsiasi quindi in particolare la porta CCCZ - può essere scomposta in termini di ad es. CNOT e porte diagonali a un qubit, dove i CNOT possono essere ottimizzati da soli seguendo una procedura di ottimizzazione classica.

Il riferimento fornisce un circuito che utilizza 16 CNOT per cancelli diagonali arbitrari a 4 qubit (Fig. 4).

Nota: mentre in linea di principio potrebbe esserci un circuito più semplice (detto circuito è stato ottimizzato tenendo presente un'architettura di circuito più limitata), dovrebbe essere vicino all'ottimale - il circuito deve creare tutti gli stati della forma per qualsiasi sottoinsieme non banale e ce ne sono 15 per 4 qubit.$\bigoplus_{i\in I}x_i$$I\subset\{1,2,3,4\}$

Si noti inoltre che questa costruzione non deve assolutamente essere ottimale.

^{1 Nota: sono un autore}