O PrelúdioThe Prelude

O Q# compilador e as máquinas-alvo incluídas no Kit de Desenvolvimento Quântico fornecem um conjunto de funções e operações intrínsecas que podem ser usadas ao escrever programas quânticos em Q# .The Q# compiler and the target machines included with the Quantum Development Kit provide a set of intrinsic functions and operations that can be used when writing quantum programs in Q#.

Operações e Funções IntrínsecasIntrinsic Operations and Functions

As operações intrínsecas definidas na biblioteca padrão enquadram-se aproximadamente numa das várias categorias:The intrinsic operations defined in the standard library roughly fall into one of several categories:

Uma vez que o conjunto de portas Clifford + $T$ é universal para computação quântica, estas operações são suficientes para implementar aproximadamente qualquer algoritmo quântico dentro de um erro insignificantemente pequeno.Since the Clifford + $T$ gate set is universal for quantum computing, these operations suffice to approximately implement any quantum algorithm within negligibly small error. Ao fornecer rotações também, Q# permite que o programador trabalhe dentro da única biblioteca unitária de qubit e cnot gate.By providing rotations as well, Q# allows the programmer to work within the single qubit unitary and CNOT gate library. Esta biblioteca é muito mais fácil de pensar porque não requer que o programador expresse diretamente a decomposição Clifford + $T$ e porque existem métodos altamente eficientes para compilar unidades de qubit únicas em clifford e portões de $T$ (ver aqui para mais informações).This library is much easier to think about because it does not require the programmer to directly express the Clifford + $T$ decomposition and because highly efficient methods exist for compiling single qubit unitaries into Clifford and $T$ gates (see here for more information).

Sempre que possível, as operações definidas no prelúdio que atuam sobre os qubits permitem a aplicação da Controlled variante, de modo a que a máquina-alvo efetue a decomposição adequada.Where possible, the operations defined in the prelude which act on qubits allow for applying the Controlled variant, such that the target machine will perform the appropriate decomposition.

Muitas das funções e operações definidas nesta parte do prelúdio estão no espaço de nomes, de tal forma que a maioria dos @"microsoft.quantum.intrinsic" Q# ficheiros de origem terá uma open Microsoft.Quantum.Intrinsic; diretiva imediatamente após a declaração inicial do espaço de nome.Many of the functions and operations defined in this portion of the prelude are in the @"microsoft.quantum.intrinsic" namespace, such that most Q# source files will have an open Microsoft.Quantum.Intrinsic; directive immediately following the initial namespace declaration. O Microsoft.Quantum.Core namespace espaço de nome é aberto automaticamente, de modo que as funções como podem ser Length function usadas sem qualquer open declaração.The Microsoft.Quantum.Core namespace namespace is automatically opened, so that functions such as Length function can be used without an open statement at all.

Operações Unitárias Single-Qubit ComunsCommon Single-Qubit Unitary Operations

O prelúdio também define muitas operações comuns de um único qubit.The prelude also defines many common single-qubit operations. Todas estas operações permitem tanto os Controlled Adjoint functores como os funtores.All of these operations allow both the Controlled and Adjoint functors.

Operadores PauliPauli Operators

A X operation operação implementa o operador pauli $X$.The X operation operation implements the Pauli $X$ operator. Isto às vezes também é conhecido como o NOT portão.This is sometimes also known as the NOT gate. Tem (Qubit => Unit is Adj + Ctl) assinatura.It has signature (Qubit => Unit is Adj + Ctl). Corresponde ao monobit unitário:It corresponds to the single-qubit unitary:

\start{equation} \start{bmatrix} 0 & 1 \ \ % FIXME: isto utiliza atualmente o hack quadwhack.\begin{equation} \begin{bmatrix} 0 & 1 \\ % FIXME: this currently uses the quadwhack hack. 1 & 0 \end{bmatrix} \end{equação}1 & 0 \end{bmatrix} \end{equation}

A Y operation operação implementa o operador pauli $Y$.The Y operation operation implements the Pauli $Y$ operator. Tem (Qubit => Unit is Adj + Ctl) assinatura.It has signature (Qubit => Unit is Adj + Ctl). Corresponde ao monobit unitário:It corresponds to the single-qubit unitary:

\start{equation} \start{bmatrix} 0 & -i \ \ % FIXME: isto utiliza atualmente o hack quadwhack.\begin{equation} \begin{bmatrix} 0 & -i \\ % FIXME: this currently uses the quadwhack hack. i & 0 \end{bmatrix} \end{equação}i & 0 \end{bmatrix} \end{equation}

A Z operation operação implementa o operador pauli $Z$.The Z operation operation implements the Pauli $Z$ operator. Tem (Qubit => Unit is Adj + Ctl) assinatura.It has signature (Qubit => Unit is Adj + Ctl). Corresponde ao monobit unitário:It corresponds to the single-qubit unitary:

\start{equation} \start{bmatrix} 1 & 0 \ \ % FIXME: isto utiliza atualmente o hack quadwhack.\begin{equation} \begin{bmatrix} 1 & 0 \\ % FIXME: this currently uses the quadwhack hack. 0 & -1 \end{bmatrix} \end{equação}0 & -1 \end{bmatrix} \end{equation}

Abaixo vemos estas transformações mapeadas para a esfera bloch (o eixo de rotação em cada caso é realçado vermelho):Below we see these transformations mapped to the Bloch sphere (the rotation axis in each case is highlighted red):

Operações de Pauli mapeadas na esfera bloch

É importante notar que a aplicação do mesmo portão Pauli duas vezes ao mesmo qubit cancela a operação (porque já realizou uma rotação completa de 2π (360°) sobre a superfície para a Esfera bloch, chegando assim ao ponto de partida).It is important to note that applying the same Pauli gate twice to the same qubit cancels out the operation (because you have now performed a full rotation of 2π (360°) over the surface to the Bloch Sphere, thus arriving back at the starting point). Isto leva-nos à seguinte identidade:This brings us to the following identity:

$$ X^2=Y^2=Z^2=\boldone $$$$ X^2=Y^2=Z^2=\boldone $$

Isto pode ser visualizado na esfera bloch:This can be visualised on the Bloch sphere:

XX = I

Outros Single-Qubit CliffordsOther Single-Qubit Cliffords

A H operation operação implementa o portão Hadamard.The H operation operation implements the Hadamard gate. Isto intermuta os eixos Pauli $X$ e $Z$ do qubit alvo, de tal forma que $H\ket {0} = \ket{+} \mathrel{:=} (\ket {0} + \ket) {1} / \sqrt {2} $ e $H\ket{+} = \ket {0} $.This interchanges the Pauli $X$ and $Z$ axes of the target qubit, such that $H\ket{0} = \ket{+} \mathrel{:=} (\ket{0} + \ket{1}) / \sqrt{2}$ and $H\ket{+} = \ket{0}$. Tem assinatura (Qubit => Unit is Adj + Ctl) , e corresponde ao único qubit unitário:It has signature (Qubit => Unit is Adj + Ctl), and corresponds to the single-qubit unitary:

\start{equation} \frac {1} {\sqrt {2} } \start{bmatrix} 1 & 1 \ \ % FIXME: isto utiliza atualmente o hack quadwhack.\begin{equation} \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ % FIXME: this currently uses the quadwhack hack. 1 & -1 \end{bmatrix} \end{equação}1 & -1 \end{bmatrix} \end{equation}

O portão Hadamard é particularmente importante, pois pode ser usado para criar uma superposição dos estados $\ket {0} $ e $\ket$ {1} .The Hadamard gate is particularly important as it can be used to create a superposition of the $\ket{0}$ and $\ket{1}$ states. Na representação da esfera bloch, é mais fácil pensar nisto como uma rotação de $\ket{\psi}$ em torno do eixo x por $\pi$ radians ($180^\circ$) seguido por uma rotação (no sentido horário) em torno do eixo y por $\pi/2$ radians ($90^\circ$):In the Bloch sphere representation, it is easiest to think of this as a rotation of $\ket{\psi}$ around the x-axis by $\pi$ radians ($180^\circ$) followed by a (clockwise) rotation around the y-axis by $\pi/2$ radians ($90^\circ$):

Operação Hadamard mapeada na esfera bloch

