Quantum bit, Gate, dan Circuit

catatan

Kifumi Numata (19 Apr 2024)

Klik di sini untuk mengunduh pdf kuliah aslinya. Perlu diperhatikan bahwa beberapa cuplikan kode mungkin sudah tidak berlaku karena ini adalah gambar statis.

Perkiraan waktu QPU untuk menjalankan eksperimen ini adalah 5 detik.

1. Pendahuluan

Bit, Gate, dan Circuit adalah blok bangunan dasar dari komputasi kuantum. Kamu akan belajar komputasi kuantum dengan model circuit menggunakan quantum bit dan gate, serta meninjau superposisi, pengukuran, dan entanglement.

Dalam pelajaran ini kamu akan belajar:

• Single-qubit Gate
• Bloch sphere
• Superposisi
• Pengukuran
• Two-qubit Gate dan kondisi entanglement

Di akhir kuliah ini, kamu akan belajar tentang kedalaman circuit (circuit depth), yang sangat penting untuk komputasi kuantum skala utilitas.

2. Komputasi sebagai diagram

Saat menggunakan qubit atau bit, kita perlu memanipulasinya agar input yang kita miliki bisa diubah menjadi output yang kita butuhkan. Untuk program paling sederhana dengan sangat sedikit bit, proses ini berguna untuk direpresentasikan dalam diagram yang dikenal sebagai circuit diagram.

Gambar kiri bawah adalah contoh circuit klasik, dan gambar kanan bawah adalah contoh quantum circuit. Dalam kedua kasus, input ada di sebelah kiri dan output ada di sebelah kanan, sementara operasi direpresentasikan oleh simbol. Simbol yang digunakan untuk operasi disebut "gate", sebagian besar karena alasan historis.

3. Single-qubit quantum Gate

3.1 Kondisi kuantum dan Bloch sphere

Kondisi sebuah qubit direpresentasikan sebagai superposisi dari $|0\rangle$ dan $|1\rangle$. Kondisi kuantum sembarang direpresentasikan sebagai

$$|\psi\rangle =\alpha|0\rangle+ \beta|1\rangle$$

di mana $\alpha$ dan $\beta$ adalah bilangan kompleks sehingga $|\alpha|^2+|\beta|^2=1$.

$|0\rangle$ dan $|1\rangle$ adalah vektor dalam ruang vektor kompleks dua dimensi:

$$|0\rangle = \begin{pmatrix} 1 \\0 \end{pmatrix}, |1\rangle = \begin{pmatrix} 0\\1 \end{pmatrix}$$

Oleh karena itu, kondisi kuantum sembarang juga direpresentasikan sebagai

$$|\psi\rangle = \alpha\begin{pmatrix} 1 \\ 0 \end{pmatrix} + \beta\begin{pmatrix}0\\ 1 \end{pmatrix} = \begin{pmatrix} \alpha \\ \beta \end{pmatrix}$$

Dari sini, kita bisa melihat bahwa kondisi sebuah quantum bit adalah vektor satuan dalam ruang hasil kali dalam kompleks dua dimensi dengan basis ortonormal $|0\rangle$ dan $|1\rangle$. Ini dinormalisasi ke 1.

$$\langle\psi|\psi\rangle = \begin{pmatrix} \alpha^* & \beta^* \end{pmatrix} \begin{pmatrix} \alpha \\ \beta \end{pmatrix} = 1$$

$|\psi\rangle =\begin{pmatrix} \alpha \\ \beta \end{pmatrix}$ juga disebut statevector.

Kondisi quantum single-qubit juga direpresentasikan sebagai

$$|\psi\rangle =\cos\frac{\theta}{2}|0\rangle+e^{i\varphi}\sin\frac{\theta}{2}|1\rangle =\left( \begin{pmatrix} \cos\frac{\theta}{2}\\ e^{i\varphi}\sin\frac{\theta}{2} \end{pmatrix}\right)$$

di mana $\theta$ dan $\varphi$ adalah sudut pada Bloch sphere pada gambar berikut.

Pada beberapa sel kode berikutnya, kita akan membangun perhitungan dasar dari bagian-bagian penyusunnya di Qiskit. Kita akan membuat circuit kosong lalu menambahkan operasi kuantum, membahas gate dan memvisualisasikan efeknya seiring kita berjalan. Kamu bisa menjalankan sel dengan "Shift" + "Enter". Import library-nya terlebih dahulu.

