DiagnósticoDiagnostics

Tal como acontece com o desenvolvimento clássico, é importante ser capaz de diagnosticar erros e erros em programas quânticos.As with classical development, it is important to be able to diagnose mistakes and errors in quantum programs. As Q# bibliotecas padrão fornecem uma variedade de maneiras diferentes para garantir a correção dos programas quânticos, conforme detalhado em Teste e depuração .The Q# standard libraries provide a variety of different ways to ensure the correctness of quantum programs, as detailed in Teste e depuração. Em grande parte, este suporte vem sob a forma de funções e operações que instruem a máquina-alvo a fornecer informações de diagnóstico adicionais ao programa de acolhimento ou ao desenvolvedor, ou a impor a correção das condições e invariantes expressas pela função ou chamada de funcionamento.Largely speaking, this support comes in the form of functions and operations that either instruct the target machine to provide additional diagnostic information to the host program or developer, or enforce the correctness of conditions and invariants expressed by the function or operation call.

Diagnóstico de MáquinasMachine Diagnostics

Os diagnósticos sobre valores clássicos podem ser obtidos utilizando a Message function função para registar uma mensagem de forma dependente da máquina.Diagnostics about classical values can be obtained by using the Message function function to log a message in a machine-dependent way. Por padrão, isto escreve a corda para a consola.By default, this writes the string to the console. Usado em conjunto com cordas interpoladas, Message function torna fácil relatar informações de diagnóstico sobre valores clássicos:Used together with interpolated strings, Message function makes it easy to report diagnostic information about classical values:

let angle = Microsoft.Quantum.Math.PI() * 2.0 / 3.0;
Message($"About to rotate by an angle of {angle}...");

Nota

Message tem assinatura (String -> Unit) , mais uma vez representando que a emissão de uma mensagem de registo de depurado não pode ser observada a partir de dentro Q# .Message has signature (String -> Unit), again representing that emitting a debug log message cannot be observed from within Q#.

Os DumpMachine function e DumpRegister function os callables instruem as máquinas-alvo a fornecer informações de diagnóstico sobre todos os qubits atualmente atribuídos ou sobre um registo específico de qubits, respectivamente.The DumpMachine function and DumpRegister function callables instruct target machines to provide diagnostic information about all currently allocated qubits or about a specific register of qubits, respectively. Cada máquina-alvo varia em que informações de diagnóstico são fornecidas em resposta a uma instrução de despejo.Each target machine varies in what diagnostic information is provided in response to a dump instruction. A máquina alvo de simulador de estado completo, por exemplo, fornece o programa de anfitrião com o vetor de estado que usa internamente para representar um registo de qubits.The full state simulator target machine, for instance, provides the host program with the state vector that it uses internally to represent a register of qubits. Em comparação, a máquina-alvo do simulador Toffoli fornece uma única bit clássica para cada qubit.By comparison, the Toffoli simulator target machine provides a single classical bit for each qubit.

Para saber mais sobre a saída completa do simulador de estado, DumpMachine veja a secção de funções de despejo do nosso artigo de teste e depuragem.To learn more about the full state simulator's DumpMachine output, take a look at the dump functions section of our testing and debugging article.

Factos e AfirmaçõesFacts and Assertions

Tal como discutido em Testes e Depuragem, uma função ou operação com assinatura Unit -> Unit Unit => Unit ou, respectivamente, pode ser marcada como um teste de unidade .As discussed in Testing and Debugging, a function or operation with signature Unit -> Unit or Unit => Unit, respectively, can be marked as a unit test . Cada teste de unidade geralmente consiste num pequeno programa quântico, juntamente com uma ou mais condições que verificam a correção desse programa.Each unit test generally consists of a small quantum program, along with one or more conditions that check the correctness of that program. Estas condições podem surgir sob a forma de qualquer um dos factos , que verificam os valores das suas entradas, ou afirmações , que verificam os estados de um ou mais qubits passados como entrada.These conditions can come in the form of either facts , which check the values of their inputs, or assertions , which check the states of one or more qubits passed as input.