A S operation operação implementa o portão de fase $S$.The S operation operation implements the phase gate $S$. Esta é a raiz quadrada da operação Pauli $Z$.This is the matrix square root of the Pauli $Z$ operation. Ou seja, $S^2 = Z$.That is, $S^2 = Z$. Tem assinatura (Qubit => Unit is Adj + Ctl) , e corresponde ao único qubit unitário:It has signature (Qubit => Unit is Adj + Ctl), and corresponds to the single-qubit unitary:

\start{equation} \start{bmatrix} 1 & 0 \ \ % FIXME: isto utiliza atualmente o hack quadwhack.\begin{equation} \begin{bmatrix} 1 & 0 \\ % FIXME: this currently uses the quadwhack hack. 0 & i \end{bmatrix} \end{equação}0 & i \end{bmatrix} \end{equation}

RotaçõesRotations

Além das operações de Pauli e Clifford acima, o Q# prelúdio fornece uma variedade de formas de expressar rotações.In addition to the Pauli and Clifford operations above, the Q# prelude provides a variety of ways of expressing rotations. Como descrito em operações de um único qubit,a capacidade de rotação é fundamental para algoritmos quânticos.As described in single-qubit operations, the ability to rotate is critical to quantum algorithms.

Começamos por recordar que podemos expressar qualquer operação de um único qubit utilizando os portões $H$ e $T$, onde $H$ é a operação Hadamard, e onde \start{equação} T \mathrel{:=} \start{bmatrix} 1 & 0 \ \ % FIXME: isto atualmente utiliza o quad back whack hack.We start by recalling that we can express any single-qubit operation using the $H$ and $T$ gates, where $H$ is the Hadamard operation, and where \begin{equation} T \mathrel{:=} \begin{bmatrix} 1 & 0 \\ % FIXME: this currently uses the quad back whack hack. 0 & e^{i \pi / 4} \end{bmatrix} \end{equação} Esta é a raiz quadrada da S operation operação, de tal forma que $T^2 = S$.0 & e^{i \pi / 4} \end{bmatrix} \end{equation} This is the square root of the S operation operation, such that $T^2 = S$. O portão $T$ é, por sua vez, implementado pela T operation operação, e tem (Qubit => Unit is Adj + Ctl) assinatura, indicando que se trata de uma operação unitária num único qubit.The $T$ gate is in turn implemented by the T operation operation, and has signature (Qubit => Unit is Adj + Ctl), indicating that it is a unitary operation on a single-qubit.

Embora isto seja, em princípio, suficiente para descrever qualquer operação arbitrária de um único qubit, as diferentes máquinas-alvo podem ter representações mais eficientes para rotações sobre os operadores de Pauli, de modo a que o prelúdio inclua uma variedade de formas de expressar convienentemente tais rotações.Even though this is in principle sufficient to describe any arbitrary single-qubit operation, different target machines may have more efficient representations for rotations about Pauli operators, such that the prelude includes a variety of ways to convienently express such rotations. O mais básico destes é a <xref:Microsoft.Quantum.Intrinsic.r> operação, que implementa uma rotação em torno de um eixo Pauli especificado, \start{equação} R(\sigma, \phi) \mathrel{:=} \exp(i\phi \sigma / 2), \end{equação} onde $\sigma$ é um operador Pauli, $\phi$ é um ângulo, e onde $\exp$ representa a matriz expoente.The most basic of these is the <xref:Microsoft.Quantum.Intrinsic.r> operation, which implements a rotation around a specified Pauli axis, \begin{equation} R(\sigma, \phi) \mathrel{:=} \exp(-i \phi \sigma / 2), \end{equation} where $\sigma$ is a Pauli operator, $\phi$ is an angle, and where $\exp$ represents the matrix exponential. Tem assinatura ((Pauli, Double, Qubit) => Unit is Adj + Ctl) , onde as duas primeiras partes da entrada representam os argumentos clássicos $\sigma$ e $\phi$ necessários para especificar o operador unitário $R(\sigma, \phi)$.It has signature ((Pauli, Double, Qubit) => Unit is Adj + Ctl), where the first two parts of the input represent the classical arguments $\sigma$ and $\phi$ needed to specify the unitary operator $R(\sigma, \phi)$. Podemos aplicar parcialmente $\sigma$ e $\phi$ para obter uma operação cujo tipo é o de um único qubit unitário.We can partially apply $\sigma$ and $\phi$ to obtain an operation whose type is that of a single-qubit unitary. Por exemplo, R(PauliZ, PI() / 4, _) tem tipo (Qubit => Unit is Adj + Ctl) .For example, R(PauliZ, PI() / 4, _) has type (Qubit => Unit is Adj + Ctl).

