Matriks gerbang tidak terkontrol terlihat seperti ini:

$$\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ \end{bmatrix}$$

Itu bekerja dengan baik ketika Anda hanya memiliki dua qubit dan Anda ingin menggunakan qubit pertama sebagai kontrol, dan qubit kedua sebagai input untuk dibalik (atau tidak).

Apakah ada metode untuk mengkonversi matriks ini untuk digunakan misalnya jika Anda memiliki 3 qubit, dan ingin menggunakan qubit 1 sebagai kontrol dan qubit 3 sebagai input yang mungkin dibalik?

Memikirkannya secara logis, saya dapat memunculkan ini:

$$\begin{bmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ \end{bmatrix}$$

Apakah ada cara yang lebih baik, lebih formal / umum untuk mengubah gerbang multi qubit untuk menggunakan qubit tertentu, daripada yang pertama $N$ dalam sebuah $N$ sirkuit qubit?

Expand-n-Swap

Jika Anda ingin menerapkan gerbang ke subset dari qubit:

• Perluas operasi hingga $2^n$x$2^n$dengan produk tensor / produk Kronecker .
• Gunakan swap swap untuk membuat target qubit berturut-turut.
• Tukar dengan pesanan sederhana, terapkan, tukar kembali.

Mungkin membosankan untuk melakukan semua perkalian matriks besar itu, tetapi matriks swap jarang dan idenya sangat mudah.

Kontrol lebih mudah

Dalam hal menambahkan kontrol ke operasi (yang berlaku untuk contoh spesifik yang Anda berikan), ada trik yang lebih mudah. Perluas operasi seperti biasa, tetapi kemudian ganti bagian mana pun dari matriks yang sesuai dengan input kontrol-gagal dengan apa yang akan menjadi matriks identitas.

Ini sedikit lebih mudah untuk dilacak jika Anda memperkenalkan "nilai kontrol" palsu$c$yang mengesampingkan perilaku biasa produk tensor , sehingga bukan$\begin{bmatrix} c \end{bmatrix} \otimes U = c \cdot U$, kamu punya $\begin{bmatrix} c \end{bmatrix} \otimes U = c \cdot I$ (dengan kata lain: ketika sebuah entri $c$ kamu tidak ubin $U$ atas entri dan skala $U$dengan entri; Kau gunakan$I$ dari pada $U$).

Tentukan "operasi" kontrol qubit-must-be-ON menjadi $C = \begin{bmatrix} c&0 \\ 0&1 \end{bmatrix}$. No-op adalah$I$, dan TIDAK adalah $X$. Maka operasi dari pertanyaan Anda dapat dihitung seperti ini (dengan asumsi pesanan big-endian):

$CNOT_{3 \rightarrow 1} = C \otimes I \otimes X$

$= \begin{bmatrix} c&0 \\ 0&1 \end{bmatrix} \otimes \begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} c\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix}&0\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \\ 0\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix}&1\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} \begin{bmatrix} c&0 \\ 0&c \end{bmatrix} & \begin{bmatrix} 0&0 \\ 0&0 \end{bmatrix} \\ \begin{bmatrix} 0&0 \\ 0&0 \end{bmatrix}&\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} c&0&0&0 \\ 0&c&0&0 \\ 0&0&1&0 \\ 0&0&0&1 \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

(catatan: akan menggunakan nol tunggal untuk secara ambigu berarti matriks 2x2 nol jika memungkinkan)

$= \begin{bmatrix} c\otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} &0&0&0 \\ 0&c \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0&0 \\ 0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0 \\ 0&0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} \end{bmatrix}$

$= \begin{bmatrix} \begin{bmatrix} c&0 \\ 0&c \end{bmatrix} &0&0&0 \\ 0&\begin{bmatrix} c&0 \\ 0&c \end{bmatrix}&0&0 \\ 0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0 \\ 0&0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} \end{bmatrix}$

$= \begin{bmatrix} c&0&0&0&0&0&0&0 \\ 0&c&0&0&0&0&0&0 \\ 0&0&c&0&0&0&0&0 \\ 0&0&0&c&0&0&0&0 \\ 0&0&0&0&0&1&0&0 \\ 0&0&0&0&1&0&0&0 \\ 0&0&0&0&0&0&0&1 \\ 0&0&0&0&0&0&1&0 \end{bmatrix}$

