Bagaimana cara melacak keterikatan ketika meniru perhitungan kuantum?

Saya mencoba membangun perpustakaan perhitungan kuantum sebagai proyek universitas saya. Saya masih mempelajari semua aspek bidang Quantum Computing. Saya tahu sudah ada perpustakaan yang efisien untuk emulasi kuantum. Saya hanya ingin membuatnya sendiri, yang akan membantu saya untuk memahami beberapa konsep inti dari Quantum Computing.

Saya tahu bahwa qubit dapat disimpan dengan elemen kompleks 2 n . Juga, gerbang n qubit adalah array 2D 2 n × 2 n . Jadi, berikut ini adalah keraguan saya (kebanyakan terkait dengan keterjeratan):$n$$2^n$$n$$2^n \times 2^n$

1. Kapan saya perlu menemukan produk tensor dari gerbang (seperti , untuk sistem 3 qubit)? Apakah selalu diperlukan untuk menghitung produk tensor pesanan 2 n × 2 n , bahkan jika qubit tidak terjerat?$I \otimes H \otimes I$$3$$2^n \times 2^n$

2. Dengan hanya elemen array (yang saya simpan koefisien), bisakah saya benar-benar menghitung qubit mana yang terjerat? Atau apakah saya perlu membuat struktur data lain untuk menyimpan informasi keterjeratan n qubit saya (tentang qubit mana yang terjerat)?$2^n$$n$

3. Apakah pertanyaan kedua saya benar-benar relevan? Apakah saya perlu melacak informasi keterjeratan sama sekali? Maksud saya, saya tidak tahu apakah mengalikan gerbang dengan koefisien sudah cukup (bahkan jika sistem terjerat). Mungkin itu relevan pada saat pengukuran saja.

Hal ini tentu cukup untuk selalu menghitung penuh kesatuan matriks, dan kemudian menerapkannya pada 2 n -entry vektor negara. Jika itu yang Anda memilih untuk melakukan, itu semua harus Anda lakukan karena semua informasi keterikatan yang terkandung dalam vektor itu. Cara cepat dan mudah untuk melihat apakah qubit tertentu terjerat adalah dengan mengambil sebagian jejak vektor keadaan (murni) Anda di atas semua qubit lainnya. Jika matriks yang dihasilkan adalah peringkat 1, qubit itu berada dalam keadaan terpisah, jika tidak terjerat.$2^n\times 2^n$$2^n$

Saya berasumsi inti dari pertanyaan Anda adalah "Bagaimana biaya komputasi yang besar ini dapat dihindari?". Secara umum, itu tidak bisa - jika Anda menggunakan kekuatan penuh dari komputer kuantum, Anda akan selalu memerlukan state state vector. Namun, ada berbagai trik yang mengurangi biaya komputasi, seperti menunda kebutuhan vektor negara besar dengan melacak keterjeratan.$2^n$

Peningkatan Efisiensi

Penghematan terbesar yang dapat Anda lakukan dibandingkan dengan implementasi naif di atas adalah untuk menghindari matriks kesatuan . Misalnya, jika Anda hanya menggunakan gerbang 1- atau 2-qubit, cukup menggunakan sparsity of matrix berarti Anda hanya perlu penyimpanan O ( 2 n ) daripada O ( 2 2 n ) .$2^n\times 2^n$$O(2^n)$$O(2^{2n})$

