Qubit, gate, dan litar kuantum

nota

Kifumi Numata (19 Apr 2024)

Klik di sini untuk memuat turun PDF kuliah asal. Perlu diingat bahawa beberapa coretan kod mungkin sudah lapuk kerana ia adalah imej statik.

Anggaran masa QPU untuk menjalankan eksperimen ini ialah 5 saat.

1. Pengenalan

Bit, gate, dan litar adalah blok binaan asas pengkomputeran kuantum. Kamu akan belajar pengkomputeran kuantum dengan model litar menggunakan bit kuantum dan gate, serta mengulang kaji superposisi, pengukuran, dan jalinan.

Dalam pelajaran ini kamu akan belajar:

• Gate Qubit tunggal
• Sfera Bloch
• Superposisi
• Pengukuran
• Gate dua Qubit dan keadaan jalinan

Di akhir kuliah ini, kamu akan belajar tentang kedalaman litar, yang penting untuk pengkomputeran kuantum berskala utiliti.

2. Pengiraan sebagai gambar rajah

Apabila menggunakan qubit atau bit, kita perlu memanipulasinya supaya input yang ada boleh diubah kepada output yang diperlukan. Untuk atur cara paling mudah dengan sangat sedikit bit, adalah berguna untuk mewakili proses ini dalam gambar rajah yang dikenali sebagai gambar rajah litar.

Rajah di bawah sebelah kiri adalah contoh litar klasik, dan rajah di bawah sebelah kanan adalah contoh Circuit kuantum. Dalam kedua-dua kes, input berada di sebelah kiri dan output berada di sebelah kanan, manakala operasi diwakili oleh simbol. Simbol yang digunakan untuk operasi dipanggil "gate", kebanyakannya atas sebab sejarah.

3. Gate kuantum Qubit tunggal

3.1 Keadaan kuantum dan sfera Bloch

Keadaan Qubit diwakili sebagai superposisi $|0\rangle$ dan $|1\rangle$. Keadaan kuantum sembarangan diwakili sebagai

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

di mana $\alpha$ dan $\beta$ ialah nombor kompleks sedemikian rupa sehingga $|\alpha|^2+|\beta|^2=1$.

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

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

Oleh itu, keadaan kuantum sembarangan juga diwakili sebagai

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

Daripada ini, kita dapat lihat bahawa keadaan bit kuantum adalah vektor unit dalam ruang hasil darab dalaman kompleks dua dimensi dengan asas ortonormal $|0\rangle$ dan $|1\rangle$. Ia dinormalkan kepada 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 dikenali sebagai statevector.

Keadaan kuantum Qubit tunggal juga boleh diwakili 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$ ialah sudut sfera Bloch dalam rajah berikut.

Dalam beberapa sel kod berikut, kita akan membina pengiraan asas daripada komponen-komponen dalam Qiskit. Kita akan membina Circuit kosong kemudian menambah operasi kuantum, membincangkan gate dan menggambarkan kesannya semasa proses. Kamu boleh menjalankan sel dengan menekan "Shift" + "Enter". Import perpustakaan 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

Sediakan Circuit kuantum

Kita akan mencipta dan melukis Circuit Qubit tunggal.

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

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

Gate X

Gate X ialah putaran $\pi$ mengelilingi paksi $x$ sfera Bloch. Menggunakan Gate X pada $|0\rangle$ menghasilkan $|1\rangle$, dan menggunakan Gate X pada $|1\rangle$ menghasilkan $|0\rangle$, jadi ia adalah operasi yang serupa dengan Gate NOT klasik, dan juga dikenali sebagai bit flip. Perwakilan matriks Gate X adalah seperti 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")

Dalam IBM Quantum®, keadaan awal ditetapkan kepada $|0\rangle$, jadi Circuit kuantum di atas dalam perwakilan 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$$

Seterusnya, mari 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 menegak dipaparkan sebagai vektor baris, dengan nombor kompleks (bahagian imaginar diindeks dengan $j$).

Gate H