Nota

A <xref:Microsoft.Quantum.Intrinsic.r> operação divide o ângulo de entrada por 2 e multiplica-o por -1.The <xref:Microsoft.Quantum.Intrinsic.r> operation divides the input angle by 2 and multiplies it by -1. Para $Z dólares rotações, isto significa que o $\ket {0} $ eigenstate é rodado por $-\phi / 2$ e o $\ket {1} $ eigenstate é rodado por $\phi / 2$, de modo que o $\ket {1} $ eigenstate é rodado por $\phi$ em relação ao $\ket {0} $ eigenstate.For $Z$ rotations, this means that the $\ket{0}$ eigenstate is rotated by $-\phi / 2$ and the $\ket{1}$ eigenstate is rotated by $\phi / 2$, so that the $\ket{1}$ eigenstate is rotated by $\phi$ relative to the $\ket{0}$ eigenstate.

Isto significa, em particular, que T e R(PauliZ, PI() / 8, _) diferem apenas por uma fase globalirrelevante.In particular, this means that T and R(PauliZ, PI() / 8, _) differ only by an irrelevant global phase. Por esta razão, $T$ é por vezes conhecido como o $\frac{\pi} {8} $-gate.For this reason, $T$ is sometimes known as the $\frac{\pi}{8}$-gate.

Note também que rodar em torno PauliI simplesmente aplica uma fase global de $\phi / 2$.Note also that rotating around PauliI simply applies a global phase of $\phi / 2$. Embora tais fases sejam irrelevantes, como argumentam os documentos conceptuais,são relevantes para PauliI rotações controladas.While such phases are irrelevant, as argued in the conceptual documents, they are relevant for controlled PauliI rotations.

Dentro de algoritmos quânticos, é frequentemente útil expressar rotações como frações dyadic, de modo que $\phi = \pi k / 2^n$ para alguns $k \in \mathbb{Z}$ e $n \in \mathbb{N}$.Within quantum algorithms, it is often useful to express rotations as dyadic fractions, such that $\phi = \pi k / 2^n$ for some $k \in \mathbb{Z}$ and $n \in \mathbb{N}$. A RFrac operation operação implementa uma rotação em torno de um eixo Pauli especificado usando esta convenção.The RFrac operation operation implements a rotation around a specified Pauli axis using this convention. Difere da medida em que o ângulo de R operation rotação é especificado como duas entradas do Int tipo, interpretadas como uma fração diádica.It differs from R operation in that the rotation angle is specified as two inputs of type Int, interpreted as a dyadic fraction. Assim, RFrac tem ((Pauli, Int, Int, Qubit) => Unit is Adj + Ctl) assinatura.Thus, RFrac has signature ((Pauli, Int, Int, Qubit) => Unit is Adj + Ctl). Implementa o monobit unitário $\exp(i\pi k \sigma / 2^n)$, onde $\sigma$ é a matriz Pauli correspondente ao primeiro argumento, $k$ é o segundo argumento, e $n$ é o terceiro argumento.It implements the single-qubit unitary $\exp(i \pi k \sigma / 2^n)$, where $\sigma$ is the Pauli matrix corresponding to the first argument, $k$ is the second argument, and $n$ is the third argument. RFrac(_,k,n,_) é o mesmo R(_,-πk/2^n,_) que; note que o ângulo é o negativo da fração.RFrac(_,k,n,_) is the same as R(_,-πk/2^n,_); note that the angle is the negative of the fraction.

A Rx operation operação implementa uma rotação em torno do eixo Pauli $X$.The Rx operation operation implements a rotation around the Pauli $X$ axis. Tem ((Double, Qubit) => Unit is Adj + Ctl) assinatura.It has signature ((Double, Qubit) => Unit is Adj + Ctl). Rx(_, _) é o mesmo R(PauliX, _, _) que.Rx(_, _) is the same as R(PauliX, _, _).

