Come tenere traccia degli intrecci durante l'emulazione del calcolo quantistico?

Sto cercando di costruire una biblioteca di calcolo quantistico come mio progetto universitario. Sto ancora imparando tutti gli aspetti del campo dell'informatica quantistica. So che ci sono già librerie efficienti per l'emulazione quantistica. Voglio solo crearne uno mio, che mi aiuterà a cogliere alcuni dei concetti chiave del calcolo quantistico.

So che qubit può essere memorizzato con un array complesso di elementi . Inoltre, un gate qubit è un array 2D . Quindi, i seguenti sono i miei dubbi (principalmente legati all'entanglement):$n$$2^n$$n$$2^n \times 2^n$

1. Quando devo trovare il prodotto tensore delle porte (come , per un sistema a qubit)? È sempre necessario calcolare il prodotto tensore dell'ordine , anche se i qubit non sono intrecciati?$I \otimes H \otimes I$$3$$2^n \times 2^n$

2. Con solo un array di elementi (che memorizzo i coefficienti), posso effettivamente calcolare in qualche modo quali qubit sono aggrovigliati? O devo creare un'altra struttura di dati per memorizzare le informazioni di entanglement dei miei qubit (su quali qubit sono intrecciati)?$2^n$$n$

3. La mia seconda domanda è effettivamente pertinente? Devo tenere traccia delle informazioni sull'entanglement? Voglio dire, non so se moltiplicare le porte con i coefficienti sia sufficiente (anche se il sistema è impigliato). Forse è rilevante solo al momento della misurazione.

È certamente sufficiente calcolare sempre l'intera matrice unitaria , quindi applicarla al vettore di stato -entry. Se è quello che scegli di fare, è tutto ciò che devi fare poiché tutte le informazioni sull'entanglement sono contenute in quel vettore. Un modo semplice e veloce per vedere se un particolare qubit è impigliato è quello di prendere la traccia parziale del tuo vettore di stato (puro) su tutti gli altri qubit. Se la matrice risultante è di grado 1, quel qubit è in uno stato separabile, altrimenti è impigliato.2 $2^n\times 2^n$$2^n$

Suppongo che il punto della tua domanda sia davvero "Come si può evitare questo enorme costo computazionale?". In generale, non può - se stai usando tutta la potenza del computer quantistico, avrai sempre bisogno del vettore di stato -entry. Tuttavia, ci sono vari trucchi che riducono il costo computazionale, come ritardare la necessità di un vettore di stato così grande tenendo traccia dell'entanglement.$2^n$

Miglioramenti dell'efficienza

Il più grande risparmio che puoi fare rispetto all'implementazione ingenua sopra è evitare le matrici unitarie . Ad esempio, se stai usando solo porte a 1 o 2 qubit, semplicemente usando la scarsità di matrici significa che hai solo bisogno di memoria O ( 2 n ) invece di O ( 2 2 n ) .$2^n\times 2^n$$O(2^n)$$O(2^{2n})$

Poi ci sono altre tattiche che puoi impiegare. Ad esempio, immagina di voler applicare il gate unitario a due qubit sui qubit i e j . Si può prendere set di 4 elementi dal vettore di stato ( | x ⟩ 1 , 2 , ... n ∖ i , j | y ⟩ i , j per fisso x ∈ { 0 , 1 } n - 2 prendendo tutte diverse y ∈ { 0 , 1 $U$$i$$j$$|x\rangle_{1,2,\ldots n\setminus i,j}|y\rangle_{i,j}$$x\in\{0,1\}^{n-2}$ ) e basta applicare la U unitaria 4 × 4 su quel vettore a 4 elementi. Ripetendo questo per ogni x si restituirà U enacted sul vettore di stato originale.$y\in\{0,1\}^2$$4\times 4$$U$$x$$U$

Immagino ci siano altre strategie che si potrebbero escogitare. Quello che si è suggerito dalla domanda originale era il monitoraggio dell'entanglement. Ciò fornisce miglioramenti della memoria e della velocità all'inizio di un calcolo, ma alla fine finisce per essere equivalente perché (presumibilmente) tutto nel computer quantistico rimarrà impigliato.

Tracciamento entanglement

Supponiamo che il tuo calcolo consista solo di evoluzione unitaria e misurazione sull'insieme di qubit, cioè che non vi siano decoerenze, mappe probabilistiche ecc. Supponiamo inoltre che inizi da uno stato completamente separabile come | 0 ⟩ ⊗ n . A questo punto, ogni qubit è separabile ed è sufficiente mantenere n registri diversi, ciascuno dei quali trasmette lo stato di un qubit separabile. Se il tuo primo gate è solo un'operazione a singolo qubit U su qubit , allora aggiorni lo stato memorizzato su qubit come e non devi toccare nulla altro.$n$$|0\rangle^{\otimes n}$$n$$U$ho | ψ i ⟩ ↦ U | ψ i$i$$i$$|\psi_i\rangle\mapsto U|\psi_i\rangle$

Se vuoi fare un gate a due qubit tra qubit e , diciamo, allora devi combinare gli stati in entrambi i siti. Pertanto, si sostituiscono due registri ciascuno della dimensione 2 con un registro della dimensione 4, contenente lo stato . Il problema è che ora non è possibile dividere nuovamente questo stato, quindi è necessario mantenere questi due qubit in un registro per sempre. Ovviamente, se hai mai un gate da 1 qubit da applicare su qubit , ora dovrai applicare . Quindi, la prossima volta che si desidera un cancello 2-qubit tra, diciamo, ei j V | ψ i ⟩ | ψ j ⟩ U i | ψ i , j ⟩ ↦ U ⊗ I | ψ i , j ⟩ j k ( i , j ) k $V$$i$$j$$V|\psi_i\rangle|\psi_j\rangle$$U$$i$$|\psi_{i,j}\rangle\mapsto U\otimes\mathbb{I}|\psi_{i,j}\rangle$$j$$k$, dovrai combinare gli spazi per e . Questi spazi continueranno a crescere, ma se un gate è localizzato su un solo spazio, devi solo applicarlo lì (usando gli operatori per riempirlo con il resto dei qubit), e non devi fare qualsiasi cosa negli altri spazi.$(i,j)$$k$$\mathbb{I}$

Se stai facendo cose del genere, non avrai (almeno per i primi passi del tuo algoritmo) un unico registro elemento. Dovrai avere un sacco di registri diversi e tenere traccia di quali qubit sono descritti da quale registro in un array separato. Ogni volta che combini gli spazi di alcuni qubit, aggiornerai quell'array aggiuntivo.$2^n$

Ecco alcuni pseudo-codici molto rozzi che possono aiutare a trasmettere il mio significato:

#initialise variables
entangled_blocks={{1},{2},{3},...,{n}}
quantum_states={{1,0},{1,0},...,{1,0}}

#apply action of each gate
for each gate
   for each gate_target
       target_block=entangled_blocks entry containing gate_target
   next gate_target
   if all target_blocks equal then
      apply gate on target_block (pad with identity on other qubits)
   else
      new_entangled_block=union(target_blocks)
      new_state_vec=tensor_product(quantum_states for each target block)
      apply gate on new_state_vec (pad with identity on other qubits)
      replace all target_blocks in entangled_blocks with new_entangled_block
      replace all quantum_states(all target blocks) with new_state_vec
   end if
next gate

Altre opzioni

(Non esaustivo)

Potresti essere interessato a leggere gli Stati dei prodotti Matrix che sono un buon modo per incapsulare le informazioni sugli stati non troppo intricati e che potrebbero fornirti un percorso alternativo, a seconda di cosa esattamente stai cercando di raggiungere.