Gate Hadamard ialah putaran $\pi$ mengelilingi paksi yang berada di tengah-tengah antara paksi $x$ dan $z$ pada sfera Bloch. Menggunakan Gate H pada $|0\rangle$ menghasilkan keadaan superposisi seperti $\frac{|0\rangle + |1\rangle}{\sqrt{2}}$. Perwakilan matriks Gate H adalah seperti 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)$$

Keadaan superposisi ini sangat biasa dan penting sehingga ia diberi simbolnya sendiri:

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

Dengan menggunakan Gate $H$ pada $|0\rangle$, kita telah mencipta superposisi $|0\rangle$ dan $|1\rangle$ di mana pengukuran dalam asas komputasi (sepanjang z dalam gambaran sfera Bloch) akan memberikan setiap keadaan dengan kebarangkalian yang sama.

Keadaan $|-\rangle$

Mungkin kamu sudah meneka bahawa terdapat keadaan $|-\rangle$ yang sepadan:

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

Untuk mencipta keadaan ini, mula-mula gunakan Gate X untuk membuat $|1\rangle$, kemudian gunakan Gate H.

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$$

Menggunakan Gate $H$ pada $|1\rangle$ menghasilkan superposisi sama rata antara $|0\rangle$ dan $|1\rangle$, tetapi tanda $|1\rangle$ adalah negatif.

3.2 Keadaan kuantum Qubit tunggal dan evolusi unitari

Tindakan semua Gate yang telah kita lihat setakat ini adalah unitari, bermakna ia boleh diwakili oleh pengoperasi unitari. Dengan kata lain, keadaan output boleh diperoleh dengan menggunakan matriks unitari pada keadaan awal:

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

Matriks unitari ialah matriks yang memenuhi syarat

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

Dari segi operasi komputer kuantum, kita boleh katakan bahawa menggunakan Gate kuantum pada Qubit akan mengevolusikan keadaan kuantum tersebut. Gate Qubit tunggal yang lazim termasuklah yang berikut.

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 darab luar dikira seperti 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 Qubit tunggal biasa yang lain:

$$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}$$

Makna dan penggunaan Gate-gate ini dijelaskan dengan lebih terperinci dalam kursus Basics of Quantum Information.

Latihan 1

Gunakan Qiskit untuk mencipta Circuit kuantum yang menyediakan keadaan-keadaan seperti yang diterangkan di bawah. Kemudian jalankan setiap Circuit menggunakan simulator statevector dan paparkan keadaan yang terhasil pada sfera Bloch. Sebagai cabaran tambahan, cuba jangka apakah keadaan akhir berdasarkan intuisi tentang Gate dan putaran pada sfera Bloch.

(1) $XX|0\rangle$

(2) $HH|0\rangle$

(3) $HZH|0\rangle$

Tips: Gate Z boleh digunakan dengan

qc.z(0)

Penyelesaian:

### (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 teorinya ialah topik yang sangat kompleks. Namun secara praktikalnya, membuat pengukuran sepanjang paksi $z$ (seperti yang dilakukan oleh semua komputer kuantum IBM®) hanya memaksa keadaan Qubit $\alpha|0\rangle+\beta|1\rangle \quad (s.t.|\alpha|^2+|\beta|^2=1)$ kepada sama ada $|0\rangle$ atau $|1\rangle,$ dan kita perhatikan hasilnya.

• $|\alpha|^2$ ialah kebarangkalian kita akan mendapat $|0\rangle$ apabila kita mengukur.
• $|\beta|^2$ ialah kebarangkalian kita akan mendapat $|1\rangle$ apabila kita mengukur.

Jadi, $\alpha$ dan $\beta$ dipanggil amplitud kebarangkalian. (lihat "Petua Born")

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

Simulator Qiskit Aer

