שערים שברירים

Package versions

The code on this page was developed using the following requirements. We recommend using these versions or newer.

qiskit[all]~=2.3.0
qiskit-ibm-runtime~=0.43.1

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

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

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

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

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

באופן פנימי, שערים שברירים אלו פועלים על ידי ביצוע ישיר של סיבוב $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 תוך שימוש בשערים שברירים. לאחר מכן משך ה-Circuit מושווה מול 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_fractional = service.backend("ibm_torino", use_fractional_gates=True)
backend_conventional = service.backend(
    "ibm_torino", 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 שהוגש ל-Qiskit Runtime נמצא מחוץ לטווח זה.

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

מבחינה היסטורית, Gates הבסיסיים הזמינים ב-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.backend("ibm_torino")
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.backend("ibm_torino")
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 או בעת סימולציה של אבולוציית זמן של מערכות קוונטיות), מגבלה זו גורמת לעומק ה-Circuit לגדול במהירות. עם זאת, שערים שברירים מסירים דרישה זו, מכיוון שסיבובי qubit הבודד ושני qubits מבוצעים ישירות, ויוצרים Circuit קוונטי יעיל יותר (ובכך מדוכא-שגיאות יותר).

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

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

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

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

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

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

הצעדים הבאים

המלצות

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