Por exemplo, EqualityFactI(1 + 1, 2, "1 + 1 != 2") representa o facto matemático de que $1 + 1 = 2$, enquanto representa a condição de que a AssertQubit(One, qubit) medição qubit devolverá um com One certeza.For example, EqualityFactI(1 + 1, 2, "1 + 1 != 2") represents the mathematical fact that $1 + 1 = 2$, while AssertQubit(One, qubit) represents the condition that measuring qubit will return a One with certainty. No primeiro caso, podemos verificar a correção da condição dado apenas os seus valores, enquanto neste último, temos de saber algo sobre o estado do qubit para avaliar a afirmação.In the former case, we can check the correctness of the condition given only its values, while in the latter, we must know something about the state of the qubit in order to evaluate the assertion.

As Q# bibliotecas-padrão fornecem várias funções diferentes para representar factos, incluindo:The Q# standard libraries provide several different functions for representing facts, including:

Teste estados qubitTesting Qubit States

Na prática, as afirmações baseiam-se no facto de que as simulações clássicas da mecânica quântica não precisam de obedecer ao teorema da não clonagem,de modo a podermos fazer medições e afirmações não físicas quando usamos um simulador para a nossa máquina-alvo.In practice, assertions rely on the fact that classical simulations of quantum mechanics need not obey the no-cloning theorem, such that we can make unphysical measurements and assertions when using a simulator for our target machine. Assim, podemos testar operações individuais num simulador clássico antes de implementar em hardware.Thus, we can test individual operations on a classical simulator before deploying on hardware. Nas máquinas-alvo que não permitem a avaliação de afirmações, as chamadas AssertMeasurement operation podem ser ignoradas com segurança.On target machines which do not allow evaluation of assertions, calls to AssertMeasurement operation can be safely ignored.

De uma forma mais geral, a AssertMeasurement operation operação afirma que a medição dos qubits dados na base pauli dada terá sempre o resultado dado.More generally, the AssertMeasurement operation operation asserts that measuring the given qubits in the given Pauli basis will always have the given result. Se a afirmação falhar, a corrida termina ligando fail com a mensagem dada.If the assertion fails, the run ends by calling fail with the given message. Por predefinição, esta operação não é implementada; os simuladores que podem apoiá-lo devem fornecer uma implementação que executa a verificação do tempo de execução.By default, this operation is not implemented; simulators that can support it should provide an implementation that performs runtime checking. AssertMeasurement tem assinatura ((Pauli[], Qubit[], Result, String) -> ()) .AssertMeasurement has signature ((Pauli[], Qubit[], Result, String) -> ()). Uma vez AssertMeasurement que é uma função com um tuple vazio como seu tipo de saída, nenhum efeito de ter chamado AssertMeasurement são observáveis dentro de um Q# programa.Since AssertMeasurement is a function with an empty tuple as its output type, no effects from having called AssertMeasurement are observable within a Q# program.

A AssertMeasurementProbability operation função de operação afirma que a medição dos qubits dados na dada base Pauli terá o resultado dado com a probabilidade dada, dentro de alguma tolerância.The AssertMeasurementProbability operation operation function asserts that measuring the given qubits in the given Pauli basis will have the given result with the given probability, within some tolerance. A tolerância é aditivo (por exemplo, abs(expected-actual) < tol ).Tolerance is additive (for example, abs(expected-actual) < tol). Se a afirmação falhar, a corrida termina ligando fail com a mensagem dada.If the assertion fails, the run ends by calling fail with the given message. Por predefinição, esta operação não é implementada; os simuladores que podem apoiá-lo devem fornecer uma implementação que executa a verificação do tempo de execução.By default, this operation is not implemented; simulators that can support it should provide an implementation that performs runtime checking. AssertMeasurementProbability tem assinatura ((Pauli[], Qubit[], Result, Double, String, Double) -> Unit) .AssertMeasurementProbability has signature ((Pauli[], Qubit[], Result, Double, String, Double) -> Unit). O primeiro dos Double parâmetros dá a probabilidade desejada do resultado, e o segundo a tolerância.The first of Double parameters gives the desired probability of the result, and the second one the tolerance.

