בנה והרץ את התוכנית הקוונטית הראשונה שלך

מבוא

בסרטון הבא, אוליביה ליינס מדריכה אותך דרך התוכן של השיעור הזה. לחלופין, אפשר לפתוח את סרטון YouTube של השיעור בחלון נפרד.

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

השיעור הראשון הזה הוא מבוא מעשי ועדין לחישוב קוונטי שמתאים גם למתחילים סקרנים וגם למנהלים עסוקים. תלמד על Circuit קוונטיים ותכתוב תוכנית קוונטית קטנה שיוצרת שזירה (entanglement), ותריץ אותה על מחשב קוונטי אמיתי של IBM®. יש לך גם אפשרות להריץ את אותה התוכנית על סימולטור, אם תחליט לדלג על הרצה על מחשב קוונטי אמיתי.

אפשר להריץ את ה-notebook הזה מהתחלה ועד הסוף ב-Google Colab runtime חדש, או להריץ אותו מקומית.

הגדרה

כדי להריץ את ה-notebook הזה ב-Google Colab, תצטרך חשבון Google כדי שתוכל לפתוח notebooks ולהריץ תאים בדפדפן.

כדי להריץ על מחשב קוונטי אמיתי של IBM, תצטרך גם (בחינם) חשבון IBM Quantum® Platform. אפשר לפתוח מופע דרך ה-Open Plan ולקבל 10 דקות של זמן יחידת עיבוד קוונטי (QPU) לכל חלון גלגול של 28 יום, וזה בעצם הרבה! אם יש לך בעיות עם החשבון שלך, ראה את דף התמיכה.

אפשר גם להריץ את ה-notebook הזה מקומית לאחר התקנת Qiskit על ידי ביצוע ההוראות ב-IBM Quantum Platform.

התקנה וייבוא

ב-Colab, אנחנו מתקינים תלויות בתוך ה-notebook כדי שכולם ירצו את אותם כלים. התא הבא מתקין את Qiskit עם מודול הוויזואליזציה בתוספת שני תוספים: Aer (סימולטורים מהירים) ו-IBM Runtime client (להרצות על מחשב קוונטי).

לאחר מכן, יש לנו מספר ייבוא. המחלקה QuantumCircuit היא המקום שבו אנחנו מגדירים את הביטים הקוונטיים שלנו, או Qubit-ים, ומגדירים פעולות על אותם Qubit-ים. זהו המונח הקוונטי הראשון שלנו: Qubit הוא אבן הבניין הבסיסית של החישוב הקוונטי, בדיוק כמו שביט הוא אבן הבניין של החישוב הקלאסי. נלמד עוד על התכונות המיוחדות של Qubit-ים בזמן שנבנה את ה-Circuit שלנו. בהמשך, plot_histogram ישמש לויזואליזציה של תוצאות ה-Circuit הקוונטי. AerSimulator מאפשר לנו לדמות את ה-Circuit הקוונטי על מחשב קלאסי. אבל סימולטורים לא יכולים להריץ Circuit קוונטיים באותה קנה מידה כמו מחשבים קוונטיים אמיתיים; בגלל זה אנחנו צריכים מחשבים קוונטיים אמיתיים. זה יכול להיות שימושי לצורכי בדיקה, דיבוג, או למטרות חינוכיות; או אם מיצית את 10 הדקות החינמיות שלך של זמן QPU. ה-preset_passmanagers עוזרים לאופטימיזציה של ה-Circuit-ים להרצה יעילה על חומרה, מה שהופך להיות חשוב מאוד ככל שה-Circuit-ים שלנו הופכים מורכבים יותר. Sampler ו-QiskitRuntimeService נחוצים כדי להריץ בפועל את ה-Circuit על המחשב הקוונטי. נרחיב על כך בהמשך.

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

!pip install 'qiskit[visualization]' qiskit-ibm-runtime qiskit-aer
# Core Qiskit imports
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit_aer import AerSimulator
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# IBM Runtime specific imports
from qiskit_ibm_runtime import SamplerV2 as Sampler, QiskitRuntimeService

