BEBERAPA QUBIT DAN KETERIKATAN

1. Pengantar

Dapat dilihat beberapa efek menarik gerbang qubit tunggal, tetapi kekuatan sebenarnya
dari komputasi kuantum diwujudkan melalui interaksi antar qubit. Pada bagian ini akan
memperkenalkan beberapa gerbang qubit dan mengeksplorasi perilaku menarik dari sistem
multi-qubit.

Biasanya, gerbang yang dapat langsung diterapkan di perangkat keras hanya akan
bertindak pada satu atau dua qubit. Di sirkuit ini, akan menggunakan gerbang kompleks yang
bekerja pada sejumlah besar qubit. Untungnya, hal ini tidak menjadi masalah. Dengan satu
dan dua gerbang qubit yang diberikan oleh perangkat keras, dimungkinkan untuk
membangun gerbang lainnya.

Dalam bab ini, pertama akan memperkenalkan gerbang multi-qubit paling dasar, serta
matematika yang digunakan untuk mendeskripsikan dan menganalisisnya. Kemudian akan
menunjukkan cara membuktikan bahwa gerbang ini dapat digunakan untuk membuat
algoritme kuantum apa pun yang memungkinkan. Bab ini kemudian diakhiri dengan melihat
penggunaan gerbang kuantum skala kecil. Misalnya, kita melihat bagaimana membangun
gerbang tiga qubit seperti Toffoli dari operasi satu dan dua qubit.

* Ini adalah Toffoli dengan 3 qubit (q0, q1, q2) masing-masing. Dalam contoh rangkaian ini, q0
dihubungkan dengan q2 tetapi q0 tidak dihubungkan dengan q1.

2. Qubit dan Status Etangled

Qubit tunggal menarik, tetapi secara individual tidak menawarkan keunggulan

komputasi. Sekarang kita akan melihat bagaimana merepresentasikan beberapa qubit, dan
bagaimana qubit ini dapat berinteraksi satu sama lain. Kita telah melihat bagaimana
merepresentasikan status qubit menggunakan vektor 2D, sekarang kita akan melihat
bagaimana merepresentasikan status beberapa qubit
 1. Mewakili Negara-negara Multi-Qubit 
Kita melihat bahwa satu bit memiliki dua status yang memungkinkan, dan status qubit
memiliki dua amplitudo kompleks. Demikian pula, dua bit memiliki empat kemungkinan
status:

00 01 10 11

Dan untuk menggambarkan keadaan dua qubit membutuhkan empat amplitudo yang
kompleks. Dan menyimpan amplitudo ini dalam vektor 4D seperti:

Aturan pengukuran masih bekerja dengan cara yang sama:

Dan implikasi yang sama berlaku, seperti kondisi normalisasi:

Jika kita memiliki dua qubit yang terpisah, kita dapat mendeskripsikan status kolektifnya
menggunakan produk tensor:
Dan mengikuti aturan yang sama, kita dapat menggunakan produk tensor untuk
mendeskripsikan status kolektif sejumlah qubit. Berikut adalah contoh dengan tiga qubit:

Jika kita punya n qubit, harus terus memantau 2n amplitudo kompleks. Seperti yang bisa kita
lihat, vektor-vektor ini tumbuh secara eksponensial dengan jumlah qubit. Inilah alasan
mengapa komputer kuantum dengan jumlah qubit yang besar sangat sulit untuk
disimulasikan. Laptop modern dapat dengan mudah mensimulasikan keadaan kuantum umum
sekitar 20 qubit, tetapi mensimulasikan 100 qubit terlalu sulit untuk superkomputer terbesar.
Mari kita lihat contoh rangkaian:

from qiskit import QuantumCircuit, Aer, assemble

from math import pi

import numpy as np

from qiskit.visualization import plot_histogram, plot_bloch_multivector

qc = QuantumCircuit(3)

# Apply H-gate to each qubit:

for qubit in range(3):

 qc.h(qubit)

# See the circuit:

qc.draw()

Setiap qubit ada di keadaan |+⟩, jadi kita harus melihat vektornya:

# mari lihat hasilnya

svsim = Aer.get_backend('statevector_simulator')

qobj = assemble(qc)

final_state = svsim.run(qobj).result().get_statevector()

# di Jupyter Noteboooks kita dapat mensimulasikan dengan baik menggunakan Latex.

# jika tidak menggunakan Jupyter Notebooks mungkin perlu menghapus