Podemos fazer mais do que afirmar uma única medição, usando que a informação clássica utilizada por um simulador para representar o estado interno de um qubit é passível de copiar, de modo que não precisamos realmente de realizar uma medição para testar a nossa afirmação.We can do more than assert a single measurement, using that the classical information used by a simulator to represent the internal state of a qubit is amenable to copying, such that we do not need to actually perform a measurement to test our assertion. Em particular, isto permite-nos raciocinar sobre medições incompatíveis que seriam impossíveis em hardware real.In particular, this allows us to reason about incompatible measurements that would be impossible on actual hardware.

Suponha que P : Qubit => Unit seja uma operação destinada a preparar o estado $\ket{\psi}$ quando a sua entrada estiver no estado $\ket {0} $.Suppose that P : Qubit => Unit is an operation intended to prepare the state $\ket{\psi}$ when its input is in the state $\ket{0}$. Deixe $\ket{\psi'}$ ser o estado real preparado por P .Let $\ket{\psi'}$ be the actual state prepared by P. Em seguida, $\ket{\psi} = \ket{\psi'}$ se e somente se medir $\ket{\psi}} no eixo descrito por $\ket{\psi}$ sempre regressa Zero .Then, $\ket{\psi} = \ket{\psi'}$ if and only if measuring $\ket{\psi'}$ in the axis described by $\ket{\psi}$ always returns Zero. Ou seja, \start{align} \ket{\psi} = \ket{\psi}} \text{ if if } \braket{\psi \ \psi'} = 1.That is, \begin{align} \ket{\psi} = \ket{\psi'} \text{ if and only if } \braket{\psi | \psi'} = 1. \end{align} Utilizando as operações primitivas definidas no prelúdio, podemos efetuar diretamente uma medição que retorne Zero se $\ket{\psi}} for um eigenstate de um dos operadores pauli.\end{align} Using the primitive operations defined in the prelude, we can directly perform a measurement that returns Zero if $\ket{\psi}$ is an eigenstate of one of the Pauli operators.

A operação AssertQubit operation fornece uma abreviatura particularmente útil para fazê-lo no caso de pretendermos testar a afirmação $\ket{\psi} = \ket {0} $.The operation AssertQubit operation provides a particularly useful shorthand to do so in the case that we wish to test the assertion $\ket{\psi} = \ket{0}$. Isto é comum, por exemplo, quando não temos acomputação de devolver os qubits de ancilla a $\ket {0} $ antes de os libertar.This is common, for instance, when we have uncomputed to return ancilla qubits to $\ket{0}$ before releasing them. Afirmar contra $\ket {0} $ também é útil quando queremos afirmar que duas preparações e operações estatais preparam o mesmo P Q estado, e quando Q Adjoint apoiamos .Asserting against $\ket{0}$ is also useful when we wish to assert that two state preparation P and Q operations both prepare the same state, and when Q supports Adjoint. Em particular,In particular,

using (register = Qubit()) {
    P(register);
    Adjoint Q(register);

    AssertQubit(Zero, register);
}