A Ry operation operação implementa uma rotação em torno do eixo Pauli $Y$.The Ry operation operation implements a rotation around the Pauli $Y$ axis. Tem ((Double, Qubit) => Unit is Adj + Ctl) assinatura.It has signature ((Double, Qubit) => Unit is Adj + Ctl). Ry(_, _) é o mesmo R(PauliY,_ , _) que.Ry(_, _) is the same as R(PauliY,_ , _).

A Rz operation operação implementa uma rotação em torno do eixo Pauli $Z$.The Rz operation operation implements a rotation around the Pauli $Z$ axis. Tem ((Double, Qubit) => Unit is Adj + Ctl) assinatura.It has signature ((Double, Qubit) => Unit is Adj + Ctl). Rz(_, _) é o mesmo R(PauliZ, _, _) que.Rz(_, _) is the same as R(PauliZ, _, _).

A R1 operation operação implementa uma rotação pelo valor dado em torno de $\ket {1} $, o $-1$ eigenstate de $Z$.The R1 operation operation implements a rotation by the given amount around $\ket{1}$, the $-1$ eigenstate of $Z$. Tem ((Double, Qubit) => Unit is Adj + Ctl) assinatura.It has signature ((Double, Qubit) => Unit is Adj + Ctl). R1(phi,_) é o mesmo R(PauliZ,phi,_) que seguido R(PauliI,-phi,_) por.R1(phi,_) is the same as R(PauliZ,phi,_) followed by R(PauliI,-phi,_).

A R1Frac operation operação implementa uma rotação fracionária pela quantidade dada em torno do estado de Z=1.The R1Frac operation operation implements a fractional rotation by the given amount around the Z=1 eigenstate. Tem ((Int,Int, Qubit) => Unit is Adj + Ctl) assinatura.It has signature ((Int,Int, Qubit) => Unit is Adj + Ctl). R1Frac(k,n,_) é o mesmo RFrac(PauliZ,-k.n+1,_) que seguido RFrac(PauliI,k,n+1,_) por.R1Frac(k,n,_) is the same as RFrac(PauliZ,-k.n+1,_) followed by RFrac(PauliI,k,n+1,_).

Um exemplo de uma operação de rotação (em torno do eixo Pauli $Z$, neste caso) mapeada na esfera bloch é mostrado abaixo:An example of a rotation operation (around the Pauli $Z$ axis, in this instance) mapped onto the Bloch sphere is shown below:

Operação de rotação mapeada na esfera bloch

Operações Multi-QubitMulti-Qubit Operations

Além das operações de um único qubit acima, o prelúdio também define várias operações multi-qubit.In addition to the single-qubit operations above, the prelude also defines several multi-qubit operations.

Primeiro, a CNOT operation operação executa um portão controlado padrão, NOT \start{equation} \operatorname{CNOT} \mathrel{:=} \start{bmatrix} 1 & 0 & 0 & \ \ 0 0 & 1 & 0 & 0 \ \ 0 & 0 & 0 & \ \ 10 & 0 & 1 & 0 \end{bmatrix}.First, the CNOT operation operation performs a standard controlled-NOT gate, \begin{equation} \operatorname{CNOT} \mathrel{:=} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{bmatrix}. \end{equation} Tem ((Qubit, Qubit) => Unit is Adj + Ctl) assinatura, representando que $\operatorname{CNOT}$ age unitariamente em dois qubits individuais.\end{equation} It has signature ((Qubit, Qubit) => Unit is Adj + Ctl), representing that $\operatorname{CNOT}$ acts unitarily on two individual qubits. CNOT(q1, q2) é o mesmo (Controlled X)([q1], q2) que.CNOT(q1, q2) is the same as (Controlled X)([q1], q2). Uma vez que o Controlled functor permite controlar um registo, usamos a matriz literal [q1] para indicar que queremos apenas um controlo.Since the Controlled functor allows for controlling on a register, we use the array literal [q1] to indicate that we want only the one control.

