Vývoj a ověření protokolu QEC

Použijte qodec modul qdk.ec z Microsoft Quantum Development Kit (QDK) k definování kódu QEC (quantum error correction) a jeho převodu do spustitelného protokolu. V tomto článku definujete kód chyby, sestavíte směrný plán qodec, ověříte jeho deklarace, vypočítáte vzdálenost miniaplikace a uložíte protokol.

Příklady v tomto článku používají kód $[[4,2;2]]$ C4 , který ukládá dva logické qubity do čtyř fyzických qubitů a detekuje všechny jednotlivé fyzické Pauli chyby.

Prerequisites

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

  • Nainstalujte QDK opravu chyb.
  • Použijte prostředí s Python verzí 3.11 nebo novější.
  • Ověřte, že qodecStim je analyzátor dostupný. Na LinuxArm64 nebo WindowsArm64, nainstalovat Stim ze zdroje a potom restartovat Python nebo Jupyter jádro před voláním build_qodec.

Definování kódu

Vytvořte objekt s stabilizátory kódu a jedním logickým qodec.Code zástupcem X a Z pro každý logický qubit.

import qodec

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"],
)

Balíček qodec používá pro řetězce řídkou notaci Pauli . Každý termín má Pauli písmeno a popisek fyzického qubitu. Například X_0 X_2 použije X na fyzické qubity 0 a 2.

Definice kódu je statický matematický objekt. Nezahrnuje okruhy, které připraví, zachovávají nebo měří kódované stavy.

Analýza kódu

Pokud chcete zkontrolovat snímek operátorů kódu, vytvořte .CodeProfile

from qdk import ec

profile = ec.CodeProfile(c4)

print("Physical support:", sorted(profile.support))
print("Physical qubits:", profile.length)
print("Logical qubits:", profile.logical_qubit_count)
print("Stabilizers:", profile.stabilizers)
print("Logical X operators:", profile.x)
print("Logical Z operators:", profile.z)

Profil se nezmění, pokud později změníte původní qodec.Code objekt.

Výpočet vzdálenosti kódu

Chcete-li zjistit minimální počet povolených fyzických chyb, které způsobují netriviální logický účinek s nulovým syndromem, zavolejte distance.

distance = profile.distance()
print("Code distance:", distance)

error = distance.witness.product
syndrome = profile.syndrome_of(error)
logical_effect = profile.logical_effect_of(error)

print("Witness:", error)
print("Syndrome:", sorted(syndrome))
print("Logical effect:", logical_effect)

assert distance.value == 2
assert profile.is_logical(error)

Ve výchozím nastavení hledání přiřadí každé chybě X, Y nebo Z náklady jednu. Distance Vrácená hodnota má certifikované hranice a svědek pro jakoukoli konečnou horní mez.

Pokud přesné náklady na vyhledávání příliš mnoho, použijte distance_bounds.

bounds = profile.distance_bounds(upper_bound=4)
print("Distance bounds:", bounds)
print("Lower bound:", bounds.lower_bound)
print("Upper bound:", bounds.upper_bound)

Výchozí řešitel je HiGHS. Pokud chcete použít jiný řešitel, nastavte solver="enumeration"nebo nainstalujte MWPF a nastavte solver="mwpf".

Vytvoření směrného plánu qodec

A qodec popisuje, jak spustit kódované instrukce. Obsahuje instrukční sady, kódy, vrstvy, miniaplikace, obvody, kontroly a rovnice čtení.

Slouží build_qodec k vytvoření dvouvrstvého C4 protokolu z kódu.

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

Tento příklad používá bare-css/v1 ke kontrole jednoduchého protokolu bez qubitů příznaků.

Caution

Strategie bare-css/v1 neslíbí okruhy odolné proti chybám. Před použitím protokolu pro hlučné experimenty vypočítejte vzdálenost jednotlivých miniaplikací.

Tvůrce se pokusí vytvořit tyto logické pokyny:

  • prepare_z_all
  • prepare_x_all
  • syndrome
  • measure_z_all
  • measure_x_all
  • h_all
  • cx_all

Přípona _all znamená, že instrukce funguje na každém logickém qubitu v bloku. Platí například cx_allCNOT mezi odpovídajícími logickými qubity ve dvou blocích.

Ne každý kód podporuje všechny kandidátské instrukce. Ve strict=Truevýchozím nastavení tvůrce vyvolá chybu, když nemůže sestavit a ověřit kandidáta. V strict=Falsenástroji tvůrce zachová podporované pokyny a záznamy vynechání protocol.metadata["qdk.ec"]["build"]["omitted"].

Zkontrolujte logickou vrstvu a její miniaplikace.

logical_layer = protocol.layers[0]

print("Instructions:")
for mnemonic in logical_layer.instruction_set.instructions:
    print(" -", mnemonic)

print("Gadgets:")
for mnemonic in logical_layer.gadgets:
    print(" -", mnemonic)

Druhá vrstva obsahuje fyzickou Stim instrukční sadu, kterou generované okruhy používají.

Kontrola miniaplikace

Logická instrukce deklaruje kontrakt. Jeho miniaplikace poskytuje okruh, který implementuje kontrakt.

Zkontrolujte prepare_z_all miniaplikaci.

gadget = logical_layer.gadgets["prepare_z_all"]
gadget_profile = ec.GadgetProfile(gadget)

print("Declared objective:")
print(gadget_profile.objective)

print("Computed action:")
print(gadget_profile.action)

Porovnejte akci vypočítanou z okruhu s deklarovaným cílem instrukce.

objective = gadget_profile.objective
assert objective is not None

if gadget_profile.action.is_equivalent_to(objective):
    print("The gadget implements its declared instruction.")
