---
title: "D-Wave průlom: Dual-rail erasure qubity dosáhly 99,9 % fidelity v entangling gate"
description: "D-Wave publikoval v Nature průlomovou demonstraci dvouqubitového entangling gate s 99,9 % fidelity na dual-rail erasure qubitech. Simulace ukazují 10× snížení logické chybovosti na každý stupeň korekce — a tím i desetinásobné snížení počtu qubitů potřebných pro fault-tolerant výpočty."
date: 2026-08-05
lastmod: 2026-08-06T06:00:00+02:00
draft: false
author: Tina
tags: ["quantum-computing", "D-Wave", "dual-rail", "erasure-qubit", "quantum-error-correction", "Nature", "fault-tolerance", "fluxonium", "Quantum-Circuits", "gate-model", "2026"]
categories: []
---

# D-Wave průlom: Dual-rail erasure qubity dosáhly 99,9 % fidelity v entangling gate

## Úvod

Společnost D-Wave Quantum (Nasdaq: QBTS), dlouho známá jako průkopník kvantové annealing (žihání) architektury, publikovala 5. srpna 2026 v prestižním časopise **Nature** práci, která představuje klíčový milník na cestě k praktickým, fault-tolerantím kvantovým počítačům. V článku s názvem *„An entangling gate for dual-rail erasure qubits"* popisuje tým dvouqubitový provazovací hradlo (entangling gate), které dosahuje **99,9 % fidelity** při době operace pouhých **500 nanosekund** — a přitom zachovává nejdůležitější vlastnost své dual-rail architektury: schopnost detekovat chyby přímo na úrovni hardwaru.

## Co jsou dual-rail erasure qubity?

Většina dnešních supravodivých kvantových počítačů — od IBM přes Google po Rigetti — používá transmon qubity, jejichž nejčastější chybou je bit-flip (překlopení stavu |0⟩ na |1⟩ nebo naopak), který je notoricky těžké detekovat bez dodatečných qubitů a komplexních error-correction kódů.

Dual-rail erasure qubity fungují na jiném principu. Informace je kódována do přítomnosti jednoho photonu (fotonu) v jedné ze dvou paralelních rezonátorových dutin — odtud název „dual-rail" (dvoukolejné). Nejčastější chybou není překlopení bitu, ale **únik photonu** z dutiny. Tuto ztrátu lze detekovat přímo hardwarem, aniž by bylo potřeto dedikovat qubity pro syndrom měření. Ostatní typy chyb — phase-flip a bit-flip — jsou mnohem vzácnější.

> „Bit-flips are practically non-existent at the 10⁻⁶ level," uvádí se přímo v článku.

Tato **hierarchie chyb** je pro korekci klíčová: nejběžnější chyba je nejjednodušší na opravu. V práci se ukazuje, že tento příznivý poměr zůstává zachován i během dvouqubitových operací.

## Technické detaily experimentu

### Parametry entangling gate

| Parametr | Hodnota |
|---|---|
| Fidelity | ~99,9 % |
| Doba hradla | ~500 ns |
| Photon loss rate | ~0,5 % per entanglement |
| Bit-flip rate | ~10⁻⁶ |
| Architektura | Superconducting dual-rail cavity qubit |
| Qubit technologie | Fluxonium (nikoliv transmon) |

D-Wave zvolila pro svou gate-model platformu technologii **fluxonia** — supravodivé obvody s velkou anharmonicitou, které jsou odolnější vůči šumu než standardní transmony. Po akvizici startupu **Quantum Circuits** (z Yale University, založen 2016, cena akvizice ~550 milionů USD) na začátku roku 2026 získala D-Wave přístup k dual-rail erasure technologii, kterou Quantum Circuits vyvíjel více než desetiletí.

Stejnou dual-rail architekturu používá také **Amazon** ve svých kvantových procesorech, což potvrzuje, že jde o jeden z nejslibnějších technologických směrů v oboru.

### Proč je 99,9 % fidelity zlomové?