A CCNOT operation operação executa o portão NÃO duplamente controlado, por vezes também conhecido como portão Toffoli.The CCNOT operation operation performs doubly-controlled NOT gate, sometimes also known as the Toffoli gate. Tem ((Qubit, Qubit, Qubit) => Unit is Adj + Ctl) assinatura.It has signature ((Qubit, Qubit, Qubit) => Unit is Adj + Ctl). CCNOT(q1, q2, q3) é o mesmo (Controlled X)([q1, q2], q3) que.CCNOT(q1, q2, q3) is the same as (Controlled X)([q1, q2], q3).

A SWAP operation operação troca os estados quânticos de dois qubits.The SWAP operation operation swaps the quantum states of two qubits. Ou seja, implementa a matriz unitária \start{equação} \operatorname{SWAP} \mathrel{:=} \start{bmatrix} 1 & 0 & 0 & 0 \ \ 0 & 0 & 1 & \ \ 0 & 1 & 0 & 0 \ \ 0 & 0 & 0 & 1 \end{bmatrix}.That is, it implements the unitary matrix \begin{equation} \operatorname{SWAP} \mathrel{:=} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}. \end{equação} Tem assinatura ((Qubit, Qubit) => Unit is Adj + Ctl) .\end{equation} It has signature ((Qubit, Qubit) => Unit is Adj + Ctl). SWAP(q1,q2) é equivalente a CNOT(q1, q2) seguido por CNOT(q2, q1) e, em CNOT(q1, q2) seguida, .SWAP(q1,q2) is equivalent to CNOT(q1, q2) followed by CNOT(q2, q1) and then CNOT(q1, q2).

Nota

O portão SWAP não é o mesmo que reorganizar os elementos de uma variável com o tipo Qubit[] .The SWAP gate is not the same as rearranging the elements of a variable with type Qubit[]. A aplicação SWAP(q1, q2) provoca uma alteração ao estado dos qubits referidos q1 q2 e, embora let swappedRegister = [q2, q1]; apenas afete a forma como nos referimos a esses qubits.Applying SWAP(q1, q2) causes a change to the state of the qubits referred to by q1 and q2, while let swappedRegister = [q2, q1]; only affects how we refer to those qubits. Além disso, (Controlled SWAP)([q0], (q1, q2)) permite estar condicionado ao estado de um terceiro SWAP qubit, que não podemos representar através da reorganização de elementos.Moreover, (Controlled SWAP)([q0], (q1, q2)) allows for SWAP to be conditioned on the state of a third qubit, which we cannot represent by rearranging elements. O portão swap controlado, também conhecido como o portão Fredkin, é poderoso o suficiente para incluir toda a computação clássica.The controlled-SWAP gate, also known as the Fredkin gate, is powerful enough to include all classical computation.

Por último, o prelúdio prevê duas operações para representar exponencial dos operadores de Pauli multi-qubit.Finally, the prelude provides two operations for representing exponentials of multi-qubit Pauli operators. A Exp operation operação executa uma rotação baseada num produto tensor de matrizes Pauli, representada pelo multi-qubit unitário \begin{equação} \operatorname{Exp}(\vec{\sigma}, \phi) \mathrel{:=} \exp\left(i\phi \sigma_0 \otimes \sigma_1 \otimes \otimes \otimes \sigma_n \right), \end{equation} where $\vec{\sigma} = (\sigma_0, \sigma_1, \pontos, \sigma_n)$ é uma sequência de operadores pauli de um único qubit, e onde $\phi$ é um ângulo.The Exp operation operation performs a rotation based on a tensor product of Pauli matrices, as represented by the multi-qubit unitary \begin{equation} \operatorname{Exp}(\vec{\sigma}, \phi) \mathrel{:=} \exp\left(i \phi \sigma_0 \otimes \sigma_1 \otimes \cdots \otimes \sigma_n \right), \end{equation} where $\vec{\sigma} = (\sigma_0, \sigma_1, \dots, \sigma_n)$ is a sequence of single-qubit Pauli operators, and where $\phi$ is an angle. A Exp rotação representa $\vec{\sigma}$ como uma variedade de Pauli elementos, de modo a que tenha assinatura ((Pauli[], Double, Qubit[]) => Unit is Adj + Ctl) .The Exp rotation represents $\vec{\sigma}$ as an array of Pauli elements, such that it has signature ((Pauli[], Double, Qubit[]) => Unit is Adj + Ctl).

