Orbit - isang Qiskit Function ng Quantum Elements

Tingnan ang API reference

Note

Ang Qiskit Functions ay isang experimental feature na available lang sa mga user ng IBM Quantum® Premium Plan, Flex Plan, at On-Prem (sa pamamagitan ng IBM Quantum Platform API) Plan. Ang mga ito ay nasa preview release status at maaaring magbago.

Overview

Patuloy na umuunlad ang quantum hardware, ngunit ang noise at decoherence ay nagpapatuloy pa ring naghihigpit sa depth at reliability ng mga praktikal na quantum circuit. Kabilang sa mga available na approach, tatlong magkakabuklod na teknik ang maaaring makabuluhang mabawasan ang mga limitasyong ito: dynamical decoupling (DD), optimized transpilation, at measurement error mitigation (MEM). Binabawasan ng optimized transpilation ang circuit depth at mas maayos na inihahanay ang mga circuit sa connectivity ng target hardware, sinusupress ng DD ang idle-time noise sa pamamagitan ng maingat na dinisenyong control sequences, at binabawasan ng MEM ang epekto ng readout errors at maaaring i-apply habang post-processing.

Ang pagpili ng epektibong DD strategy ay partikular na hindi simple dahil maraming available na sequence family, at ang isang sequence na maganda ang performance para sa isang circuit o noise environment ay maaaring hindi maganda ang performance para sa iba. Ang mga benepisyo ng transpilation, DD, at MEM ay depende sa problema, hardware, at workload; ginamit man nang mag-isa o pinagsama, maaari nilang mapahusay ang performance, ngunit hindi ito laging kapaki-pakinabang sa bawat configuration.

Ang Orbit, isang Qiskit Function na binuo ng Quantum Elements, ay maayos na pinagsasama ang tatlong komponent sa isang unified workflow, na ginagawang madaling gamitin ang mga ito para pahusayin ang pagpapatakbo ng circuit sa IBM Quantum hardware. Sa pangunahing anyo nito, awtomatikong inilalapat ng Orbit ang mga active error-suppression strategy na nagpoprotekta sa quantum states habang idle periods, habang pinapanatili ang orihinal na circuit logic. Kapansin-pansin, ginagawa nito ito nang hindi nagpapakilala ng karagdagang quantum o classical pre-processing time, sa gayon ay iniiwasan ang hindi kinakailangang karagdagang gastos o wait time sa loob ng workflow.

Sa halip na gumana bilang black box, hinahayaan ng Orbit ang mga user na suriin at i-fine-tune ang mga optimization component nito para sa isang partikular na eksperimento. Maaaring independiyenteng paganahin o i-disable ng mga user ang optimized transpilation, DD, at MEM; ikumpara ang awtomatikong pagpili ng DD sa mga user-specified sequence; at magpatakbo ng maraming configuration sa loob ng parehong workflow. Sa pamamagitan ng paghahambing ng bawat configuration sa raw circuit, matutukoy ng mga user kung aling teknik ang nagbibigay ng nasusukat na benepisyo para sa kanilang circuit at backend, matukoy ang mga interaksyon sa pagitan ng iba't ibang optimization method, at pumili ng configuration na pinakamahusay na sumusuporta sa kanilang layuning eksperimental. Ginagabayan ng prosesong ito ang mga user sa pag-unawa kung saan nagmumula ang mga pagpapahusay sa performance at sa paggawa ng mas may-kaalamang mga desisyon kapag ino-optimize ang mga quantum circuit para sa isang partikular na workload.

Description

Ang Orbit ay idinisenyo para pahusayin ang pagpapatakbo ng mga quantum circuit sa mga IBM Quantum backend. Sa automated mode, maaaring maayos na ilapat ng mga user ang mga high-order, robust DD sequence nang hindi na kailangang manu-manong piliin o i-configure ang mga ito. Sa halip, maaaring mag-eksperimento ang mga advanced na user sa mga available na higher-order sequence para matukoy at i-optimize ang approach na nagbibigay ng pinakamahusay na performance para sa isang partikular na circuit.