# Added by doQumentation — required packages for this notebook
!pip install -q qiskit qiskit-aer qiskit-ibm-runtime

# Import the qiskit library
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
from qiskit_ibm_runtime import Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.visualization import plot_histogram

Menyiapkan quantum Circuit

Kita akan membuat dan menggambar single-qubit circuit.

# Create the single-qubit quantum circuit
qc = QuantumCircuit(1)

# Draw the circuit
qc.draw("mpl")

X Gate

X Gate adalah rotasi $\pi$ mengelilingi sumbu $x$ pada Bloch sphere. Menerapkan X Gate pada $|0\rangle$ menghasilkan $|1\rangle$, dan menerapkan X Gate pada $|1\rangle$ menghasilkan $|0\rangle$, sehingga ini adalah operasi yang mirip dengan gate NOT klasik, dan juga dikenal sebagai bit flip. Representasi matriks dari X Gate adalah sebagai berikut.

$$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \\ \end{pmatrix}$$

qc = QuantumCircuit(1)  # Prepare the single-qubit quantum circuit

# Apply a X gate to qubit 0
qc.x(0)

# Draw the circuit
qc.draw("mpl")

Di IBM Quantum®, kondisi awal diatur ke $|0\rangle$, sehingga quantum circuit di atas dalam representasi matriks adalah

$$X|0\rangle= \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \end{pmatrix} =\begin{pmatrix} 0 \\ 1 \end{pmatrix} = |1\rangle$$

Selanjutnya, mari kita jalankan circuit ini menggunakan simulator statevector.

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([0.+0.j, 1.+0.j],
            dims=(2,))

Vektor vertikal ditampilkan sebagai vektor baris, dengan bilangan kompleks (bagian imajiner diindeks dengan $j$).

H Gate

Hadamard Gate adalah rotasi $\pi$ mengelilingi sumbu yang berada di tengah antara sumbu $x$ dan $z$ pada Bloch sphere. Menerapkan H Gate pada $|0\rangle$ membuat kondisi superposisi seperti $\frac{|0\rangle + |1\rangle}{\sqrt{2}}$. Representasi matriks dari H Gate adalah sebagai berikut.

$$H = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \\ \end{pmatrix}$$

qc = QuantumCircuit(1)  # Create the single-qubit quantum circuit

# Apply an Hadamard gate to qubit 0
qc.h(0)

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([0.70710678+0.j, 0.70710678+0.j],
            dims=(2,))

Ini adalah

$$H|0\rangle= \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} \begin{pmatrix} 1 \\0 \end{pmatrix} =\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix} =\begin{pmatrix} 0.707 \\ 0.707 \end{pmatrix} =\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$$

Kondisi superposisi ini sangat umum dan penting, sehingga diberi simbolnya sendiri:

$$|+\rangle \equiv \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle).$$

Dengan menerapkan gate $H$ pada $|0\rangle$, kita membuat superposisi dari $|0\rangle$ dan $|1\rangle$ di mana pengukuran dalam basis komputasi (sepanjang z dalam gambaran Bloch sphere) akan memberikan setiap kondisi dengan probabilitas yang sama.

Kondisi $|-\rangle$

Kamu mungkin sudah menduga bahwa ada kondisi $|-\rangle$ yang bersesuaian:

$$|-\rangle \equiv \frac{|0\rangle -|1\rangle}{\sqrt{2}}.$$

Untuk membuat kondisi ini, pertama terapkan X Gate untuk membuat $|1\rangle$, kemudian terapkan H Gate.

qc = QuantumCircuit(1)  # Create the single-qubit quantum circuit

# Apply a X gate to qubit 0
qc.x(0)

# Apply an Hadamard gate to qubit 0
qc.h(0)

# draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([ 0.70710678+0.j, -0.70710678+0.j],
            dims=(2,))

Ini adalah

$$H|1\rangle= \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\\ 1 & -1 \end{pmatrix} \begin{pmatrix} 0 \\\ 1 \end{pmatrix} =\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\\ -1 \end{pmatrix} =\begin{pmatrix} 0.707 \\\ -0.707 \end{pmatrix} =\frac{1}{\sqrt{2}}(|0\rangle-|1\rangle) = |-\rangle$$

