הצעד הראשון לתוך מחשוב קוונטי

רמות קושי: מתחיל
זמן שימוש ב-QPU: 11 שניות

ברוכים הבאים, האקרים! אנחנו שמחים שאתם איתנו בסדנה. המטרה העיקרית של הסשן ההרצאתי-מעשי הזה היא להכין אתכם למסע הקוונטי שלכם: 1) להדריך אתכם איך להתקין את qiskit 2) איך ליצור חשבון IBM Cloud ולהכין api_key ו-crn לשימוש במחשב קוונטי אמיתי 3) ליצור את ה-Circuit הקוונטי הראשון שלכם 4) לפתור חידת מצב קוונטי 5) להריץ את ה-Circuits שלכם על מחשב קוונטי אמיתי ולהציג את התוצאה.

1. קודם כל: Qiskit

מה זה Qiskit

Qiskit SDK הוא ערימת תוכנה בעלת ביצועים גבוהים שנבנתה כדי לעזור למפתחים וחוקרים לרתום את מלוא עוצמתם של המחשבים הקוונטיים בקנה מידה של שימושיות ומעבר לכך. בבסיסו נמצא Qiskit SDK – ערכת פיתוח תוכנה בקוד פתוח לעבודה עם מחשבים קוונטיים ברמה של Circuits קוונטיים מורחבים, אופרטורים ופרימיטיבים. Qiskit SDK מאפשר לכל אחד לקבל ביצועים אופטימליים ממחשבים קוונטיים אמיתיים תוך שימוש בסביבת המחשוב המועדפת עליו.

מעבר ל-SDK, Qiskit כולל גם חבילה של כלים ושירותים בעלי ביצועים גבוהים, כמו Qiskit Runtime Service, המאפשר חישובים מאופטמים במחשבים קוונטיים של IBM דרך הענן באמצעות פרימיטיבים שמנהלים מיתון שגיאות. שירות ה-Qiskit Transpiler מספק שיטות היוריסטיות ומבוססות-AI מהמתקדמות ביותר, המשפרות ביצועים במשימות נפוצות של אופטימיזציית Circuit קוונטי.

פונקציות Qiskit הן קטלוג של שירותי IBM וצד שלישי שמקלים על אופטימיזציית עומסי עבודה ומינוף Qiskit לתרחישי שימוש בתעשייה. בין אם אתם מפתחי תוכנה קוונטית, אנשי ניסוי קוונטי, מדעני מחשוב, או פשוט רוצים להתחיל – המסגרת המודולרית והגמישה של Qiskit מאפשרת לכם לעבוד ברמת ההפשטה שהכי מתאימה לצרכים שלכם.

Qiskit תוכנן עם יכולות הרחבה והתאמה אישית, כך שתוכלו להפיק ביצועים מובילים בתעשייה ולהתמודד עם סוגים חדשים של בעיות. בסיס קוד בעל ביצועים גבוהים אומר ש-Qiskit SDK עובד מהר יותר, צורך פחות זיכרון, ומספק תוצאות טובות יותר מאי פעם. בנוסף, Qiskit מציג אתכם לקהילה עצומה של משתמשים ומפתחים שרוצים לקבל אתכם ולעזור לענות על שאלותיכם. תוכנית Qiskit advocate, שהושקה לראשונה ב-2019, היא יוזמה גלובלית וממוקדת-קהילה שמגייסת אנשי מקצוע ואוהדי מחשוב קוונטי מכל העולם. לאורך השנים, advocates הפכו למנהיגים מוכרים בקהילת הקוונטום. רוצים להיות המנהיגים הקוונטיים הבאים? אל תהססו להגיש מועמדות – כאן

התקנת Qiskit

קודם כל, ודאו שגרסת Python שאתם משתמשים בה בסביבה שלכם היא python>=3.10, כדי לוודא שהיא תואמת לגרסת Qiskit האחרונה שנשתמש בה.

from platform import python_version

print(python_version())

אם זה לא המצב, תוכלו לשדרג אותה באמצעות הכלי המועדף עליכם. אם אתם לא בטוחים איך לעשות זאת, הנה כמה אפשרויות מומלצות:

MacOS: Homebrew
Linux: sudo apt-get update

מדריך מפורט על שדרוג Python בהתאם למערכת ההפעלה שלכם מופיע כאן: How to update Python