A ExpFrac operation operação executa a mesma rotação, utilizando a notação de fração dyad discutida acima.The ExpFrac operation operation performs the same rotation, using the dyadic fraction notation discussed above. Tem ((Pauli[], Int, Int, Qubit[]) => Unit is Adj + Ctl) assinatura.It has signature ((Pauli[], Int, Int, Qubit[]) => Unit is Adj + Ctl).

Aviso

As exponenciais do produto tensor dos operadores Pauli não são os mesmos que os produtos tensores dos exponencial dos operadores da Pauli.Exponentials of the tensor product of Pauli operators are not the same as tensor products of the exponentials of Pauli operators. Ou seja, $e^{i (Z \otimes Z) \phi} \ne e^{i Z \phi} \otimes e^{i Z \phi}$.That is, $e^{i (Z \otimes Z) \phi} \ne e^{i Z \phi} \otimes e^{i Z \phi}$.

MediçõesMeasurements

Ao medir, o valor de +1 do operador a ser medido corresponde a um Zero resultado e o -1 égénico para One um resultado.When measuring, the +1 eigenvalue of the operator being measured corresponds to a Zero result, and the -1 eigenvalue to a One result.

Nota

Embora esta convenção possa parecer estranha, tem duas vantagens muito boas.While this convention might seem odd, it has two very nice advantages. Em primeiro lugar, observar o resultado $\ket {0} $ é representado pelo Result Zero valor, enquanto observa $\ket {1} $ corresponde a One .First, observing the outcome $\ket{0}$ is represented by the Result value Zero, while observing $\ket{1}$ corresponds to One. Em segundo lugar, podemos escrever que o eigenvalue $\lambda$ correspondente a um resultado $r$ é $\lambda = (-1)^r$.Second, we can write out that the eigenvalue $\lambda$ corresponding to a result $r$ is $\lambda = (-1)^r$.

As operações de medição não suportam nem o Adjoint functor nem o Controlled functor.Measurement operations support neither the Adjoint nor the Controlled functor.

A Measure operation operação efetua uma medição conjunta de um ou mais qubits no produto especificado dos operadores da Pauli.The Measure operation operation performs a joint measurement of one or more qubits in the specified product of Pauli operators. Se a matriz de Pauli e a matriz de qubits forem diferentes comprimentos, então a operação falha.If the Pauli array and qubit array are different lengths, then the operation fails. Measure tem assinatura ((Pauli[], Qubit[]) => Result) .Measure has signature ((Pauli[], Qubit[]) => Result).

Note que uma medição articular não é a mesma que medir cada qubit individualmente.Note that a joint measurement is not the same as measuring each qubit individually. Por exemplo, considere o estado $\ket {11} = \ket {1} \otimes \ket {1} = X\otimes X \ket {00} $.For example, consider the state $\ket{11} = \ket{1} \otimes \ket{1} = X\otimes X \ket{00}$. Medindo $Z_0$ e $Z_1$ cada um individualmente, obtemos os resultados $r_0 = 1$ e $r_1 = 1$.Measuring $Z_0$ and $Z_1$ each individually, we get the results $r_0 = 1$ and $r_1 = 1$. Medindo $Z_0 Z_1$, no entanto, obtemos o único resultado $r_{\textrm{joint}} = 0$, representando que a paridade de $\ket {11} $ é positiva.Measuring $Z_0 Z_1$, however, we get the single result $r_{\textrm{joint}} = 0$, representing that the pairity of $\ket{11}$ is positive. Dito de forma diferente, $(-1)^{r_0 + r_1} = (-1)^r_{\textrm{joint}})$.Put differently, $(-1)^{r_0 + r_1} = (-1)^r_{\textrm{joint}})$. Criticamente, uma vez que aprendemos a paridade com esta medida, qualquer informação quântica representada na superposição entre os dois estados de dois qubits de paridade positiva, $\ket {00} $ e $\ket {11} $, é preservada.Critically, since we only learn the parity from this measurement, any quantum information represented in the superposition between the two two-qubit states of positive parity, $\ket{00}$ and $\ket{11}$, is preserved. Esta propriedade será essencial mais tarde, enquanto discutimos a correção de erros.This property will be essential later, as we discuss error correction.