Menerapkan gate $H$ pada $|1\rangle$ menghasilkan superposisi yang sama dari $|0\rangle$ dan $|1\rangle$, tapi tanda dari $|1\rangle$ adalah negatif.

3.2 Kondisi quantum single-qubit dan evolusi uniter

Aksi semua gate yang sudah kita lihat sejauh ini bersifat uniter, yang berarti dapat direpresentasikan oleh operator uniter. Dengan kata lain, kondisi output dapat diperoleh dengan mengoperasikan kondisi awal dengan matriks uniter:

$$|\psi^{'}\rangle = U|\psi\rangle$$

Matriks uniter adalah matriks yang memenuhi

$$U^{\dagger}U =U U^{\dagger} = I.$$

Dalam konteks operasi komputer kuantum, kita bisa mengatakan bahwa menerapkan quantum Gate pada qubit mengevolusi kondisi kuantum. Gate single-qubit yang umum mencakup yang berikut ini.

Gate Pauli:

$$X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \\ \end{pmatrix} = |0\rangle \langle 1|+|1\rangle \langle 0|$$ $$Y = \begin{pmatrix} 0 & -i \\ i & 0 \\ \end{pmatrix} = -i|0\rangle \langle 1|+i|1\rangle \langle 0|$$ $$Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \\ \end{pmatrix} = |0\rangle \langle 0|-|1\rangle \langle 1|$$

di mana hasil kali luar dihitung sebagai berikut:

$$|0\rangle \langle 0|= \begin{bmatrix} 1 \\ 0 \end{bmatrix} \begin{bmatrix} 1 & 0 \end{bmatrix} =\begin{bmatrix} 1 & 0 \\ 0 & 0 \\ \end{bmatrix}, \quad |1\rangle \langle 0|= \begin{bmatrix} 0 \\ 1 \end{bmatrix} \begin{bmatrix} 1 & 0 \end{bmatrix} =\begin{bmatrix} 0 & 0 \\ 1 & 0 \\ \end{bmatrix}, \quad$$ $$|0\rangle \langle 1|= \begin{bmatrix} 1 \\ 0 \end{bmatrix} \begin{bmatrix} 0 & 1 \end{bmatrix} =\begin{bmatrix} 0 & 1 \\ 0 & 0 \\ \end{bmatrix}, \quad |1\rangle \langle 1|= \begin{bmatrix} 0 \\ 1 \end{bmatrix} \begin{bmatrix} 0 & 1 \end{bmatrix} =\begin{bmatrix} 0 & 0 \\ 0 & 1 \\ \end{bmatrix}, \quad$$

Gate single-qubit tipikal lainnya:

$$H= \frac{1}{\sqrt{2}}\begin{bmatrix} 1 & 1 \\ 1 & -1 \\ \end{bmatrix},\quad S = \begin{bmatrix} 1 & 0 \\ 0 & i \\ \end{bmatrix}, \quad T = \begin{bmatrix} 1 & 0 \\ 0 & exp(i\pi/4) \\ \end{bmatrix}$$ $$R_x(\theta) = e^{-i\theta X/2} = cos\frac{\theta}{2}I - i sin \frac{\theta}{2}X = \begin{bmatrix} cos\frac{\theta}{2} & -i sin \frac{\theta}{2} \\ -i sin \frac{\theta}{2} & cos\frac{\theta}{2} \\ \end{bmatrix}$$ $$R_y(\theta) = e^{-i\theta Y/2} = cos\frac{\theta}{2}I - i sin \frac{\theta}{2}Y = \begin{bmatrix} cos\frac{\theta}{2} & - sin \frac{\theta}{2} \\ sin \frac{\theta}{2} & cos\frac{\theta}{2} \\ \end{bmatrix}$$ $$R_z(\theta) = e^{-i\theta Z/2} = cos\frac{\theta}{2}I - i sin \frac{\theta}{2}Z = \begin{bmatrix} e^{-i\theta /2} & 0 \\ 0 & e^{i\theta /2} \\ \end{bmatrix}$$

Arti dan penggunaan ini dijelaskan lebih rinci dalam kursus Basics of Quantum Information.

Latihan 1

Gunakan Qiskit untuk membuat quantum circuit yang menyiapkan kondisi yang dijelaskan di bawah ini. Kemudian jalankan setiap circuit menggunakan simulator statevector dan tampilkan kondisi yang dihasilkan pada Bloch sphere. Sebagai bonus, coba lihat apakah kamu bisa memperkirakan apa kondisi akhirnya berdasarkan intuisi tentang gate dan rotasi di Bloch sphere.

(1) $XX|0\rangle$

(2) $HH|0\rangle$

(3) $HZH|0\rangle$

Tips: Z Gate bisa digunakan dengan

qc.z(0)

Solusi:

### (1) XX|0> ###

# Create the single-qubit quantum circuit
qc = QuantumCircuit(1)  ##your code goes here##

# Add a X gate to qubit 0
qc.x(0)  ##your code goes here##

# Add a X gate to qubit 0
qc.x(0)  ##your code goes here##

# Draw a circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([1.+0.j, 0.+0.j],
            dims=(2,))