למידע נוסף, הציצו ב-QGSS (Qiskit Global Summer School) 2025 wiki: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

תוכלו לוודא את ההתקנה שלכם על ידי הרצת התא הבא. אם ההתקנה בוצעה נכון, הוא יחזיר את גרסת 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__}")

פתרון בעיות

אם התא הקודם העלה שגיאה, תוכלו לבחור להתקין את Qiskit בסביבה וירטואלית (להלן שתי שיטות מוצעות). אם אין לכם שגיאות, תוכלו להתעלם מהתא הזה ולהמשיך לבא.

כאן אנחנו מציעים שתי שיטות שונות להגדרת סביבה וירטואלית להתקנת Qiskit.

שימוש ב-venv, כפי שמוסבר ב-מדריך ההתקנה של Qiskit.
שימוש ב-conda, כפי שמוסבר בסרטון הזה של Coding with Qiskit.

2. הגדרת חשבון IBM Cloud שלכם

כדי להשתמש במחשב קוונטי אמיתי, אתם צריכים api key – כרטיס הכניסה הראשי לענן, ו-crn – טוקן שיביא לכם את המשאבים שלכם על ידי הגדרת החשבון.

הגדירו את החשבון שלכם כך:

לכו ל-IBM Quantum® Platform.
לכו לפינה הימנית העליונה (כפי שמוצג בתמונה למעלה), צרו את טוקן ה-API שלכם, והעתיקו אותו למקום מאובטח.
בתא הבא, החליפו את deleteThisAndPasteYourAPIKeyHere במפתח ה-API שלכם.
לכו לפינה השמאלית התחתונה (כפי שמוצג בתמונה למעלה) ו-צרו את ה-instance שלכם. ודאו שאתם בוחרים ב-open plan.
לאחר יצירת ה-instance, העתיקו את קוד ה-CRN המשויך אליו. ייתכן שתצטרכו לרענן כדי לראות את ה-instance.
בתא הבא, החליפו את deleteThisAndPasteYourCRNHere בקוד ה-CRN שלכם.

ראו מדריך זה לפרטים נוספים על הגדרת חשבון IBM Cloud® שלכם.

⚠️ הערה: התייחסו למפתח ה-API שלכם כאל סיסמה מאובטחת. ראו את מדריך Cloud setup למידע נוסף על שימוש במפתח ה-API שלכם בסביבות מאובטחות ולא מהימנות.

בנוסף, אם אתם חברים ברשת השותפים האוניברסיטאית של IBM, השתמשו בכתובת הדוא"ל של המוסד שלכם עבור ה-IBM ID שלכם כדי לקבל את הטבת השותף.

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 הקוונטי הראשון שלכם

Circuits קוונטיים

היחידה הבסיסית של Qiskit היא ה-Circuit הקוונטי, שהוא סדרת הוראות שמחשב קוונטי יכול להשתמש בהן לעבודה עם סיביות קוונטיות של מידע, המוכרות גם בשם Qubits. ל-Qubits אלה יש תכונות מיוחדות שמאפשרות למחשבים קוונטיים לגשת לבעיות באופן שונה מהמחשב הנייד שלכם או מה-iPhone. Qiskit מתקדם במהירות כטכנולוגיה – אמנם עדיין ניתן לתכנן ידנית את ה-Circuits הקוונטיים שלכם ולהחליט איך תרצו שיפעלו (ויש לכך לא מעט סיבות טובות), אך IBM Quantum גם מספקת לכם כלים שמפשטים את התהליך. לצורך הלמידה, אנחנו הולכים לתכנן Circuit פשוט מאוד ולהריץ אותו על סימולטור.

אנחנו רצים מהר דרך הסקירה הזו כי, בכנות, יכולנו לבלות שעות רק בהסבר יסודות המידע והמחשוב הקוונטי. למעשה, IBM Quantum כבר עשתה זאת, ויצרה קורס כתוב וסדרת הרצאות וידאו המוקדשות לנושא. אם אתם צריכים רענון, בדקו אותם!

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

פעולות בסיסיות על Qubits ומדידות

כתיבת מצבי Qubit בודד

