Langkah Pertama ke Pengkomputeran Kuantum

Tahap Kesukaran: Pemula
Penggunaan masa QPU: 11s

Selamat datang, para penggemar! Kami sangat gembira dapat bersama anda dalam workshop ini. Matlamat utama sesi hands-on pengenalan ini adalah untuk menyediakan anda bagi perjalanan kuantum dengan 1) membimbing anda cara memasang qiskit 2) cara mencipta akaun IBM Cloud dan menyediakan api_key dan crn untuk menggunakan komputer kuantum sebenar dan 3) membuat Circuit kuantum pertama anda, 4) menyelesaikan kuiz keadaan kuantum dan 5) Menjalankan Circuit anda pada komputer kuantum sebenar dan memetakan hasilnya.

1. Perkara Pertama Dahulu: Qiskit

Apa itu Qiskit

Qiskit SDK ialah tindanan perisian berprestasi tinggi yang dibina untuk membantu pembangun dan penyelidik memanfaatkan sepenuhnya kuasa komputer kuantum pada skala utiliti dan seterusnya. Teras utamanya ialah Qiskit SDK, kit pembangunan perisian sumber terbuka untuk bekerja dengan komputer kuantum pada peringkat Circuit kuantum yang lanjutan. Operator dan primitif. Qiskit SDK membolehkan sesiapa sahaja mendapat prestasi optimum daripada komputer kuantum sebenar menggunakan persekitaran pengkomputeran pilihan mereka.

Selain SDK, Qiskit juga merangkumi set alatan dan perkhidmatan berprestasi tinggi seperti Qiskit Runtime Service, yang membolehkan pengiraan yang dioptimumkan pada komputer kuantum IBM melalui awan menggunakan primitif yang menguruskan pengurangan ralat. Qiskit Transpiler service pula menyediakan kaedah heuristik dan dikuasakan AI yang terkini untuk meningkatkan prestasi bagi tugas-tugas pengoptimuman Circuit kuantum yang biasa.

Fungsi-fungsi Qiskit, sebuah katalog perkhidmatan IBM dan pihak ketiga yang memudahkan pengoptimuman beban kerja dan memanfaatkan Qiskit untuk kes penggunaan industri. Sama ada anda seorang pembangun perisian kuantum, eksperimentalis kuantum, saintis pengiraan, atau sekadar ingin bermula — rangka kerja modular dan fleksibel Qiskit membolehkan anda bekerja pada tahap abstraksi yang paling sesuai dengan keperluan anda.

Qiskit direka untuk kebolehpanjangan dan penyesuaian, supaya anda boleh menghasilkan prestasi terbaik dalam industri dan menangani masalah-masalah baharu. Pangkalan kod berprestasi tinggi bermakna Qiskit SDK berfungsi lebih pantas, menggunakan lebih sedikit memori, dan memberikan hasil yang lebih baik daripada sebelumnya. Dan Qiskit juga memperkenalkan anda kepada komuniti pengguna dan pembangun yang luas yang tidak sabar untuk menyambut anda dan membantu menjawab soalan anda. Dilancarkan pertama kali pada 2019, program Qiskit advocate ialah inisiatif bertumpukan komuniti global yang merekrut profesional dan peminat pengkomputeran kuantum dari seluruh dunia. Selama bertahun-tahun, para advocate telah menjadi pemimpin yang diiktiraf dalam komuniti kuantum. Mahu jadi pemimpin kuantum seterusnya? Jangan teragak-agak untuk memohon — di sini

Pasang Qiskit

Pertama, pastikan versi Python yang anda gunakan dalam persekitaran anda adalah python>=3.10, untuk memastikan ia serasi dengan versi Qiskit terkini yang akan kita gunakan

from platform import python_version

print(python_version())

Jika tidak demikian, anda boleh menaik tarafnya menggunakan alatan pilihan anda. Jika anda tidak pasti cara melakukannya, beberapa pilihan yang disyorkan ialah:

MacOS: Homebrew
Linux: sudo apt-get update

Panduan terperinci tentang cara menaik taraf Python bergantung pada OS anda diperincikan di sini: How to update Python