### (2) HH|0> ###
##your code goes here##
qc = QuantumCircuit(1)
qc.h(0)
qc.h(0)
qc.draw("mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([1.+0.j, 0.+0.j],
            dims=(2,))

### (3) HZH|0> ###
##your code goes here##
qc = QuantumCircuit(1)
qc.h(0)
qc.z(0)
qc.h(0)
qc.draw("mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Statevector([0.+0.j, 1.+0.j],
            dims=(2,))

3.3 Pengukuran

Pengukuran secara teori adalah topik yang sangat rumit. Tapi secara praktis, melakukan pengukuran sepanjang $z$ (seperti yang dilakukan semua komputer kuantum IBM®) hanya memaksa kondisi qubit $\alpha|0\rangle+\beta|1\rangle \quad (s.t.|\alpha|^2+|\beta|^2=1)$ menjadi $|0\rangle$ atau $|1\rangle,$ dan kita mengamati hasilnya.

• $|\alpha|^2$ adalah probabilitas kita mendapatkan $|0\rangle$ saat mengukur.
• $|\beta|^2$ adalah probabilitas kita mendapatkan $|1\rangle$ saat mengukur.

Jadi, $\alpha$ dan $\beta$ disebut amplitudo probabilitas. (lihat "aturan Born")

Sebagai contoh, $\frac{\sqrt{2}}{2}|0\rangle+\frac{\sqrt{2}}{2}|1\rangle$ memiliki probabilitas yang sama untuk menjadi $|0\rangle$ atau $|1\rangle$ saat diukur. $\frac{\sqrt{3}}{2}|0\rangle-\frac{1}{2}i|1\rangle$ memiliki peluang 75% untuk menjadi $|0\rangle$.

Qiskit Aer Simulator

Selanjutnya, mari kita ukur sebuah circuit yang menyiapkan superposisi probabilitas sama di atas. Kita perlu menambahkan gate pengukuran, karena Qiskit Aer simulator mensimulasikan perangkat keras kuantum ideal (tanpa noise) secara default. Catatan: Simulator Aer juga bisa menerapkan model noise berdasarkan komputer kuantum nyata. Kita akan kembali ke model noise nanti.

# Create a new circuit with one qubits (first argument) and one classical bits (second argument)
qc = QuantumCircuit(1, 1)
qc.h(0)
qc.measure(0, 0)  # Add the measurement gate

qc.draw(output="mpl")

Kita sekarang siap untuk menjalankan circuit kita pada simulator Aer. Dalam contoh ini, kita akan menggunakan shots=1024 secara default, yang berarti kita akan mengukur sebanyak 1024 kali. Kemudian kita akan memplot hitungan tersebut dalam histogram.

# Run the circuit on a simulator to get the results
# Define backend
backend = AerSimulator()

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc])
result = job.result()

# Print the results
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'0': 521, '1': 503}

Kita melihat bahwa 0 dan 1 diukur dengan probabilitas hampir 50% masing-masing. Meskipun noise tidak disimulasikan di sini, kondisinya tetap bersifat probabilistik. Jadi meskipun kita mengharapkan distribusi kira-kira 50-50, kita jarang menemukan tepat seperti itu. Sama seperti 100 lemparan koin yang jarang menghasilkan tepat 50 masing-masing sisi.

4. Multi-qubit quantum gate dan entanglement

4.1 Multi-qubit quantum Circuit