Nagbibigay din ang Orbit ng instantaneous MEM nang hindi na kailangan ang karagdagang mga job na karaniwang kailangan para sa hiwalay na calibration at mitigation workflows. Para sa mga workload kung saan hindi dapat baguhin ng transpilation ang istruktura ng circuit, gaya ng mga quantum error-correction circuit na may mid-circuit measurements o dynamic circuits, maaaring ilapat ng Orbit ang DD at MEM nang hindi nakikialam sa umiiral nang transpilation strategy ng user. Para sa mga user na wala pang preferred na approach, kasama rin sa Orbit ang built-in na transpiler para i-optimize ang mga circuit para sa target hardware bago ilapat ang error-suppression at readout-mitigation techniques.

Hindi tulad ng mga approach na umaasa sa karagdagang circuit sampling, extrapolation, o malawak na classical post-processing, nakatuon ang Orbit sa pagsupress ng mga error habang pagpapatakbo. Idinisenyo ang function na magpakilala ng mababang overhead habang pinapanatili ang orihinal na circuit logic. Maaaring suriin ng mga user ang resultang circuit at direktang ikumpara ang mga Orbit-optimized na pagpapatakbo sa mga standard na pagpapatakbo.

Ang isang praktikal na Orbit workflow ay:

1. Magtakda ng quantum circuit at piliin ang Orbit sa pamamagitan ng Qiskit Functions Catalog.

2. Isama ang circuit nang walang Orbit gamit ang 'Raw' mode para magtatag ng raw-circuit baseline.

3. Piliin kung aling optimization strategy ang ilalapat, kabilang ang awtomatiko o user-selected na DD sequences, MEM, at optimized transpilation.

4. Paganahin o i-disable ang mga indibidwal na method, o magsumite ng maraming configuration, para suriin ang kanilang hiwalay at pinagsamang epekto.

Partikular na kapaki-pakinabang ang Orbit para sa mga circuit na may idle periods o scheduling gaps kung saan hindi aktibong lumalahok ang mga qubit sa mga gate. Sinusuportahan nito ang static at dynamic circuits, kabilang ang mga workflow na may mid-circuit measurements at fault-tolerant quantum-computing experiments. Kabilang sa mga karaniwang aplikasyon ang quantum error correction, surface-code experiments sa square at heavy-hex lattices, oracular algorithms tulad ng Bernstein-Vazirani, Fourier transform circuits, variational quantum algorithms, Hamiltonian simulation, benchmarking experiments, at hardware-aware circuit optimization.

Sa pagtingin sa hinaharap na era ng fault tolerance, compatible rin ang Orbit sa fault-tolerant quantum computing workflows, dahil maaari itong maayos na pagsamahin sa quantum error correction. Sa mahabang panahon, itinuturo ng Orbit ang logical-level dynamical decoupling [1] bilang isang future-facing na landas para sa pagprotekta sa mga logical qubit. Sa halimbawa sa ibaba, dalawang logical qubit ang na-entangle para lumikha ng logical Bell state sa ilalim ng quantum error detection. Ang quantum error detection lamang ay humantong sa pagbaba ng Bell-state fidelity sa humigit-kumulang 44% sa loob ng ilang tens ng microseconds, habang ang QED na pinagsama sa Orbit-style na proteksyon ay pinanatili ang logical Bell-state fidelity malapit sa itaas ng scale, umaabot sa humigit-kumulang 95.3% sa parehong time window.

Benchmarks

Sinasalarawan ng mga sumusunod na resulta ang mga representative na Orbit run sa IBM Quantum hardware. Tulad ng iba pang hardware benchmark, depende ang mga resulta sa napiling device, calibration state, circuit, at execution settings.