עכשיו נעשה בדיקת סביבה מהירה. נאמת גרסאות ונאשר ייבוא.

אם משהו נכשל כאן, זה בדרך כלל בעיית התקנת תלויות; תיקון זה עכשיו מונע שגיאות מבלבלות בהמשך.

import sys

import qiskit
import qiskit_aer
import qiskit_ibm_runtime

print("Python:", sys.version.split()[0])
print("qiskit:", qiskit.__version__)
print("qiskit-aer:", qiskit_aer.__version__)
print("qiskit-ibm-runtime:", qiskit_ibm_runtime.__version__)

Python: 3.12.2
qiskit: 2.2.3
qiskit-aer: 0.17.2
qiskit-ibm-runtime: 0.41.1

סטייה קצרה: שימוש ב-Composer

לפני שנכתוב קוד, כדאי לראות Circuit-ים בצורה ויזואלית. IBM Quantum Composer מאפשר לך לבנות Circuit-ים על ידי גרירת Gate-ים על קווים. זוהי דרך מצוינת ללמוד מה Circuit עושה מבלי להסתבך בתחביר.

פתח את Composer כאן.

ברגע שהוא נטען, הפעל את המדריך המודרך מהתפריט: Help | Build your first circuit. עבור דרכו בקצב שלך. בזמן שאתה עובר, שים לב איך כל Gate משנה מה אתה מצפה למדוד.

המדריך עובר שלב אחר שלב בבניית מעגל ה-"Hello World". הוא מוצג במה שנקרא דיאגרמת Circuit, שבה ה-Qubit-ים מיוצגים על ידי קווים אופקיים וה-Gate-ים הפועלים על אותם Qubit-ים מיוצגים על ידי תיבות או סמלים אחרים על הקווים. ה-Circuit הזה מציג לנו כמה תכונות מפתח של Qubit-ים ומחשבים קוונטיים:

ראשית, התיבה האדומה עם הכיתוב "H" היא Hadamard Gate, שיוצר מצב סופרפוזיציה של Qubit 0. בניגוד לביט, שיכול להיות רק במצב 1 או 0, מצב Qubit יכול לכלול את שתי האפשרויות בו-זמנית, עם משקלים מסוימים (הנקראים אמפליטודות) שמחוברים לכל אחת מהן. סופרפוזיציה לא אומרת שתראה אי פעם את שתי התוצאות במדידה אחת; היא אומרת שהמצב מוגדר כך שכל אחת מהתוצאות יכולה לקרות כשמודדים.

שנית, העיגולים והקו האנכי המחברים את שני ה-Qubit-ים הם CNOT Gate, שמייצר שזירה (entanglement) בין שני ה-Qubit-ים. שזירה היא סוג מיוחד של קשר בין Qubit-ים. כשה-Qubit-ים שזורים, תוצאות המדידות יכולות להיות מתואמות בחוזקה בדרך שלא תואמת את מה שנצפה מהטלות מטבע עצמאיות רגילות, או מכל קורלציה קלאסית. כשני Qubit-ים שזורים, מדידת אחד מהם תגלה לך מיידית את תוצאת המדידה של השני.

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

בדוק את ההבנה שלך

חשוב על כל שאלה למטה, ואז לחץ כדי לגלות את התשובה.

האם אפשר לראות סופרפוזיציה ישירות ממדידה בודדת?

תשובה

לא. מדידה בודדת תמיד מחזירה ערך קלאסי: 0 או 1. הרעיון של "תערובת" מופיע רק בסטטיסטיקות שרואים לאחר הרצות רבות, הנקראות גם shots.

במילים פשוטות, מה שזירה נותנת לך?

תשובה

היא נותנת לך תוצאות מקושרות. מדידת Qubit אחד אומרת לך משהו על השני. הקשר הזה חזק יותר מאקראיות עצמאית וחזק יותר ממה שכל קורלציה קלאסית גרידא או אקראיות משותפת יכולים להסביר.

