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. Anda akan belajar pengkomputeran kuantum dengan model litar menggunakan bit kuantum dan gate, serta mengulang kaji superposisi, pengukuran, dan keterjeratan.

Dalam pelajaran ini Anda akan belajar:

• get qubit tunggal
• Sfera Bloch
• Superposisi
• Pengukuran
• get dua qubit dan keadaan jalinan

Di akhir kuliah ini, Anda 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 litar 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. get 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 litar kosong kemudian menambah operasi kuantum, membincangkan gate dan menggambarkan kesannya semasa proses. Anda 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 litar kuantum

Kita akan mencipta dan melukis litar qubit tunggal.

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

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

get X

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

get H

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

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

Untuk mencipta keadaan ini, mula-mula gunakan get X untuk membuat $|1\rangle$, kemudian gunakan get 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 get $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 get 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 get kuantum pada qubit akan mengevolusikan keadaan kuantum tersebut. get qubit tunggal yang lazim termasuklah yang berikut.

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

get 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 get ini dijelaskan dengan lebih terperinci dalam kursus Basics of Quantum Information.

Latihan 1

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

(1) $XX|0\rangle$

(2) $HH|0\rangle$

(3) $HZH|0\rangle$

Tips: get 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 litar yang menyediakan superposisi kebarangkalian sama rata di atas. Kita perlu menambah get 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 litar 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. get kuantum pelbagai qubit dan keterjeratan

4.1 litar kuantum pelbagai qubit

Kita boleh mencipta litar kuantum dua qubit dengan kod berikut. Kita akan menerapkan get 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 litar kuantum, $|q_0\rangle$ sentiasa diletakkan di bahagian atas litar. Dengan mengambil kira perkara ini, keadaan kuantum litar 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 litar 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 get kuantum pelbagai qubit

get CNOT

get CNOT ("controlled NOT" atau CX) ialah get 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 get 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 get 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 get 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 get CNOT, keadaan $|01\rangle$ kini telah menjadi $|11\rangle$.

Mari kita sahkan keputusan ini dengan menjalankan litar 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 litar dan pengendali kuantum
2. Optimumkan untuk perkakasan sasaran
3. Laksanakan pada perkakasan sasaran
4. Proses selepas keputusan

Langkah 1. Petakan masalah kepada litar dan pengendali kuantum

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

Sel kod berikut mencipta litar 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 litar abstrak kepada litar QISA (Quantum Instruction Set Architecture) yang mematuhi kekangan perkakasan sasaran dan mengoptimumkan prestasi litar. 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 litar adalah satu lagi proses yang kompleks. Secara ringkas, ini menulis semula litar kepada litar yang setara secara logik menggunakan "gate asli" (gate yang boleh dilaksanakan oleh komputer kuantum tertentu) dan memetakan qubit dalam litar 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, litar telah ditulis semula menggunakan gate baru. Untuk maklumat lanjut, rujuk dokumentasi ECRGate.

Langkah 3. Laksanakan litar sasaran

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

Menggunakan QuantumCircuit.depth(), kita boleh menyemak kedalaman litar kuantum kita. Kedalaman litar di atas ialah 4. qubit paling atas hanya mempunyai tiga get termasuk pengukuran. Tetapi terdapat laluan dari qubit paling atas ke sama ada qubit 1 atau qubit 2 yang melibatkan satu get 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 litar yang sedangkal mungkin. Kedalaman litar kuantum yang paling cetek ialah 5, termasuk get 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 litar menggunakan bit kuantum dan get, serta telah mengkaji semula superposisi, pengukuran, dan keterjeratan. Anda juga telah mempelajari kaedah untuk melaksanakan litar kuantum pada peranti kuantum sebenar.

Dalam latihan akhir untuk mencipta litar GHZ, anda telah cuba mengurangkan kedalaman litar, 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 litar 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'