Spustit a dekódovat logické programy

Pomocí Microsoft Quantum Development Kit (QDK) zkompilujte logický Q# program nebo OpenQASM program do Quantum Intermediate Representation (QIR) a pak použijte qdk.simulation.run_qir ke spuštění programu prostřednictvím qodec. Nastavte model šumu a pak zvolte předdefinovaný dekodér syndromu nebo volitelný deq dekodér na úrovni obvodu.

Prerequisites

Než začnete, proveďte tyto úkoly:

Nainstalujte QDK pro opravu chyb.
Vyvíjejte a ověřte protokol QEC nebo získejte kompletní qodec z jiného zdroje.
Auditujte qodec pomocí qdk.ec.audit.

Příklady Q# používají qodec s názvem protocol, který obsahuje pokyny pro kód C4. Pokud ho chcete vytvořit, přečtěte si článek Vývoj a ověření protokolu QEC.

import qodec
from qdk import ec

c4 = qodec.Code(
    "C4",
    stabilizers=["X_0 X_1 X_2 X_3", "Z_0 Z_1 Z_2 Z_3"],
    x=["X_0 X_1", "X_0 X_2"],
    z=["Z_0 Z_2", "Z_0 Z_1"],
)

protocol = ec.build_qodec(
    c4,
    strategy="bare-css/v1",
    strict=False,
)

report = ec.audit(protocol)
if report.errors or report.warnings:
    raise ValueError(str(report))

Před spuštěním qodec proveďte audit. Modul runtime důvěřuje kontrolám prvku qodec, výstupům, příznakům a rovnicím rámců, takže neplatné deklarace můžou způsobit nesprávné logické výsledky nebo selhání dekódovače.

Tento pracovní postup používá qdk.simulation.run_qir s qodec. Nástroje qodec používají samostatný StimPython balíček k analýze obvodů gadgetů ve formátu Stim. Nevolá se qdk.stim.run. Na Arm64Windows nebo LinuxArm64 nainstalujte Stim ze zdroje a restartujte qodec nebo jádro Stim před spuštěním Jupyter, která obsahuje obvody ve formátu Python.

Přiřaďte QIR volání k qodec pokynům

Přiřaďte každé kvantové volání v programu QIR k instrukci v horní sadě instrukcí qodec. Mnemotechnická zkratka instrukce musí přesně odpovídat jménu volané funkce QIR.

Následující tabulka ukazuje ukázková mapování:

Zdrojové volání	Požadovaný qodec měmonic
Q# `X(q)` nebo OpenQASM`x q;`	`__quantum__qis__x__body`
Q# `H(q)` nebo OpenQASM`h q;`	`__quantum__qis__h__body`
Q# `CNOT(a, b)` nebo OpenQASM`cx a, b;`	`__quantum__qis__cx__body`
Q# `Adjoint S(q)` nebo OpenQASM`sdg q;`	`__quantum__qis__s__adj`
Q# `M(q)` nebo OpenQASM`c = measure q;`	`__quantum__qis__m__body`
Q# intrinsická operace `Foo`	`Foo`
OpenQASM intrinsic gate nebo `def` s názvem `foo`	`foo`

QIR argumenty se svážou s qodec instrukčními prvky v tomto pořadí:

Argumenty ukazatele qubitu jsou vázány na operandy bloku.
Skalární argumenty se vážou k parametrům instrukce.
Ukazatelové argumenty pro výsledek přijímají výsledky instrukce a všechny vrácené příznaky.

Kompilátor vyvolá chybu, pokud kvantové volání neodpovídá instrukci v nejvyšší sadě instrukcí.

Deklarujte logické instrukce v Q#

Sestavení qodec z C4 kódu zpřístupňuje vlastní instrukce, jako je prepare_z_all, measure_z_all, syndrome a cx_all. Deklarujte Q# intrinsic operace se stejnými názvy.

Inicializujte Q# s adaptivním cílovým profilem, protože vlastní operace měření jej vyžadují.

from qdk import TargetProfile, qsharp

qsharp.init(target_profile=TargetProfile.Adaptive_RI)

Deklarujte C4 instrukce jako Q# operace.

qsharp.eval("""
@Measurement()
operation prepare_z_all(block : Qubit) : Result { body intrinsic; }

@Measurement()
operation prepare_x_all(block : Qubit) : Result { body intrinsic; }

@Measurement()
operation measure_z_all(block : Qubit) : (Result, Result) { body intrinsic; }

@Measurement()
operation measure_x_all(block : Qubit) : (Result, Result) { body intrinsic; }

operation cx_all(control : Qubit, target : Qubit) : Unit { body intrinsic; }
operation syndrome(block : Qubit) : Unit { body intrinsic; }
""")

V tomto programu každý Q#Qubit představuje jeden kódovaný blok. Blok C4 má dva logické qubity, takže každá operace měření vrátí dva logické výsledky. Každá operace přípravy vrátí jeden příznak zamítnutí.

Zkompilujte logický Q# experiment

Definujte experiment přípravy a měření stavu (SPAM).

