Wie kann man Verwicklungen bei der Emulation von Quantenberechnungen verfolgen?

Ich versuche, eine Quantenberechnungsbibliothek als mein Universitätsprojekt aufzubauen. Ich lerne immer noch alle Aspekte des Quantum Computing-Bereichs. Ich weiß, dass es bereits effiziente Bibliotheken für die Quantenemulation gibt. Ich möchte nur meine eigenen erstellen, um einige der Kernkonzepte des Quantum Computing zu verstehen.

Ich weiß, dass $n$ Qubits mit einem komplexen Array mit $2^n$ Elementen gespeichert werden können . Ein $n$ Qubit-Gate ist auch ein $2^n \times 2^n$ 2D-Array. Das Folgende sind meine Zweifel (hauptsächlich im Zusammenhang mit Verstrickungen):

1. Wann muss ich das Tensorprodukt von Gates finden (wie $I \otimes H \otimes I$ für ein $3$ Qubit-System)? Ist es immer notwendig, das Tensorprodukt der Ordnung zu berechnen $2^n \times 2^n$, auch wenn die Qubits nicht verwickelt sind?

2. Kann ich mit nur einem $2^n$ Element-Array (in dem ich die Koeffizienten speichere) tatsächlich irgendwie berechnen, welche Qubits verwickelt sind? Oder muss ich eine andere Datenstruktur erstellen, um die Verschränkungsinformationen meines n zu speichern?$n$ Qubits (über welche Qubits verschränkt sind)?

3. Ist meine 2. Frage tatsächlich relevant? Muss ich die Verschränkungsinformationen überhaupt nachverfolgen? Ich meine, ich weiß nicht, ob das Multiplizieren von Gates mit Koeffizienten ausreicht (selbst wenn das System verwickelt ist). Möglicherweise ist es nur zum Zeitpunkt der Messung relevant.

Es ist sicherlich ausreichend, immer die vollständige Einheitsmatrix zu berechnen und sie dann auf den 2 n -Eintrittszustandsvektor anzuwenden. Wenn Sie sich dafür entscheiden, ist es das$2^n\times 2^n$$2^n$ alles müssen, da alle Verschränkungsinformationen in diesem Vektor enthalten sind. Eine schnelle und einfache Möglichkeit, um festzustellen, ob ein bestimmtes Qubit verwickelt ist, besteht darin, die Teilspur Ihres (reinen) Zustandsvektors über alle anderen Qubits zu ziehen. Wenn die resultierende Matrix Rang 1 hat, befindet sich dieses Qubit in einem trennbaren Zustand, andernfalls ist es verwickelt.

Ich gehe davon aus, dass der Punkt Ihrer Frage wirklich lautet: "Wie können diese enormen Rechenkosten vermieden werden?". Im Allgemeinen ist dies nicht möglich. Wenn Sie die volle Leistung des Quantencomputers nutzen, benötigen Sie immer die $2^n$ Zustandsvektor mit Einträgen. Es gibt jedoch verschiedene Tricks, die den Rechenaufwand reduzieren, beispielsweise die Verzögerung der Notwendigkeit eines so großen Zustandsvektors, indem die Verschränkung verfolgt wird.

Effizienzverbesserungen

Die größte Einsparung, die Sie im Vergleich zur obigen naiven Implementierung erzielen können, besteht darin, die einheitlichen Matrizen zu vermeiden . Wenn Sie beispielsweise nur 1- oder 2-Qubit-Gatter verwenden, bedeutet die einfache Verwendung der geringen Anzahl von Matrizen, dass Sie nur O ( 2 n ) -Speicher anstelle von O ( 2 2 n ) benötigen .$2^n\times 2^n$$O(2^n)$$O(2^{2n})$