Kita bisa membuat quantum Circuit dua qubit dengan kode berikut. Kita akan menerapkan H Gate ke setiap qubit.

# Create the two qubits quantum circuit
qc = QuantumCircuit(2)

# Apply an H gate to qubit 0
qc.h(0)

# Apply an H gate to qubit 1
qc.h(1)

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

Statevector([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j],
            dims=(2, 2))

Catatan: Urutan bit di Qiskit

Qiskit menggunakan notasi Little Endian saat mengurutkan qubit dan bit, artinya qubit 0 adalah bit paling kanan dalam bitstring. Contoh: $|01\rangle$ berarti q0 adalah $|1\rangle$ dan q1 adalah $|0\rangle$. Perhatikan ini karena sebagian literatur komputasi kuantum menggunakan notasi Big Endian (qubit 0 adalah bit paling kiri), begitu pula banyak literatur mekanika kuantum.

Hal lain yang perlu diperhatikan adalah saat merepresentasikan quantum Circuit, $|q_0\rangle$ selalu ditempatkan di bagian atas Circuit. Dengan mempertimbangkan hal ini, keadaan kuantum pada Circuit di atas bisa ditulis sebagai tensor product dari keadaan kuantum single-qubit.

$|q1\rangle \otimes|q0\rangle = (a|0\rangle+b|1\rangle) \otimes (c|0\rangle+d|1\rangle)$

$= ac|0\rangle|0\rangle+ad|0\rangle|1\rangle+bc|1\rangle|0\rangle+bd|1\rangle|1\rangle$

$= ac|00\rangle+ad|01\rangle+bc|10\rangle+bd|11\rangle$

( $|ac|^2+ |ad|^2+ |bc|^2+ |bd|^2=1$ )

Keadaan awal Qiskit adalah $|0\rangle|0\rangle=|00\rangle$, jadi dengan menerapkan $H$ ke setiap qubit, keadaan berubah menjadi superposisi yang setara.

$H|0\rangle \otimes H|0\rangle=\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle) \otimes \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle) = \frac{1}{2}(|00\rangle+|01\rangle+|10\rangle+|11\rangle)$

$$=\frac{1}{2}\left( \begin{pmatrix} 1 \\ 1 \end{pmatrix} \otimes \begin{pmatrix} 1 \\ 1 \end{pmatrix}\right) = \frac{1}{2}\begin{pmatrix} 1 \\ 1 \\ 1 \\ 1 \end{pmatrix}=\frac{1}{2}\left(\begin{pmatrix} 1 \\ 0 \\ 0 \\ 0 \end{pmatrix}+\begin{pmatrix} 0 \\ 1 \\ 0 \\ 0 \end{pmatrix}+\begin{pmatrix} 0 \\ 0 \\ 1 \\ 0 \end{pmatrix}+\begin{pmatrix} 0 \\ 0 \\ 0 \\ 1 \end{pmatrix}\right)$$

Aturan pengukuran juga sama seperti kasus single qubit, probabilitas mengukur $|00\rangle$ adalah $|ac|^2$.

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Selanjutnya, mari kita ukur Circuit ini.

# Create a new circuit with two qubits (first argument) and two classical bits (second argument)
qc = QuantumCircuit(2, 2)

# Apply the gates
qc.h(0)
qc.h(1)

# Add the measurement gates
qc.measure(0, 0)  # Measure qubit 0 and save the result in bit 0
qc.measure(1, 1)  # Measure qubit 1 and save the result in bit 1

# Draw the circuit
qc.draw(output="mpl")

Sekarang, kita akan menggunakan simulator Aer lagi untuk memverifikasi secara eksperimental bahwa probabilitas relatif dari semua kemungkinan keadaan output kira-kira setara.

# Run the circuit on a simulator to get the results
# Define backend
backend = AerSimulator()

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(mode=backend)
job = sampler.run([isa_qc])
result = job.result()

# Print the results
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'10': 262, '01': 246, '00': 265, '11': 251}

Sesuai perkiraan, keadaan $|00\rangle$, $|01\rangle$, $|10\rangle$, $|11\rangle$ masing-masing diukur hampir 25%.

4.2 Multi-qubit quantum Gate

CNOT Gate