Halimbawa	Metric	Mga Qubit	QPU	Karagdagang detalye	Pagpapabuti ng Orbit
Bernstein–Vazirani	Hidden-bitstring fidelity	26 60 70	Heron r3	Raw versus Full Orbit, Transpilation only versus Full Orbit, Full Orbit Only	75x 66x N/A
QFT (unitary)	Fidelity	10	Heron r2 Heron r3	Orbit versus raw: ~44% versus ~35% ~67% versus ~61%	1.26x 1.09x
QFT (dynamic circuits)	Fidelity	10 20	Heron r3	Orbit versus raw: ~55% versus ~2% ~10% versus ~0%	27.51x N/A
Long-range Bell state (dynamic circuits)	Fidelity	30 60	Heron r2	N/A	1.78x 1.11x
Surface code (square lattice)	Logical error probability	25	Nighthawk r1	1 round 5 rounds 10 rounds	1.01x 1.15x 1.12x
Surface code (heavy-hex)	Logical error probability	65	Heron r3	1 round 5 rounds 10 rounds	4.11x 2.04x 1.39x
VQE	Absolute error relative to the ideal energy	8	Heron r3	Orbit versus raw: 56mHa versus 1342 mHa	24x
QAOA	Success probability	5	Heron r2	N/A	1.46x
[[4,2,2]] code (logical-level error suppression)	Entangled Bell-state logical fidelity	4	Heron r2	Average fidelity over 55 μs	1.63x

Mga kahulugan ng Metric

• Bernstein–Vazirani hidden-bitstring fidelity: Probability ng pagsukat ng tamang hidden bitstring. Ipinapakita ng metric na ito kung gaano kapanatag na nababawi ng algorithm ang nilalayong solusyon habang lumalaki ang circuit size. Iniuulat ng talahanayan ang tatlong pinakamalaking hidden bitstring na matagumpay na na-evaluate sa ilalim ng tatlong magkaibang configuration: (i), raw circuits na walang Orbit, na umabot sa 26 qubits; (ii), mga circuit na may transpilation lamang, na umabot sa 60 qubits; at (iii), mga circuit gamit ang buong Orbit workflow, na umabot sa 70 qubits. Para sa mga raw circuit (i), kinakatawan ng improvement factor ang pagtaas ng performance na nakamit ng DD at MEM kaugnay ng hindi binagong mga circuit. Para sa transpilation-only configuration (ii), kinakatawan nito ang pagtaas na nakamit sa pagdaragdag ng DD at MEM sa mga optimally transpiled na circuit. Para sa buong Orbit configuration (iii), walang iniulat na baseline improvement factor dahil isang nonzero na success probability lamang ang nakuha noong pinagana ang lahat ng Orbit component (transpilation, DD, at MEM). Ibinigay sa ibaba ang isang ilustratibong halimbawa.

• Quantum Fourier transform fidelity: Para sa parehong unitary at dynamic-circuit na implementasyon ng QFT [2], sinusukat ng fidelity ang pagkakatugma sa pagitan ng eksperimental na naipatupad na transformation at ng ideal na proseso ng QFT sa 20 magkaibang input state. Naglalaman ang dynamic circuits ng malaking idle time dahil sa mid-circuit measurements at classical feedforward, kung saan maaaring i-suppress ng dynamical decoupling ang decoherence. Inihahambing ng iniulat na pagtaas ang fidelity na nakuha gamit ang Orbit sa raw fidelity.

• Long-range Bell-state preparation: Paglikha ng Bell state gamit ang dynamic circuits at feedforward operations sa pagitan ng dalawang qubit na pinaghihiwalay ng hanggang 60 intermediate qubits, sa gayon ay ipinapakita ang epektibong long-range entanglement sa locally connected na quantum hardware [3]. Tinutukoy ng Orbit ang pinakamahusay na qubit routing, pinapanatili ang mga qubit habang feedforward measurements, at inilalapat ang MEM para mabawasan ang readout errors.

• Surface-code logical error probability: Para sa heavy-hex surface code [4] at square-lattice surface code [5], isinagawa ang mga quantum-memory experiment kung saan pinanatili ang isang encoded logical state sa loob ng paulit-ulit na round ng error correction. Sinusukat ng logical error probability ang probability na ang mga akumuladong error ay magiging dahilan ng maling pagbawi ng encoded information (mas mainam ang mas mababang error). Inihahambing ng iniulat na pagtaas ang logical error probability mula sa raw circuits sa nakuha gamit ang Orbit.