בואו נתחיל בהסתכלות על Qubit בודד. ההבדל העיקרי בין סיבית קלאסית, שיכולה לקבל רק את הערכים 0 ו-1, הוא שסיבית קוונטית, או Qubit, יכולה להיות במצבים $\vert0\rangle$ , $\vert1\rangle$ , וכן בצירוף לינארי של שני מצבים אלה. תכונה זו מוכרת בשם סופרפוזיציה, ומאפשרת לנו לכתוב את המצב הכללי ביותר של Qubit כ:

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

אם היינו מודדים את מצב ה-Qubit הזה, היינו מוצאים את התוצאה $1$ עם הסתברות $p$ , ואת התוצאה $0$ עם הסתברות $1-p$ . כפי שאפשר לראות, ההסתברות הכוללת היא $1$ , כלומר אנחנו אכן נמדוד $0$ או $1$ , ואין תוצאות אחרות.

בנוסף ל- $p$ , ייתכן שהבחנתם בפרמטר נוסף למעלה. המשתנה $\phi$ מציין את הפאזה הקוונטית היחסית בין שני המצבים $\vert0\rangle$ ו- $\vert1\rangle$ . כפי שנגלה מאוחר יותר, הפאזה היחסית הזו חשובה מאוד. לעת עתה, מספיק לציין שהפאזה הקוונטית היא מה שמאפשר אינטרפרנציה בין מצבים קוונטיים, מה שמאפשר לנו לכתוב אלגוריתמים קוונטיים לפתרון משימות ספציפיות.

ויזואליזציה של מצבים קוונטיים

אנחנו מדמיינים מצבים קוונטיים לאורך תרגיל זה באמצעות מה שמוכר בשם qsphere. כך נראה ה-qsphere עבור המצבים $\vert0\rangle$ ו- $\vert1\rangle$ , בהתאמה. שימו לב שהחלק העליון ביותר של הכדור מייצג את המצב $\vert0\rangle$ , בעוד החלק התחתון מייצג $\vert1\rangle$ .

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

ניתן ליצור את אותו QSphere בדיוק באמצעות Circuit קוונטי. ה-Statevector שאנו משתמשים בו כאן הוא מהמצב $|0\rangle$ . ב-Qiskit, ה-Qubit מאותחל במצב $|0\rangle$ . נסו להריץ את ה-Circuit הבא ולראות אם אתם מקבלים את אותו QSphere.

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

עכשיו בואו נדמיין את המצב $|1\rangle$ . לא אמורה להיות הפתעה שמצב הסופרפוזיציה עם פאזה קוונטית $\phi = 0$ והסתברות $p = 1/2$ (כלומר סיכוי שווה למדידת 0 ו-1) מוצג ב-qsphere עם שתי נקודות. עם זאת, שימו לב גם שגודל העיגולים בשתי הנקודות קטן יותר מאשר כאשר היה לנו פשוט $\vert0\rangle$ ו- $\vert1\rangle$ למעלה. זה מפני שגודל העיגולים פרופורציונלי להסתברות למדידת כל אחד מהם, שכעת הצטמצמה בחצי.

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

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

במקרה של מצבי סופרפוזיציה, שבהם הפאזה הקוונטית אינה אפס, ה-qsphere מאפשר לנו לדמיין את הפאזה הזו על ידי שינוי צבע הבועה המתאימה. לדוגמה, המצב עם $\phi = 90^\circ$ (מעלות) והסתברות $p = 1/2$ מוצג ב-qsphere למטה.

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

מניפולציה של Qubits

Qubits מטופלים על ידי הפעלת Gates קוונטיים. בואו נעבור על סקירה של ה-Gates השונים שנשקול בתרגילים הבאים.

ראשית, בואו נתאר איך אנחנו יכולים לשנות את הערך של $p$ עבור המצב הקוונטי הכללי שלנו. לשם כך, נשתמש בשני Gates:

$X$ -Gate: Gate זה מחליף בין שני המצבים $\vert0\rangle$ ו- $\vert1\rangle$ . פעולה זו זהה ל-Gate NOT הקלאסי. כתוצאה מכך, ה- $X$ -Gate מכונה לפעמים bit flip או NOT gate. מבחינה מתמטית, ה- $X$ gate משנה את $p$ ל- $1-p$ , כך שבפרט מ-0 ל-1 ולהיפך.
$H$ -Gate: Gate זה מאפשר לנו לעבור מהמצב $\vert0\rangle$ למצב $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . מצב זה מוכר גם כ- $\vert+\rangle$ . מבחינה מתמטית, המשמעות היא מעבר מ- $p=0, \phi=0$ ל- $p=1/2, \phi=0$ . מאחר שהמצב הסופי של ה-Qubit הוא סופרפוזיציה של $\vert0\rangle$ ו- $\vert1\rangle$ , ה-Hadamard gate מייצג פעולה קוונטית אמיתית.

