שערים שבריים

Package versions

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

qiskit[all]~=2.5.2
qiskit-ibm-runtime~=0.47.0

דף זה מציג שני סוגי Gates שנתמכים לאחרונה בצי ה-QPUs של IBM Quantum®. שערים שבריים אלה נתמכים על QPUs מסוג Heron בצורה של:

• $R_{ZZ}(\theta)$ עבור $0 \lt \theta \leq \pi/2$
• $R_X(\theta)$ עבור כל $\theta$

דף זה דן במקרי השימוש שבהם הטמעת שערים שבריים יכולה לשפר את יעילות תהליכי העבודה שלך, וכן כיצד להשתמש בשערים אלו על QPUs של IBM Quantum.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

כיצד להשתמש בשערים שבריים

באופן פנימי, שערים שבריים אלו פועלים על ידי ביצוע ישיר של סיבוב $R_{ZZ}(\theta)$ ו-$R_X(\theta)$ עבור זווית שרירותית. שימוש ב-Gate $R_X(\theta)$ יכול להפחית את משך הזמן והשגיאה של סיבובי qubit בודד בזווית שרירותית עד פי שניים. ביצוע ישיר של סיבוב Gate $R_{ZZ}(\theta)$ מונע פירוק למספר אובייקטים CZGate, ומפחית באופן דומה את משך Circuit ואת שגיאותיו. הדבר שימושי במיוחד עבור circuits המכילים סיבובים רבים של qubit בודד ושני qubits, כגון בעת סימולציה של דינמיקה של מערכת קוונטית או בעת שימוש ב-variational ansatz עם פרמטרים רבים.

בעוד שסוגי Gates אלו נמצאים בספריית השערים הסטנדרטית ש-QuantumCircuit יכול להכיל, ניתן להשתמש בהם רק על QPUs ספציפיים של IBM Quantum, אשר יש לטעון עם הדגל use_fractional_gates מוגדר ל-True (כמוצג להלן). דגל זה יבטיח שהשערים השבריים ייכללו ב-Target של ה-Backend עבור ה-Transpiler.

service = QiskitRuntimeService()
backend = service.backend('ibm_torino', use_fractional_gates=True)

דוגמת קוד זו מדגימה כיצד להשתמש בשערים שבריים בהקשר של תהליך עבודה המדמה את הדינמיקה של שרשרת Ising תוך שימוש בשערים שבריים. לאחר מכן משך המעגל מושווה מול Backend שאינו משתמש בשערים שבריים.

הערה לגבי שיעורי שגיאה מדווחים

ערך השגיאה המדווח ב-Target של Backend עם שערים שבריים מופעלים הוא רק עותק של המקבילה של ה-Gate הלא-שברי (שעשויה שלא להיות זהה). הסיבה לכך היא שדיווח שיעורי שגיאה על שערים שבריים אינו נתמך עדיין.

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

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization.timeline import draw as draw_timeline, IQXSimple

from qiskit_ibm_runtime import QiskitRuntimeService

num_qubits = 5
num_time_steps = 3
rx_angle = 0.1
rzz_angle = 0.1

ising_circuit = QuantumCircuit(num_qubits)
for i in range(num_time_steps):
    # rx layer
    for q in range(num_qubits):
        ising_circuit.rx(rx_angle, q)
    for q in range(1, num_qubits - 1, 2):
        ising_circuit.rzz(rzz_angle, q, q + 1)
    # 2nd rzz layer
    for q in range(0, num_qubits - 1, 2):
        ising_circuit.rzz(rzz_angle, q, q + 1)
    ising_circuit.barrier()
ising_circuit.draw("mpl")

ציין שני אובייקטי Backend: אחד עם שערים שבריים מופעלים, והשני עם שערים שבריים מושבתים, ולאחר מכן בצע Transpile לשניהם.

service = QiskitRuntimeService()
backend_name = service.least_busy(operational=True, simulator=False).name
backend_fractional = service.backend(backend_name, use_fractional_gates=True)
backend_conventional = service.backend(
    backend_name, use_fractional_gates=False
)

pm_fractional = generate_preset_pass_manager(
    optimization_level=3, backend=backend_fractional, scheduling_method="alap"
)
pm_conventional = generate_preset_pass_manager(
    optimization_level=3,
    backend=backend_conventional,
    scheduling_method="alap",
)

ising_circuit_fractional = pm_fractional.run(ising_circuit)
ising_circuit_conventional = pm_conventional.run(ising_circuit)

הצג את ציר הזמן של ה-Circuit תוך שימוש בשני סוגי ה-Gates.

# Draw timeline of circuit with conventional gates
draw_timeline(
    ising_circuit_conventional,
    idle_wires=False,
    target=backend_conventional.target,
    time_range=(0, 500),
    style=IQXSimple(),
)

# Draw timeline of circuit with fractional gates
draw_timeline(
    ising_circuit_fractional,
    idle_wires=False,
    target=backend_fractional.target,
    time_range=(0, 500),
    style=IQXSimple(),
)

אילוצי זווית