else:
    print(objective.why_not_equivalent_to(gadget_profile.action))

Snímek GadgetProfile jeho vstupu pořídí, takže neodráží pozdější změny. Po úpravě miniaplikace vytvořte nový profil.

Auditování protokolu

Slouží audit ke kontrole celého qodecsouboru .

report = ec.audit(protocol)
print(report)

Pokud audit nenajde žádné chyby nebo upozornění, vytiskne se:

audit: ok

Audit kontroluje tyto oblasti:

  • Algebra kódu
  • Struktura instrukcí a vrstev
  • Volání okruhu a vazby parametrů
  • Akce miniaplikace
  • Kontroly a rovnice pro čtení
  • Označení rovnic
  • Relace vstupního a výstupního rámce
  • Referenční hranice a úplnost protokolu

Pokud chcete pracovat s konkrétními závažnostmi, použijte kolekce sestav.

if report.errors:
    for diagnostic in report.errors:
        print(diagnostic)
    raise ValueError("The qodec has audit errors.")

if report.warnings:
    for diagnostic in report.warnings:
        print(diagnostic)

Hodnota report.ok znamená, že sestava nemá žádné chyby. Upozornění tato vlastnost nemění.

Odvodit chybějící rovnice

Používá se filled , když koncept miniaplikace nebo qodec vynechá kontroly nebo logické rovnice čtení, které mohou odvodit přesnou simulaci.

Následující příklad vytvoří neúplnou kopii protokolu.

draft = qodec.Qodec.loads(protocol.dumps())
draft_gadgets = draft.layers[0].gadgets

draft_gadgets["measure_x_all"].readouts = []
draft_gadgets["cx_all"].checks = []

print(ec.audit(draft))

Vyplňte podporované rovnice a pak proveďte audit výsledku.

completed = ec.filled(draft)
print(ec.audit(completed))

Funkce filled vrátí novou miniaplikaci nebo qodec nezmění její vstup. Odvozuje kontroly, pozorovatelné čtecí rovnice a vztahy rámců. Zachovává vazby příznaků, protože simulace bez šumu nedokáže určit, které chyby by měl příznak rozpoznat.

Pokud původní protokol již ověřil přímé rovnice, ponechá je, filled pokud je to možné.

Analýza chyb miniaplikace

Audit bez chyb prokáže bez šumu konzistenci. Neprokazuje odolnost proti chybám.

Volání GadgetProfile.distance s cílem najít minimální počet povolených chyb okruhu, které způsobí logické selhání, zatímco všechny deklarované kontroly a příznaky zůstanou nulové. Kombinovaná chyba musí také ponechat každý výstup uvnitř svého prostoru kódu.

protocol = completed

for mnemonic, gadget in sorted(protocol.layers[0].gadgets.items()):
    result = ec.GadgetProfile(gadget).distance()
    witness = result.witness if result.upper_bound is not None else "none"
    print(f"{mnemonic}: distance={result}, witness={witness}")

Výchozí model selhání zahrnuje tyto události po každém volání okruhu:

  • Chyba Pauli u qubitů, na které se hovor dotýká
  • Překlopení bitu čtení, který volání vytvoří
  • Korelace kombinace těchto chyb

Každá událost stojí jedno volání, i když má korelovanou chybu s vícequbity.

Kód může mít vzdálenost dvě, zatímco jedna z jeho miniaplikací má jednu vzdálenost. Například jedna chyba okruhu se může šířit přes ancilla a vytvořit nedetekovanou logickou chybu. Přidejte kontroly nebo označte obvody příznakem a pak vytvořte novou GadgetProfile a znovu vypočítejte vzdálenost.

Kontrola konkrétní chyby

Slouží FaultEvent.after k definování chyby po indexu volání okruhu založeného na nule.

gadget = protocol.layers[0].gadgets["syndrome"]
profile = ec.GadgetProfile(gadget)

fault = ec.FaultEvent.after(0, ec.Pauli("X_0"))
(effect,) = profile.effects_of([fault])

print("Fault:", fault)
print("Changed quantities:", effect)

Znak A FaultEffect může zahrnovat změněné kontroly, logické čtení a značky výstupního rámce. Pokud výchozí model na úrovni okruhu neodpovídá vašim předpokladům hardwaru, použijte explicitní sady chyb.

result = profile.distance(faults=[fault])
print(result)

Přesné vyhledávání miniaplikace může trvat dlouho, protože výchozí sada chyb roste exponenciálně s podporou jednotlivých volání. Použijte distance_boundsexplicitní sadu chyb nebo upper_bound když potřebujete omezit vyhledávání.

Uložení protokolu

Než ho uložíte, před uložením ho qodec auditujte.

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

Uložte protokol jako jednu YAML sadu a pak ho znovu načtěte, abyste zkontrolovali, že odpovídá původnímu souboru.

from pathlib import Path

output_directory = Path("qodec-output")
output_directory.mkdir(exist_ok=True)

saved_path = protocol.save(str(output_directory), single_file=True)
loaded = qodec.Qodec.load(saved_path)

assert loaded == protocol
print("Saved qodec:", saved_path)

Sada s jedním souborem ukládá manifest, definice kódu, instrukční sady, miniaplikace a zdroje okruhů v jednom YAML souboru, což usnadňuje sdílení a opětovné načtení.

Spuštění protokolu

Jakmile qodec projde audit a splní vaše požadavky na vzdálenost, zkompilujte logický program do kvantové přechodné reprezentace (QIR) a spusťte ho přes protokol. Viz Spuštění a dekódování logických programů.

Úplný příklad, který přidává okruhy příznaků a porovnává logické chybové míry, najdete v návodu k protokolu QEC v QDK úložišti GitHub.

  • Poslední aktualizace v