Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
Terwijl u met Q# werkt, ontdekt u dat Pauli-metingen een gebruikelijk type meting zijn. Pauli-metingen generaliseren rekenkundige basismetingen om metingen in andere bases en pariteit tussen verschillende qubits op te nemen. In dergelijke gevallen is het gebruikelijk om het meten van een Pauli-operator te bespreken, een operator zoals $X,Y,Z$ of $Z\otimes Z, X\otimes X, X\otimes Y$, enzovoort. Zie De qubit en meerdere qubits voor de basisbeginselen van kwantummeting.
Het bespreken van metingen in termen van Pauli-operators is gebruikelijk in het subveld van kwantumfoutcorrectie.
Q# gids volgt een vergelijkbare conventie; in dit artikel wordt deze alternatieve weergave van metingen uitgelegd.
Tip
In Q#, multi-qubit Pauli operators worden over het algemeen vertegenwoordigd door matrices van het type Pauli[].
Als u bijvoorbeeld X Z Y wilt vertegenwoordigen$, kunt u de matrix \otimesgebruiken.\otimes$[PauliX, PauliZ, PauliY]
Voordat u de details van een Pauli-meting gaat bekijken, is het handig om na te denken over wat het meten van één qubit in een kwantumcomputer doet met de kwantumstatus. Stel u een n-qubit kwantumtoestand$ voor; bij het meten van één qubit worden onmiddellijk de helft van de $2^n$ mogelijkheden uitgesloten waarin de toestand zich bevindt. Met andere woorden, de meting projecteert de kwantumstatus op een van twee halve spaties. U kunt de manier waarop u denkt over metingen generaliseren om deze intuïtiefheid weer te geven.
Om deze subruimten beknopt te kunnen identificeren, heeft men een taal nodig om ze te beschrijven. Een manier om de twee subruimten te beschrijven, is door ze op te geven via een matrix die slechts twee unieke eigenwaarden heeft, genomen volgens de conventie om \pm 1$ te zijn$. Bekijk $Z$ voor een eenvoudig voorbeeld van het beschrijven van subruimten op deze manier:
$$ \begin{ \begin{align} Z & =\begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}. \end{align} $$
Wanneer u de diagonale elementen van de Pauli-$Z$ matrix leest, ziet u dat $Z$ twee eigenvectors heeft, $\ket{0}$ en $\ket{1}$, met bijbehorende eigenwaarden $\pm 1$.
Als een meting van de qubit resulteert in Zero (overeenkomend met de status $\ket{0}$), is het dus bekend dat de toestand van de qubit een $+1$ eigenstate van de operator $Z$ is.
Als het resultaat Oneis, is het ook bekend dat de toestand van de qubit een $-1$ eigenstate van $Z$is.
Dit proces wordt aangeduid in de taal van Pauli-metingen als " het meten van Pauli $Z,quot$&; en is volledig gelijk aan het uitvoeren van een rekenkundige basismeting.
Elke $2\times 2$ matrix die een eenheidstransformatie van $Z$ is, voldoet ook aan deze criteria. Dat wil zeggen, u kunt ook een matrix $A=U^\dagger Z U$gebruiken, waarbij $U$ een andere unitaire matrix is, om een matrix te krijgen die de twee uitkomsten van een meting definieert in de eigenvectoren met $\pm 1$. De notatie van Pauli-metingen verwijst naar deze eenheidsequivalentie door $X,Y,Z$ metingen te identificeren als gelijkwaardige metingen die u kunt doen om informatie te verkrijgen uit een qubit. Deze metingen worden hier voor het gemak gegeven.
| Pauli-meting | Eenheidstransformatie |
|---|---|
| $Z$ | $\mathbf{1}$ |
| $X$ | $H$ |
| $Y$ | $HS^{\dagger}$ |
Dat wil zeggen, in deze taal, &"meting $Y$&" is gelijk aan het toepassen van $HS^\dagger$ en dan meten in de computationele basis, waarbij S een intrinsieke kwantumbewerking is die soms de &"fasepoort"& wordt genoemd, en kan worden gesimuleerd met behulp van de unitaire matrix.
$$ \begin{ \begin{align}S =\begin{bmatrix}1 & 0 \\0 & i\end{bmatrix}. \end{align} $$
Het is ook vergelijkbaar met het toepassen van $HS^-\dagger$ op de kwantumstatusvector en vervolgens het meten van $Z$, zodat de volgende bewerking gelijk is aan Measure([PauliY], [q]):
operation MeasureY(qubit : Qubit) : Result {
mutable result = Zero;
within {
Adjoint S(q);
H(q);
} apply {
result = M(q);
}
return result;
}
De juiste status wordt vervolgens gevonden door terug te transformeren naar de rekenkundige basis, wat neerkomt op het toepassen van $SH$ op de kwantumstatusvector. In het codefragment wordt de transformatie terug naar de rekenkundige basis automatisch verwerkt met het gebruik van het within … apply blok.
In Q#, het resultaat---dat wil zeggen, de klassieke informatie geëxtraheerd uit de interactie met de toestand---wordt gegeven met een Result waarde $j \in \{\texttt{Zero}, \texttt{One}\}$ die aangeeft of het resultaat zich in de $(-1)^j$ eigenspace bevindt gemeten met de Pauli-operator.
Metingen met meerdere qubits
Metingen van pauli-operators met meerdere qubits worden op dezelfde manier gedefinieerd, zoals te zien is in:
$$Z Z\otimes=\begin{bmatrix}1 & 0 & 0& 0 0\\& amp;-1& 0& 0\\ 0& 0&-1& 0\\ 0& 0& 0& 1\end{bmatrix}. $$
De tensorproducten van twee Pauli-Z-operators$$ vormen dus een matrix die bestaat uit twee spaties die bestaan uit $+1$ en $-1$ eigenwaarden. Net als bij het geval van één qubit vormen beide een halve ruimte, wat betekent dat de helft van de toegankelijke vectorruimte deel uitmaakt van de $+1$ eigenruimte en de resterende helft van de $-1$ eigenspace. Over het algemeen is het gemakkelijk te zien uit de definitie van het tensor-product dat elk tensor-product van Pauli-$Z$ operators en de identiteit hier ook aan voldoet. Bijvoorbeeld:
$$ \begin{align} Z \otimes\mathbf{{1}=\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & -1 & 0 \\ 0 & 0 & 0 & -1 \end{bmatrix}. \end{align} $$
Net als voorheen beschrijft elke eenheidstransformatie van dergelijke matrices ook twee halfruimtes, die gelabeld zijn met $\pm 1$ eigenwaarden. Bijvoorbeeld, $X\otimes X = H\otimes H(Z\otimes Z)H\otimes H$ uitgaande van de identiteit dat $Z=HXH$. Net als bij het geval van één qubit kunnen alle twee qubit Pauli-metingen worden geschreven als $U^\dagger (Z\otimes 1) U-$ voor $4\times 4$ unitaire matrices $U$. De transformaties worden opgesomd in de volgende tabel.
Notitie
In deze tabel wordt $\operatorname{SWAP}$ gebruikt om de matrix $$\begin{align}\operatorname{SWAP}& aan te geven; =\left(\begin{matrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 &\end{matrix}\right) \end{align}$$ gebruikt om de intrinsieke bewerking SWAP te simuleren.
| Pauli meting | Eenheidstransformatie |
|---|---|
| $Z\otimes\mathbf{1}$ | $\mathbf{1}\otimes \mathbf{1}$ |
| $X\otimes\mathbf{1}$ | $H\otimes\mathbf{1}$ |
| $Y\otimes\mathbf{1}$ | $HS^\dagger\otimes\mathbf{1}$ |
| $\mathbf{1} \otimes Z$ | $\operatorname{RUILEN}$ |
| $\mathbf{1} \otimes X$ | $(H\otimes\mathbf{1})\operatorname{RUILEN}$ |
| $\mathbf{1} \otimes Y$ | $(HS^\dagger\otimes\mathbf{1})\operatorname{SWAP}$ |
| $Z\otimes Z$ | $\operatorname{CNOT}_{10}$ |
| $X\otimes Z$ | $\operatorname{CNOT}_{10}(H\otimes\mathbf{1})$ |
| $Y\otimes Z$ | $\operatorname{CNOT}_{10}(HS^\dagger\otimes\mathbf{1})$ |
| $Z\otimes X$ | $\operatorname{CNOT}_{10}(\mathbf{1}\otimes H)$ |
| $X\otimes X$ | $\operatorname{CNOT}_{10}(H\otimes )$ |
| $Y\otimes X$ | $\operatorname{CNOT}_{10}(HS^\dagger\otimes H)$ |
| $Z\otimes Y$ | $\operatorname{CNOT}_{10}(\mathbf{1}\otimes HS^\dagger)$ |
| $X\otimes Y$ | $\operatorname{CNOT}_{10}(H\otimes HS^\dagger)$ |
| $Y\otimes Y$ | $\operatorname{CNOT}_{10}(HS^\dagger\otimes HS^\dagger)$ |
Hier wordt de CNOT bewerking weergegeven om de volgende reden.
Elke Pauli-meting die niet de $\mathbf{1}$ matrix omvat, is volgens de eerdere redenering equivalent tot een unitaire transformatie naar $Z\otimes Z$.
De eigenwaarden van $Z\otimes Z$ zijn alleen afhankelijk van de pariteit van de qubits die elke rekenkundige basisvector vormen en de gecontroleerde niet-bewerkingen dienen om deze pariteit te berekenen en op te slaan in de eerste bit.
Zodra de eerste bit is gemeten, kunt u de identiteit van de resulterende halve ruimte herstellen, wat gelijk is aan het meten van de Pauli-operator.
Hoewel het verleidelijk kan zijn om ervan uit te gaan dat het meten van $Z\otimes Z$ hetzelfde is als het opeenvolgend meten van $Z-\otimes\mathbb{{1}$ en vervolgens $\mathbb{1}\otimes Z$, zou deze aanname onwaar zijn. De reden hiervoor is dat het meten van $Z\otimes Z$ de kwantumstatus projecteert in de $eigenstate +1$ of $-1$ van deze operators. Meten van $Z\otimes\mathbb{1}$ en vervolgens $\mathbb{1}\otimes Z$ projecteert eerst de kwantumtoestandvector op een halve ruimte van $Z\otimes\mathbb{{1}$ en vervolgens op een halve ruimte van$\mathbb{{1}\otimes Z.$ Omdat er vier rekenkundige basisvectoren zijn, vermindert het uitvoeren van beide metingen de status tot een kwartruimte en vermindert het dus tot één rekenkundige basisvector.
Correlaties tussen qubits
Een andere manier om te kijken naar het meten van tensorproducten van Pauli-matrices, zoals $X\otimes X$ of $Z\otimes Z$, is dat u met deze metingen gegevens kunt bekijken die zijn opgeslagen in de correlaties tussen de twee qubits. Met X $\otimes 1$ kunt u informatie bekijken die lokaal is opgeslagen in de eerste qubit. Hoewel beide typen metingen even waardevol zijn in kwantumcomputing, verlicht de voormalige de kracht van kwantumcomputing. Het laat zien dat in kwantumcomputing vaak de informatie die u wilt leren niet wordt opgeslagen in één qubit, maar eerder niet lokaal is opgeslagen in alle qubits tegelijk, en daarom alleen door ernaar te kijken via een gezamenlijke meting (bijvoorbeeld $Z\otimes Z$) wordt deze informatie manifest.
Willekeurige Pauli-operators zoals $X\otimes Y \otimes Z \otimes\mathbf{1}$ kunnen ook worden gemeten. Alle dergelijke tensorproducten van Pauli-operators hebben slechts twee eigenwaarden $\pm 1$ en beide eigenspaces vormen halve spaties van de gehele vectorruimte. Ze vallen dus samen met de eerder genoemde vereisten.
In Q#, dergelijke metingen retourneren $j$ als de meting een resultaat oplevert in de eigenruimte van het teken $(-1)^j$. Pauli-metingen als een ingebouwde functie in Q# is nuttig omdat het meten van dergelijke operators lange ketens van gecontroleerde-NOT-poorten en basistransformaties vereist om de diagonalisatie te beschrijven met de $U$-poort die nodig is om de operatie uit te drukken als het tensorproduct van $Z$ en $1$. Door op te geven dat u een van deze vooraf gedefinieerde metingen wilt uitvoeren, hoeft u zich geen zorgen te maken over het transformeren van uw basis, zodat een berekeningsbasismeting de benodigde informatie levert. Q# verwerkt alle benodigde basistransformaties automatisch voor u.
Het No-Cloning-theorema
Kwantuminformatie is krachtig. Hiermee kunt u geweldige dingen doen, zoals factornummers exponentieel sneller dan de bekendste klassieke algoritmen, of efficiënt gecorreleerde elektronensystemen simuleren die klassiek exponentiële kosten vereisen om nauwkeurig te simuleren. Er gelden echter beperkingen voor de kracht van kwantumcomputing. Een dergelijke beperking wordt gegeven door de No-Cloning Theorem.
Het No-Cloning Theorem heeft terecht deze naam gekregen. Het verbiedt het klonen van algemene kwantumtoestanden door een kwantumcomputer. Het bewijs van de theorema is opmerkelijk eenvoudig. Hoewel een volledig bewijs van het no-clone theorem te technisch is voor dit artikel, is het bewijs in het geval van geen aanvullende qubits binnen het bereik.
Voor een dergelijke kwantumcomputer moet de kloonbewerking worden beschreven met een unitaire matrix. Kwantummeting is niet toegestaan, omdat het de kwantumtoestand die gekloond moet worden zou verstoren. Als u de kloonbewerking wilt simuleren, moet de gebruikte eenheidsmatrix de eigenschap $$ U \ket{\psi}\ket{{0}=\ket{\psi}\ket{\psi}$$ voor elke status $\ket{\psi}$hebben. De lineariteitseigenschap van matrixvermeniging impliceert dat voor elke tweede kwantumtoestand $\ket{\phi}$,
$$ \begin{ \begin{align} U \left[ \frac{{1}{\sqrt{{2}}\left(\ket{\phi}+\ket{\psi}\right) \right] \ket{{0}& =\frac{1}{\sqrt{2}} U\ket{\phi}\ket{{0} + \frac{1}{\sqrt{{2}} U\ket{\psi}\ket{0}\\& =\frac{1}{\sqrt{2}}\left( \ket{\phi}\ket{\phi} + \ket{\psi}\ket{\psi}\right) \\& \ne\left( \frac{{1}{\sqrt{{2}}\left(\ket{\phi}+\ket{\psi}\right) \right) \otimes\left( \frac{1}{\sqrt{{2}}\left(\ket{\phi}+\ket{\psi}\right) \right). \end{align} $$
Dit biedt de fundamentele intuïtie achter het no-cloning-theorema: elk apparaat dat een onbekende kwantumtoestand kopieert, moet fouten induceren op ten minste enkele van de toestanden die het kopieert. Hoewel de belangrijkste veronderstelling dat de kloon lineair op de invoerstatus reageert, kan worden geschonden door het toevoegen en meten van hulp-qubits, lekken dergelijke interacties ook informatie over het systeem via de meetstatistieken en voorkomen ook exacte kloon in dergelijke gevallen.
De No-Cloning Theorem is belangrijk voor kwalitatief begrip van kwantumcomputing. Als u kwantumtoestanden goedkoop zou kunnen klonen, krijgt u een bijna magische mogelijkheid om te leren van kwantumtoestanden. Je zou inderdaad het onzekerhedenprincipe van Heisenberg kunnen schenden. U kunt ook een optimale kloon gebruiken om één voorbeeld uit een complexe kwantumdistributie te nemen en alles te leren wat u mogelijk kunt leren over die distributie vanuit slechts één voorbeeld. Dit zou zijn alsof je een munt spiegelt en hoofden observeert en vervolgens een vriend vertelt over het resultaat dat ze " De verdeling van die munt moet Bernoulli zijn met $p=0,512643\ldots$!" Een dergelijke instructie zou onsensisch zijn, omdat één beetje informatie (het hoofdresultaat) eenvoudigweg niet kan voorzien in de vele stukjes informatie die nodig is om de distributie te coderen zonder substantiële voorafgaande informatie. Op dezelfde manier kunt u zonder voorafgaande informatie een kwantumtoestand niet perfect klonen, net zoals u geen ensemble van dergelijke munten kunt voorbereiden zonder $p$te kennen.
Informatie is niet gratis in kwantumcomputing. Elke qubit die wordt gemeten, geeft één beetje informatie en de No-Cloning Theorem laat zien dat er geen achterdeur is die kan worden misbruikt om de fundamentele afweging te omzeilen tussen informatie die over het systeem is verkregen en de verstoring die erop wordt aangeroepen.