# fungsi array_to_latex dan menggunakan print(final_state) sebagai gantinya.

from qiskit_textbook.tools import array_to_latex

array_to_latex(final_state, pretext="\\text{Statevector} = ")

Dan mendapatkan hasil yang diharapkan.

2. Gerbang Qubit Tunggal pada Multi-Qubit Statevectors 

Kita telah melihat bahwa gerbang-X diwakili oleh matriks:

Dan itu berlaku atas status |0⟩ sebagai:

tetapi mungkin tidak jelas bagaimana gerbang-X akan bertindak pada qubit dalam vektor
multi-qubit. Untungnya, aturannya cukup sederhana; sama seperti kita menggunakan hasil
kali tensor untuk menghitung vektor keadaan banyak qubit, kita menggunakan hasil perkalian
tensor untuk menghitung matriks yang bekerja pada vektor keadaan ini. Misalnya pada
rangkaian di bawah ini:

qc = QuantumCircuit(2)

qc.h(0)
qc.x(1)

qc.draw()

kita dapat merepresentasikan operasi simultan (H & X) menggunakan produk tensornya:

Pengoperasiannya terlihat seperti ini:

Yang kemudian dapat kita terapkan ke statevector 4D  |q1q0⟩. Ini bisa menjadi sangat
berantakan, Anda akan sering melihat notasi yang lebih jelas:

Alih-alih menghitung ini dengan tangan, kita dapat menggunakan Qiskit unitary_simulator

untuk menghitung ini. Simulator kesatuan mengalikan semua gerbang di sirkuit bersama-
sama untuk menyusun matriks kesatuan tunggal yang melakukan seluruh sirkuit kuantum:

usim = Aer.get_backend('unitary_simulator')

qobj = assemble(qc)

unitary = usim.run(qobj).result().get_unitary()
dan lihat hasilnya,

# di Jupyter Noteboooks kita dapat mensimulasikan dengan baik menggunakan Latex.

# jika tidak menggunakan Jupyter Notebooks mungkin perlu menghapus

# fungsi array_to_latex dan menggunakan print(final_state) sebagai gantinya.

from qiskit_textbook.tools import array_to_latex

array_to_latex(unitary, pretext="\\text{Circuit = }\n")

Jika kita ingin menerapkan gerbang hanya ke satu qubit pada satu waktu (seperti pada
rangkaian di bawah), kita menggambarkannya menggunakan produk tensor dengan matriks
identitas, misalnya:

qc = QuantumCircuit(2)

qc.x(1)

qc.draw()
# simulasikan kesatuan

usim = Aer.get_backend('unitary_simulator')

qobj = assemble(qc)

unitary = usim.run(qobj).result().get_unitary()

# tampilkan hasilnya:

array_to_latex(unitary, pretext="\\text{Circuit = } ")

Kita dapat melihat Qiskit telah melakukan produk tensor:

3. Gerbang Multi-Qubit 
Sekarang kita tahu bagaimana merepresentasikan keadaan beberapa qubit. Gerbang dua-qubit
yang penting adalah gerbang CNOT.

3.1 Gerbang CNOT 

  Gerbang ini adalah gerbang bersyarat yang melakukan gerbang X pada qubit (target) kedua,
jika keadaan qubit pertama (kontrol) adalah |1⟩.  Gerbang digambar pada sirkuit seperti ini,
dengan q0 sebagai kontrol dan q1 sebagai target:
qc = QuantumCircuit(2)

# mengaplikasikan CNOT

qc.cx(0,1)

#melihat sirkuit:

qc.draw()

Ketika qubit tidak berada dalam superposisi dari |0⟩ atau |1⟩ (berperilaku sebagai bit klasik),
gerbang ini sangat sederhana dan intuitif untuk dipahami. Kita dapat menggunakan tabel
kebenaran klasik:

Dan bertindak pada vektor keadaan 4D, ia memiliki salah satu dari dua matriks:

tergantung pada qubit mana yang menjadi kontrol dan mana yang menjadi target. Buku,
simulator, dan makalah yang berbeda mengurutkan qubit mereka secara berbeda. Dalam
kasus ini, matriks kiri sesuai dengan CNOT di sirkuit di atas. Matriks ini menukar amplitudo |
01⟩ dan  |11⟩ di status vektor:
Kita telah melihat bagaimana ini bekerja pada keadaan klasik, tetapi sekarang mari kita lihat
bagaimana ia bekerja pada qubit dalam superposisi. Kita akan menempatkan satu qubit di
keadaan |+⟩:

qc = QuantumCircuit(2)

# simulasikan gerbang H untuk yang pertama:

qc.h(0)

qc.draw()

# mari lihat hasilnya,

svsim = Aer.get_backend('statevector_simulator')

qobj = assemble(qc)

final_state = svsim.run(qobj).result().get_statevector()

# print statevector dengan rapi:

array_to_latex(final_state, pretext="\\text{Statevector = }")

Seperti yang diharapkan, ini menghasilkan keadaan  |0⟩⊗|+⟩=|0+⟩:

Dan mari kita lihat apa yang terjadi ketika kita menerapkan gerbang CNOT:

qc = QuantumCircuit(2)

# Terapkan gerbang-H ke yang pertama:

qc.h(0)

# Terapkan CNOT:

qc.cx(0,1)

qc.draw()

# mari dapatkan hasilnya:

qobj = assemble(qc)

result = svsim.run(qobj).result()

# Print statevector dengan rapi:

final_state = result.get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector = }")

Dapat dilihat memiliki status:

Keadaan ini sangat menarik, karena keterikatan ( terjerat).  

3.2 Keadaan yang Terjerat 

Dapat dilihat di bagian sebelumnya dapat membuat status:

Ini dikenal sebagai keadaan Bell . Kita dapat melihat bahwa keadaan ini memiliki

kemungkinan 50% untuk diukur dalam keadaan |00⟩, dan 50% kemungkinan diukur di
keadaan |11⟩. Yang paling menarik, ia memiliki peluang  0% untuk diukur di keadaan |
01⟩ atau  |10⟩. Kita bisa melihat ini di Qiskit:

plot_histogram(result.get_counts())
Keadaan gabungan ini tidak dapat ditulis sebagai dua keadaan qubit yang terpisah, yang
memiliki implikasi menarik. Meskipun qubit kita berada dalam superposisi, mengukur satu
akan memberi tahu kita keadaan yang lain dan meruntuhkan superposisinya. Misalnya, jika
kita mengukur qubit teratas dan mendapatkan status |1⟩, status kolektif qubit kita berubah
seperti ini:

Bahkan jika kita memisahkan qubit ini sejauh beberapa tahun cahaya, mengukur satu qubit
akan meruntuhkan superposisi dan tampaknya memiliki efek langsung pada qubit lainnya. Ini
adalah 'aksi seram di kejauhan' yang membuat marah banyak fisikawan di awal abad ke-20.

Penting untuk dicatat bahwa hasil pengukuran adalah acak, dan statistik pengukuran satu
qubit tidak terpengaruh oleh operasi apa pun pada qubit lainnya. Karena itu, tidak ada
cara untuk menggunakan status kuantum bersama untuk berkomunikasi. Ini dikenal sebagai
teorema tanpa komunikasi.

3.3 Memvisualisasikan Keadaan Terjerat/Keterikatan 

Kita telah melihat bahwa keadaan ini tidak dapat ditulis sebagai dua keadaan qubit yang
terpisah, ini juga berarti kita kehilangan informasi ketika kita mencoba untuk memplot
keadaan kita pada bidang Bloch yang terpisah:

plot_bloch_multivector ( final_state )
Mengingat bagaimana kita mendefinisikan bola Bloch di bab-bab sebelumnya, mungkin tidak
jelas bagaimana Qiskit menghitung vektor Bloch dengan qubit keterikatan seperti ini. Dalam
kasus qubit tunggal, posisi vektor Bloch di sepanjang sumbu sesuai dengan nilai harapan
pengukuran dalam basis itu.  Jika kita mengambil ini sebagai  aturan yang merencanakan
Bloch vektor, kita sampai pada kesimpulan ini di atas. Ini menunjukkan kepada kita
bahwa tidak ada  dasar pengukuran qubit tunggal yang menjamin pengukuran tertentu. Ini
kontras dengan status qubit tunggal kita, di mana selalu dapat memilih basis qubit
tunggal. Melihat qubit individu dengan cara ini, kita kehilangan efek penting dari korelasi
antara qubit. Kita tidak dapat membedakan antara keadaan keterikatan yang
berbeda. Misalnya, dua status:

keduanya akan terlihat sama pada bola Bloch yang terpisah ini, meskipun keadaannya sangat
berbeda dengan hasil pengukuran yang berbeda.