Seterusnya, mari kita ukur sebuah Circuit yang menyediakan superposisi kebarangkalian sama rata di atas. Kita perlu menambah Gate pengukuran, kerana simulator Qiskit Aer mensimulasikan perkakasan kuantum yang ideal (tanpa bunyi) secara lalai. Nota: Simulator Aer juga boleh menerapkan model bunyi berdasarkan komputer kuantum sebenar. Kita akan kembali kepada model bunyi kemudian.

# 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 kini bersedia untuk menjalankan Circuit kita pada simulator Aer. Dalam contoh ini, kita akan menggunakan shots=1024 sebagai nilai lalai, bermakna kita akan mengukur sebanyak 1024 kali. Kemudian kita akan memplot kiraan 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 dapati bahawa 0 dan 1 diukur dengan kebarangkalian hampir 50% setiap satu. Walaupun bunyi tidak disimulasikan di sini, keadaan-keadaan masih bersifat kebarangkalian. Jadi walaupun kita jangkakan taburan 50-50, kita jarang mendapati ia tepat begitu. Sama seperti 100 lambungan syiling jarang menghasilkan tepat 50 kali bagi setiap sisi.

4. Gate kuantum pelbagai Qubit dan keterjeratan

4.1 Circuit kuantum pelbagai Qubit

Kita boleh mencipta Circuit kuantum dua Qubit dengan kod berikut. Kita akan menerapkan Gate H pada 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))

Nota: Susunan bit Qiskit

Qiskit menggunakan notasi Little Endian untuk menyusun Qubit dan bit, bermakna Qubit 0 ialah bit paling kanan dalam rentetan bit. Contoh: $|01\rangle$ bermaksud q0 ialah $|1\rangle$ dan q1 ialah $|0\rangle$. Berhati-hati kerana sebahagian literatur komputasi kuantum menggunakan notasi Big Endian (Qubit 0 ialah bit paling kiri), dan banyak literatur mekanik kuantum juga berbuat demikian.

Perkara lain yang perlu diperhatikan ialah apabila menggambarkan Circuit kuantum, $|q_0\rangle$ sentiasa diletakkan di bahagian atas Circuit. Dengan mengambil kira perkara ini, keadaan kuantum Circuit di atas boleh ditulis sebagai hasil darab tensor keadaan kuantum satu 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 ialah $|0\rangle|0\rangle=|00\rangle$, jadi dengan menerapkan $H$ pada setiap Qubit, ia berubah kepada keadaan superposisi yang sama rata.

$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)$$

Peraturan pengukuran juga sama seperti kes satu Qubit, kebarangkalian mengukur $|00\rangle$ ialah $|ac|^2$.

# Draw a Bloch sphere
plot_bloch_multivector(out_vector)

Seterusnya, 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 sekali lagi untuk mengesahkan secara eksperimental bahawa kebarangkalian relatif semua keadaan output yang mungkin adalah lebih kurang sama.

# 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}

Seperti yang dijangka, keadaan $|00\rangle$, $|01\rangle$, $|10\rangle$, $|11\rangle$ diukur hampir 25% setiap satu.

4.2 Gate kuantum pelbagai Qubit

Gate CNOT

Gate CNOT ("controlled NOT" atau CX) ialah Gate dua Qubit, bermakna tindakannya melibatkan dua Qubit sekaligus: Qubit kawalan dan Qubit sasaran. CNOT membalikkan Qubit sasaran hanya apabila Qubit kawalan berada dalam keadaan $|1\rangle$.

Input (sasaran,kawalan)	Output (sasaran,kawalan)
00	00
01	11
10	10
11	01

Mari kita simulasikan tindakan Gate dua Qubit ini apabila q0 dan q1 kedua-duanya $|0\rangle$, dan dapatkan vektor keadaan output. Sintaks Qiskit yang digunakan ialah qc.cx(qubit kawalan, qubit sasaran).

# 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))

Seperti yang dijangka, menerapkan Gate CNOT pada $|00\rangle$ tidak mengubah keadaan, kerana Qubit kawalan berada dalam keadaan $|0\rangle$. Mari kita kembali kepada operasi CNOT kita. Kali ini kita akan menerapkan Gate CNOT pada $|01\rangle$ dan lihat apa yang berlaku.

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 telah menjadi $|11\rangle$.

