Posts

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

---
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."


---
title: "ESA instalovala svůj první kvantový počítač: Bell-1 má pomoci s modelováním klimatu a předpovědí počasí z vesmíru"
date: 2026-07-18T07:00:00+02:00
lastmod: 2026-07-18T07:00:00+02:00
draft: false
tags: ["quantum-computing", "ESA", "Equal1", "Bell-1", "silicon-spin-qubits", "CMOS", "Earth-Observation", "Φ-lab", "ESRIN", "hybrid-quantum", "climate-modeling", "2026"]
description: "Evropská vesmírná agentura (ESA) instalovala 17. července 2026 svůj první kvantový počítač na vlastních prostorích. Systém Bell-1 od irské firmy Equal1 využívá křemíkové spinové qubity vyrobené standardním CMOS procesem a je napojen přímo na superpočítačové centrum ESA-ESRIN ve Frascati u Říma. Cílem je vybudovat hybridní kvantově-klasické algoritmy pro zpracování dat ze satelitních pozorování Země — od modelování klimatu až po plánování misí."
author: "Tina"
---

*Zdroje: [ESA Φ-lab](https://philab.esa.int/esas-first-quantum-computer-will-shift-computing-frontiers-in-space/), [Quantum Computing Report](https://quantumcomputingreport.com/esa-installs-its-first-on-premises-quantum-computer-to-boost-earth-observation-capabilities/), [Equal1](https://www.equal1.com/), [ESA Commercialisation — Space HPC](https://commercialisation.esa.int/space-hpc/)*

# ESA instalovala svůj první kvantový počítač: Bell-1 má pomoci s modelováním klimatu a předpovědí počasí z vesmíru

Evropská vesmírná agentura (ESA) udělala 17. července 2026 historický krok, který by se dal v jedné větě shrnout takto: **kvantový počítač poprvé stojí fyzicky v budově vesmírné agentury**. Systém s jménem Bell-1, který dodala irská deep-tech společnost Equal1, byl instalován přímo v datovém centru ESA-ESRIN — Centru pro pozorování Země ve Frascati nedaleko Říma.

Nejde o demonstraci ani o cloudový experiment. Bell-1 je zapojený do stávající superpočítačové infrastruktury ESA a bude sloužit jako výzkumná testbed pro hybridní kvantově-klasické algoritmy, které mají zpracovávat obrovské množství dat ze satelitů sledujících naši planetu — od globálních klimatických modelů přes plánování misí až po predikci počasí v reálném čase.

## Bell-1: Kvantový počítač, který se vejde do serverové skříně

Bell-1 se od většiny dnešních kvantových systémů liší hned v několika parametrech, které společně dělají z jeho instalace v běžném datacentru vůbec možnou. Zatímco systémy od IBM či Google vyžadují obří diluční chladicí boxy pohybující se kolem absolutní nuly (15 milikelvin, tj. −273,135 °C) a externí zásobníky kapalného hélia, Bell-1 se vejde do standardní 19palcové serverové skříně.

| Parametr | Hodnota |
|---|---|
| Architektura qubitů | Křemíkové spinové qubity (silicon spin) |
| Výrobní proces | Standardní komerční CMOS |
| Počet fyzických qubitů | 6 |
| Provozní teplota | 0,3 Kelvinu (−272,85 °C) |
| Chlazení | Integrovaný uzavřený cyklus |
| Příkon | 1,6 kW |
| Form factor | Rack-mount (19") |

Číslo 1,6 kilowattu je v kontextu kvantových počítačů bezprecedentní — odpovídá spotřebě jednoho výkonného podnikového serveru. Celý systém lze nasadit v běžné serverovné místnosti bez speciálních úprav infrastruktury, což je přesně to, co ESA pro své účely potřebovala.

## Křemíkové spinové qubity: Výroba jako procesor v telefonu

Klíčem ke kompaktnosti Bell-1 je volba technologie qubitů. Equal1 nepoužívá supravodiče (jako IBM či Google), ani nepracuje s ionty (jako IonQ či Quantinuum). Místo toho využívá **křemíkové spinové qubity**, které jsou vyráběny standardním CMOS procesem — tedy přesně tou samou výrobní metodou, kterou používají továrny jako TSMC či Intel pro výrobu klasických procesorů do telefonů a notebooků.

Tento přístup má tři zásadní výhody:

1. **Škálovatelnost výroby.** Protože CMOS proces je desítky let optimalizovaný a dostupný v masových kapacitách, lze qubitové čipy vyrábět ve stejných továrnách jako klasické procesory. To dramatičtě snižuje náklady a zvyšuje reprodukovatelnost.

2. **Vyšší provozní teplota.** Křemíkové spinové qubity fungují při 0,3 K — což je sice stále extrémně chladné, ale o několik řádů teplejší než milikelvinové režimy supravodičů. To umožňuje použít kompaktní uzavřené chladicí cykly namísto obřích externích systémů s kapalným heliem.

3. **Integrace s klasickou elektronikou.** Protože qubity i řídicí elektronika mohou být na stejném křemíkovém substrátu, odpadají složité propojovací struktury mezi klasickým a kvantovým světem, které jsou zdrojem šumu a ztrát.

## Proč kvantový počítač pro pozorování Země?

Satelity ESA v rámci programů Copernicus, Sentinel a dalších generují denně **desítky terabajtů** dat. Zpracování těchto datových toků — ať už jde o klasifikaci povrchu země pro sledování odlesňování, detekci environmentálních škod, nebo o optimalizaci tras satelitních misí — vytěžuje stále více kapacity klasických superpočítačů.

Zde přichází na scénu koncept **hybridního kvantového počítání**. Nápad zní jednoduše: klasický superpočítač provede předzpracování a redukci dat, zatímco kvantový procesor dostane úzkou, ale matematicky složitou úlohu — například optimalizaci vícerozměrných matic, hledání vzorů v šumu, nebo kvantové strojové učení (QML) pro klasifikaci obrazových dat.

ESA je realistická: Bell-1 má jen 6 fyzických qubitů, takže v dohledné době nepředstavuje kvantovou výhodu proti klasickým systémům. Jde o **testbed a výzkumnou platformu**. Cílem je pochopit, jak se kvantové algoritmy chovají na reálných datech z pozorování Země, identifikovat úlohy, kde kvantové zpracání dříve či později nabídne výhodu, a vybudovat know-how uvnitř ESA.

## Φ-lab: Inkubátor vesmírné inteligence

Výzkum povede **ESA Φ-lab** (čti „fi-lab") — divize pro datem řízenou inovaci a pozemskou inteligenci, která sídlí právě v ESRIN. Tým Φ-lab se dlouhodobě zabývá aplikacemi umělé inteligence a pokročilých výpočetních metod na data z pozorování Země a kvantové počítání je logickým dalším krokem.

Naplánovaný výzkum má dvě fáze:

**Fáze 1 (nyní — konec 2026):** Interní výzkum a integrace. Tým Φ-lab bude pracovat na hybridních kvantových neuronových sítích pro automatickou klasifikaci pokryvu zemského povrchu, sledování environmentálních škod a optimalizaci trasování satelitních misí. V této fázi jde především o vybudování softwarové infrastruktury a akumulaci zkušeností.

**Fáze 2 (od konce 2026):** Pilotní demonstrace a publikace výsledků. ESA a Equal1 společně uspořádají workshop pro širší vědeckou komunitu, kde představí praktické benchmarky z reálných datových sad. Tyto výsledky mají pomoci definovat budoucí směřování kvantových technologií v rámci evropského vesmírného programu.

## Strategický kontext: Evropa buduje kvantovou suverenitu

Instalace Bell-1 neexistuje ve vakuu. Evropská unie i jednotlivé členské státě ESA v posledních letech výrazně zintenzivnily investice do kvantových technologií. Evropská komise v roce 2025 představila strategii pro kvantové technologie v rámci programu Horizon Europe a Digital Decade, která počítá s vybudováním panevropské kvantové komunikační infrastruktury (EuroQCI) a podporou domácího kvantového hardwaru.

V tomto kontextu je volba Equal1 strategická. Společnost sídlí v Dublinu a její technologie qubitů je založena na výzkumu z Trinity College Dublin. Tím ESA podporuje evropský ekosystém kvantových technologií — což je v době, kdy dominantní pozici ve kvantovém hardwaru drží americké firmy (IBM, Google, Quantinuum, IonQ) a čínské instituce, politicky i technologicky významné.

## Co to znamená pro budoucnost

Instalace prvního kvantového počítače v prostorách vesmírné agentury je symbolickým milníkem, ale její praktický dopad se projeví až v příštích letech. Pokud Φ-lab prokáže, že hybridní kvantově-klasické algoritmy dokážou zlepšit zpracování satelitních dat — i když jen v určitých specifických úlohách — otevře to cestu k nasazení výkonnějších kvantových systémů v budoucnu.

Equal1 plánuje škálovat svou architekturu na desítky a později stovky qubitů v rámci jedné serverové skříně. Pokud se tento plán naplní, mohla by ESA v příštích pěti letech provozovat kvantové systémy, které nebudou vyžadovat specializované laboratoře, ale stanou se běžnou součástí datových center — stejně jako dnes GPU akcelerátory pro AI.

A to je možná nejdůležitější poselství instalace Bell-1: **kvantový počítač přestal být laboratorní kuriozitou a stal se serverem v racku**. Zeptajte se správce datacentra, co to znamená — a on vám řekne, že přechod z laboratoře do serverovny je přesně ten moment, kdy technologie začíná být skutečně užitečná.

---

*Cover photo: ESA-ESRIN Centre for Earth Observation, Frascati, Italy. Ilustrační foto: Equal1 Bell-1 quantum system.*


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

---
title: "Jižní Korea staví největší kvantovou fabrice na světě. Chce být lídrem druhé generace kvantových počítačů"
date: 2026-03-24T06:00:00+01:00
draft: false
description: "Jižní Korea investuje miliardy do kvantových fabrik a vývoje vlastních QPU čipů. KAIST otevřel Národní kvantovou fabrikou za 33 milionů dolarů, KRISS vyvíjí 20-qubitový systém a cílí na 1000-qubitovou platformu z neutrálních atomů."
tags: ["Korea", "QPU", "kvantové fabriky", "neutral atom", "supravodivé qubity", "národní strategie", "KAIST", "KRISS"]
categories: ["Zprávy"]
image: ""
author: "Quantum CZ"
---

## Kvantová fabrika jako národní priorita

 zatímco USA, Čína a Evropa svádějí boj o kvantovou nadvládu, Jižní Korea vsadila na jinou strategii — budování vlastní výrobní infrastruktury pro kvantové čipy. V prosinci 2025 zahájil [KAIST (Korea Advanced Institute of Science and Technology)](https://www.kaist.ac.kr) výstavbu Národního kvantového výzkumného institutu (National Quantum Fab Research Institute) a 23. června 2026 oznámil rozšíření plánů s cílem stát se globálním lídrem v takzvané druhé generaci kvantových počítačů.

**„Pokud se spolehneme na zahraniční foundries, může know-how a technologie procesů unikat ven,"** varoval Cho Yong-hoon, ředitel KAIST National Quantum Fab Research Institute. **„Chceme tyto schopnosti budovat doma."**

## 33 milionů dolarů na první fázi

První fáze projektu zahrnuje výstavbu hlavní budovy kvantové fabrik y v areálu KAIST s celkovou investicí přes 45 miliard jihokorejských wonů (přibližně **33 milionů USD**). Dokončení je plánováno na rok 2027 a plný provoz na rok 2028. Po dokončení se stane největší open-access kvantovou výrobnou v Jižní Koreji — závodem specializovaným na výzkum a vývoj výrobních procesů pro QPU (Quantum Processing Unit) čipy.

Souběžně funguje i **Quantum Nano Fab** na campusu UNIST (Ulsan National Institute of Science and Technology), který byl otevřen 13. června 2025 s investicí 30 miliard KRW. Toto zařízení zvládá kompletní cyklus od návrhu kvantových zařízení přes výrobu, analýzu, verifikaci až po demonstraci — vše pod jednou střechou.

## Proč jsou kvantové fabrik y tak náročné

Výroba kvantových čipů je řádově náročnější než výroba běžných polovodičů. Kvantová zařízení vyžadují prostředí s extrémně přísnými podmínkami — i nepatrné kolísání teploty, vibrace, elektromagnetický šum nebo prachové částice mohou výrazně zhoršit výkon. Navíc je pole stále v rané fázi s více platformami současně:

- **Supravodivé qubity** (IBM, Google)
- **Iontové pasti** (IonQ, Quantinuum)
- **Neutrální atomy** (Pasqal, QuEra)
- **Fotony** (Xanadu, PsiQuantum)
- **Semikonduktorové spiny** (Intel, Samsung)

Tato nejednotnost ztěžuje standardizaci výrobních procesů a dělá domácí výrobu strategickou výhodou.

## Dvě vývojové větve: KRISS a její kvantové QPU

Korea Research Institute of Standards and Science (KRISS) pokračuje ve vývoji vlastních QPU na dvou paralelních stopách:

### Supravodivé qubity
KRISS plánuje v druhé polovině roku 2026 zpřístupnit cloudovým uživatelům pilotní verzi svého interně vyvinutého **20-qubitového systému**. Dalším cílem je dosáhnout **50-qubitového systému** v horizontu několika let.

### Neutrální atomy — 1000 qubitů
Ambicióznější je program neutrálních atomů. KRISS spolupracuje s firmami SDT, LG Electronics, Wooshin Kiyeon a s univerzitami MIT a Stanford na vývoji **1000-qubitové platformy založené na atomech ytterbia**. Toto je v současnosti jedna z nejslibnějších cest k vysoce výkonným kvantovým systémům.

## Průmyslový zájem: Datacentra chtějí kvantové hybridy

Rozhodující pro komerční budoucnost kvantových fabrik je rostoucí zájem průmyslu. Generální ředitel SDT Yoon Ji-won řekl: **„Datacentra, která dnes provozují GPU a HPC klastry, hledají nové výpočetní zdroje. Roste poptávka po kvantových počítačích v hybridním serverovém formátu kombinovaném s GPU."**

Podobně CEO Bright Quantum Lee Dong-han poznamenal, že americké firmy z financí a dalších odvětví zvyšují investice do kvantových technologií s vidinou toho, že se stanou „game changery".

## Rychlá reakce vlády: 15 milionů USD na IonQ spolupráci

Kromě domácích investic korejská vláda plánuje investovat **15 milionů USD** v průběhu tří let na spolupráci s americkou společností IonQ. Důvodem je vysoká cena cloudového kvantového výpočetního času — podle Seoul Economic Daily stojí jedna minuta výpočtu na kvantovém cloudu **100 USD**, což představuje značnou bariéru pro domácí výzkum.

## Hybridní kvantum-HPC: IonQ + KISTI + NVIDIA

Jedním z konkrétních výstupů korejské strategie je memorandem o porozumění (MOU) mezi **IonQ**, **KISTI** (Korea Institute of Science and Technology Information) a **NVIDIA**. Toto partnerství si klade za cíl integrovat IonQ kvantový hardware do KISTI HPC infrastruktury pomocí **NVIDIA NVQLink** — otevřené architektury pro propojení kvantových počítačů s GPU superpočítači.

**„Tato spolupráce je kritickým krokem k budování národní kvantové HPC infrastruktury schopné řešit nejsložitější vědecké výzvy,"** uvedl Jaegyoon Hahm, ředitel Centra pro kvantové výpočetní služby KISTI. **„Využíváme NVIDIA AI a akcelerované výpočetní platformy společně s IonQ iontovými kvantovými systémy, abychom zajistili, že korejští výzkumníci a podniky zůstanou na špici kvantové éry."**

## Druhá generace kvantových počítačů: Korea vsadila na správnou kartu?

Nejzajímavější strategická poznámka celého plánu spočívá v načasování. Jižní Korea neinvestuje do současných (prvogeneračních) kvantových počítačů, kde zaostává za IBM, Google či IonQ. Místo toho se zaměřuje na budování výrobních kapacit a infrastruktury pro **druhou generaci** — tedy éru kvantových počítačů, které budou dostatečně stabilní a výkonné pro praktické nasazení.

**„Protože současné kvantové počítače jsou první generace, očekáváme, že v generaci druhé může Korea vstoupit do vedoucí skupiny, ne-li na samotný vrchol,"** shrnuje oficiální postoj.

Ať už tento optimismus splní či nikoliv, jedno je jisté: Korea se rozhodla nebýt jen spotřebitelem kvantových technologií — chce být jejich tvůrcem.

---

*Zdroje: [Seoul Economic Daily](https://en.sedaily.com/finance/2026/03/23/korea-builds-quantum-fabs-targets-second-gen-quantum), [Evertiq](https://evertiq.com/design/2026-03-23-ionq-teams-up-with-kisti-to-advance-quantum-hpc-tech)*


---
title: "Kvantová AI předvídá chaos: Přelom v predikci turbulentních systémů"
description: "Výzkumníci z UCL dokázali spojit kvantové počítače s umělou inteligencí pro dramaticky přesnější predikce chaotických systémů. Hybridní přístup přináší 20% zlepšení přesnosti a stovkykrát nižší spotřebu paměti."
date: 2026-04-20
tags: ["quantum-computing", "artificial-intelligence", "UCL", "chaos-theory", "fluid-dynamics", "IQM", "quantum-advantage", "machine-learning"]
author: "Tina"
cover:
  image: "/images/quantum-ai-chaos.png"
  alt: "Kvantová AI predikce chaotických systémů"
---

# Kvantová AI předvídá chaos: Přelom v predikci turbulentních systémů

**Nová studie publikovaná v časopise Science Advances ukazuje, že spojení kvantového počítání s umělou inteligencí může revolučně zlepšit predikce komplexních fyzikálních systémů.** Výzkumníci z University College London (UCL) demonstrovali praktickou kvantovou výhodu v oblasti, kde klasické superpočítače dosahují svých limitů.

## Problém: Chaos je nepředvídatelný

Představte si, že se snažíte předpovědět počasí s týdenním předstihem, modelovat průtok krve v žilách pacienta nebo optimalizovat výkon větrné farmy. Všechny tyto úlohy sdílejí jeden společný problém: **turbulentnost a chaos**.

Chaotické systémy jsou extrémně citlivé na počáteční podmínky — malá změna na začátku může vést k dramaticky odlišným výsledkům. Toto známé "efekt motýlích křídel" dělá dlouhodobé predikce téměř nemožnými.

Dosud existovaly dvě možnosti, jak se s tímto problémem vypořádat:

1. **Plná simulace** — extrémně přesná, ale může trvat týdny, což je často příliš dlouho na praktické využití
2. **AI modely** — rychlé, ale časem ztrácejí přesnost a jsou nespolehlivé při dlouhodobých predikcích

## Řešení: Kvantově informovaná umělá inteligence

Tým vedený profesorem Peterem Coveneyem z UCL přišel s přelomovým přístupem, který integruje kvantové počítače do procesu trénování AI. Místo aby se spoléhali pouze na klasické výpočetní prostředky, využívají kvantový počítač k identifikaci skrytých vzorů v datech.

### Jak to funguje

1. **Kvantová extrakce vzorů**: Kvantový počítač (20-qubitový systém od finské společnosti IQM) zpracuje trénovací data a identifikuje **invariantní statistické vlastnosti** — vzory, které zůstávají stabilní i v turbulentních systémech

2. **Klasické trénování**: Tyto kvantově identifikované vzory pak slouží jako vodítko při trénování klasického AI modelu na superpočítači

3. **Predikce**: Výsledný hybridní model poskytuje výrazně přesnější predikce s menší spotřebou prostředků

> "Naše kvantově informovaná AI znamená, že můžeme poskytovat přesnější predikce rychleji. Predikce fluidní dynamiky a turbulence je fundamentální vědecká výzva, ale má také mnoho aplikací. Naše metoda může být použita v klimatickém modelování, simulaci průtoku krve a interakce molekul, nebo pro lepší návrh větrných farem," vysvětluje profesor Coveney.

## Výsledky: 20% zlepšení a stovkykrát méně paměti

Hybridní systém přinesl několik významných vylepšení oproti standardním AI modelům:

| Metrika | Zlepšení |
|---------|----------|
| **Přesnost predikcí** | +20 % oproti klasickým AI modelům |
| **Stabilita** | Udržuje přesnost i při dlouhodobých predikcích chaotických systémů |
| **Paměťová efektivita** | Stovkykrát nižší spotřeba paměti |
| **Náklady na výpočet** | Dramaticky nižší díky kompaktní kvantové reprezentaci |

### Proč kvantové počítače excelují v této úloze

Kvantové počítače mají dvě unikátní vlastnosti, které je činí ideálními pro modelování komplexních systémů:

- **Entanglement (provázanost)**: Qubity mohou ovlivňovat navzájem bez ohledu na vzdálenost, což umožňuje modelovat vzájemné vlivy vzdálených částí systému
- **Superpozice**: Qubit může existovat v mnoha stavech současně, což umožňuje kompaktní reprezentaci obrovského množství možných stavů

Zajímavě, mnoho komplexních systémů vykazuje chování podobné kvantovým efektům — změny v jedné oblasti mohou ovlivnit vzdálené části systému způsobem, který připomíná kvantovou provázanost.

## Praktická kvantová výhoda

Dosud byly demonstrace kvantové výhody (quantum advantage) často akademickými cvičeními s omezeným praktickým dopadem. Tento výzkum je jiný:

> "Naše nová metoda demonstruje praktickou kvantovou výhodu — kvantový počítač překonává to, co je možné pouze klasickým výpočtem. Tato zjištění mohou inspirovat vývoj nových klasických přístupů, které dosáhnou ještě vyšší přesnosti, ale pravděpodobně postrádající pozoruhodnou kompresi dat a efektivitu parametrů, které nabízí naše metoda," říká Maida Wang, první autorka studie.

### Klíčová inovace: Jednorázové použití kvantového počítače

Současné kvantové počítače čelí problémům jako šum, chyby a interference. Nová metoda tato omezení elegantně obchází — kvantový počítač se používá **pouze jednou** během workflow pro extrakci vzorů, nikoli opakovaně v každém kroku predikce.

Toto minimalizuje dopad kvantových chyb a umožňuje využít kvantovou výhodu i na současném "noisy intermediate-scale quantum" (NISQ) hardware.

## Experimentální nastavení

Studie využívala špičkovou infrastrukturu:

- **Kvantový hardware**: 20-qubitový IQM kvantový počítač (finský výrobce kvantových počítačů)
- **Klasické prostředky**: Superpočítače v Leibniz Supercomputing Centre v Mnichově
- **Podmínky**: Kvantový počítač běžel při teplotách blízkých absolutní nule (-273°C)

## Aplikační oblasti

Tato technologie má potenciál transformovat několik kritických oblastí:

### 🌍 Klimatické modelování
Přesnější dlouhodobé predikce počasí a klimatických změn, což je klíčové pro adaptační strategie.

### 🩺 Medicína a biologie
Simulace průtoku krve, modelování interakcí molekul pro vývoj léků, predikce šíření epidemií.

### ⚡ Energetika
Optimalizace větrných farem pro maximální výkon, predikce spotřeby energie, stabilizace elektrických sítí.

### 🚗 Doprava
Modelování dopravních toků, optimalizace logistiky, predikce zpoždění.

## Co dál? Budoucnost kvantově informované AI

Výzkumníci identifikují několik směrů dalšího rozvoje:

1. **Škálování na větší datasety**: Aplikace na realistické scénáře s větší komplexitou
2. **Teoretický rámec**: Vývoj formálního matematického důkazu kvantové výhody v této doméně
3. **Integrace s dalšími AI architekturami**: Aplikace na jazykové modely, generativní AI, reinforcement learning

> "V této práci demonstrujeme poprvé, že kvantové počítání může být smysluplně integrováno s klasickými metodami strojového učení pro řešení komplexních dynamických systémů, včetně mechaniky fluidů. Je vzrušující vidět tento 'kvantově informovaný' přístup směřující k praktickému využití," dodává Xiao Xue, spoluautor studie.

## Závěr: Nová éra hybridních výpočtů

Tato studie ukazuje, že budoucnost výpočetní techniky není o nahrazení klasických počítačů kvantovými, ale o **inteligentní hybridní přístupy**, které kombinují nejlepší vlastnosti obou světů.

Kvantové počítače excelují v specifických úlohách — extrakce vzorů, komprese dat, reprezentace komplexních stavů — zatímco klasické systémy dominují v obecném zpracování a inference. Správná kombinace může přinést výsledky, které překonávají možnosti každého systému samostatně.

Pro český kvantový ekosystém a projekty jako CZQCi (Česká kvantová komunikační infrastruktura) toto znamená nové příležitosti — integrace kvantového hardware do AI workflow může být klíčovou aplikací, která přivede kvantové technologie z laboratoří do praxe.

---

**Zdroj:** Wang, M., Xue, X., et al. (2026). *Quantum-informed machine learning for complex dynamical systems*. Science Advances. UCL & IQM Quantum Computers & Leibniz Supercomputing Centre.


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

---
title: "Microsoft a Quantinuum prolomili rekord v korekci chyb: Nezávislé peer review v Nature potvrdilo 800násobné snížení chybovosti"
date: 2026-06-14T06:00:00+02:00
lastmod: 2026-06-14T06:00:00+02:00
draft: false
tags: ["quantum-computing", "Microsoft", "Quantinuum", "error-correction", "Nature", "carbon-code", "tesseract-code", "trapped-ion", "logical-qubits", "fault-tolerance", "2026"]
description: "Nezávislé peer review v časopise Nature potvrdilo, že Microsoft Quantum a Quantinuum dosáhli 800násobného snížení chybovosti kvantových výpočtů na reálném hardwaru s iontovými pastmi. S 12 logickými qubity a dvěma novými korekčními kódy se kvantové počítače poprvé prokazatelně dostaly za bod zlomu."
author: "Tina"
---

# Microsoft a Quantinuum prolomili rekord v korekci chyb: Nezávislé peer review v Nature potvrdilo 800násobné snížení chybovosti

Kvantové počítače slibují řešení problémů, které jsou pro klasické stroje nedosažitelné — od simulace molekul pro vývoj léků až po lámání šifrovacích algoritmů. Ale je tu jeden drobný problém: jejich qubity jsou extrémně křehké. Nejmenší výkyv teploty, vibrace nebo elektromagnetické rušení dokáže převrátit výsledek výpočtu dříve, než skončí. Korekce chyb proto není jen technický detail — je to existence, na které stojí celá budoucnost tohoto oboru.

A právě tento týden se tato budoucnost posunula o velký kus dopředu. V prestižním časopise **Nature** bylo **10. června 2026** publikováno nezávisle recenzované schválení výsledků, které původně zněly jako marketingový slib: tým z **Microsoft Quantum** a **Quantinuum** dosáhl **800násobného snížení chybovosti** v reálných kvantových výpočtech na hardwaru s iontovými pastmi. Je to největší rozdíl mezi fyzikální a logickou chybrovostí, jaký kdy prošel nezávislým vědeckým peer review.

## Proč je to průlom — a ne jen další tisková zpráva

Kvantová korekce chyb je často popisována jako most mezi dnešními experimentálními systémy a budoucími praktickými kvantovými počítači. Na rozdíl od klasických počítačů, kde lze data jednoduše kopírovat a chránit tak před chybami, kvantová mechanika zakazuje přímé duplikování neznámého kvantového stavu (tzv. no-cloning teorém). Místo toho je nutné informaci jednoho logického qubitu rozprostřít přes mnoho fyzických qubitů a nepřetržitě diagnostikovat chyby prostřednictvím tzv. **syndrome extrakce** — procesu, který měří nepřímé vlastnosti qubitového pole, aniž by kolapsoval samotný kvantový stav.

Klíčová otázka, která trápila obor od roku 1995, kdy Peter Shor navrhl první korekční kód, zní: **vyplatí se to vůbec?** Každý krok korekce přináší nové příležitosti pro chybu. Pokud režie za korekci generuje více chyb, než jich zachytí, je celé schéma kontraproduktivní. Bod, kdy logické qubity skutečně překonají surový fyzický hardware, na kterém běží — tzv. **break-even threshold** — byl svatým grálem oboru.

Výsledky publikované v Nature tento threshold nejen překročily, ale udělaly tak s ohromnou rezervou. A důležité: stalo se tak na reálném hardwaru, nikoli v simulaci.

## Dva kódy, jeden cíl: Carbon a Tesseract

Tým vyvinul dvě komplementární schémata korekce chyb, obě optimalizovaná pro architekturu iontových pastí Quantinuum:

**Carbon code** využívá 12 fyzických qubitů k ochraně dvou logických qubitů. Je inspirován prací Emanuela Knilla, jednoho z průkopníků kvantové korekce chyb. Tento kód klade důraz na stabilitu a spolehlivost při opakované korekci během probíhajícího výpočtu.

**Tesseract subsystem code** používá 16 fyzických qubitů k ochraně čtyř logických qubitů. Je definován na geometrické struktuře čtyřdimenzionální hyperkrychle (tesseractu) s kodovou vzdáleností čtyři — což znamená, že dokáže detekovat a opravit chybu na jakémkoliv jednom qubitu. Konstrukce typu CSS (Calderbank-Shor-Steane) umožňuje detekovat a opravovat bit-flip i phase-flip chyby současně pomocí oddělených sad stabilizátorových měření.

Kombinací obou kódů tým spustil obvody s až **12 paralelními logickými qubity**, přičemž syndrome extrakce běžela kontinuálně během výpočtu — identifikovala a opravovala chyby v reálném čase dříve, než se mohly rozšířit.

## Čísla mluví jasně

V hlavním testu, přípravě Bellova stavu (základní forma kvantového provázání), vykazovaly nechráněné fyzické qubity chybovost přibližně **0,8 %**. Po aplikaci carbon code bez agresivního filtrování klesla na **0,17 %**. Ale nejdramatičtější výsledek přišel, když výzkumníci použili strategii kombinující korekci s selektivním odmítnutím běhů, které vykazovaly nejednoznačné chybové signatury. Za těchto podmínek **nepozorovali žádnou chybu ve více než 15 000 akceptovaných pokusech**. Statisticky to odpovídá odhadované chybrovosti **0,001 %** — tedy 800násobnému zlepšení oproti fyzikálnímu základu.

V celé sadě experimentů se zlepšení pohybovalo od **11násobku po 800násobek**, v závislosti na typu a složitosti obvodu. Tým také prokázal schopnost provést až **10 kol opakované korekce chyb** během jednoho probíhajícího výpočtu — což je zásadní, protože reálné kvantové algoritmy budou vyžadovat nepřetržitou korekci po celou dobu běhu, nikoli jen na začátku a na konci.

Celkem dokumentuje článek **14 000 individuálních běhů obvodů bez jediné chyby** — výsledek, který byl poprvé citován už v tiskové zprávě z dubna 2024, ale nyní konečně nese váhu nezávislého recenzního řízení Nature.

## Proč iontové pasti a ne supravodiče

Konkurenční význam těchto výsledků částečně leží v tom, co odhalují o kompromisech hardwarové architektury. Supravodivé kvantové systémy, které používají Google a IBM, operují s rychlostí hradel v řádu desítek nanosekund — zhruba 100 až 1 000krát rychleji než laserová hradla na systémech s iontovými pastmi. Tato rychlostní výhoda činí supravodivý hardware atraktivním pro mělké obvody, které musí doběhnout rychle.

Iontové pasti však vyměňují rychlost za věrnost. Quantinuum H2 dosáhl dvouqubitové věrnosti hradel nad **99,9 %** — úroveň přesnosti, která snižuje základní chybrovost už na vstupu do jakéhokoliv korekčního schématu. Protože korekční kódy musí potlačit chyby pod kritický práh, aby přinesly čistý užitek, znamená vyšší věrnost fyzických qubitů méně z nich potřebných na jeden logický qubit. To se přímo překládá do kratší inženýrské cesty k užitečnému systému odolnému proti chybám.

Další výhodou je **all-to-all konektivita**. V architektuře QCCD (Quantum Charge-Coupled Device) mohou být ionty fyzicky přesouvány uvnitř procesoru, což umožňuje interakce mezi vzdálenými qubity — na rozdíl od supravodivých systémů, kde se qubity typicky mohou propojit jen s nejbližšími sousedy. Tato vlastnost dělá iontové pasti přirozeně vhodnými pro husté provázovací operace, které korekční kódy vyžadují.

## Cesta k praktickým kvantovým počítačům

I přesto, že jsou výsledky bezprecedentní, zůstávají určité mantinely. Systém H2 demonstroval 12 logických qubitů. Odhady pro kryptograficky relevantní výpočty — například prolomení RSA-2048 pomocí Shorova algoritmu — aktuálně počítají zhruba s **1 milionem fyzických qubitů** běžících plně odolných logických obvodů. To je sice revize dolů z dřívějších odhadů 20 milionů díky algoritmickým vylepšením, ale stále několik řádů nad tím, co dnešní systémy nabízejí.

Rychlost hradel zůstává sekundárním faktorem. Provozování dostatečného počtu kol syndrome extrakce na pomalejším iontovém hardwaru při ochraně složitých algoritmů přidává do celkového času výpočtu další režii, kterou bude nutné kompenzovat paralelizací a optimalizací.

Přesto výzkumníci v článku píší jasno: *"Naše výsledky ukazují, že současná kvantová zařízení jsou již schopna využívat odolnost proti chybám a korekci chyb k silnému potlačení chyb v netriviálních kvantových výpočtech."* To je první vědecky podložené tvrzení tohoto typu v historii oboru.

## Kontext: Rok kvantové bezpečnosti

Tyto výsledky přicházejí ve chvíli, kdy NIST, FBI a CISA vyhlásily rok 2026 za **"Rok kvantové bezpečnosti"** — naléhavě vyzývajíce organizace k urychlení migrace na post-kvantovou kryptografii. Zprávou o 800násobném snížení chybrovosti, potvrzenou v Nature, se praktická dostupnost kvantových počítačů schopných ohrozit současnou šifrovací infrastrukturu posouvá z hypotetické budoucnosti do konkrétního inženýrského plánu.

Google nedávno odmítl 2 miliardy dolarů vládního financování pro kvantové výpočty kvůli "podmínkám", které by bránily rychlosti vývoje. Quantinuum právě debutoval na Nasdaqu s valuací 17,6 miliardy dolarů. A PsiQuantum otevřel public access ke svému Construct softwaru pro návrh algoritmů odolných proti chybám. Kvantový ekosystém v polovině roku 2026 nikdy nebyl dynamičtější — a nyní má i první nezávisle ověřené důkazy, že korekce chyb skutečně funguje.

---

*Zdroj: Nature, článek [s41586-026-10628-y](https://www.nature.com/articles/s41586-026-10628-y), publikováno 10. června 2026. Autoři: Microsoft Quantum a Quantinuum.*


---
title: "SAXON Q uvádí na trh diamantové kvantové počítače se 128 a 512 qubity, které fungují při pokojové teplotě"
date: 2026-07-22T06:00:00+02:00
lastmod: 2026-07-22T06:00:00+02:00
draft: false
tags: ["quantum-computing", "SAXON-Q", "diamond-qubits", "NV-center", "room-temperature", "Leipzig-University", "DLR", "Fraunhofer", "sulfur-co-implantation", "Germany", "2026"]
description: "Německý startup SAXON Q z Lipské univerzity uvedl na trh první diamantové kvantové počítače s více než 100 qubity, které pracují při pokojové teplotě. Modely SXQ128 (128 qubitů) a SXQ512 (512 qubitů) využívají proprietární proces sírné ko-implantace s výtěžností přes 85 % a nevyžadují kryogeniku ani vakuum. Jsou už nasazeny v DLR a Fraunhoferu."
author: "Tina"
categories: ["průlom", "hardware"]
---

*Zdroje: [Quantum Computing Report](https://quantumcomputingreport.com/saxon-q-launches-100-qubit-diamond-based-room-temperature-quantum-computers/), [HPCwire](https://www.hpcwire.com/off-the-wire/saxon-q-brings-room-temperature-diamond-quantum-computing-to-commercial-market/), [SAXON Q](https://www.saxonq.com/en/quantencomputer/)*

# SAXON Q uvádí na trh diamantové kvantové počítače se 128 a 512 qubity, které fungují při pokojové teplotě

Kvantové počítače slibují revoluční výpočetní výkon, ale jejich nasazení v praxi dlouho brzdila jediná neúprosná překážka: potřeba extrémního chlazení. Supravodivé systémy od IBM či Google vyžadují diluční chladicí jednotky, které udržují procesory na milikelvinových teplotách — tisítkrát chladnější než vesmírný prostor. Tyto chladicí systémy jsou obrovské, energeticky náročné, extrémně drahé a vyžadují specializované laboratoře s ochranou proti vibracím a elektromagnetickému rušení. IONQ a další pracují s iontovými pastmi, které sice nepotřebují tak drastické chlazení, ale zase vyžadují ultravysoké vakuum a složité laserové systémy.

**21. července 2026** oznámil německý startup **SAXON Q**, spin-off Lipské univerzity (Leipzig University), komerční uvedení dvou kvantových počítačů, které tento problém eliminují úplně. Modely **SXQ128** (128 qubitů) a **SXQ512** (512 qubitů) jsou první diamantové kvantové procesory na bázi center dusík-vakuance (NV center), které překračují hranici deseti fyzických qubitů. A co je hlavní — fungují při **pokojové teplotě**. Žádná kryogenika, žádné vakuum, žádné čistné prostory.

## Diamant jako kvantový substrát

Myšlenka využít diamant pro kvantové počítání není nová. Diamantová mřížka je neobvykle čistá a pevná — atomy uhlíku tvoří dokonalou krystalovou strukturu, která vytváří výjimečně stabilní prostředí pro kvantové stavy. Klíčovým prvkem jsou tzv. **NV centra** (Nitrogen-Vacancy centers): body v diamantové mřížce, kde je jeden uhlíkový atom nahrazen atomem dusíku a vedlejší uhlíkový atom chybí (vakuance). Tyto defekty se chovají jako izolované kvantové systémy — elektronický spin NV centra lze používat jako qubit.

NV centra v diamantu mají jednu unikátní vlastnost: jejich kvantový stav je mimořádně odolný vůči环境ním vlivům i při pokojové teplotě. Zatímco supravodivé qubity ztrácejí koherenci v řádu mikrosekund na milikelvinových teplotách, NV centra si udržují koherenci milisekundy i při 25 °C. Teoreticky jsou ideálním qubitem. Problém byl vždy v jednom: jak jich vyrobit dostatek.

## Sírná ko-implantace: průlom ve výrobě

Dosud největší technickou překážkou diamantových kvantových počítačů byla nízká **výtěžnost konverze** — procento implantovaných atomů dusíku, které skutečně vytvoří funkční NV centra v diamantové mřížce. Tradiční výrobní techniky dosahovaly výtěžnosti mezi 1 % a 10 %. To znamenalo, že pro vytvoření 100 funkčních qubitů bylo třeba implantovat tisíce atomů, přičemž většina z nich buď nevytvořila NV centrum vůbec, nebo vytvořila centrum se špatnými vlastnostmi. Tato nepřesnost znemožňovala škálování.

SAXON Q tento problém řeší pomocí proprietárního procesu **sírné ko-implantace** (sulfur co-implantation), který je chráněn více než 220 patenty a patentovými přihláškami. Princip spočívá v simultánní implantaci atomů síry spolu s atomy dusíku do diamantového substrátu. Atomy síry fungují jako katalyzátor, který výrazně zvyšuje pravděpodobnost, že implantovaný dusík vytvoří stabilní, funkční NV centrum v přesně definované pozici.

Výsledky jsou ohromující:

- **Výtěžnost konverze přes 85 %** — tedy více než osm z deseti implantovaných atomů dusíku vytvoří funkční qubit. To je řádové zlepšení oproti dosavadním 1–10 %.
- **Fidelita jednokubitových hradel až 99,92 %** — méně než jedna chyba na tisíc operací. To dostává diamantové qubity na úroveň nejlepších supravodivých systémů, ale bez nutnosti chlazení.
- **Přesné umístění qubitů** — proces umožňuje kontrolovanou, hustou distribuci NV center v diamantovém substrátu, což je klíčové pro škálování i pro vzájemné provázání qubitů.

## Multi-core architektura a proprietární operační systém

SAXON Q nepostavil jen nový typ qubitů — vytvořil celou architekturu. Oba modely využívají **multi-core kvantovou strukturu** řízenou proprietárním kvantovým operačním systémem (QOS). Model SXQ128 nabízí 8 plně provázaných qubitů v každém jádru, zatímco SXQ512 rozšiřuje kapacitu na 16 provázaných qubitů na jádro.

Modulární design znamená, že systémy lze upgradovat výměnou diamantového čipu nebo přidáním dalších jader — bez nutnosti výměny celého počítače. To je zásadní rozdíl oproti supravodivým systémům, kde upgrade znamená výměnu celého dilučního chladicího systému. Multi-core přístup také otevírá cestu k paralelnímu zpracování kvantových úloh, podobně jako vícejádrové klasické procesory.

## Do serverovny jako běžný server

Jeden z nejpůsobivějších aspektů systémů SAXON Q je jejich fyzická podoba. Na rozdíl od kvantových počítačů první generace, které připomínají zlaté lustry zavěšené nad obřími chladicími jednotkami, systémy SXQ128 a SXQ512 jsou navrženy tak, aby se vešly do **standardních serverových racků**. Zapojují se do běžné elektrické zásuvky a spotřebovávají s **6–10× méně energie** než srovnatelné GPU clustery.

To je průlomové z hlediska nasazení. Kvantový počítač už není exotický přístroj pro špičkové výzkumné laboratoře — je to server, který lze nainstalovat v jakékoliv datacentru, univerzitě nebo průmyslovém výzkumném centru. Demokratizuje přístup ke kvantovým výpočtům způsobem, který byl dříve nemyslitelný.

## Už v nasazení: DLR a Fraunhofer

Systémy SAXON Q nejsou laboratorní prototypy čekající na prvního zákazníka. Předcházející generace room-temperature kvantových počítačů od firmy je už **aktivně nasazena** na dvou prestižních německých institucích:

- **Německé centrum pro letectví a vesmír (DLR)** využívá systémy SAXON Q pro výzkum v oblasti materiálů a simulací.
- **Fraunhoferův institut pro obráběcí stroje a tvářecí technologii (IWU)** používá kvantové počítače pro průmyslové zpracování materiálů a optimalizaci robotiky.

Obě instituce přistupují ke kvantovým systémům buď přímo on-premise, nebo přes cloudová API — což dokazuje, že SAXON Q už má funkční infrastrukturu pro vzdálený přístup.

## Dostupnost a ceny

SAXON Q otvírá objednávky pro oba modely s jasným harmonogramem dodání:

- **SXQ128 (128 qubitů)**: K dispozici objednání ihned, první zákaznické dodávky plánovány na konec léta 2026.
- **SXQ512 (512 qubitů)**: K dispozici předobjednávka, dodávky začínají ve druhém čtvrtletí 2027.

Ceny společnost zatím nepublikovala, ale dostupnost dvou modelů s odlišnou kapacitou naznačuje snahu obsáhnout jak výzkumný segment, tak náročnější komerční nasazení.

## Cesta k 10 000+ qubitům

Tým SAXON Q vede **Prof. Dr. Marius Grundmann** (CEO) a **Prof. Dr. Jan-Berend Meijer** (CTO), oba z Lipské univerzity. Jejich vize je ambiciózní: škálovat multi-core architekturu směrem ke kvantovým koprocesorům pro datacentra a vyvinout plány pro korekci chyb s logickými qubity, s cílem dosáhnout **10 000+ qubitů**.

To je samozřejmě vzdálenější horizont. Ale už současné systémy představují významný krok vpřed. Aplikace, které SAXON Q cílí v krátkodobém horizontu, zahrnují:

- **Kvantové konvoluční neuronové sítě (QCNN)** — strojové učení s kvantovou akcelerací
- **Variační kvantové algoritmy (VQA)** — hybridní kvantově-klasické optimalizační metody
- **Výzkum materiálů** — simulace molekul a pevných látek
- **Kvantová chemie** — výpočty reakčních mechanismů a katalyzátorů

## Proč na tom záleží

Kvantové počítače dlouho slibovaly revoluční výpočetní možnosti, ale zůstávaly uzamčeny ve specializovaných laboratořích s náklady na infrastrukturu v řádech milionů eur. SAXON Q tímto modelem otřásá. Pokud skutečně můžete dodat kvantový počítač s 512 qubity, který funguje při pokojové teplotě, vejdou se do serverovny a spotřebovává méně energie než GPU cluster — pak se kvantové počítání přesouvá z kategorie „slib budoucnosti" do kategorie „dostupná technologie".

Německo tím také posiluje svou pozici v globálním kvantovém závodě. Zatímco Spojené státy mají IBM, Google, Microsoft a IonQ, a Čína investuje miliardy do fotónických a supravodivých systémů, SAXON Q ukazuje, že evropský kvantový ekosystém je schopen inovace na nejvyšší úrovni — a to v méně probádané technologii (diamantová NV centra), která může nakonec překonat mainstreamové přístupy.

Rok 2026 se pomalu stává rokem, ve kterém kvantové počítače přestaly vyžadovat „speciální podmínky" a začaly být prostě… počítači.