Bagaimana lagi kita bisa memvisualisasikan statevector ini? Vektor keadaan ini hanyalah
kumpulan dari empat amplitudo (bilangan kompleks), dan ada banyak cara untuk
memetakannya ke gambar. Salah satu visualisasi tersebut adalah Q-sphere, di sini setiap
amplitudo diwakili oleh gumpalan pada permukaan bola. Ukuran gumpalan sebanding
dengan besarnya amplitudo, dan warnanya sebanding dengan fase amplitudo. Amplitudo
untuk |00⟩ dan  |11⟩ sama, dan semua amplitudo lainnya adalah 0:

from qiskit.visualization import plot_state_qsphere

plot_state_qsphere(final_state)
Di sini kita dapat dengan jelas melihat korelasi antara qubit. Bentuk Q-sphere tidak memiliki
arti penting, itu hanyalah cara yang bagus untuk mengatur gumpalan; jumlah 0s dalam
keadaan sebanding dengan posisi keadaan pada sumbu Z, jadi di sini kita dapat melihat
amplitudo dari |00⟩ berada di kutub atas bola, dan amplitudo |11⟩ berada di kutub bawah bola.

3. Phase Kickback

1. Menjelajahi Gerbang CNOT 

Pada bagian sebelumnya, kita melihat beberapa hasil yang sangat mendasar dengan gerbang
CNOT. Di sini kita akan mengeksplorasi beberapa hasil yang lebih menarik.

Dapat dilihat bahwa kita dapat menjerat dua qubit dengan menempatkan qubit kontrol dalam
status |+⟩:

Tetapi apa yang terjadi jika kita menempatkan qubit kedua dalam superposisi?

from qiskit import QuantumCircuit, Aer, assemble

from math import pi

import numpy as np

from qiskit.visualization import plot_bloch_multivector, plot_histogram

# Di Jupyter Notebooks kita dapat menampilkannya dengan baik menggunakan

Latex.

# Jika tidak menggunakan Jupyter Notebooks, kita mungkin perlu menghapus

# fungsi array_to_latex dan menggunakan print() sebagai gantinya.

from qiskit_textbook.tools import array_to_latex

qc = QuantumCircuit(2)

qc.h(0)

qc.h(1)

qc.cx(0,1)

qc.draw()

Dalam rangkaian di atas, kita memiliki CNOT yang bekerja pada keadaan:
Karena CNOT menukar amplitudo dari  |01⟩ dan  |11⟩, kita tidak melihat perubahan:

qc = QuantumCircuit(2)

qc.h(0)

qc.h(1)

qc.cx(0,1)

display(qc.draw()) # `display` adalah perintah untuk notebook Jupyter

# mirip dengan `print`, tetapi untuk konten yang kaya

# Mari kita lihat hasilnya

svsim = Aer.get_backend('statevector_simulator')

qobj = assemble(qc)

final_state = svsim.run(qobj).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)
Mari kita letakkan target qubit di keadaan  |-⟩, sehingga memiliki fase negatif:

qc = QuantumCircuit(2)

qc.h(0)

qc.x(1)

qc.h(1)

qc.draw()

Ini menciptakan status:

qc = QuantumCircuit(2)

qc.h(0)

qc.x(1)
qc.h(1)

display(qc.draw())

# lihat hasilnya

qobj = assemble(qc)

final_state = svsim.run(qobj).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)
Jika CNOT bekerja pada keadaan ini, kita akan menukar amplitudo |01⟩ dan |11⟩,
menghasilkan keadaan:

Ini menarik, karena mempengaruhi status qubit kontrol sementara status qubit target tidak

berubah.

qc.cx(0,1)

display(qc.draw())

qobj = assemble(qc)

final_state = svsim.run(qobj).result().get_statevector()

array_to_latex(final_state, pretext="\\text{Statevector} = ", precision=1)

plot_bloch_multivector(final_state)
Jika ingat transformasi gerbang -H |+⟩→|0⟩  dan  |-⟩→|1⟩, kita dapat melihat bahwa membuat
CNOT di gerbang -H memiliki perilaku yang setara dengan CNOT yang bekerja dalam arah
yang berlawanan:

Dapat memverifikasi ini menggunakan simulator kesatuan Qiskit:

qc = QuantumCircuit(2)

qc.h(0)

qc.h(1)

qc.cx(0,1)

qc.h(0)

qc.h(1)

display(qc.draw())

usim = Aer.get_backend('unitary_simulator')

qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()

array_to_latex(unitary, pretext="\\text{Circuit = }\n")

qc = QuantumCircuit(2)

qc.cx(1,0)