עבור Gate $R_{ZZ}(\theta)$ של שני qubits, ניתן לבצע רק זוויות בין $0$ ל-$\pi/2$ על חומרת IBM Quantum. אם Circuit מכיל Gates $R_{ZZ}(\theta)$ עם זווית מחוץ לטווח זה, אז צינור ה-Transpilation הסטנדרטי בדרך כלל יתקן זאת עם טרנספורמציית Circuit מתאימה (דרך ה-pass FoldRzzAngle). עם זאת, עבור כל Gate $R_{ZZ}(\theta)$ המכיל Parameter אחד או יותר, ה-Transpiler יניח שפרמטרים אלו יקבלו זוויות בטווח זה בזמן ריצה. המשימה תיכשל אם אחד מערכי הפרמטרים שצוינו ב-PUB שהוגש ל-IBM Quantum Compute Service נמצא מחוץ לטווח זה.

היכן להשתמש בשערים שבריים

מבחינה היסטורית, שערי הבסיס הזמינים ב-QPUs של IBM Quantum היו CZ, X, RZ, SX ו-ID, שאינם יכולים לייצג באופן יעיל circuits עם סיבובי qubit בודד ושני qubits שאינם כפולות של $\pi / 2$. לדוגמה, Gate $R_X(\theta)$, כאשר עובר Transpilation, חייב להתפרק לסדרה של Gates $RZ$ ו-$\sqrt{X}$, מה שיוצר Circuit עם שני Gates בעלי משך סופי במקום אחד.

באופן דומה, כאשר סיבובים של שני qubits כגון Gate $R_{ZZ}(\theta)$ עוברים Transpilation, הפירוק דורש שני Gates CZ ומספר Gates של qubit בודד, מה שמגדיל את עומק ה-Circuit. פירוקים אלו מוצגים בקוד הבא.

qc = QuantumCircuit(1)
param = Parameter("θ")
qc.rx(param, 0)
qc.draw("mpl")

# Decomposition of an RX(θ) gate using the IBM Quantum QPU basis
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
optimization_level = 3
pm = generate_preset_pass_manager(optimization_level, backend=backend)
transpiled_circuit = pm.run(qc)
transpiled_circuit.draw("mpl", idle_wires=False)

from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpiler import generate_preset_pass_manager

from qiskit_ibm_runtime import QiskitRuntimeService

qc = QuantumCircuit(2)
param = Parameter("θ")
qc.rzz(param, 0, 1)
qc.draw("mpl")

# Decomposition of an RZZ(θ) gate using the IBM Quantum QPU basis
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
optimization_level = 3
pm = generate_preset_pass_manager(optimization_level, backend=backend)
transpiled_circuit = pm.run(qc)
transpiled_circuit.draw("mpl", idle_wires=False)

עבור תהליכי עבודה שדורשים סיבובי $R_X(\theta)$ רבים על qubit בודד או סיבובים על שני qubits (כמו ב-variational ansatz או בסימולציה של אבולוציית זמן של מערכות קוונטיות), אילוץ זה גורם לעומק המעגל לגדול במהירות. עם זאת, שערים שבריים מסירים דרישה זו, מכיוון שהסיבובים על qubit בודד ועל שני qubits מבוצעים ישירות, ויוצרים מעגל קוונטי יעיל יותר (ולכן עם שגיאות מדוכאות יותר).

מתי לא להשתמש בשערים שבריים

חשוב לציין כי שערים שבריים הם תכונה ניסיונית והתנהגות הדגל use_fractional_gates עשויה להשתנות בעתיד. ראה בהערות הגרסה עבור גרסאות חדשות של qiskit-ibm-runtime לקבלת מידע נוסף. ראה גם את תיעוד ה-API reference עבור QiskitRuntimeService.backend, המתאר את use_fractional_gates.

בנוסף, ל-Transpiler של Qiskit יש יכולת מוגבלת להשתמש ב-$R_{ZZ}(\theta)$ במעברי האופטימיזציה שלו. הדבר דורש ממך להיות זהיר יותר בעיצוב ואופטימיזציה של circuits המכילים הוראות אלו.

לבסוף, שימוש בשערים שבריים אינו נתמך עבור:

• Pauli twirling - עם זאת, twirling של מדידות עם TREX נתמך.
• ביטול שגיאות הסתברותי
• אקסטרפולציית אפס-רעש (באמצעות הגברת שגיאות הסתברותית)

קרא את המדריך על אפשרויות primitive כדי ללמוד עוד על התאמה אישית של טכניקות הפחתת שגיאות ודיכוי שגיאות עבור עומס עבודה קוונטי נתון.

אילו backends תומכים בשערים שבריים?

לא כל ה-backends תומכים בשערים שבריים. הרץ service.backends(use_fractional_gates=True) כדי למצוא את אלה שכן תומכים. עם השחרור של qiskit-ibm-runtime גרסה 0.48, אפשר גם להריץ service.least_busy(fractional_gates=True) כדי למצוא את ה-backend הכי פחות עמוס שתומך בשערים שבריים. backend מדומה תומך בשערים שבריים רק אם ה-backend ה"אמיתי" הקשור אליו תומך בהם.

שים לב ש-backends מדומים אינם תומכים בשערים שבריים כברירת מחדל, מכיוון ששערים שבריים מושבתים כברירת מחדל. כדי להפעיל שערים שבריים ב-backend מדומה שתומך בהם, רענן את התצורה שלו.

Example:

service = QiskitRuntimeService()
fake_backend = FakeBoston()
fake_backend.refresh(service=service, use_fractional_gates=True)

הצעדים הבאים

המלצות

• למידע נוסף על Transpilation, ראה את דף מבוא ל-Transpilation.
• קרא על כתיבת מעבר Transpiler מותאם אישית.
• הבן כיצד להגדיר הפחתת שגיאות.