Pro porovnání: standardní error-correction kódy (např. surface code) vyžadují fyzickou chybovost pod ~1 %, aby vůbec mohly začít logické qubity opravovat. S 99,9 % fidelity (tedy ~0,1 % chybovostí) na dvouqubitové hradlo se D-Wave dostává **pod tento práh**. Navíc díky erasure detekci je efektivní chybovost po odfiltrování detekovatelných ztrát photonů ještě nižší.

## Simulace: 10× snížení logické chybovosti

Nejdůležitějším výsledkem pro budoucnost jsou simulace. Ty ukazují, že dual-rail architektura může **snížit logickou chybovost až 10×** pro každý další stupeň error correction — tedy hodnotu **Lambda (Λ) = 10**. Pro srovnání, dnešní surface code na transmon qubitech dosahuje typicky Λ ≈ 2–3.

Prakticky to znamená, že pro dosažení stejné logické chybovosti by D-Wave mohla potřebovat **desetkrát méně fyzických qubitů** než tradiční architektury. To je rozdíl mezi milionem qubitů a statisíci qubitů — mezi zařízením, které se dá postavit, a zařízením, které zůstane laboratorní vizí.

## Tříletá roadmapa

D-Wave představila jasnou, fázovanou roadmapu pro gate-model vývoj:

| Rok | Systém | Qubity | Cíl |
|---|---|---|---|
| 2026 | DR17 | 17 | Logická chybovost 2× nižší než fyzická |
| 2027 | DR49 | 49 | 20× snížení chybovosti |
| 2028 | DR181 | 181 | 2 000× snížení chybovosti |
| 2032 | — | — | **100 logických qubitů, 1 milion+ operací** |

Roadmapa kombinuje vlastní supravodivou infrastrukturu s integrovaným kryogenním řízením (on-chip control), které snižuje počet řídicích linek o řádově velikosti — což je kritické pro škálování, neboť dnešní kvantové počítače trpí „provazovým problemem" stále složitějších kabeláží do kryostatu.

Již v roce 2026 je **Aqumen Seeker™** — 17-qubitový dual-rail systém — dostupný pro alpha uživatele, včetně instalace v laboratořích Quantum Circuits v New Havenu (Connecticut).

## D-Wave jako „dual-platform" společnost

Na rozdíl od většiny kvantových firem, které sázejí na jednu technologii, D-Wave provozuje **dvě paralelní platformy**:

1. **Quantum Annealing** (kvantové žíhání) — jejíž systémy Advantage™ s více než 5 000 qubity jsou komerčně dostupné přes cloud platformu Leap™ a jsou využívané pro optimalizační úlohy (logistika, finance, machine learning).
2. **Gate-Model** — nová dual-rail architektura, která cílí na univerzální fault-tolerant výpočty.

Tato strategie dává D-Wave unikátní pozici: annealing platforma generuje příjmy a komerční reference už dnes (partneři jako Mastercard, Volkswagen, AT&T nebo Nasdaq Verafin), zatímco gate-model roadmapa buduje dlouhodobou technologickou hlubinu.

## Kontext v oboru

### Srovnání s konkurencí

| Společnost | Architektura | Přístup k QEC | Λ (Lambda) |
|---|---|---|---|
| **D-Wave** | Dual-rail erasure (fluxonium) | Hardware-level erasure detection | ~10 (simulováno) |
| IBM | Transmon (Heron) | Surface/spacetime codes | ~2–3 |
| Google | Transmon (Willow) | Surface + color codes | ~2,5 |
| Microsoft | Topological (Majorana) | Topologická ochrana | TBD |
| Amazon | Dual-rail (cat qubit) | Erasure detection | ~5–8 |
| Quantinuum | Trapped ion (H2) | Non-Abelian anyons | ~3–5 |

D-Wave se řadí do skupiny firem (spolu s Amazonem), které sázejí na **erasure qubit** paradigm — kde je detekce chyb zabudována do hardwaru, nikoliv dodána dodatečným softwarem. Simulovaná hodnota Λ = 10 je v této tabulce nejvyšší, i když zatím nebyla experimentálně potvrzena ve větším měřítku.

### Akvizice Quantum Circuits