display(qc.draw())

qobj = assemble(qc)

unitary = usim.run(qobj).result().get_unitary()

array_to_latex(unitary, pretext="\\text{Circuit = }\n")

Identitas ini adalah contoh dari  fase kickback, 

2. Fase Kickback 

2.1 Menjelaskan Identitas Sirkuit CNOT 

Pada bagian sebelumnya kita melihat identitas ini:

Ini adalah contoh kickback (atau, fase kickback ) yang sangat penting dan digunakan di

hampir setiap algoritma kuantum. Kickback adalah tempat nilai eigen yang ditambahkan oleh
gerbang ke qubit 'ditendang kembali' ke qubit yang berbeda melalui operasi yang
dikendalikan. Sebagai contoh, kita melihat bahwa melakukan gerbang X pada a|-⟩ qubit
memberikannya fase -1:

Ketika qubit kontrol kita ada di keduanya |0⟩ atau |1⟩, fase ini mempengaruhi seluruh
keadaan, namun ini adalah fase global dan tidak memiliki efek yang dapat diamati:

Efek yang menarik adalah ketika qubit kontrol berada dalam superposisi, komponen qubit
kontrol yang terletak pada arah |1⟩ menerapkan faktor fase ini ke qubit target, yang pada
gilirannya mengembalikan fase relatif ke qubit kontrol:
Ini kemudian dapat ditulis sebagai dua status qubit yang dapat dipisahkan:

Membungkus CNOT dalam gerbang- H mengubah qubit dari basis komputasi menjadi  (|+⟩,
|-⟩) dasar, di mana kita melihat efek ini. Identitas ini sangat berguna dalam perangkat keras,
karena beberapa perangkat keras hanya mengizinkan CNOT dalam satu arah di antara dua
qubit tertentu. Kita dapat menggunakan identitas ini untuk mengatasi masalah ini dan
memungkinkan CNOT di kedua arah.

2.2 Kickback dengan gerbang-T 

Mari kita lihat operasi terkontrol lainnya, gerbang T-terkontrol:

qc = QuantumCircuit(2)

qc.cp(pi/4, 0, 1)

qc.draw()

Gerbang-T memiliki matriks:

Dan gerbang T-terkontrol memiliki matriks:

Dapat memverifikasi ini menggunakan simulator kesatuan Qiskit:

qc = QuantumCircuit(2)

qc.cp(pi/4, 0, 1)

display(qc.draw())

# lihat hasilnya:

qobj = assemble(qc)

unitary = usim.run(qobj).result().get_unitary()

array_to_latex(unitary, pretext="\\text{Controlled-T} = \n")

Secara lebih umum, kita dapat menemukan matriks dari setiap operasi U-terkontrol
menggunakan aturan:

Atau, menggunakan pemesanan qubit Qiskit:

Jika kita menerapkan gerbang-T ke qubit dalam keadaan |1⟩|1⟩, kita tambahkan fase
dari eiπ/4 ke qubit ini:

Ini adalah fase global dan tidak dapat diamati. Tetapi jika kita mengontrol operasi ini
menggunakan qubit lain di|+⟩|+⟩ state, the phase is no longer global but relative, which
changes the relative phase in our control qubit:

Ini memiliki efek memutar qubit kontrol kami di sekitar sumbu Z dari bola Bloch, sementara
membiarkan qubit target tidak berubah. Mari kita lihat ini di Qiskit:

qc = QuantumCircuit(2)

qc.h(0)

qc.x(1)
display(qc.draw())

# See Results:

qobj = assemble(qc)

final_state = svsim.run(qobj).result().get_statevector()

plot_bloch_multivector(final_state)

qc = QuantumCircuit(2)

qc.h(0)

qc.x(1)

# Add Controlled-T

qc.cp(pi/4, 0, 1)

display(qc.draw())

# See Results:

qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()

plot_bloch_multivector(final_state)

Kita dapat melihat qubit paling kiri telah diputar oleh π/4π/4di sekitar sumbu Z bola
Bloch seperti yang diharapkan. Setelah menjelajahi perilaku ini, mungkin menjadi jelas
mengapa Qiskit menggambar gerbang rotasi Z terkontrol dengan cara simetris ini (dua
kontrol, bukan kontrol dan target). Tidak ada kontrol yang jelas atau target qubit untuk
semua kasus.
4. Identitas Sirkuit

5. Pembuktian Univesitalitas
6. Komputasi Klasik pada Komputer Quantum