Mari kita sahkan keputusan 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}

Keputusan seharusnya menunjukkan bahawa $|11\rangle$ telah diukur dengan kebarangkalian 100%.

4.3 Keterjeratan kuantum dan pelaksanaan pada peranti kuantum sebenar

Mari kita mulakan dengan memperkenalkan satu keadaan keterjeratan tertentu yang sangat penting dalam komputasi kuantum, kemudian kita akan takrifkan istilah "keterjeratan":

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

dan keadaan ini dipanggil keadaan Bell.

Keadaan keterjeratan ialah keadaan $|\psi_{AB}\rangle$ yang terdiri daripada keadaan kuantum $|\psi_A\rangle$ dan $|\psi_B\rangle$ yang tidak boleh diwakili oleh hasil darab tensor keadaan kuantum individu.

Jika $|\psi_{AB}\rangle$ di bawah mempunyai 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$$

hasil darab tensor kedua-dua keadaan ini adalah seperti 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$$

tetapi tiada pekali $a_0, a_1, b_0,$ dan $b_1$ yang boleh memenuhi kedua-dua persamaan ini. Oleh itu, $|\psi_{AB}\rangle$ tidak boleh diwakili oleh hasil darab tensor keadaan kuantum individu, $|\psi\rangle_A$ dan $|\psi\rangle_B$, dan ini bermakna $|\psi_{AB}\rangle = \frac{1}{\sqrt{2}}(|00\rangle +|11\rangle)$ ialah keadaan yang terjerat.

Mari kita cipta keadaan Bell dan jalankan pada komputer kuantum sebenar. Sekarang kita akan ikuti empat langkah untuk menulis program kuantum, yang dipanggil corak Qiskit:

1. Petakan masalah kepada Circuit dan pengendali kuantum
2. Optimumkan untuk perkakasan sasaran
3. Laksanakan pada perkakasan sasaran
4. Proses selepas keputusan

Langkah 1. Petakan masalah kepada Circuit dan pengendali kuantum

Dalam program kuantum, Circuit kuantum ialah format asli untuk mewakili arahan kuantum. Apabila mencipta Circuit, anda biasanya akan mencipta objek QuantumCircuit baru, kemudian menambah arahan ke dalamnya secara berurutan.

Sel kod berikut mencipta Circuit yang menghasilkan keadaan Bell, iaitu keadaan keterjeratan dua Qubit khusus dari atas tadi.

qc = QuantumCircuit(2, 2)

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

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

qc.draw("mpl")

Langkah 2. Optimumkan untuk perkakasan sasaran

Qiskit menukar Circuit abstrak kepada Circuit QISA (Quantum Instruction Set Architecture) yang mematuhi kekangan perkakasan sasaran dan mengoptimumkan prestasi Circuit. Jadi sebelum pengoptimuman, kita akan tentukan perkakasan sasaran. Jika anda tidak mempunyai qiskit-ibm-runtime, anda perlu memasangnya terlebih dahulu. Untuk maklumat lanjut tentang Qiskit Runtime, lihat rujukan API.

# Install
# !pip install qiskit-ibm-runtime

Kita akan tentukan perkakasan sasaran.

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 satu lagi proses yang kompleks. Secara ringkas, ini menulis semula Circuit kepada Circuit yang setara secara logik menggunakan "gate asli" (gate yang boleh dilaksanakan oleh komputer kuantum tertentu) dan memetakan Qubit dalam Circuit anda kepada Qubit sebenar yang optimum pada komputer kuantum sasaran. Untuk maklumat 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)

Anda boleh lihat bahawa dalam transpilasi, Circuit telah ditulis semula menggunakan gate baru. Untuk maklumat lanjut, rujuk dokumentasi ECRGate.

Langkah 3. Laksanakan Circuit sasaran

Sekarang, kita akan menjalankan Circuit sasaran pada peranti sebenar.

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

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