Lalu ada taktik lain yang bisa Anda pakai. Misalnya, bayangkan Anda ingin menerapkan gerbang kesatuan dua-qubit pada qubit i dan j . Anda dapat mengambil set 4 elemen dari vektor negara Anda ( | x ⟩ 1 , 2 , ... n ∖ i , j |$U$$i$$j$ untuk tetap x ∈ { 0 , 1 } n - 2 dengan mengambil semua berbeda y ∈ { 0 , 1 $|x\rangle_{1,2,\ldots n\setminus i,j}|y\rangle_{i,j}$$x\in\{0,1\}^{n-2}$ ) dan hanya menerapkan U 4 × 4 kesatuanpada vektor 4-elemen itu. Mengulang ini untuk setiap x akan mengembalikan U yang diberlakukan pada vektor keadaan asli.$y\in\{0,1\}^2$$4\times 4$$U$$x$$U$

Saya membayangkan ada strategi lain yang bisa muncul. Salah satu yang menyarankan dirinya dari pertanyaan awal adalah pelacakan keterjeratan. Ini memberikan peningkatan memori dan kecepatan pada awal perhitungan, tetapi akhirnya menjadi setara karena (mungkin) semua yang ada di komputer kuantum akan terjerat.

Pelacakan Keterjeratan

Mari kita asumsikan bahwa perhitungan Anda hanya terdiri dari evolusi kesatuan dan pengukuran pada himpunan qubit, yaitu tidak ada dekoherensi, peta probabilistik dll. Mari kita asumsikan lebih lanjut bahwa Anda mulai dari keadaan yang sepenuhnya dapat dipisahkan seperti | 0 ⟩ ⊗ $n$$|0\rangle^{\otimes n}$ . Pada titik ini, setiap qubit dapat dipisahkan, dan cukup untuk menyimpan register yang berbeda, masing-masing menyampaikan status qubit yang dapat dipisahkan. Jika gerbang pertama Anda hanya operasi single-qubit U pada qubit i , maka Anda cukup memperbarui status yang disimpan di qubit i sebagai | ψ i ⟩ ↦ U $n$$U$$i$$i$ , dan Anda tidak perlu menyentuh apa pun.$|\psi_i\rangle\mapsto U|\psi_i\rangle$

Jika Anda ingin melakukan gerbang dua-qubit antara qubit i dan j , katakanlah, maka Anda harus menggabungkan status di kedua situs. Jadi, Anda mengganti dua register masing-masing dimensi 2 dengan satu register dimensi 4, yang berisi status V | ψ i ⟩ | ψ j ⟩ . Masalahnya adalah bahwa Anda sekarang tidak dapat membagi status ini lagi, jadi Anda harus menyimpan kedua qubit itu dalam register selamanya. Tentu saja, jika Anda pernah memiliki gerbang 1-qubit U untuk diterapkan pada qubit i , Anda sekarang harus menerapkan | ψ i , j ⟩ ↦ U ⊗ $V$$i$$j$$V|\psi_i\rangle|\psi_j\rangle$$U$$i$ . Kemudian, saat berikutnya Anda menginginkan gerbang 2-qubit antara, katakanlah, j dan k , Anda harus menggabungkan spasi untuk ( i , j ) dan k . Ruang-ruang itu akan terus bertambah, tetapi jika sebuah gerbang dilokalkan hanya pada satu ruang, Anda hanya perlu menerapkannya di sana (menggunakanoperator I untuk memasangnyapada sisa qubit), dan Anda tidak perlu melakukan apa pun pada ruang lain.$|\psi_{i,j}\rangle\mapsto U\otimes\mathbb{I}|\psi_{i,j}\rangle$$j$$k$$(i,j)$$k$$\mathbb{I}$

Jika Anda melakukan hal-hal seperti ini, Anda tidak akan memiliki (setidaknya untuk beberapa langkah pertama dari algoritma Anda) register elemen tunggal . Anda harus memiliki banyak register yang berbeda, dan melacak qubit mana yang dijelaskan oleh register mana dalam array yang terpisah. Setiap kali Anda menggabungkan spasi dari beberapa qubit, Anda akan memperbarui array ekstra itu.$2^n$

Berikut ini beberapa pseudo-code kasar yang dapat membantu menyampaikan maksud saya:

#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

Pilihan lain

(Tidak berarti lengkap)

Anda mungkin tertarik untuk membaca tentang Matrix Product States yang merupakan cara yang bagus untuk merangkum informasi tentang negara-negara yang tidak terlalu terjerat, dan itu dapat memberikan rute alternatif untuk Anda, tergantung pada apa tepatnya yang ingin Anda capai.