T-poorten en T-fabrieken

In dit artikel wordt de rol van T-poorten en T-factory's in fouttolerante kwantumcomputing beschreven. Als u een kwantumalgoritmen geeft, wordt de schatting van de vereiste resources voor het uitvoeren van de T-gates en T-factory's van cruciaal belang.

Universele set kwantumpoorten

Volgens de criteria van DiVincenzo moet een schaalbare kwantumcomputer een universele set kwantumpoorten kunnen implementeren. Een universele set bevat alle poorten die nodig zijn om kwantumberekeningen uit te voeren. Dat wil gezegd dat elke berekening weer moet worden opgesplitst in een eindige reeks universele poorten. Een kwantumcomputer moet minimaal enkele qubits kunnen verplaatsen naar elke positie op de Bloch Sphere (met behulp van poorten met één qubit) en verstrengeling in het systeem kunnen introduceren, waarvoor een multi-qubit-poort is vereist.

Er zijn slechts vier functies die een bit-naar-een-bit toewijzen op een klassieke computer. Er is daarentegen een oneindig aantal eenheidstransformaties op één qubit op een kwantumcomputer. Daarom kan geen enkele eindige set primitieve kwantumbewerkingen of -poorten exact de oneindige set unitaire transformaties repliceren die zijn toegestaan in kwantumcomputing. Dit betekent, in tegenstelling tot klassieke computing, dat het onmogelijk is voor een kwantumcomputer om elk mogelijk kwantumprogramma exact te implementeren met behulp van een eindig aantal poorten. Kwantumcomputers kunnen dus niet universeel zijn in dezelfde zin als klassieke computers. Als we dus zeggen dat een set poorten universeel is voor kwantumcomputing, bedoelen we eigenlijk iets zwakker dan we bedoelen met klassieke computing.

Voor universaliteit is vereist dat een kwantumcomputer alleen elke unitaire matrix binnen een eindige fout benadert met behulp van een eindige lengtepoortreeks.

Met andere woorden, een set poorten is een universele poortset als een unitaire transformatie ongeveer kan worden geschreven als een product van poorten uit deze set. Het is vereist dat er voor elke voorgeschreven foutgrens poorten $bestaan G_{1}, G_{2}, \ldots, G_N$ van de poortset zodanig dat

$${G_N G_N-1}\cdots G_2 G_1 \approx U.$$

Omdat de conventie voor matrixvermenigvuldiging is om van rechts naar links te vermenigvuldigen, is de eerste poortbewerking in deze reeks, $G_N$, eigenlijk de laatste die wordt toegepast op de kwantumtoestandvector. Formeler wordt gezegd dat een dergelijke poortset universeel is als voor elke fouttolerantie $\epsilon>0$ er $bestaat G_1, \ldots, G_N$ zodanig dat de afstand tussen $G_N\ldots G_1$ en $U$ hooguit $\epsilon$ is. In het ideale geval moet de waarde van $N$ die nodig is om deze afstand van $\epsilon$ te bereiken poly-logaritmisch schalen met $1/\epsilon$.

De set die wordt gevormd door Hadamard-, CNOT- en T-poorten is bijvoorbeeld een universele set, waaruit elke kwantumberekening (op een willekeurig aantal qubits) kan worden gegenereerd. De Hadamard- en T-gateset genereert een enkele qubitpoort:

$$H=\frac{1}{\sqrt{ 1 amp; 1 \\ 1 &-1 \end{bmatrix}, \qquad T=\begin{bmatrix} 1 & 0 \\ 0 & e^{i\pi/4}\end{bmatrix}.&{2}}\begin{bmatrix} $$

In een kwantumcomputer kunnen kwantumpoorten worden geclassificeerd in twee categorieën: Clifford-poorten en niet-Clifford-poorten, in dit geval de T-poort. Kwantumprogramma's die zijn gemaakt van alleen Clifford-poorten kunnen efficiënt worden gesimuleerd met behulp van een klassieke computer en daarom zijn niet-Clifford-poorten vereist om kwantumvoordelen te verkrijgen. In veel QEC-schema's (kwantumfoutcorrectie) zijn de zogenaamde Clifford-poorten eenvoudig te implementeren, dat wil gezegd dat ze zeer weinig resources nodig hebben in termen van bewerkingen en qubits om fouttolerantie te implementeren, terwijl niet-Clifford-poorten vrij kostbaar zijn wanneer fouttolerantie is vereist. In een universele kwantumpoortset wordt de T-poort vaak gebruikt als de niet-Clifford-poort.

De standaardset clifford-poorten met één qubit, standaard opgenomen in Q#,

$$ H=\frac{{1}{\sqrt{{2}}\begin{bmatrix} 1 & 1 \\ 1 &-1 \end{bmatrix} , \qquad S =\begin{bmatrix} 1 & 0 \\ 0 & i \end{bmatrix}= T^2, \qquad X=\begin{bmatrix} 0 & 1 \\ 1& 0 \end{bmatrix}= HT^4H, $$

$$ Y =\begin{bmatrix} 0 & -i \\ i amp &; 0 \end{bmatrix}=T^2HT^4 HT^6, \qquad Z=\begin{bmatrix}1& 0\\ 0&-1 \end{bmatrix}=T^4. $$

Samen met de niet-Clifford-poort (de T-poort) kunnen deze bewerkingen worden samengesteld om elke eenheidstransformatie op één qubit te benaderen.

T-factory's in de Azure Quantum Resource Estimator

De niet-Clifford T-poortvoorbereiding is van cruciaal belang omdat de andere kwantumpoorten niet voldoende zijn voor universele kwantumberekeningen. Als u niet-Clifford-bewerkingen wilt implementeren voor algoritmen op praktische schaal, is een laag foutpercentage T-poorten (of T-statussen) vereist. Ze kunnen echter moeilijk rechtstreeks te implementeren zijn op logische qubits en kunnen ook moeilijk zijn voor sommige fysieke qubits.

In een fouttolerante kwantumcomputer worden de vereiste T-statussen met een lage foutfrequentie geproduceerd met behulp van een T-statusdestillatiefabriek, of kort gezegd T-fabriek. Deze T-fabrieken omvatten meestal een reeks distillatierondes, waarbij elke ronde veel luidruchtige T-toestanden neemt die zijn gecodeerd in een kleinere afstandscode, ze verwerkt met behulp van een distillatie-eenheid, en minder luidruchtige T-toestanden produceert die zijn gecodeerd in een grotere afstandscode, waarbij het aantal rondes, distillatie-eenheden en afstanden allemaal parameters zijn die kunnen worden gevarieerd. Deze procedure wordt gehalveerd, waarbij de T-uitvoerstatussen van de ene ronde als invoer worden ingevoerd in de volgende ronde.

Op basis van de duur van de T-factory bepaalt de Azure Quantum Resource Estimator hoe vaak een T-factory kan worden aangeroepen voordat deze de totale runtime van het algoritme overschrijdt, en dus hoeveel T-statussen kunnen worden geproduceerd tijdens de runtime van het algoritme. Normaal gesproken zijn er meer T-statussen vereist dan wat kan worden geproduceerd in de aanroepen van één T-factory tijdens de runtime van het algoritme. Om meer T-statussen te produceren, gebruikt de Resource Estimator kopieën van de T-factory's.

Fysieke schatting van T-fabriek

De Resource Estimator berekent het totale aantal T-statussen dat nodig is om het algoritme uit te voeren, en het aantal fysieke qubits voor één T-factory en de bijbehorende runtime.

Het doel is om alle T-statussen binnen de algoritmeruntime te produceren met zo min mogelijk T-factory-kopieën. In het volgende diagram ziet u een voorbeeld van de runtime van het algoritme en de runtime van één T-factory. U ziet dat de runtime van de T-factory korter is dan de runtime van het algoritme. In dit voorbeeld kan één T-fabriek één T-toestand destilleren. Er rijzen twee vragen:

• Hoe vaak kan de T-factory worden aangeroepen vóór het einde van het algoritme?
• Hoeveel kopieën van de T-fabrieksdestillatieronde zijn nodig om het aantal T-statussen te maken dat is vereist tijdens de runtime van het algoritme?

Vóór het einde van het algoritme kan de T-fabriek acht keer worden aangeroepen, wat een distillatieronde wordt genoemd. Als u bijvoorbeeld statussen van 30 T nodig hebt, wordt één T-factory acht keer aangeroepen tijdens runtime van het algoritme en worden er dus acht T-statussen gemaakt. Vervolgens moet u vier exemplaren van de T-fabrieksdestillatieronde parallel uitvoeren om de benodigde 30 T-toestanden te destilleren.

Notitie

Houd er rekening mee dat T factory-kopieën en T factory-aanroepen niet hetzelfde zijn.

De T-staatsdistillatiefabrieken worden geïmplementeerd in een reeks rondes, waarbij elke ronde bestaat uit een reeks kopieën van distillatie-eenheden die parallel worden uitgevoerd. De Resource Estimator berekent hoeveel fysieke qubits er nodig zijn om één T-factory uit te voeren en hoe lang de T-factory wordt uitgevoerd, naast andere vereiste parameters.

U kunt alleen volledige aanroepen van een T-fabriek uitvoeren. Daarom kunnen er situaties zijn waarin de geaccumuleerde runtime van alle T-factory-aanroepen kleiner is dan de runtime van het algoritme. Omdat qubits opnieuw worden gebruikt door verschillende rondes, is het aantal fysieke qubits voor één T-factory het maximum aantal fysieke qubits dat voor één ronde wordt gebruikt. De runtime van de T-factory is de som van de runtime in alle rondes.

Notitie

Als het foutpercentage van de fysieke T-poort lager is dan het vereiste foutpercentage van de logische T-status, kan de Resource Estimator geen goede resource-schatting uitvoeren. Wanneer u een resourceschattingstaak indient, kan de T-factory niet worden gevonden omdat het vereiste foutpercentage voor logische T-status te laag of te hoog is.

Zie Bijlage C van Beoordeling van vereisten om te schalen naar praktisch kwantumvoordeel voor meer informatie.

Volgende stappen

• Kwantumcircuits
• Kwantum-oracles
• Algoritme van Grover
• Tussenliggende kwantumweergave