Untuk maklumat lanjut, lihat wiki QGSS (Qiskit Global Summer School) 2025: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Anda boleh mengesahkan pemasangan anda dengan menjalankan sel di bawah. Jika anda memasang dengan betul, ia akan mengembalikan versi qiskit.

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

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Penyelesaian Masalah

Jika sel sebelumnya menunjukkan ralat, anda boleh memilih untuk memasang Qiskit dalam persekitaran maya (dua kaedah yang dicadangkan berikut). Jika tiada ralat, anda boleh abaikan sel ini dan teruskan ke sel seterusnya.

Di sini kami mencadangkan dua kaedah berbeza untuk menyediakan persekitaran maya bagi memasang Qiskit.

Menggunakan venv, seperti yang dijelaskan dalam panduan pemasangan Qiskit.
Menggunakan conda, seperti yang dijelaskan dalam video Coding with Qiskit ini.

2. Sediakan Akaun IBM Cloud Anda

Untuk menggunakan komputer kuantum sebenar, anda memerlukan api key — tiket masuk utama ke awan — dan crn — token yang akan membawa sumber anda kepada anda dengan menetapkan akaun anda.

Sediakan akaun anda seperti berikut:

Pergi ke IBM Quantum® Platform.
Pergi ke sudut kanan atas (seperti yang ditunjukkan dalam gambar di atas), cipta token API anda, dan salinnya ke lokasi yang selamat.
Dalam sel seterusnya, gantikan deleteThisAndPasteYourAPIKeyHere dengan kunci API anda.
Pergi ke sudut kiri bawah (seperti yang ditunjukkan dalam gambar di atas) dan cipta instans anda. Pastikan anda memilih pelan terbuka.
Selepas instans dicipta, salin kod CRN yang berkaitan dengannya. Anda mungkin perlu memuat semula untuk melihat instans tersebut.
Dalam sel di bawah, gantikan deleteThisAndPasteYourCRNHere dengan kod CRN anda.

Lihat panduan ini untuk maklumat lanjut tentang cara menyediakan akaun IBM Cloud® anda.

⚠️ Nota: Layani kunci API anda seperti kata laluan yang selamat. Lihat panduan Cloud setup untuk maklumat lanjut tentang penggunaan kunci API anda dalam persekitaran yang selamat dan tidak dipercayai.

Selain itu, jika anda adalah ahli universiti rangkaian rakan kongsi IBM, gunakan alamat e-mel institusi anda untuk ID IBM anda bagi menerima faedah rakan kongsi.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Circuit Kuantum Pertama Anda

Circuit kuantum

Unit asas Qiskit ialah Circuit kuantum, iaitu satu siri arahan yang boleh digunakan oleh komputer kuantum untuk bekerja dengan bit maklumat kuantum, juga dikenali sebagai Qubit. Qubit ini mempunyai sifat-sifat istimewa yang membolehkan komputer kuantum mendekati masalah secara berbeza daripada cara laptop atau iPhone anda melakukannya. Qiskit sedang berkembang pesat sebagai teknologi — walaupun anda masih boleh mereka bentuk Circuit kuantum anda secara manual dan memutuskan cara anda mahu menjalankannya (dan ada banyak sebab baik untuk berbuat demikian), IBM Quantum juga menyediakan alatan yang memudahkan proses tersebut. Demi pembelajaran, kita akan mereka bentuk Circuit yang sangat mudah dan menjalankannya pada simulator.

Kami mempercepatkan gambaran keseluruhan ini kerana, sejujurnya, kita boleh menghabiskan berjam-jam hanya untuk menjelaskan asas-asas maklumat dan pengiraan kuantum. Malah, IBM Quantum sudah melakukannya, menghasilkan kursus bertulis dan siri kuliah video yang didedikasikan untuk topik tersebut. Jika anda memerlukan ulang kaji, semak mereka!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Operasi Asas pada Qubit dan Pengukuran

Menulis keadaan Qubit tunggal