V lednu 2026 D-Wave oznámila akvizici Quantum Circuits Inc. (QCI) za přibližně 550 milionů USD v akciích. QCI byl jedním z průkopníků dual-rail cavities, které vznikly ve výzkumné skupině **Roba Schoelkopfa** na Yale University — jedné z nejplodnějších kvantových laboratoří na světě (z Yale pochází i první kvantový procesor s error correction v roce 2024). Akvizice přinesla nejen IP, ale i tým inženýrů s desetiletou zkušeností v supravodivých rezonátorech.

## Proč je to důležité pro českého čtenáře

### Evropský kontext

D-Wave je kanadsko-americká firma, ale dual-rail výzkum má silné evropské kořeny. Erasure qubit koncept byl částečně inspirován prací skupiny **Sébastiena Weidta** na University of Sussex (UK) a mikrovlnných rezonátorových experimentů na **KIT** (Karlsruhe Institute of Technology). Česká kvantová komunita — zastoupená například skupinou prof. Radima Filipa na **Palackého univerzitě v Olomouci** — dlouhodobě zkoumá teoretické limity erasure korekce a její integraci do hybridních protokolů.

### Ekonomický dopad

Pokud D-Wave skutečně dosáhne Λ = 10 ve větším měřítku, znamenalo by to, že fault-tolerantí kvantové výpočty by mohly být komerčně dostupné **o roky dříve**, než se dnes předpokládá. McKinsey ve své zprávě z června 2026 odhaduje tržní potenciál kvantových výpočtů na 2,7 miliardy USD do roku 2035 — ale tento odhad předpokládá Λ ≈ 3. S Λ = 10 by se trh mohl otevřít mnohem rychleji.

## Otevřené otázky

1. **Bude Λ = 10 potvrzeno experimentálně?** Simulace používají pseudo-threshold noise modely, které mohou být příliš optimistické. Reálné zařízení bude čelit dalším zdrojům šumu (fluktuace přechodových frekvencí, infračervené záření, TWO-LEVEL systémy).

2. **Škálovatelnost kryogenní infrastruktury.** Dual-rail dutiny vyžadují vysoce kvalitní 3D rezonátory, které jsou prostorově náročnější než 2D planární transmony. Otázkou zůstává, zda jich lze umístit tisíce do jednoho kriostatu.

3. **Konkurence topologických qubitů.** Microsoft v červnu 2026 představil Majorana 2 procesor s topologickou ochranou na úrovni hardwaru. Pokud se topologické qubity osvědčí, nabízejí jinou cestu ke stejnému cíli — hardware-level imunity vůči chybám.

## Závěr

Práce D-Wave publikovaná v Nature je jedním z nejvýznamnějších hardwarových milníků roku 2026 v oboru kvantových výpočtů. Demonstruje, že dual-rail erasure architektura není jen teoretický koncept, ale funkční technologie, která dokáže provádět dvouqubitové operace s dostatečnou kvalitou pro error correction. Simulované Λ = 10 je ambiciózní — pokud bude potvrzeno, mohlo by to zcela přepsat mapu konkurence ve prospěch hardwarově vestavěné korekce chyb.

Pro D-Wave, která byla dlouho vnímána jako „annealing-only" společnost, to znamená vstup do nejvyšší ligy gate-model vývoje. Roadmapa k 100 logickým qubitům do roku 2032 je sice vzdálená, ale první krok — prokázání, že dual-rail qubity mohou spolehlivě provádět entangling operace — je za nimi.

---

**Zdroje:**
- *Nature* (2026). „An entangling gate for dual-rail erasure qubits." DOI: [10.1038/s41586-026-10822-y](https://doi.org/10.1038/s41586-026-10822-y)
- D-Wave Quantum Inc. (5. 8. 2026). Press release: „D-Wave Demonstrates Major Hardware Breakthrough for Quantum Error Correction."
- Ars Technica (5. 8. 2026). „D-Wave on rails: Company tests entanglement on its dual-rail qubits."
- The Quantum Insider (5. 8. 2026). „D-Wave Publishes Research on Dual-Rail Qubit Gate for Quantum Error Correction."
- Quantum Computing Report (2026). „D-Wave Outlines Superconducting Gate-Model Roadmap Targeting 100 Logical Qubits."

1 min · Tina