qsharp.eval("""
operation TestSpamZ() : (Result[], Result[]) {
    use block = Qubit();
    let reject = prepare_z_all(block);
    let (left, right) = measure_z_all(block);
    ([reject], [left, right])
}
""")

TestSpamZ Zkompilujte operaci pro QIR.

qir = str(qsharp.compile("TestSpamZ()"))

QIR zachovává volání do prepare_z_all a measure_z_all. Při spuštění programu qodec modul runtime porovnává tyto názvy s horní sadou instrukcí a nahradí každé logické volání jeho gadgetem.

Spusťte s integrovaným dekodérem

Zavolejte run_qir a předejte mu qodec. Pokud je decoderNone, modul runtime používá integrovaný dekodér minimální hmotnosti Pauli.

from qdk.simulation import run_qir

results = run_qir(
    qir,
    qodec=protocol,
    type="stabilizer",
    shots=100,
    seed=42,
)

print(results[:5])

Ke spuštění qodec použijte tyto možnosti simulátoru:

Hodnota `type`	Behavior
`None` nebo `"stabilizer"`	Použijte backend stabilizátoru
`"cpu"`	Použijte back-end vektoru stavu pro podporované programy
`"gpu"`	Nepodporováno s qodec

Modul runtime připraví každý qubit programu před prvním použitím, ledaže první instrukce vytvoří jeho blok. Instrukce pro přípravu obsahuje výstupní bloky, žádné vstupní bloky a akci, která stabilizuje logický Z.

Opravy dekodéru s jedním qubitem Pauli a qodec aktualizace rámce používají bezšumový Pauli rámec, nikoli hlučné fyzické brány.

Nastavit šum simulátoru

Definujte šum pro operace simulátoru, ne qodec názvy instrukcí. Modul runtime překládá jednotlivé instrukce v dolní vrstvě do jedné nebo více operací simulátoru, takže nastavení šumu platí pro tyto operace.

Tento C4 názorný postup používá tato mapování:

Instrukce spodní vrstvy	Provoz simulátoru	`NoiseConfig` Pole
`R`	Připravte nebo resetujte na Z+	`mresetz`
`H`	Hadamard	`h`
`CX`	Řízený X	`cx`
`M`	Měření v bázi Z	`mresetz`

Vytvořte jednoduchý model 1% šumu:

from qdk.simulation import NoiseConfig

noise = NoiseConfig()
for gate in (noise.h, noise.cx):
    gate.set_depolarizing(0.01)
noise.mresetz.x = 0.01

Spusťte experiment s šumem:

results = run_qir(
    qir,
    qodec=protocol,
    noise=noise,
    type="stabilizer",
    shots=1000,
    seed=42,
    on_shot_failure="discard",
)

Šum na mresetz působí na qubit po měření nebo přípravě. Nepřeklopí bit měření, který už simulátor zaznamenal. Ke studiu zaznamenaných překlopení bitů použijte qodec modely chyb čtení a analýzu gadgetů.

Selhání kontrolních snímků

Pomocí on_shot_failure zvolíte, jak modul runtime reaguje, když příznak qodec, dekodér nebo výstup nevygeneruje přijatý snímek.

Value	Behavior
`"discard"`	Vynechejte neúspěšné snímky z vráceného seznamu. Tato hodnota je výchozí.
`"raise"`	Zastavte, když první pokus selže.
`"retry"`	Restartujte neúspěšný snímek až o `max_retries` dalších pokusů.

Při použití zásady "discard" argument shots započítává i pokusy o snímky, takže vrácený seznam může obsahovat méně položek než shots.

Zásada snímku se aktivuje pouze tehdy, když logický program tento příznak neobdrží. Q# @Measurement() Pokud operace vrátí další Result příznak, program obdrží příznak a rozhodne, zda má výstřel odmítnout.

V tomto příkladu TestSpamZ program vrátí příznak přípravy v prvním poli. on_shot_failure="discard" Nastavení tedy neodebere řádky, ve kterých je Onevrácený příznak .

Vyberte dekodér

Pokud chcete zvolit způsob dekódování chyb, použijte parametr decoder k předání volatelné funkce pro přípravu dekodéru pro každou zakódovanou vrstvu.

Má QDK následující dekodéry:

Dekodér	Použijte ho k
Výchozí dekodér syndromu	Odvoďte opravy s minimální hmotností Pauli na základě syndromu. Použijte `decoder=None`.
Dekodér rámce	Sledujte bezšumové rámce bez odvozování fyzických závad. Použijte `prepare_frame_decoder`.
deq dekodér	Dekódujte modely poruch na úrovni obvodu pomocí deq. Použijte `prepare_deq_decoder`.

Použijte výchozí deq konfiguraci

Nainstalujte deq a deq-runtimepak předejte prepare_deq_decoder.

from qdk.simulation.decoders import prepare_deq_decoder

results = run_qir(
    qir,
    qodec=protocol,
    decoder=prepare_deq_decoder,
    noise=noise,
    type="stabilizer",
    shots=1000,
    seed=42,
    on_shot_failure="discard",
)

Adaptér ve výchozím nastavení deq používá relay belief propagation a window coordinator. Pokud chcete tato nastavení změnit, použijte runtime factory.