Pelaksanaan pada peranti sebenar mungkin memerlukan menunggu dalam giliran, kerana komputer kuantum adalah sumber yang berharga dan sangat diminati. job_id digunakan untuk menyemak status pelaksanaan dan keputusan kerja kemudian.

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

Anda juga boleh menyemak status kerja dari papan pemuka IBM Quantum anda：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 selepas keputusan

Akhir sekali, kita mesti memproses keputusan kita untuk mencipta output dalam format yang dijangka, seperti nilai atau graf.

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

Seperti yang dapat dilihat, $|00\rangle$ dan $|11\rangle$ adalah yang paling kerap diperhatikan. Terdapat beberapa keputusan selain daripada data yang dijangka, dan ia disebabkan oleh hingar dan penyahrincian Qubit. Kita akan belajar lebih lanjut tentang ralat dan hingar dalam komputer kuantum dalam pelajaran-pelajaran kemudian dalam kursus ini.

4.4 Keadaan GHZ

Konsep keterjeratan boleh diperluaskan kepada sistem lebih daripada dua Qubit. Keadaan GHZ (keadaan Greenberger-Horne-Zeilinger) ialah keadaan yang terjerat sepenuhnya bagi tiga atau lebih Qubit. Keadaan GHZ bagi tiga Qubit ditakrifkan sebagai

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

Ia boleh dicipta dengan Circuit kuantum 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" Circuit kuantum ialah metrik yang berguna dan lazim untuk menggambarkan Circuit kuantum. Jejaki laluan melalui Circuit kuantum, bergerak dari kiri ke kanan, hanya menukar Qubit apabila ia disambungkan oleh Gate pelbagai Qubit. Kira bilangan Gate di sepanjang laluan tersebut. Bilangan maksimum Gate untuk mana-mana laluan sedemikian melalui Circuit ialah kedalamannya. Dalam komputer kuantum berderau moden, Circuit berkedalaman rendah mempunyai lebih sedikit ralat dan berkemungkinan besar memberikan keputusan yang baik. Circuit yang sangat dalam tidak begitu.

Menggunakan QuantumCircuit.depth(), kita boleh menyemak kedalaman Circuit kuantum kita. Kedalaman Circuit di atas ialah 4. Qubit paling atas hanya mempunyai tiga Gate termasuk pengukuran. Tetapi terdapat laluan dari Qubit paling atas ke sama ada Qubit 1 atau Qubit 2 yang melibatkan satu Gate CNOT lagi.

qc.depth()

4

Latihan 2

Keadaan GHZ bagi sistem 8 Qubit ialah

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

Tulis kod untuk menyediakan keadaan ini dengan Circuit yang sedangkal mungkin. Kedalaman Circuit kuantum yang paling cetek ialah 5, termasuk Gate pengukuran.

Penyelesaian:

# 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

Anda telah mempelajari komputasi kuantum dengan model Circuit menggunakan bit kuantum dan Gate, serta telah mengkaji semula superposisi, pengukuran, dan keterjeratan. Anda juga telah mempelajari kaedah untuk melaksanakan Circuit kuantum pada peranti kuantum sebenar.

Dalam latihan akhir untuk mencipta Circuit GHZ, anda telah cuba mengurangkan kedalaman Circuit, yang merupakan faktor penting untuk mendapatkan penyelesaian berskala utiliti dalam komputer kuantum berderau. Dalam pelajaran-pelajaran kemudian dalam kursus ini, anda akan belajar tentang hingar dan kaedah pengurangan ralat secara terperinci. Dalam pelajaran ini, sebagai pengenalan, kita mempertimbangkan pengurangan kedalaman Circuit dalam peranti ideal, tetapi dalam realiti, kita mesti mempertimbangkan kekangan peranti sebenar, seperti ketersambungan Qubit. Anda akan belajar lebih lanjut tentang ini dalam pelajaran-pelajaran seterusnya dalam kursus ini.

# See the version of Qiskit
import qiskit

qiskit.__version__

'2.0.2'