• VQE absolute error: Paggamit ng VQE na may optimized unitary coupled-cluster ansatz para tantiyahin ang ground-state energy ng LiH [6]. Inihahambing ang nasukat na energy sa katumbas na ideal na energy na nakuha mula sa noiseless circuit. Ang metric ay ang absolute na pagkakaiba sa pagitan ng nasukat at ideal na energy (mas mainam ang mas mababang value). Ang iniulat na pagtaas ay:

$$\text{Improvement factor} = \frac{|E_{\mathrm{raw}}-E_{\mathrm{ideal}}|} {|E_{\mathrm{Orbit}}-E_{\mathrm{ideal}}|}.$$

Ang mga value na mas malaki sa isa ay nagpapahiwatig na binabawasan ng Orbit ang energy error kaugnay ng pagpapatakbo nang walang dynamical decoupling.

• QAOA success probability: Probability ng pagsukat ng bitstring na katumbas ng isang optimal na solusyon ng optimization problem na tinutukoy sa butterfly graph. Inihahambing ng iniulat na pagtaas ang success probability na nakuha gamit ang Orbit laban sa nakuha mula sa raw circuits.

• Logical fidelity: Sa [[4,2,2]] logical dynamical-decoupling experiment [1], dalawang logical qubit ang na-encode sa apat na physical qubit at inihanda bilang isang entangled logical Bell state. Sinusukat ng logical fidelity ang pagkakatugma sa pagitan ng nabaling encoded state at ng target na logical Bell state. Inihahambing ng iniulat na pagtaas ang average logical fidelity na nakuha gamit ang Orbit at error detection (kakayahan ng code) sa nakuha kapag gamit lamang ang code mismo.

Magsimula

Mag-authenticate gamit ang iyong IBM Quantum Platform API key, at piliin ang Orbit function tulad ng sumusunod. Ipinapalagay ng snippet na ito na na-save mo na ang iyong account sa iyong local environment.

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

from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit import QuantumCircuit

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Verify that you have access to the function.
catalog.list()

[QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")

Example

Ang sumusunod na halimbawa ay bumubuo ng isang Bernstein-Vazirani circuit at isinusumite ito sa Orbit sa dalawang paraan sa isang job: raw execution at Orbit defaults.

Gamitin ang pattern na ito kapag gusto mo ng direktang raw-versus-Orbit comparison.

Bumuo ng Bernstein-Vazirani circuit

Piliin ang hidden bitstring at bumuo ng logical circuit. Ang extra qubit ang oracle target, habang sinusukat ang mga input qubit.

def create_bv_circuit(hidden_bitstring: str) -> QuantumCircuit:
    width = len(hidden_bitstring)
    circuit = QuantumCircuit(width + 1, width)

    circuit.x(width)
    circuit.h(range(width + 1))

    for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
        if bit == "1":
            circuit.cx(input_qubit, width)

    circuit.barrier()
    circuit.h(range(width + 1))
    circuit.measure(range(width), range(width))
    return circuit

circuit_width = 50
hidden_bitstring = "1" * circuit_width
shots = 4096

bv_circuit = create_bv_circuit(hidden_bitstring)
bv_circuit.count_ops()

OrderedDict([('h', 102),
             ('cx', 50),
             ('measure', 50),
             ('x', 1),
             ('barrier', 1)])

Ihanda ang Orbit workload

Gumawa ng isang Sampler PUB, pagkatapos ay i-duplicate ito para sa dalawang comparison mode. Tinatanggap ng Orbit ang logical circuit at ini-map ito sa napiling backend habang pagpapatakbo.

base_pub = (bv_circuit, None, shots)
comparison_labels = ["raw", "orbit"]
pubs = [base_pub] * len(comparison_labels)

Patakbuhin ang raw at Orbit default

Itinatalaga ng pub_options ang unang PUB sa raw mode, na nilalaktawan ang Orbit optimization, DD, at MEM, at itinatalaga ang ikalawang PUB sa Orbit defaults, na kinabibilangan ng optimized transpilation, awtomatikong dynamical decoupling (DD) insertion, at measurement error mitigation (MEM).

backend_name = "ibm_kingston"

job = orbit.run(
    primitive="sampler",
    pubs=pubs,
    backend_name=backend_name,
    options={
        "pub_options": [
            {"mode": "raw"},
            {"mode": "orbit"},
        ],
        "save_backend_info": True,
    },
)

# Check the job ID and status
print(job.job_id)
print(job.status())

c0f1b99c-8dfa-4ebb-9560-d9a37c990acc
QUEUED

Kunin ang resulta at ikumpara ang raw at Orbit-enhanced circuits gamit ang counts. Para sa mga resulta ng Sampler, ang get_counts() sa ibinalik na classical register ay nagbibigay ng output histogram. Kapag matagumpay ang MEM para sa Orbit PUB, na-MEM-corrected na ang histogram na ito; ang mga unmitigated na counts ay nananatiling available sa Orbit metadata sa ilalim ng measurementErrorMitigation["rawCounts"].

def extract_counts(pub_result) -> dict[str, int]:
    data = getattr(pub_result, "data", None)
    if data is None:
        raise TypeError("pub_result.data is missing")

    for name in dir(data):
        if name.startswith("_"):
            continue
        register = getattr(data, name)
        get_counts = getattr(register, "get_counts", None)
        if callable(get_counts):
            counts = get_counts()
            if counts:
                return counts

    raise TypeError(
        "No classical register with get_counts() found in pub_result.data"
    )

result = job.result()
if len(result) != len(comparison_labels):
    raise RuntimeError(
        f"Expected {len(comparison_labels)} PUB results, received {len(result)}."
    )

comparison_counts = {
    label: extract_counts(pub_result)
    for label, pub_result in zip(comparison_labels, result, strict=True)
}
correct_counts = {
    label: counts.get(hidden_bitstring, 0)
    for label, counts in comparison_counts.items()
}

print(
    {
        "hidden_bitstring": hidden_bitstring,
        "correct_counts": correct_counts,
        "shots": shots,
    }
)

{'hidden_bitstring': '11111111111111111111111111111111111111111111111111', 'correct_counts': {'raw': 0, 'orbit': 184}, 'shots': 4096}

Gumawa ng visual na paghahambing ng raw at Orbit-enhanced circuits.

import matplotlib.pyplot as plt

labels = list(correct_counts)
values = list(correct_counts.values())
fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.bar(labels, values, width=0.55)
ax.bar_label(bars, labels=[f"{value:g}" for value in values], padding=3)
ax.set_xlabel("Circuit execution mode")
ax.set_ylabel("Correct hidden-bitstring count")
ax.set_title(f"{circuit_width}-qubit Bernstein-Vazirani on {backend_name}")
ax.set_ylim(0, max(1, 1.15 * max(values)))
ax.grid(axis="y", alpha=0.25)
fig.tight_layout()
plt.show()

Kumuha ng suporta

Makipag-ugnayan sa Quantum Elements support: info@quantumelements.ai

Siguraduhing isama ang sumusunod na impormasyon:

• Qiskit Function Job ID (qiskit-ibm-catalog), job.job_id

• Pangalan ng backend

• pub_options ng Orbit na ginamit para sa raw at Orbit modes

• Isang detalyadong paglalarawan ng isyu

• Anumang kaugnay na error messages o codes

• Mga hakbang para maulit ang isyu

Mga susunod na hakbang

Recommendations

• Subukan ang ibang backend, bilang ng qubit, o ibang hidden bitstring.

• Basahin ang aming tutorial tungkol sa quantum Fourier transform para matutuhan kung paano magtakda ng orbit-enabled custom DD strategies, gayundin ang pag-apply ng DD sa dynamic circuits na may mid-circuit measurements at feedforward operations.

• Bisitahin ang API reference para sa detalyadong paglalarawan ng lahat ng opsyon ng Orbit.

References

1. Logical-level error suppression combined with Quantum Error Detection, Nature Communications (2026)

2. Quantum Fourier Transform Using Dynamic Circuits, Physical Review Letters (2024)

3. Efficient Long-Range Entanglement Using Dynamic Circuits, PRX Quantum (2024)

4. Surface code scaling experiments on IBM Heron with heavy-hex connectivity, arXiv:2510.18847

5. Surface code experiments on IBM Nighthawk with square-lattice connectivity, arXiv:2606.11496

6. VQE benchmark reference, Nature Physics (2024)