De um modo mais geral, porém, podemos não ter acesso a afirmações sobre estados que não coincidem com os estados da Eigenstates dos operadores da Pauli.More generally, however, we may not have access to assertions about states that do not coincide with eigenstates of Pauli operators. Por exemplo, $\ket{\psi} = (\ket {0} + e^{i \pi / 8} \ket {1} ) / \sqrt {2} $ não é um eigenstate de qualquer operador Pauli, de modo que não podemos usar AssertMeasurementProbability operation para determinar exclusivamente que um estado $\ket{\psi'}$ é igual a $\ket{\psi}$.For example, $\ket{\psi} = (\ket{0} + e^{i \pi / 8} \ket{1}) / \sqrt{2}$ is not an eigenstate of any Pauli operator, such that we cannot use AssertMeasurementProbability operation to uniquely determine that a state $\ket{\psi'}$ is equal to $\ket{\psi}$. Em vez disso, temos de decompor a afirmação $\ket{\psi}} = \ket{\psi}$ em pressupostos que podem ser testados diretamente usando os primitivos suportados pelo nosso simulador.Instead, we must decompose the assertion $\ket{\psi'} = \ket{\psi}$ into assumptions that can be directly tested using the primitives supported by our simulator. Para tal, deixe $\ket{\psi} = \alfa \ket {0} + \beta \ket {1} $ para números complexos $\alpha = a _ r + a _ i$ e $\beta$.To do so, let $\ket{\psi} = \alpha \ket{0} + \beta \ket{1}$ for complex numbers $\alpha = a_r + a_i i$ and $\beta$. Note que esta expressão requer quatro números reais $ { a _ r, a _ i, _ b, b _ i $ para especificar, uma vez que cada número complexo pode ser expresso como a soma } de uma parte real e imaginária.Note that this expression requires four real numbers ${a_r, a_i, b_r, b_i}$ to specify, as each complex number can be expressed as the sum of a real and imaginary part. Devido à fase global, no entanto, podemos escolher $a _ i = 0$, de modo que só precisamos de três números reais para especificar um estado de um único qubit.Due to the global phase, however, we can choose $a_i = 0$, such that we only need three real numbers to uniquely specify a single-qubit state.

Assim, precisamos de especificar três afirmações que são independentes umas das outras para afirmar o estado que esperamos.Thus, we need to specify three assertions which are independent of each other in order to assert the state that we expect. Fazemos isso encontrando a probabilidade de observar Zero para cada medida Pauli dado $\alpha$ e $\beta$, e afirmando cada um de forma independente.We do so by finding the probability of observing Zero for each Pauli measurement given $\alpha$ and $\beta$, and asserting each independently. Deixe $x$, $y$, e $z$ sejam Result valores para as medições de Pauli $X$, $Y$e $Z$ respectivamente.Let $x$, $y$, and $z$ be Result values for Pauli $X$, $Y$, and $Z$ measurements respectively. Em seguida, utilizando a função de probabilidade para medições quânticas, \begin{align} \Pr(x = \texttt{Zero} / \alpha, \beta) & = \frac12 + a _ r b r + a i b i _ _ _ \ \ \Pr(y = \texttt{Zero} / \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \alpha, \beta) & = \frac12 + a r b _ i - a i b _ _ _ \ \ \Pr(z = \texttt{Zero} ] \ alpha, \beta) & = \frac12\left( 1 + a _ r^2 + a _ i^2 + b _ r^2 + b _ i^2 \direita).Then, using the likelihood function for quantum measurements, \begin{align} \Pr(x = \texttt{Zero} | \alpha, \beta) & = \frac12 + a_r b_r + a_i b_i \\ \Pr(y = \texttt{Zero} | \alpha, \beta) & = \frac12 + a_r b_i - a_i b_r \\ \Pr(z = \texttt{Zero} | \alpha, \beta) & = \frac12\left( 1 + a_r^2 + a_i^2 + b_r^2 + b_i^2 \right). \end{align}\end{align}

A AssertQubitIsInStateWithinTolerance operation operação implementa estas afirmações dadas representações de $\alpha$ e $\beta$ como valores do tipo Complex user defined type .The AssertQubitIsInStateWithinTolerance operation operation implements these assertions given representations of $\alpha$ and $\beta$ as values of type Complex user defined type. Isto é útil quando o estado esperado pode ser calculado matematicamente.This is helpful when the expected state can be computed mathematically.

Afirmação da Igualdade das Operações QuânticasAsserting Equality of Quantum Operations

Até agora, temos estado preocupado com as operações de ensaio que se destinam a preparar determinados Estados.Thus far, we have been concerned with testing operations which are intended to prepare particular states. Muitas vezes, porém, estamos interessados em como uma operação age para inputs arbitrários e não para uma única entrada fixa.Often, however, we are interested in how an operation acts for arbitrary inputs rather than for a single fixed input. Por exemplo, suponhamos que implementámos uma operação U : ((Double, Qubit[]) => () : Adjoint) correspondente a uma família de operadores unitários $U(t)$, e fornecemos um bloco explícito em vez de utilizar adjoint adjoint auto .For example, suppose we have implemented an operation U : ((Double, Qubit[]) => () : Adjoint) corresponding to a family of unitary operators $U(t)$, and have provided an explicit adjoint block instead of using adjoint auto. Podemos estar interessados em afirmar que $U^\dagger(t) = U(-t)$, como esperado se $t$ representar um tempo de evolução.We may be interested in asserting that $U^\dagger(t) = U(-t)$, as expected if $t$ represents an evolution time.