(sekarang kami sudah selesai dengan produk tensor dan tidak perlu $c$lagi)

$\rightarrow \begin{bmatrix} 1&0&0&0&0&0&0&0 \\ 0&1&0&0&0&0&0&0 \\ 0&0&1&0&0&0&0&0 \\ 0&0&0&1&0&0&0&0 \\ 0&0&0&0&0&1&0&0 \\ 0&0&0&0&1&0&0&0 \\ 0&0&0&0&0&0&0&1 \\ 0&0&0&0&0&0&1&0 \end{bmatrix}$

Masuk akal?

Jangan gunakan metode swap, ini sangat tidak efisien. Dan jawaban orang lain khusus untuk gerbang CNOT, dan terus terang, terlalu rumit.

Berikut adalah algoritma yang sangat sederhana yang memecahkan masalah Anda untuk setiap kasus, bukan hanya gerbang CNOT, untuk bit sembarang.

Algoritma:

let sys = matrix representing the current state of the system
let n = number of qubits being simulated
let lgm = logic gate matrix of size 2^n by 2^n
let f = our logic gate transformation function
for i = 0 to (2^n) - 1:
    lgm[column = i] = f(i)
sys = sys × lgg

Di komputer klasik, ada sesuatu yang dikenal sebagai "decoder". Katakanlah saya hanya memiliki 3 kabel, secara efektif, 3 bit. Tapi saya ingin mengendalikan 8 kabel. Bisakah itu dilakukan? Ya, karena 3 bit memiliki 8 kemungkinan berbeda: 000, 001, 010, 011, 100, 101, 110, 111. Jadi kita dapat menetapkan setiap kemungkinan ke salah satu dari 8 kabel output kami. Ini disebut "decoding".

Jika saya memasukkan angka 101 dan kami memiliki 3 bit, kami tahu 101 = 5, maka saya akan mengatur kawat keluaran 5 ke tegangan tinggi dan 7 kabel keluaran lainnya akan 0, yang dapat kami wakili seperti ini: decode (101) = [0, 0, 0, 0, 0, 1, 0, 0].

Dalam algoritma ini, saya menyebutkan "fungsi transformasi" yang disebut "f". Untuk komputer klasik, fungsi transformasi hanya mengambil nilai input dan mengembalikan versi "yang didekodekan" dari nilai output. Jadi jika kita memiliki 3 bit, dan outputnya adalah 4, maka kita akan mengembalikan [0, 0, 0, 0, 0, 1, 0, 0, 0]. Kami kemudian menetapkan itu sebagai kolom matriks kami untuk nilai itu.

Mari kita pikirkan "decoding" dalam hal qubit. Bagaimana kita bisa mendekode qubit | 101>?

Kita tahu bahwa untuk vektor probabilitas qubit kita, | 0> adalah [1, 0] dan | 1> adalah [0, 1]. Decoding qubit kemudian dapat dilakukan apa yang disebut produk Kronecker.

Jadi jika kita mengonversi setiap bit ke vektor probabilitas setara dan mengambil produk Kronecker dari semuanya, kita dapatkan ...

|101> = |1> ⊗ |0> ⊗ |1> = [0, 1] ⊗ [1, 0] ⊗ [0, 1] = [0, 0, 0, 0, 0, 1, 0, 0]

Inilah cara kami ingin memecahkan kode qubit. Algoritma ini dapat diterapkan untuk qubit sama saja menggunakan ini.

Mari kita coba algoritma ini pada masalah yang lebih sederhana.

Mari kita asumsikan kita memiliki sistem dengan hanya 2 qubit. Jika kita ingin menerapkan gerbang Hadamard menjadi hanya 1 qubit, kita dapat menghasilkan gerbang logika untuk kedua qubit yang hanya menerapkan gerbang Hadamard ke satu qubit. Mari kita asumsikan qubit tunggal yang ingin kita terapkan adalah qubit kita yang paling signifikan dan yang paling signifikan tidak akan terpengaruh.