Mari kita mulakan dengan melihat satu Qubit tunggal. Perbezaan utama antara bit klasik, yang hanya boleh mengambil nilai 0 dan 1, adalah bahawa bit kuantum, atau Qubit, boleh berada dalam keadaan $\vert0\rangle$ , $\vert1\rangle$ , serta kombinasi linear kedua-dua keadaan ini. Ciri ini dikenali sebagai superposisi, dan membolehkan kita menulis keadaan paling umum bagi sebuah Qubit sebagai:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Jika kita mengukur keadaan Qubit ini, kita akan mendapati hasil $1$ dengan kebarangkalian $p$ , dan hasil $0$ dengan kebarangkalian $1-p$ . Seperti yang anda dapat lihat, jumlah kebarangkalian ialah $1$ , bermakna kita sememangnya akan mengukur sama ada $0$ atau $1$ , dan tiada hasil lain yang wujud.

Selain $p$ , anda mungkin perasan satu lagi parameter di atas. Pemboleh ubah $\phi$ menunjukkan fasa kuantum relatif antara dua keadaan $\vert0\rangle$ dan $\vert1\rangle$ . Seperti yang akan kita temui kemudian, fasa relatif ini cukup penting. Buat masa ini, cukuplah untuk diketahui bahawa fasa kuantum inilah yang membolehkan gangguan antara keadaan kuantum, menghasilkan kemampuan kita untuk menulis algoritma kuantum bagi menyelesaikan tugas-tugas tertentu.

Memvisualisasikan keadaan kuantum

Kita memvisualisasikan keadaan kuantum sepanjang latihan ini menggunakan apa yang dikenali sebagai qsphere. Berikut adalah rupa qsphere untuk keadaan $\vert0\rangle$ dan $\vert1\rangle$ , masing-masing. Perhatikan bahawa bahagian paling atas sfera mewakili keadaan $\vert0\rangle$ , manakala bahagian bawah mewakili $\vert1\rangle$ .

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Anda boleh membuat QSphere yang sama tepat menggunakan Circuit kuantum. Statevector yang kita gunakan di sini adalah dari keadaan $|0\rangle$ . Dalam Qiskit, Qubit dimulakan dalam keadaan $|0\rangle$ . Cuba jalankan Circuit di bawah dan lihat jika anda boleh mendapatkan QSphere yang sama.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Sekarang mari kita visualisasikan keadaan $|1\rangle$ . Tidak hairanlah bahawa keadaan superposisi dengan fasa kuantum $\phi = 0$ dan kebarangkalian $p = 1/2$ (bermakna kemungkinan yang sama untuk mengukur 0 dan 1) ditunjukkan pada qsphere dengan dua titik. Namun, perhatikan juga bahawa saiz bulatan pada dua titik tersebut lebih kecil berbanding apabila kita hanya mempunyai $\vert0\rangle$ dan $\vert1\rangle$ di atas. Ini kerana saiz bulatan adalah berkadar dengan kebarangkalian mengukur masing-masing, yang kini dikurangkan separuh.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

Dalam kes keadaan superposisi, di mana fasa kuantum bukan sifar, qsphere membolehkan kita memvisualisasikan fasa tersebut dengan menukar warna blob yang berkenaan. Sebagai contoh, keadaan dengan $\phi = 90^\circ$ (darjah) dan kebarangkalian $p = 1/2$ ditunjukkan dalam qsphere di bawah.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Manipulating qubits

Qubit dimanipulasi dengan menggunakan quantum gate. Jom kita tengok gambaran keseluruhan gate-gate berbeza yang akan kita guna dalam latihan-latihan berikut.

Pertama, jom kita huraikan macam mana kita boleh ubah nilai $p$ untuk keadaan kuantum umum kita. Untuk buat ni, kita akan guna dua Gate:

$X$ -gate: Gate ini membalikkan antara dua keadaan $\vert0\rangle$ dan $\vert1\rangle$ . Operasi ini sama dengan gate NOT klasik. Sebab tu, $X$ -gate kadang-kadang dirujuk sebagai bit flip atau NOT gate. Secara matematik, $X$ gate mengubah $p$ kepada $1-p$ , jadi khususnya dari 0 kepada 1, dan sebaliknya.
$H$ -gate: Gate ini membolehkan kita pergi dari keadaan $\vert0\rangle$ ke keadaan $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . Keadaan ini juga dikenali sebagai $\vert+\rangle$ . Secara matematik, ini bermaksud pergi dari $p=0, \phi=0$ ke $p=1/2, \phi=0$ . Oleh sebab keadaan akhir Qubit adalah superposisi antara $\vert0\rangle$ dan $\vert1\rangle$ , Hadamard gate mewakili operasi kuantum yang sebenar.