Em termos gerais, existem duas estratégias diferentes que podemos seguir para afirmar que duas operações U e agir de forma V idêntica.Broadly speaking, there are two different strategies that we can follow in making the assertion that two operations U and V act identically. Primeiro, podemos verificar se U(target); (Adjoint V)(target); preserva cada estado numa determinada base.First, we can check that U(target); (Adjoint V)(target); preserves each state in a given basis. Segundo, podemos verificar se U(target); (Adjoint V)(target); agir em metade de um estado emaranhado preserva esse emaranhado.Second, we can check that U(target); (Adjoint V)(target); acting on half of an entangled state preserves that entanglement. Estas estratégias são implementadas pelas operações canónicas AssertOperationsEqualInPlace operation AssertOperationsEqualReferenced operation e, respectivamente.These strategies are implemented by the canon operations AssertOperationsEqualInPlace operation and AssertOperationsEqualReferenced operation, respectively.

Nota

A afirmação referida discutida acima de obras baseadas no isomorfismo Choi-Jamiłkowski, um quadro matemático que relaciona operações em $n$ qubits a estados emaranhados em qubits de $2n$The referenced assertion discussed above works based on the Choi–Jamiłkowski isomorphism, a mathematical framework which relates operations on $n$ qubits to entangled states on $2n$ qubits. Em particular, a operação de identidade em $n$ qubits é representada por cópias $n$ do estado emaranhado $\ket{\beta_ {00} } \mathrel{:=} (\ket {00} + \ket) {11} / \sqrt {2} $.In particular, the identity operation on $n$ qubits is represented by $n$ copies of the entangled state $\ket{\beta_{00}} \mathrel{:=} (\ket{00} + \ket{11}) / \sqrt{2}$. A operação PrepareChoiState operation implementa este isomorfismo, preparando um estado que representa uma determinada operação.The operation PrepareChoiState operation implements this isomorphism, preparing a state that represents a given operation.

Grosso modo, estas estratégias distinguem-se por uma troca temporal.Roughly, these strategies are distinguished by a time–space tradeoff. A iteração através de cada estado de entrada leva tempo adicional, enquanto a utilização do emaranhado como referência requer o armazenamento de qubits adicionais.Iterating through each input state takes additional time, while using entanglement as a reference requires storing additional qubits. Nos casos em que uma operação implementa uma operação clássica reversível, de tal forma que só estamos interessados no seu comportamento em estados computacionais, AssertOperationsEqualInPlaceCompBasis operation testa a igualdade neste restrito conjunto de entradas.In cases where an operation implements a reversible classical operation, such that we are only interested in its behavior on computational basis states, AssertOperationsEqualInPlaceCompBasis operation tests equality on this restricted set of inputs.

Dica

A iteração sobre os estados de entrada é tratada pelas operações de enumeração IterateThroughCartesianProduct operation e IterateThroughCartesianPower operation .The iteration over input states is handled by the enumeration operations IterateThroughCartesianProduct operation and IterateThroughCartesianPower operation. Estas operações são úteis de forma mais geral para a aplicação de uma operação a cada elemento do produto Cartesiano entre dois ou mais conjuntos.These operations are useful more generally for applying an operation to each element of the Cartesian product between two or more sets.

No entanto, mais criticamente, as duas abordagens testam diferentes propriedades das operações em análise.More critically, however, the two approaches test different properties of the operations under examination. Uma vez que a afirmação no local chama cada operação várias vezes, uma vez para cada estado de entrada, quaisquer escolhas aleatórias e resultados de medição podem mudar entre chamadas.Since the in-place assertion calls each operation multiple times, once for each input state, any random choices and measurement results might change between calls. Em contrapartida, a afirmação referenciada chama a cada operação exatamente uma vez, de modo a verificar se as operações são iguais num único tiro .By contrast, the referenced assertion calls each operation exactly once, such that it checks that the operations are equal in a single shot . Ambos os testes são úteis para garantir a correção dos programas quânticos.Both of these tests are useful in ensuring the correctness of quantum programs.

Ler MaisFurther Reading