Gate CNOT ("controlled NOT" atau CX) adalah Gate dua qubit, artinya aksinya melibatkan dua qubit sekaligus: qubit kontrol dan qubit target. CNOT membalik qubit target hanya ketika qubit kontrol berada dalam keadaan $|1\rangle$.

Input (target,kontrol)	Output (target,kontrol)
00	00
01	11
10	10
11	01

Mari kita simulasikan aksi Gate dua qubit ini ketika q0 dan q1 keduanya $|0\rangle$, dan dapatkan statevector outputnya. Sintaks Qiskit yang digunakan adalah qc.cx(qubit kontrol, qubit target).

# Create a circuit with two quantum registers and two classical registers
qc = QuantumCircuit(2, 2)

# Apply the CNOT (cx) gate to a |00> state.
qc.cx(0, 1)  # Here the control is set to q0 and the target is set to q1.

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

Statevector([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
            dims=(2, 2))

Sesuai perkiraan, menerapkan Gate CNOT pada $|00\rangle$ tidak mengubah keadaan, karena qubit kontrol berada dalam keadaan $|0\rangle$. Mari kembali ke operasi CNOT kita. Kali ini kita akan menerapkan Gate CNOT ke $|01\rangle$ dan melihat apa yang terjadi.

qc = QuantumCircuit(2, 2)

# q0=1, q1=0
qc.x(0)  # Apply a X gate to initialize q0 to 1
qc.cx(0, 1)  # Set the control bit to q0 and the target bit to q1.

# Draw the circuit
qc.draw(output="mpl")

# See the statevector
out_vector = Statevector(qc)
print(out_vector)

Statevector([0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
            dims=(2, 2))

Dengan menerapkan Gate CNOT, keadaan $|01\rangle$ kini menjadi $|11\rangle$.

Mari kita verifikasi hasil ini dengan menjalankan Circuit pada simulator.

# Add measurements
qc.measure(0, 0)
qc.measure(1, 1)

# Draw the circuit
qc.draw(output="mpl")

# Run the circuit on a simulator to get the results
# Define backend
backend = AerSimulator()

# Transpile to backend
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

# Run the job
sampler = Sampler(backend)
job = sampler.run([isa_qc])
result = job.result()

# Print the results
counts = result[0].data.c.get_counts()
print(counts)

# Plot the counts in a histogram
plot_histogram(counts)

{'11': 1024}

Hasilnya menunjukkan bahwa $|11\rangle$ diukur dengan probabilitas 100%.

4.3 Entanglement kuantum dan eksekusi pada perangkat kuantum nyata

Mari kita mulai dengan memperkenalkan keadaan tertentu yang sangat penting dalam komputasi kuantum, lalu kita akan mendefinisikan istilah "entangled":

$$\frac{1}{\sqrt{2}}|00\rangle + \frac{1}{\sqrt{2}}|11\rangle$$

dan keadaan ini disebut Bell state.

Keadaan terjalin (entangled) adalah keadaan $|\psi_{AB}\rangle$ yang terdiri dari keadaan kuantum $|\psi_A\rangle$ dan $|\psi_B\rangle$ yang tidak bisa direpresentasikan sebagai tensor product dari keadaan kuantum individual.

Jika $|\psi_{AB}\rangle$ di bawah memiliki dua keadaan $|\psi\rangle_A$ dan $|\psi\rangle_B$;

$$|\psi_{AB}\rangle = \frac{1}{\sqrt{2}}(|00\rangle +|11\rangle) = \frac{1}{\sqrt{2}}(|0\rangle_A|0\rangle_B +|1\rangle_A|1\rangle_B)$$ $$|\psi\rangle_A = a_0|0\rangle+a_1|1\rangle$$ $$|\psi\rangle_B = b_0|0\rangle+b_1|1\rangle$$

maka tensor product dari dua keadaan ini adalah sebagai berikut

$$|\psi\rangle _A\otimes |\psi\rangle _B = a_0 b_0|00\rangle+a_0 b_1|01\rangle+a_1 b_0|10\rangle+a_1 b_1|11\rangle$$

tapi tidak ada koefisien $a_0, a_1, b_0,$ dan $b_1$ yang bisa memenuhi dua persamaan ini. Oleh karena itu, $|\psi_{AB}\rangle$ tidak bisa direpresentasikan sebagai tensor product dari keadaan kuantum individual, $|\psi\rangle_A$ dan $|\psi\rangle_B$, dan ini berarti bahwa $|\psi_{AB}\rangle = \frac{1}{\sqrt{2}}(|00\rangle +|11\rangle)$ adalah keadaan terjalin (entangled).

Mari kita buat Bell state dan jalankan di komputer kuantum nyata. Sekarang kita akan mengikuti empat langkah untuk menulis program kuantum, yang disebut Qiskit patterns:

1. Petakan masalah ke quantum Circuit dan operator
2. Optimalkan untuk hardware target
3. Eksekusi di hardware target
4. Proses pasca hasil

Langkah 1. Petakan masalah ke quantum Circuit dan operator

Dalam program kuantum, quantum Circuit adalah format asli untuk merepresentasikan instruksi kuantum. Saat membuat Circuit, biasanya kamu membuat objek QuantumCircuit baru, lalu menambahkan instruksi ke dalamnya secara berurutan.

Kode berikut membuat Circuit yang menghasilkan Bell state, keadaan terjalin dua qubit tertentu dari atas.

qc = QuantumCircuit(2, 2)

qc.h(0)
qc.cx(0, 1)

qc.measure(0, 0)
qc.measure(1, 1)

qc.draw("mpl")

Langkah 2. Optimalkan untuk hardware target

Qiskit mengonversi Circuit abstrak ke Circuit QISA (Quantum Instruction Set Architecture) yang memenuhi batasan hardware target dan mengoptimalkan performa Circuit. Jadi sebelum optimasi, kita akan menentukan hardware target. Jika kamu belum memiliki qiskit-ibm-runtime, kamu perlu menginstalnya terlebih dahulu. Untuk informasi lebih lanjut tentang Qiskit Runtime, lihat referensi API.

# Install
# !pip install qiskit-ibm-runtime

Kita akan menentukan hardware target.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
service.backends()

# You can specify the device
# backend = service.backend('ibm_kingston')

# You can also identify the least busy device
backend = service.least_busy(operational=True)
print("The least busy device is ", backend)

Transpilasi Circuit adalah proses yang cukup kompleks. Secara singkat, ini menulis ulang Circuit menjadi yang setara secara logis menggunakan "native gate" (Gate yang bisa diimplementasikan oleh komputer kuantum tertentu) dan memetakan qubit dalam Circuit ke qubit nyata yang optimal di komputer kuantum target. Untuk lebih lanjut tentang transpilasi, lihat dokumentasi ini.

# Transpile the circuit into basis gates executable on the hardware
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
target_circuit = pm.run(qc)

target_circuit.draw("mpl", idle_wires=False)

Kamu bisa melihat bahwa dalam transpilasi, Circuit ditulis ulang menggunakan Gate baru. Untuk informasi lebih lanjut, lihat dokumentasi ECRGate.

Langkah 3. Eksekusi Circuit target

Sekarang, kita akan menjalankan Circuit target di perangkat nyata.

sampler = Sampler(backend)
job_real = sampler.run([target_circuit])

job_id = job_real.job_id()
print("job id:", job_id)

Eksekusi di perangkat nyata mungkin memerlukan waktu antrian, karena komputer kuantum adalah sumber daya yang berharga dan sangat diminati. Job_id digunakan untuk memeriksa status eksekusi dan hasil job nantinya.

# Check the job status (replace the job id below with your own)
job_real.status(job_id)

Kamu juga bisa memeriksa status job dari dashboard IBM Quantum kamu: https://quantum.cloud.ibm.com/workloads

# If the Notebook session got disconnected you can also check your job status
# by running the following code
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
job_real = service.job(job_id)  # Input your job-id between the quotations
job_real.status()

# Execute after job has successfully run
result_real = job_real.result()
print(result_real[0].data.c.get_counts())

Langkah 4. Proses pasca hasil

Terakhir, kita harus memproses hasil kita untuk membuat output dalam format yang diharapkan, seperti nilai atau grafik.

plot_histogram(result_real[0].data.c.get_counts())

Seperti yang bisa kamu lihat, $|00\rangle$ dan $|11\rangle$ adalah yang paling sering diamati. Ada beberapa hasil selain data yang diharapkan, dan itu disebabkan oleh noise dan dekoherensi qubit. Kita akan mempelajari lebih lanjut tentang error dan noise dalam komputer kuantum di pelajaran selanjutnya dari kursus ini.

4.4 Keadaan GHZ

Konsep entanglement bisa diperluas ke sistem yang terdiri dari lebih dari dua qubit. Keadaan GHZ (Greenberger-Horne-Zeilinger state) adalah keadaan terjalin maksimal dari tiga qubit atau lebih. Keadaan GHZ untuk tiga qubit didefinisikan sebagai

$$\frac{1}{\sqrt 2}(|000\rangle + |111\rangle)$$

Keadaan ini bisa dibuat dengan quantum Circuit berikut.

qc = QuantumCircuit(3, 3)

qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)

qc.measure(0, 0)
qc.measure(1, 1)
qc.measure(2, 2)

qc.draw("mpl")

"Kedalaman" (depth) dari quantum Circuit adalah metrik yang berguna dan umum untuk mendeskripsikan quantum Circuit. Ikuti jalur melalui quantum Circuit, bergerak dari kiri ke kanan, hanya berpindah qubit ketika terhubung oleh Gate multi-qubit. Hitung jumlah Gate sepanjang jalur tersebut. Jumlah Gate maksimum untuk jalur mana pun melalui Circuit adalah kedalaman (depth). Pada komputer kuantum modern yang masih berisik, Circuit dengan kedalaman rendah memiliki lebih sedikit error dan kemungkinan besar memberikan hasil yang baik. Circuit yang sangat dalam tidak demikian.

Menggunakan QuantumCircuit.depth(), kita bisa memeriksa kedalaman quantum Circuit kita. Kedalaman Circuit di atas adalah 4. Qubit teratas hanya memiliki tiga Gate termasuk pengukuran. Tapi ada jalur dari qubit teratas ke qubit 1 atau qubit 2 yang melibatkan Gate CNOT tambahan.

qc.depth()

4

Latihan 2

Keadaan GHZ dari sistem 8-qubit adalah

$$\frac{1}{\sqrt 2}(|00000000\rangle + |11111111\rangle)$$

Tulis kode untuk menyiapkan keadaan ini dengan Circuit sedangkal mungkin. Kedalaman quantum Circuit terdangkal adalah 5, termasuk Gate pengukuran.

Solusi:

# Step 1
qc = QuantumCircuit(8, 8)

##your code goes here##
qc.h(0)
qc.cx(0, 4)
qc.cx(4, 6)
qc.cx(6, 7)

qc.cx(4, 5)

qc.cx(0, 2)
qc.cx(2, 3)

qc.cx(0, 1)
qc.barrier()  # for visual separation

# measure
for i in range(8):
    qc.measure(i, i)

qc.draw("mpl")
# print(qc.depth())

print(qc.depth())

5

from qiskit.visualization import plot_histogram
# Step 2
# For this exercise, the circuit and operators are simple, so no optimizations are needed.

# Step 3
# Run the circuit on a simulator to get the results
backend = AerSimulator()

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

sampler = Sampler(mode=backend)
job = sampler.run([isa_qc], shots=1024)
result = job.result()

counts = result[0].data.c.get_counts()
print(counts)

# Step 4
# Plot the counts in a histogram

plot_histogram(counts)

{'11111111': 535, '00000000': 489}

5. Ringkasan

Kamu telah mempelajari komputasi kuantum dengan model Circuit menggunakan quantum bit dan Gate, serta telah mengulas superposisi, pengukuran, dan entanglement. Kamu juga telah mempelajari metode untuk mengeksekusi quantum Circuit di perangkat kuantum nyata.

Dalam latihan terakhir untuk membuat Circuit GHZ, kamu telah mencoba mengurangi kedalaman Circuit, yang merupakan faktor penting untuk mendapatkan solusi skala utilitas pada komputer kuantum yang masih berisik. Pada pelajaran selanjutnya dari kursus ini, kamu akan mempelajari tentang noise dan metode mitigasi error secara detail. Dalam pelajaran ini, sebagai pengantar, kita mempertimbangkan pengurangan kedalaman Circuit pada perangkat ideal, tetapi pada kenyataannya, kita harus mempertimbangkan batasan perangkat nyata, seperti konektivitas qubit. Kamu akan mempelajari lebih lanjut tentang ini di pelajaran berikutnya dalam kursus ini.

# See the version of Qiskit
import qiskit

qiskit.__version__

'2.0.2'