שימו לב ששני ה-Gates שינו את הערך של $p$ , אך לא את $\phi$ . למזלנו, די קל לדמיין את פעולת ה-Gates הללו על ידי הסתכלות בתמונה למטה.

לאחר שיש לנו את המצב $\vert+\rangle$ , נוכל לשנות את הפאזה הקוונטית על ידי הפעלת מספר Gates נוספים. לדוגמה, $S$ gate מוסיף פאזה של $90$ מעלות ל- $\phi$ , ואילו $Z$ gate מוסיף פאזה של $180$ מעלות ל- $\phi$ . כדי להחסיר פאזה של $90$ מעלות, נוכל להפעיל את ה- $S^\dagger$ gate, הנקרא S-dagger, ומוכתב בדרך כלל כ-sdg. לבסוף, יש $Y$ gate שמפעיל רצף של $Z$ ו- $X$ Gates.

תוכלו להתנסות עם ה-Gates $X$ , $Y$ , $Z$ , $H$ , $S$ ו- $S^\dagger$ כדי להתרגל לפעולות השונות ולאופן שבו הן משפיעות על מצב ה-Qubit. לשם כך, תוכלו לבקר ב-Circuit Composer ולהתחיל את ווידג'ט ה-Circuit שלנו. לאחר ביקור ב-Circuit Composer, בחרו Gate להפעיל על Qubit, ואז בחרו את ה-Qubit (בדוגמאות הראשונות, ה-Qubit היחיד לבחירה הוא qubit 0). צפו כיצד המצב המתאים משתנה עם כל Gate, וכן התיאור של אותו מצב. הוא גם יספק לכם את הקוד שיוצר את ה-Circuit הקוונטי המתאים ב-Qiskit.

אם אתם רוצים ללמוד עוד על תיאור מצבים קוונטיים, אופרטורי Pauli ו-Gates חד-Qubit נוספים, ראו Quantum Information של ה-Single System של קורס Basics of Quantum Information מאת John Watrous.

תרגולים: Circuits קוונטיים באמצעות Gates חד-Qubit

הנה ארבעה תרגולים קטנים להשגת מצבים שונים ב-qsphere. תוכלו לפתור אותם עם Circuit Composer ולהעתיק-הדביק את הקוד שהוא מספק לתאים המתאימים ליצירת ה-Circuits הקוונטיים, או שתוכלו להכניס ישירות שילוב של שורות הקוד הבאות לתוך התוכנית כדי להפעיל את ה-Gates השונים:

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) מציין שאנו מפעילים את ה-Gate הזה על Qubit q0, שהוא ה-Qubit הראשון (ובמקרה הזה היחיד).

נסו להשיג את המצב הנתון ב-qsphere בכל אחד מהתרגילים הבאים.

i) בואו נתחיל בביצוע bit flip. המטרה היא להגיע למצב $\vert1\rangle$ החל מהמצב $\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) עכשיו, בואו ניצור סופרפוזיציה. המטרה היא להגיע למצב $|+\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) בואו נשלב את השניים. המטרה היא להגיע למצב $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

האם תוכלו לשלב את שתי המשימות הקודמות כדי להגיע לפתרון?

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) לבסוף, אנחנו עוברים למספרים מרוכבים. המטרה היא להגיע למצב $|\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. חידון קוונטי עם Gate-ים על מרובי-Qubit

עבודה מצוינת! עכשיו שהבנתם את ה-Gate-ים על Qubit יחיד, בואו נסתכל על Gate-ים שפועלים על מספר Qubit-ים. כאן תתבקש לפתור 4 חידות מצב קוונטי על ידי שילוב של Gate-ים על Qubit יחיד עם Gate-ים על מרובי-Qubit. ה-Gate-ים הבסיסיים על שני Qubit-ים הם:

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

אם תרצו לקרוא עוד על ה-Gate-ים השונים על מרובי-Qubit ועל הקשרים ביניהם, כנסו ל-Quantum Information של מערכות מרובות, בקורס Basics of Quantum Information של ג'ון.