Perasan tak yang kedua-dua Gate mengubah nilai $p$ , tapi bukan $\phi$ . Nasib baik, kita boleh bayangkan tindakan gate-gate ni dengan mudah dengan tengok rajah di bawah.

Selepas kita dapat keadaan $\vert+\rangle$ , kita boleh ubah fasa kuantum dengan menggunakan beberapa gate lain. Contohnya, gate $S$ menambah fasa sebanyak $90$ darjah kepada $\phi$ , manakala gate $Z$ menambah fasa sebanyak $180$ darjah kepada $\phi$ . Untuk tolak fasa sebanyak $90$ darjah, kita boleh gunakan gate $S^\dagger$ , yang dibaca sebagai S-dagger, dan biasanya ditulis sebagai sdg. Akhir sekali, ada gate $Y$ yang menggunakan urutan gate $Z$ dan $X$ .

Korang boleh cuba dengan gate $X$ , $Y$ , $Z$ , $H$ , $S$ dan $S^\dagger$ untuk biasakan diri dengan operasi-operasi berbeza dan macam mana ia mempengaruhi keadaan Qubit. Untuk buat tu, korang boleh lawati Circuit Composer dan mulakan widget Circuit kita. Selepas melawati circuit composer, pilih gate untuk digunakan pada Qubit, kemudian pilih Qubit (dalam contoh pertama, satu-satunya Qubit yang boleh dipilih ialah qubit 0). Perhatikan macam mana keadaan yang sepadan berubah dengan setiap gate, serta penerangan keadaan tersebut. Ia juga akan berikan korang kod yang mencipta quantum circuit yang sepadan dalam Qiskit.

Kalau korang nak tahu lebih lanjut tentang menghuraikan keadaan kuantum, operator Pauli, dan gate satu-Qubit lain, tengok Quantum Information dalam Single System dalam Kursus Basics of Quantum Information oleh John Watrous.

Practices: Quantum Circuits Using Single-Qubit Gates

Ni ada empat latihan kecil untuk mencapai keadaan berbeza pada qsphere. Korang boleh sama ada selesaikan dengan circuit composer dan salin-tampal kod yang ia berikan ke dalam sel masing-masing untuk mencipta quantum circuit, atau korang boleh terus masukkan kombinasi baris kod berikut ke dalam program untuk menggunakan gate-gate berbeza:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

'(0)' menunjukkan bahawa kita menggunakan gate ni pada qubit 'q0', iaitu Qubit pertama (dan dalam kes ini satu-satunya).

Cuba untuk mencapai keadaan yang diberikan pada qsphere dalam setiap latihan berikut.

i) Jom mulakan dengan melakukan bit flip. Matlamatnya adalah untuk mencapai keadaan $\vert1\rangle$ bermula dari keadaan $\vert0\rangle$ .

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Seterusnya, jom cipta superposisi. Matlamatnya adalah untuk mencapai keadaan $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ .

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Jom gabungkan kedua-dua tu. Matlamatnya adalah untuk mencapai keadaan $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

Boleh tak korang gabungkan dua tugasan di atas untuk dapatkan penyelesaian?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Akhir sekali, kita beralih kepada nombor kompleks. Matlamatnya adalah untuk mencapai keadaan $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Quantum Quiz with Multi-Qubit Gates

Bagus! Sekarang yang korang dah faham tentang single-qubit gate, jom kita tengok gate yang beroperasi pada berbilang Qubit. Di sini korang akan diminta untuk selesaikan 4 kuiz keadaan kuantum dengan menggabungkan single-qubit gate dan multi-qubit gate. Gate asas pada dua Qubit diberikan oleh

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Kalau korang nak baca lebih lanjut tentang pelbagai multi-qubit gate dan hubungan mereka, lawati Quantum Information bagi berbilang sistem, dalam Kursus Basics of Quantum Information John.

Perlu diambil perhatian bahawa untuk dua Qubit, keadaan umum berbentuk $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , di mana $a$ , $b$ , $c$ , dan $d$ adalah nombor kompleks yang nilai mutlak kuasaduanya memberikan kebarangkalian untuk mengukur keadaan masing-masing; contohnya, $|a|^2$ ialah kebarangkalian untuk berakhir dalam keadaan '0' pada kedua-dua Qubit. Ini bermakna kita kini boleh ada sehingga empat titik pada qsphere.