Kami menginginkan fungsi transformasi yang untuk setiap kemungkinan input kami, menghasilkan output yang benar. Kami memiliki dua qubit, ini berarti ada empat kemungkinan output.

f(|00>) = ?
f(|01>) = ?
f(|10>) = ?
f(|11>) = ?

Kami tahu qubit yang paling tidak signifikan tidak akan terpengaruh, sehingga kami dapat mengisinya.

f(|00>) = ? ⊗ |0>
f(|01>) = ? ⊗ |1>
f(|10>) = ? ⊗ |0>
f(|11>) = ? ⊗ |1>

Kita juga tahu apa yang dilakukan Hadamard terhadap qubit, sehingga:

H(|0>) = 1/sqrt(2)|0> + 1/sqrt(2)|1>
H(|1>) = 1/sqrt(2)|0> - 1/sqrt(2)|1>

Jadi fungsi transformasi kami hanyalah:

f(|00>) = (1/sqrt(2)|0> + 1/sqrt(2)|1>) ⊗ |0>
f(|01>) = (1/sqrt(2)|0> + 1/sqrt(2)|1>) ⊗ |1>
f(|10>) = (1/sqrt(2)|0> - 1/sqrt(2)|1>) ⊗ |0>
f(|11>) = (1/sqrt(2)|0> - 1/sqrt(2)|1>) ⊗ |1>

Perluas ini ke bentuk vektor probabilitas normalisasi kami ...

f(|00>) = [ 1/sqrt(2), 1/sqrt(2) ] ⊗ [ 1, 0 ]
f(|01>) = [ 1/sqrt(2), 1/sqrt(2) ] ⊗ [ 0, 1 ]
f(|10>) = [ 1/sqrt(2), -1/sqrt(2) ] ⊗ [ 1, 0 ]
f(|11>) = [ 1/sqrt(2), -1/sqrt(2) ] ⊗ [ 0, 1 ]

Sekarang mari kita selesaikan ini ...

f(|00>) = [ 1/sqrt(2), 0, 1/sqrt(2), 0 ]
f(|01>) = [ 0, 1/sqrt(2), 0, 1/sqrt(2) ]
f(|10>) = [ 1/sqrt(2), 0, -1/sqrt(2), 0 ]
f(|11>) = [ 0, 1/sqrt(2), 0, -1/sqrt(2) ]

Itulah fungsi transformasi kami.

Matriks gerbang logika kami, "lgm", berukuran 2 ^ n x 2 ^ n di mana n = jumlah qubit yang disimulasikan, jadi dalam hal ini 2 ^ 2 x 2 x 2 atau 4x4. Algoritma kami memberi tahu kami bahwa untuk setiap kolom i, setel kolom sama dengan f (i). Kami telah menetapkan fungsi transformasi probabilitas kami, sehingga kami dapat dengan mudah mengisi kolom ini.

lgm = 
    |00>       |01>        |10>        |11>
[ 1/sqrt(2),         0,  1/sqrt(2),          0 ] 
[         0, 1/sqrt(2),          0,  1/sqrt(2) ]
[ 1/sqrt(2),         0, -1/sqrt(2),          0 ]
[         0, 1/sqrt(2),          0, -1/sqrt(2) ]

Sekarang langkah terakhir dalam algoritma kami adalah hanya mengalikan matriks matriks kami yang mewakili seluruh sistem kuantum, sys, dengan gerbang logika ini, lgm.

Dan itu melakukan apa yang kita inginkan. Ini akan menerapkan gerbang hadamard hanya untuk qubit paling dan meninggalkan qubit paling signifikan sendirian. Jika Anda tidak percaya kepada saya, Anda dapat mencobanya sendiri dan melihat bahwa itu berhasil.

Alasan ini sangat kuat adalah karena itu berlaku untuk kasus apa pun.

Mari kita coba algoritma ini untuk masalah Anda.