שימו לב שעבור שני Qubit-ים מצב כללי הוא מהצורה $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , כאשר $a$ , $b$ , $c$ ו- $d$ הם מספרים מרוכבים שהערכים המוחלטים בריבוע שלהם נותנים את ההסתברות למדוד את המצב המתאים; למשל, $|a|^2$ תהיה ההסתברות לסיים במצב '0' על שני ה-Qubit-ים. זה אומר שעכשיו יכולים להיות לנו עד ארבע נקודות על ה-qsphere.

אנחנו מתחילים עם Gate-ה שתי-Qubit הקנוני, ה-controlled-NOT (גם CNOT או CX). כאן, כמו עם כל Gate-י שני-Qubit מבוקרים, Qubit אחד מסומן כ-"control", והשני נקרא "target". אם ה-Qubit של control נמצא במצב $|0\rangle$ , הוא מחיל את Gate-ה זהות $I$ על ה-target, כלומר לא מתבצעת פעולה. לעומת זאת, אם ה-Qubit של control נמצא במצב $|1\rangle$ , מתבצע X-Gate על ה-Qubit של target. לכן, כאשר שני ה-Qubit-ים נמצאים באחד משני המצבים הקלאסיים, $|0\rangle$ או $|1\rangle$ , ה-CNOT Gate מוגבל לפעולות קלאסיות.

המצב הזה משתנה באופן דרמטי כאשר נחיל תחילה Hadamard Gate על ה-Qubit של control, ונכניס אותו למצב הסופרפוזיציה $|+\rangle$ . פעולת ה-CNOT Gate על קלט לא-קלאסי זה יכולה לייצר מצבים שזורים מאוד בין ה-Qubit-ים של control ו-target. אם ה-Qubit של target נמצא בתחילה במצב $|0\rangle$ , המצב שנוצר מסומן על ידי $|\Phi^+\rangle$ , והוא אחד מה-Bell states המפורסמים.

i) בנה את ה-Bell state $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

עבור מצב זה תהיה לנו הסתברות $\frac{1}{2}$ למדוד "00" והסתברות $\frac{1}{2}$ למדוד "11". לכן, תוצאות שני ה-Qubit-ים מתואמות בצורה מושלמת.

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

עכשיו, נסו ליצור את המצב של Qubit-ים שהתוצאות שלהם מנוגדות לחלוטין. שימו לב לסימן המינוס כאן, שמסמן את הפאזה היחסית בין שני המצבים.

ii) בנה את ה-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) ניתן לך ה-Circuit הקוונטי המתואר בפונקציה למטה. החלף את המצבים של ה-Qubit הראשון והשני כדי לקבל את ה-QSphere הזו.

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) כתוב תוכנית מאפס שיוצרת את מצב ה-GHZ (על שלושה 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. הרץ את ה-Circuit שלך וראה את תוצאת המדידה עם מחשב קוונטי אמיתי

עכשיו שאנחנו יודעים איך לבנות Circuit קוונטי כדי לתפעל statevector של Qubit-ים. והגיע הזמן לחלק המרגש ביותר: להריץ אותו ולראות את הפלט! כאן נלמד את הדרך המודרנית והאפקטיבית להריץ את ה-Circuit-ים שלנו באמצעות Qiskit.

תבנית Qiskit היא מסגרת כללית לפירוק בעיות ספציפיות לתחום ולהקשרת יכולות נדרשות בשלבים. זה מאפשר קומפוזיביליות חלקה של יכולות חדשות שפותחו על ידי חוקרי IBM Quantum (ואחרים) ומאפשר עתיד שבו משימות מחשוב קוונטי מתבצעות על ידי תשתית מחשוב הטרוגנית עוצמתית (CPU/GPU/QPU).

ארבעת השלבים של תבנית Qiskit הם:

מיפוי בעיה ל-Circuit-ים קוונטיים ולאופרטורים
אופטימיזציה לחומרת היעד
ביצוע על חומרת היעד
עיבוד-לאחר תוצאות

זה עתה סיימנו את שלב 1: מיפוי, על ידי בניית Circuit-ים קוונטיים ליצירת המצב הקוונטי הרצוי. עכשיו, בואו נעבור על השלבים הנותרים כדי לראות את התוצאות.

אופטימיזציה

הנה אנחנו נגדיר את ה-Backend להרצת Circuit-ים - אפשר לבחור את ה-QPU הכי פחות עמוס מבין קבוצות ה-QPU הנגישות לך, או פשוט לבחור סימולטור

השלב הבא מרגש - אנחנו הולכים להריץ את ה-Circuit הקוונטי באמצעות Qiskit Runtime!

נעשה זאת באמצעות שניים מה-Qiskit primitives:

Sampler דוגם את רגיסטר הפלט מהרצת Circuit-ים קוונטיים אחד או יותר. הפלט שלו הוא ספירות על מדידות לכל shot.
Estimator מחשב את ערך הציפייה של אובזרבל אחד או יותר ביחס למצבים שנוצרו על ידי ה-Circuit הקוונטי. הפלט שלו מורכב מערכי הציפייה יחד עם שגיאות התקן שלהם.

כאן, נשתמש ב-Sampler להרצת ה-Circuit-ים שלנו. תא הקוד למטה מראה לך תחילה להגדיר Backend ו-pass manager עבורו. לאחר מכן, הוא יוסיף measurement לכל ה-Circuit-ים ויצור מערך של Circuit-ים קוונטיים (pub) להעביר ל-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))