Por conveniência, o prelúdio também fornece duas outras operações para medir qubits.For convenience, the prelude also provides two other operations for measuring qubits. Em primeiro lugar, uma vez que a realização de medições de um único qubit é bastante comum, o prelúdio define uma abreviatura para este caso.First, since performing single-qubit measurements is quite common, the prelude defines a shorthand for this case. A M operation operação mede o operador pauli $Z$ num único qubit, e tem assinatura (Qubit => Result) .The M operation operation measures the Pauli $Z$ operator on a single qubit, and has signature (Qubit => Result). M(q) é equivalente a Measure([PauliZ], [q]).M(q) is equivalent to Measure([PauliZ], [q]).

As <xref:microsoft.quantum.measurement.MultiM> medidas que o Operador Pauli $Z$ separadamente em cada uma de uma matriz de qubits, devolvendo a matriz de Result valores obtidos para cada qubit.The <xref:microsoft.quantum.measurement.MultiM> measures the Pauli $Z$ operator separately on each of an array of qubits, returning the array of Result values obtained for each qubit. Em alguns casos, isto pode ser otimizado.In some cases this can be optimized. Tem assinatura ( Qubit[] => Result[]) .It has signature (Qubit[] => Result[]). MultiM(qs) equivale a:MultiM(qs) is equivalent to:

mutable rs = new Result[Length(qs)];
for (index in 0..Length(qs)-1)
{
    set rs[index] = M(qs[index]);
}
return rs;

Funções e Operações de ExtensãoExtension Functions and Operations

Além disso, o prelúdio define um conjunto rico de funções de conversão matemática e tipo ao nível .NET para utilização dentro do Q# código.In addition, the prelude defines a rich set of mathematical and type conversion functions at the .NET level for use within Q# code. Por exemplo, o Microsoft.Quantum.Math namespace espaço de nome define operações úteis tais como e Sin function Log function .For instance, the Microsoft.Quantum.Math namespace namespace defines useful operations such as Sin function and Log function. A implementação fornecida pelo Kit de Desenvolvimento Quântico utiliza a clássica biblioteca de classe base .NET, podendo assim envolver uma viagem de ida e volta de comunicações adicional entre programas quânticos e seus condutores clássicos.The implementation provided by the Quantum Development Kit uses the classical .NET base class library, and thus may involve an additional communications round trip between quantum programs and their classical drivers. Embora isto não apresente um problema para um simulador local, este pode ser um problema de desempenho ao usar um simulador remoto ou hardware real como uma máquina alvo.While this does not present a problem for a local simulator, this can be a performance issue when using a remote simulator or actual hardware as a target machine. Dito isto, uma máquina-alvo individual pode mitigar este impacto de desempenho, sobrepôs-se a estas operações com versões mais eficientes para esse sistema específico.That said, an individual target machine may mitigate this performance impact by overriding these operations with versions that are more efficient for that particular system.

MatemáticaMath

O Microsoft.Quantum.Math namespace espaço de nomes fornece muitas funções úteis da classe base da System.Math biblioteca.NET.The Microsoft.Quantum.Math namespace namespace provides many useful functions from the .NET base class library's System.Math class. Estas funções podem ser utilizadas da mesma forma que quaisquer Q# outras funções:These functions can be used in the same manner as any other Q# functions:

open Microsoft.Quantum.Math;
// ...
let y = Sin(theta);

Quando um método estático .NET tiver sido sobrecarregado com base no tipo dos seus argumentos, a função correspondente Q# é anotada com um sufixo que indique o tipo da sua entrada:Where a .NET static method has been overloaded based on the type of its arguments, the corresponding Q# function is annotated with a suffix indicating the type of its input:

let x = AbsI(-3); // x : Int = 3
let y = AbsD(-PI()); // y : Double = 3.1415...

Operações BitwiseBitwise Operations

Finalmente, o Microsoft.Quantum.Bitwise namespace espaço de nomes fornece várias funções úteis para manipular inteiros através de operadores bitwise.Finally, the Microsoft.Quantum.Bitwise namespace namespace provides several useful functions for manipulating integers through bitwise operators. Por exemplo, Parity function devolve a paridade de um inteiro como outro inteiro.For instance, Parity function returns the bitwise parity of an integer as another integer.