אם Qubit נמצא בסופרפוזיציה, מה רואים במדידה בודדת, ולמה צריך הרבה shots?

תשובה

במדידה בודדת רואים רק תוצאה קלאסית אחת: 0 או 1. צריך הרבה shots כי ה-"סופרפוזיציה" מתבטאת כפילוג הסתברות, שאפשר להעריך רק על ידי איסוף סטטיסטיקות על פני הרצות חוזרות.

הסתכל על היסטוגרמת המדידות של מעגל ה-Hello World שלך ב-Composer. מה אתה רואה? למה זה סימן מובהק לשזירה?

תשובה

רואים הסתברות של 50% להיות במצב $|00\rangle$ והסתברות של 50% להיות במצב $|11\rangle$. המשמעות היא שאם מודדים שאחד הוא 0, השני יהיה גם 0, ואם מודדים שאחד הוא 1, השני יהיה גם 1. זוהי קורלציה בין שני ה-Qubit-ים שניתן להסבירה על ידי שזירה.

יצירה והרצה של תוכנית קוונטית באמצעות Qiskit

אוקיי, חזרה לקידוד. אנחנו הולכים לייצר את אותו מצב שזור כמו שעשינו ב-Composer (הנקרא מצב Bell $\Phi^+$ (phi-plus)) אבל הפעם, נכתוב את הקוד ביד. אנחנו צריכים לפתח את המיומנות הזו כי ככל שנרחיב לעוד Qubit-ים ו-Circuit-ים מורכבים יותר, ה-Composer לא יוכל לעזור לנו.

כדי לבנות את ה-Circuit של Bell state, אנחנו משתמשים ב-$H$ Gate (Hadamard) כדי להכניס את ה-Qubit הראשון לסופרפוזיציה שווה. לאחר מכן מפעילים $CX$ Gate (controlled-NOT), שמשזר את שני המצבים יחדיו. שני ה-Qubit-ים מתואמים עכשיו בדרך שאין לה מקביל קלאסי.

# --- Build the Bell circuit (phi-plus) ---
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()  # creates a classical register named "meas"

bell.draw("mpl")

פונקציית עזר להרצת Circuit-ים

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

def run_circuit_and_get_counts(circuit, backend, shots=1000):
    """
    Runs a quantum circuit on a specified backend and returns the measurement counts.

    Args:
        circuit (QuantumCircuit): The quantum circuit to run.
        backend: The Qiskit backend (real device or simulator).
        shots (int): The number of shots to run the circuit.

    Returns:
        dict: A dictionary of measurement counts.
    """
    pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
    isa_circuit = pm.run(circuit)

    sampler = Sampler(mode=backend)

    job = sampler.run([isa_circuit], shots=shots)
    result = job.result()

    return result[0].data.meas.get_counts()

הרצה על QPU וויזואליזציה של תוצאות

לבסוף, אנחנו מריצים את ה-Circuit על יחידת עיבוד קוונטי (QPU) של IBM בענן ל-1000 shots ומציגים את התוצאות בגרף. QPU-ים של IBM הם מערכות פיזיות שיכולות לקלוט רעש, ולכן Gate-ים אינם מושלמים לגמרי, מדידות יכולות להיות שגויות לפעמים, וכיול ההתקן משתנה עם הזמן.

הרצה על מחשבים קוונטיים אמיתיים גם מציגה שיקולים מעשיים. Jobs יכולים לחכות בתור, כיוון שאנשים רבים עשויים להשתמש באותו התקן. כמו כן צריך לבחור מספר shots שמאזן שיקולים סטטיסטיים (יותר shots שווה ביחס אות לרעש גבוה יותר) עם אילוצי זמן/עלות.