Nakonfigurujte monolitické deq runtime prostředí

Chcete-li zvolit nastavení deq přímo, předejte továrnu modulu runtime do prepare_deq_decoder.

from functools import partial
from deq.runtime import Runtime
from qdk.simulation import decoders


def make_runtime(seed: int) -> Runtime:
    return Runtime(
        decoder="black-box-relay-bp",
        decoder_config={"parallel": 1, "seed": seed},
        coordinator="monolithic",
        controller="jit",
    )


results = run_qir(
    qir,
    qodec=protocol,
    decoder=partial(
        decoders.prepare_deq_decoder,
        runtime_factory=make_runtime,
    ),
    noise=noise,
    type="stabilizer",
    shots=1000,
    seed=42,
    on_shot_failure="discard",
)

Vrátí nový Runtime při každém volání tovární funkce. QDK spustí a zavře každý modul runtime.

Note

Adaptér deq vyžaduje:

Jedna kódovaná vrstva
Trasování provádění nezávislé na měření Clifford
backend stabilizátoru
Model šumu bez ztrát qubitů

Adaptér deq nepodporuje zásady opakování pokusů. Nepodporované programy vyvolávají chybu místo použití jiného dekodéru.

Odmítnout výsledky s nízkou spolehlivostí deq

Adaptér deq vrátí skóre pro každý logický odečet. Nižší skóre označují silnější předvolbu zvolené opravy. Skóre nejsou kalibrované pravděpodobnosti selhání.

Pokud chcete odmítnout výsledky s nízkou spolehlivostí, předejte při přípravě dekodéru hodnotu max_readout_score, například jako v následujícím příkladu:

from functools import partial
from qdk.simulation import decoders

scored_decoder = partial(
    decoders.prepare_deq_decoder,
    max_readout_score=0.2,
)

results = run_qir(
    qir,
    qodec=protocol,
    decoder=scored_decoder,
    noise=noise,
    type="stabilizer",
    shots=1000,
    on_shot_failure="discard",
)

Modul runtime přijímá vzorek pouze v případech, kdy má každý vrácený logický odečet skóre na prahové hodnotě nebo pod ní. Prahová hodnota se nevztahuje na raw flagy ani nepoužité mezivýstupy.

Odmítnutí na základě skóre může snížit logickou chybovost přijatých snímků. Zároveň ale snižuje počet přijatých snímků a přidává práci dekodéru.

Kompilujte OpenQASM programy

Standardní OpenQASM operace používají stejná QIR mnemotechnická pravidla jako standardní Q# operace.

from qdk import TargetProfile, openqasm

source = """
OPENQASM 3.0;
include "stdgates.inc";
qubit q;
bit c;
x q;
c = measure q;
"""

qir = openqasm.compile(
    source,
    target_profile=TargetProfile.Adaptive_RI,
)

print(qir)

Chcete-li tento program spustit prostřednictvím qodec, ujistěte se, že nejvyšší instrukční sada prvku qodec má __quantum__qis__x__body a __quantum__qis__m__body, s kompatibilními blokovými operandy a jedním výsledkem měření.

OpenQASM Vnitřní brána nebo podprogram pojmenovaný foo používá mnemotechnickou zkratku foo. Argumenty qubitu jsou vázány na operandy bloku. Argumenty float, int a bool jsou vázány na parametry instrukce v pořadí deklarací.

OpenQASM má tato omezení pro qodec volání:

Vlastní intrinsické funkce nemůžou vrátit QIRResult. Pokud chcete získat jeden výsledek měření, použijte standardní příkaz statement measure.
OpenQASM programy nemůžou spouštět vlastní měření, přijímat několik výsledků z jednoho volání nebo přijímat vrácené příznaky. V těchto případech použijte operace Q#@Measurement().
Běhové prostředí řídí všechny příznaky, které program OpenQASM nemůže přijmout, a tyto příznaky mohou odmítnout pokus.

Podrobné příklady mapování najdete v následujících QDK poznámkových blocích:

Zkontrolujte požadavky a omezení

Než spustíte velký experiment, projděte si tyto požadavky, omezení a rozdíly ve výsledku.

Požadavky:

Každé QIR kvantové volání se musí převést na instrukci nejvyšší vrstvy qodec.
Před spuštěním záznamu proveďte audit. Běhové prostředí qodec runtime důvěřuje rovnicím, které píšete, a nekontroluje je.

Omezení:

Režim simulace nepodporuje qodec provádění.
Výchozí množina poruch gadgetu může exponenciálně růst, takže přesné hledání vzdálenosti může trvat dlouhou dobu.
Balíčky deq a Stim mají omezení platformy. Další informace naleznete v tématu Nainstalovat QDK pro opravu chyb.

Rozdíly výsledků:

Přesný počet výstupů se může lišit podle dekodéru.
Zásady zahazování a opakování můžou změnit vrácenou distribuci výsledků.

Úplný Q# experiment s procházením hodnot šumu, deq dekódováním a zamítnutím založeným na spolehlivosti najdete v návodu k protokolu QEC.

Váš názor

Byla tato stránka užitečná?

Poslední aktualizace v 2026-10-22