Dann gibt es andere Taktiken, die Sie anwenden können. Stellen Sie sich zum Beispiel vor, Sie möchten das Zwei-Qubit-Einheitsgatter auf die Qubits i und j anwenden . Sie können Gruppen von 4 Elementen aus dem Zustandsvektor nehmen ( | x ⟩ 1 , 2 , ... n ∖ i , j | y ⟩ i , j für feste x ∈ { 0 , 1 } n - 2 durch all verschiedene Einnahme y ∈ { 0 , $U$$i$$j$$|x\rangle_{1,2,\ldots n\setminus i,j}|y\rangle_{i,j}$$x\in\{0,1\}^{n-2}$das auf dem ursprünglichen Zustandsvektor festgelegt ist.$y\in\{0,1\}^2$) und nur das Einheits- U auf diesen 4-Element-Vektor anwenden . Wenn Sie dies für jedes x wiederholen, wird $4\times 4$$U$$x$$U$

Ich stelle mir vor, es gibt andere Strategien, die man sich ausdenken könnte. Diejenige, die sich aus der ursprünglichen Frage ergab, war die Verfolgung von Verstrickungen. Dies führt zu Speicher- und Geschwindigkeitsverbesserungen zu Beginn einer Berechnung, ist jedoch letztendlich gleichwertig, da (vermutlich) alles im Quantencomputer verwickelt wird.

Verschränkungsverfolgung

Nehmen wir an, dass Ihre Berechnung nur aus einer einheitlichen Entwicklung und Messung der Menge von Qubits besteht, dh es gibt keine Dekohärenz, Wahrscheinlichkeitskarten usw. Nehmen wir weiter an, dass Sie von einem vollständig trennbaren Zustand wie | ausgehen 0 ⟩ ⊗ n . Zu diesem Zeitpunkt ist jedes Qubit trennbar, und es reicht aus, n verschiedene Register zu führen, die jeweils den Zustand eines trennbaren Qubits übermitteln. Wenn Ihr erstes Gate nur eine Single-Qubit-Operation U auf Qubit ist$n$$|0\rangle^{\otimes n}$$n$$U$ , aktualisieren Sie einfach den auf Qubit i gespeicherten Statusals | ψ i ⟩ ↦ U $i$$i$ , und Sie haben nichts anderes zu berühren.$|\psi_i\rangle\mapsto U|\psi_i\rangle$

Wenn Sie beispielsweise ein Zwei-Qubit-Gate zwischen den Qubits i und j ausführen möchten, müssen Sie die Zustände an beiden Standorten kombinieren. Sie ersetzen also jeweils zwei Register der Dimension 2 durch ein Register der Dimension 4, das den Zustand V | enthält ψ i ⟩ | ψ j ⟩ . Das Problem ist, dass Sie diesen Status jetzt nicht mehr aufteilen können, sodass Sie diese beiden Qubits für immer in einem Register aufbewahren müssen. Wenn Sie jemals ein 1-Qubit-Gatter U haben , das auf Qubit i angewendet werden soll , müssen Sie jetzt | anwenden ψ i , j ⟩ ↦ U ⊗ $V$$i$$j$$V|\psi_i\rangle|\psi_j\rangle$$U$$i$ . Wenn Sie dann das nächste Mal ein 2-Qubit-Gate zwischen beispielsweise j möchten$|\psi_{i,j}\rangle\mapsto U\otimes\mathbb{I}|\psi_{i,j}\rangle$$j$und , Sie müssen die Leerzeichen für kombinieren$k$ und k. Diese Leerzeichen werden weiter wachsen, aber wenn ein Gate nur auf einem Leerzeichen lokalisiert ist, müssen Sie es nur dort anwenden (indem Sie I- Operatoren verwenden, um es auf den Rest der Qubits aufzufüllen), und Sie müssen nichts mit dem tun andere Räume.$(i,j)$$k$$\mathbb{I}$

Wenn Sie solche Dinge tun, haben Sie (zumindest für die ersten Schritte Ihres Algorithmus) kein einziges -Elementregister. Sie müssen eine Reihe verschiedener Register haben und verfolgen, welche Qubits von welchem ​​Register in einem separaten Array beschrieben werden. Jedes Mal, wenn Sie die Leerzeichen einiger Qubits kombinieren, aktualisieren Sie dieses zusätzliche Array.$2^n$

Hier ist ein sehr grober Pseudocode, der mir helfen kann, meine Bedeutung zu vermitteln:

#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

Andere Optionen

(Auf keinen Fall erschöpfend)

Vielleicht möchten Sie mehr über Matrix-Produktzustände erfahren, die eine gute Möglichkeit darstellen, Informationen über nicht zu verwickelte Zustände zu kapseln, und die möglicherweise eine alternative Route für Sie darstellen, je nachdem, was genau Sie erreichen möchten.