ביצוע

בואו נריץ את ה-Circuit-ים שלנו. במקרה שיש תור המתנה ארוך בענן, הדפסו ושמרו את job_id לשימוש מאוחר יותר ובדקו את job_status. אחרי שתראה שהסטטוס של ה-job משתנה ל-Done, אחזר את תוצאת ה-job.

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

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

עיבוד-לאחר

השלב האחרון הוא לפרש את הוויזואליזציה כדי להבין את המצבים הקוונטיים שיצרנו. לפני ציור מספר גרפים, בואו נביא את כל הספירות מכל ה-Circuit-ים. אחר כך נכין 4 תרשימים על ידי סיווג ה-Circuit-ים.

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

מצבי Qubit יחיד

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

מצבי Qubit יחיד בסופרפוזיציה

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

מצבי שני Qubit

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

מצבי שלושה Qubit

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

אתגר נוסף

האם מצאת רעש בתוצאות הניסוי של ה-Backend האמיתי? הסרת רעש מ-Qubit היא אחד מתחומי המחקר הפעילים. נסו את אפשרויות הפחתת השגיאה והדיכוי השונות של Qiskit Runtime כדי לראות איך הרעש בתוצאות ההרצה משתנה! (הערה) אפשרויות אלה מאפשרות יותר זמן QPU.

מידע נוסף

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

נוצר על ידי: Sophy Shin

נסקר על ידי: 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. קודם כל: Qiskit​

מה זה Qiskit​

התקנת Qiskit​

פתרון בעיות​

2. הגדרת חשבון IBM Cloud שלכם ​

3. ה-Circuit הקוונטי הראשון שלכם​

Circuits קוונטיים​

פעולות בסיסיות על Qubits ומדידות​

כתיבת מצבי Qubit בודד​

ויזואליזציה של מצבים קוונטיים​

מניפולציה של Qubits​

תרגולים: Circuits קוונטיים באמצעות Gates חד-Qubit​

i) בואו נתחיל בביצוע bit flip. המטרה היא להגיע למצב ∣1⟩\vert1\rangle∣1⟩ החל מהמצב ∣0⟩\vert0\rangle∣0⟩.​

ii) עכשיו, בואו ניצור סופרפוזיציה. המטרה היא להגיע למצב ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) בואו נשלב את השניים. המטרה היא להגיע למצב ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) לבסוף, אנחנו עוברים למספרים מרוכבים. המטרה היא להגיע למצב ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. חידון קוונטי עם Gate-ים על מרובי-Qubit​

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

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

iii) ניתן לך ה-Circuit הקוונטי המתואר בפונקציה למטה. החלף את המצבים של ה-Qubit הראשון והשני כדי לקבל את ה-QSphere הזו.​

iv) כתוב תוכנית מאפס שיוצרת את מצב ה-GHZ (על שלושה 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. הרץ את ה-Circuit שלך וראה את תוצאת המדידה עם מחשב קוונטי אמיתי​

אופטימיזציה​

ביצוע​

עיבוד-לאחר​

אתגר נוסף​

מידע נוסף​