עקוב אחר ההוראות בהערות הקוד של התא הבא. לאחר הרצת התא, אמורה להופיע היסטוגרמה עם ספירות בערך שוות עבור מחרוזות הביטים $00$ ו-$11$, עם כמה מופעים של $01$ או $10$ עקב רעש. התא הבא ב-notebook הזה מריץ את אותו ה-Circuit על סימולטור, אם תחליט לדלג על הרצה על QPU.

# Syntax for first saving your token.  Delete these lines after saving your credentials.
QiskitRuntimeService.save_account(
    channel="ibm_quantum_platform",
    token="YOUR_TOKEN_HERE",
    overwrite=True,
    set_as_default=True,
)
service = QiskitRuntimeService(channel="ibm_quantum_platform")

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_fez".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_fez")
print(backend.name)

ibm_pittsburgh

counts = run_circuit_and_get_counts(bell, backend, shots=1000)
plot_histogram(counts)

הרצה על סימולטור וויזואליזציה של תוצאות

סימולטור הוא גרסת "עולם מושלם" של חישוב קוונטי. כאן אנחנו מריצים את ה-Circuit על סימולטור ל-1000 shots ומציגים את התוצאות. אמורות להופיע ספירות בערך שוות עבור המצבים $00$ ו-$11$, ללא מופעים של $01$ או $10$, שזהו הסימן המובהק של הקורלציה המושלמת של Bell state.

backend = AerSimulator()
counts = run_circuit_and_get_counts(bell, backend, shots=1000)

plot_histogram(counts)

בדוק את ההבנה שלך

מהם שני ה-Gate-ים שיוצרים את Bell state כאן?

תשובה

H Gate על Qubit 0, ואחריו CX Gate עם Qubit 0 כשליטה ו-Qubit 1 כיעד.

על סימולטור אידיאלי, אילו שתי מחרוזות ביטים אמורות לשלוט בהיסטוגרמה?

תשובה

00 ו-11 אמורות לשלוט.

למה סימולטור מושלם לא תמיד יניב את אותו מספר מדויק של ספירות 00 כמו ספירות 11?

תשובה

גם אם סימולטור הוא "מושלם" ומוביל למצב Bell מושלם, הוא עדיין מדמה תהליך אקראי מטבעו, ולכן תנודות סטטיסטיות עדיין יתרחשו. זה כמו להטיל מטבע 1000 פעמים: גם אם יש סיכוי מדויק של 50-50 שהמטבע ינחת על ראש או פלי, זה לא אומר שתקבל תמיד בדיוק 500 מופעי ראש ו-500 מופעי פלי.

למה מחשב קוונטי אמיתי עשוי להראות תוצאות 01 או 10 למרות שהסימולטור לא הראה כאלו?

תשובה

כי להתקנים אמיתיים יש רעש. Gate-ים ומדידות אינם מושלמים, וזה יכול להכניס שגיאות מדי פעם.

מהו הבדל מעשי אחד בין סימולטורים למחשבים קוונטיים אמיתיים מעבר לרעש?

תשובה

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

סיכום

התחלנו בהגדרת Qiskit בסביבת Colab חדשה, שזה בדיוק איך עבודות notebook רבות בעולם האמיתי מתחילות. עקבנו אחרי מסע לחישוב קוונטי באמצעות ה-Composer. לאחר מכן בנינו Circuit פשוט בעל שני Qubit-ים שמייצר את מצב ה-$\Phi^+$ Bell, השתמשנו בדגימה חוזרת וויזואליזציה של השזירה כקורלציה בהיסטוגרמת מדידת ה-Qubit. ראינו גם איך מחשבים קוונטיים אמיתיים מכניסים רעש ושגיאות.

מטרת הלמידה

עכשיו שעברנו על איך ליצור את מצב ה-$\Phi^+$ Bell, בדוק אם תוכל לערוך את הקוד כדי ליצור אחד משלושת מצבי Bell האחרים. בפרט, מצב ה-$\Psi^-$ ישמש בשיעור עתידי, אז אם תצליח לגלות איך ליצור אותו, תהיה צעד אחד לפני.

© IBM Corp., 2017-2026