Kita mulakan dengan gate dua qubit yang paling asas, iaitu controlled-NOT (juga CNOT atau CX) gate. Di sini, seperti semua gate dua qubit terkawal, satu Qubit dilabelkan sebagai "control", manakala yang lain dipanggil "target". Kalau Qubit control berada dalam keadaan $|0\rangle$ , ia menggunakan gate identiti $I$ pada target, iaitu tiada operasi dilakukan. Sebaliknya, kalau Qubit control berada dalam keadaan $|1\rangle$ , X-gate dilakukan pada Qubit target. Oleh itu, dengan kedua-dua Qubit dalam salah satu daripada dua keadaan klasik, $|0\rangle$ atau $|1\rangle$ , gate CNOT terhad kepada operasi klasik.

Situasi ni berubah dengan dramatik apabila kita mula-mula menggunakan Hadamard gate pada Qubit control, membawanya ke dalam keadaan superposisi $|+\rangle$ . Tindakan gate CNOT pada input bukan klasik ini boleh menghasilkan keadaan yang sangat terjerat antara Qubit control dan target. Kalau Qubit target pada mulanya berada dalam keadaan $|0\rangle$ , keadaan yang terhasil dilambangkan dengan $|\Phi^+\rangle$ , dan merupakan salah satu daripada Bell states yang dipanggil begitu.

i) Bina Bell state $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Untuk keadaan ini kita akan ada kebarangkalian $\frac{1}{2}$ untuk mengukur "00" dan kebarangkalian $\frac{1}{2}$ untuk mengukur "11". Jadi, hasil kedua-dua Qubit berkorelasi dengan sempurna.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Seterusnya, cuba cipta keadaan Qubit yang berkorelasi terbalik dengan sempurna. Perhatikan tanda tolak di sini, yang menunjukkan fasa relatif antara dua keadaan.

ii) Bina Bell state $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Anda diberi quantum circuit yang diterangkan dalam fungsi di bawah. Tukar keadaan Qubit pertama dan kedua untuk mendapatkan QSphere ini.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Tulis program dari awal yang mencipta keadaan GHZ (pada tiga Qubit), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Jalankan Circuit anda dan tengok keputusan pengukuran dengan komputer kuantum sebenar

Sekarang kita dah tahu cara bina quantum circuit untuk manipulasi statevector Qubit. Dan dah tiba masanya untuk bahagian paling seronok: jalankannya dan tengok outputnya! Di sini kita akan belajar cara moden dan berkesan untuk melaksanakan Circuit kita menggunakan Qiskit.

Pola Qiskit adalah rangka kerja umum untuk memecahkan masalah khusus domain dan mengkontekstualisasikan keupayaan yang diperlukan dalam peringkat-peringkat. Ini membolehkan kebolehkomposisian yang lancar bagi keupayaan baru yang dibangunkan oleh penyelidik IBM Quantum (dan lain-lain) serta membolehkan masa depan di mana tugas pengkomputeran kuantum dilaksanakan oleh infrastruktur pengkomputeran heterogen (CPU/GPU/QPU) yang berkuasa.

Empat langkah pola Qiskit adalah seperti berikut:

Peta masalah kepada quantum circuits dan operator
Optimumkan untuk perkakasan sasaran
Laksanakan pada perkakasan sasaran
Proses-lepas keputusan

Kita baru je habis Langkah 1: Pemetaan, dengan membina quantum circuits untuk menjana keadaan kuantum yang dikehendaki. Sekarang, jom kita ikuti langkah-langkah selebihnya untuk tengok keputusannya.

Optimumkan

Di sini kita akan tetapkan Backend untuk menjalankan circuits — anda boleh pilih least busy qpu daripada kumpulan qpu yang boleh anda akses, atau anda boleh pilih simulator je kalau tak ada cukup masa GPU yang tinggal. Setelah pilih Backend, pass_manager akan transpile circuits anda kepada set gate natif bagi Backend yang anda pilih dan mengoptimumkannya untuk anda dapatkan keputusan yang lebih baik. Anda boleh isytiharkan pass_manager dengan mudah menggunakan generate_preset_pass_manager dan tetapkan optimization_level, di mana nombor yang lebih tinggi menunjukkan lebih banyak langkah pengoptimuman.