Bayangkan kita memiliki sistem 3 qubit dan kita ingin menerapkan gerbang CNOT ke qubit [0] dan qubit [2]. Jika Anda mencari matriks CNOT di Wikipedia, matriks itu hanya berlaku untuk sistem 2-qubit. Solusi naif adalah menambahkan matriks identitas untuk itu menggunakan produk Kronecker untuk membuatnya bekerja pada sistem dengan tiga qubit. Tapi ini gagal di sini: qubit [0] dan qubit [2] tidak berdekatan, jadi hanya menambahkan matriks identitas tidak akan berfungsi.

Kita bisa menukar qubit [0] dengan qubit [1], menerapkan gerbang CNOT, lalu menukarnya kembali. Tapi itu lambat. Sebagai gantinya, kami bisa membuat gerbang CNOT yang tidak berdekatan untuk masalah kami menggunakan algoritma di atas.

Pertama-tama kita perlu membuat fungsi transformasi untuk setiap kasus.

f(|000>) = |0> ⊗ |0> ⊗ |0>
f(|001>) = |0> ⊗ |0> ⊗ |1>
f(|010>) = |0> ⊗ |1> ⊗ |0>
f(|011>) = |0> ⊗ |1> ⊗ |1>
f(|100>) = |1> ⊗ |0> ⊗ |1>
f(|101>) = |1> ⊗ |0> ⊗ |0>
f(|110>) = |1> ⊗ |1> ⊗ |1>
f(|111>) = |1> ⊗ |1> ⊗ |0>

Jika Anda memahami gerbang CNOT, Anda dapat memahami mengapa ini adalah fungsi kami. Pikirkan ini seperti tabel kebenaran. Karena qubit kontrol kami adalah qubit yang paling signifikan, qubit [2], hanya ketika qubit itu adalah | 1> maka qubit yang paling tidak signifikan, qubit [0], akan dinegasikan.

Perluas ini ke bentuk vektor probabilitas normalisasi kami ...

f(|000>) = [ 1, 0 ] ⊗ [ 1, 0 ] ⊗ [ 1, 0 ]
f(|001>) = [ 1, 0 ] ⊗ [ 1, 0 ] ⊗ [ 0, 1 ]
f(|010>) = [ 1, 0 ] ⊗ [ 0, 1 ] ⊗ [ 1, 0 ]
f(|011>) = [ 1, 0 ] ⊗ [ 0, 1 ] ⊗ [ 0, 1 ]
f(|100>) = [ 0, 1 ] ⊗ [ 1, 0 ] ⊗ [ 0, 1 ]
f(|101>) = [ 0, 1 ] ⊗ [ 1, 0 ] ⊗ [ 1, 0 ]
f(|110>) = [ 0, 1 ] ⊗ [ 0, 1 ] ⊗ [ 0, 1 ]
f(|111>) = [ 0, 1 ] ⊗ [ 0, 1 ] ⊗ [ 1, 0 ]

Sekarang mari kita selesaikan ini ...

f(|000>) = [ 1, 0, 0, 0, 0, 0, 0, 0 ]
f(|001>) = [ 0, 1, 0, 0, 0, 0, 0, 0 ]
f(|010>) = [ 0, 0, 1, 0, 0, 0, 0, 0 ]
f(|011>) = [ 0, 0, 0, 1, 0, 0, 0, 0 ]
f(|100>) = [ 0, 0, 0, 0, 0, 1, 0, 0 ]
f(|101>) = [ 0, 0, 0, 0, 1, 0, 0, 0 ]
f(|110>) = [ 0, 0, 0, 0, 0, 0, 0, 1 ]
f(|111>) = [ 0, 0, 0, 0, 0, 0, 1, 0 ]

Mari kita buat ini kolom dari matriks lgm kita.

lgm =
[ 1, 0, 0, 0, 0, 0, 0, 0 ]
[ 0, 1, 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 1, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 1, 0, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 1, 0, 0 ]
[ 0, 0, 0, 0, 1, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 0, 0, 1 ]
[ 0, 0, 0, 0, 0, 0, 1, 0 ]

Sekarang jika matriks-gandakan seluruh matriks sistem kami, sys, dengan matriks gerbang logika kami, lgm, hasil kami akan menjadi efek menerapkan gerbang CNOT ke qubit [2] dan qubit [0] di mana qubit [2] adalah kontrol qubit.