Langkah seterusnya sangat menarik — kita akan jalankan quantum circuit menggunakan Qiskit Runtime!

Kita akan buat itu menggunakan dua primitif Qiskit:

Sampler mengambil sampel daftar output daripada pelaksanaan satu atau lebih quantum circuits. Outputnya ialah kiraan pada pengukuran per-shot.
Estimator mengira nilai jangkaan satu atau lebih boleh-cerapan berkenaan dengan keadaan yang dijana oleh quantum circuit. Outputnya terdiri daripada nilai jangkaan bersama ralat piawainya.

Di sini, kita akan guna Sampler untuk melaksanakan Circuit kita. Sel kod di bawah menunjukkan anda mula-mula tentukan Backend dan pass manager untuknya. Kemudian, ia akan tambah measurement ke semua circuits dan cipta array quantum circuits (pub) untuk dihantar ke Sampler.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Laksanakan

Jom kita laksanakan Circuit kita. Sekiranya ada banyak giliran menunggu di cloud, cetak dan simpan job_id untuk kegunaan kemudian dan semak job_status. Selepas anda nampak status kerja bertukar kepada Done, dapatkan semula keputusan kerja.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Proses-Lepas

Langkah terakhir adalah untuk mentafsir visualisasi bagi memahami keadaan kuantum yang kita cipta. Sebelum plot beberapa graf, jom kita kumpulkan semua kiraan daripada semua circuits. Kemudian kita akan buat 4 plot dengan mengkategorikan circuits.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Keadaan Qubit Tunggal

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Keadaan Satu Qubit yang Tersuperposisi

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Keadaan Dua Qubit

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Keadaan Tiga Qubit

plot_distribution(counts_all[8], legend=['qc9'])

Cabaran Lanjutan

Adakah anda jumpa sebarang hingar dalam keputusan eksperimen Backend sebenar? Menghapuskan hingar Qubit adalah salah satu bidang penyelidikan yang aktif. Cuba pelbagai pilihan pengurangan dan penindasan ralat Qiskit Runtime untuk tengok bagaimana hingar dalam keputusan pelaksanaan berubah! (Nota) Pilihan-pilihan ini memerlukan lebih banyak masa QPU.

Maklumat Tambahan

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Dicipta oleh: Sophy Shin

Disemak oleh: Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.

1. Perkara Pertama Dahulu: Qiskit​

Apa itu Qiskit​

Pasang Qiskit​

Penyelesaian Masalah​

2. Sediakan Akaun IBM Cloud Anda ​

3. Circuit Kuantum Pertama Anda​

Circuit kuantum​

Operasi Asas pada Qubit dan Pengukuran​

Menulis keadaan Qubit tunggal​

Memvisualisasikan keadaan kuantum​

Manipulating qubits​

Practices: Quantum Circuits Using Single-Qubit Gates​

i) Jom mulakan dengan melakukan bit flip. Matlamatnya adalah untuk mencapai keadaan ∣1⟩\vert1\rangle∣1⟩ bermula dari keadaan ∣0⟩\vert0\rangle∣0⟩.​

ii) Seterusnya, jom cipta superposisi. Matlamatnya adalah untuk mencapai keadaan ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) Jom gabungkan kedua-dua tu. Matlamatnya adalah untuk mencapai keadaan ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) Akhir sekali, kita beralih kepada nombor kompleks. Matlamatnya adalah untuk mencapai keadaan ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. Quantum Quiz with Multi-Qubit Gates​

i) Bina Bell state ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Bina Bell state ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Anda diberi quantum circuit yang diterangkan dalam fungsi di bawah. Tukar keadaan Qubit pertama dan kedua untuk mendapatkan QSphere ini.​

iv) Tulis program dari awal yang mencipta keadaan GHZ (pada tiga Qubit), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Jalankan Circuit anda dan tengok keputusan pengukuran dengan komputer kuantum sebenar​

Optimumkan​

Laksanakan​

Proses-Lepas​

Cabaran Lanjutan​

Maklumat Tambahan​