Tutorial: Explorar o entrelaçamento com Q#Tutorial: Explore entanglement with Q#

Neste tutorial, mostramos-lhe como escrever um Q# programa que manipula e mede qubits e demonstra os efeitos da superposição e do emaranhado.In this tutorial, we show you how to write a Q# program that manipulates and measures qubits and demonstrates the effects of superposition and entanglement.

Vai escrever uma aplicação denominada Bell para demonstrar o entrelaçamento quântico.You will write an application called Bell to demonstrate quantum entanglement. O nome Bell refere-se aos estados de Bell, que são estados quânticos específicos de dois qubits, utilizados para representar os exemplos mais simples de sobreposição e de entrelaçamento quântico.The name Bell is in reference to Bell states, which are specific quantum states of two qubits that are used to represent the simplest examples of superposition and quantum entanglement.

Pré-requisitosPre-requisites

Se estiver preparado para começar a programar, siga estes passos antes de continuar:If you are ready to start coding, follow these steps before proceeding:

  • Instale o Kit de Desenvolvimento Quântico utilizando o seu ambiente de linguagem e desenvolvimento preferido.Install the Quantum Development Kit using your preferred language and development environment.
  • Se já tiver o QDK instalado, confirme que o atualizou para a versão mais recenteIf you already have the QDK installed, make sure you have updated to the latest version

Também pode acompanhar a narrativa sem instalar o QDK, revendo as visãos gerais da linguagem de Q# programação e os primeiros conceitos de computação quântica.You can also follow along with the narrative without installing the QDK, reviewing the overviews of the Q# programming language and the first concepts of quantum computing.

Neste tutorial, irá aprender a:In this tutorial, you'll learn how to:

  • Criar e combinar operações em Q#Create and combine operations in Q#
  • Criar operações para colocar qubits em superposição, enredar e medi-los.Create operations to put qubits in superposition, entangle and measure them.
  • Demonstre o emaranhado quântico com um Q# programa executado num simulador.Demonstrate quantum entanglement with a Q# program run in a simulator.

Demonstrando comportamento qubit com o QDKDemonstrating qubit behavior with the QDK

Enquanto os bits clássicos contêm um único valor binário como 0 ou 1, o estado de um qubit pode estar numa sobreposição de 0 e 1.Where classical bits hold a single binary value such as a 0 or 1, the state of a qubit can be in a superposition of 0 and 1. Conceptualmente, o estado de um qubit pode ser considerado como uma direção em um espaço abstrato (também conhecido como um vetor).Conceptually, the state of a qubit can be thought of as a direction in an abstract space (also known as a vector). Um estado qubit pode estar em qualquer uma das direções possíveis.A qubit state can be in any of the possible directions. Os dois estados clássicos são as duas direções, que representam 100% de probabilidade de medir 0 e 100% de probabilidade de medir 1.The two classical states are the two directions; representing 100% chance of measuring 0 and 100% chance of measuring 1.

O ato de medição produz um resultado binário e altera o estado de um qubit.The act of measurement produces a binary result and changes a qubit state. A medição produz um valor binário, 0 ou 1.Measurement produces a binary value, either 0 or 1. O qubit vai do estado de sobreposição (qualquer direção) até um dos estados clássicos.The qubit goes from being in superposition (any direction) to one of the classical states. Depois disso, repetir a mesma medição sem nenhuma operação intermediária produz o mesmo resultado binário.Thereafter, repeating the same measurement without any intervening operations produces the same binary result.

É possível entrelaçar vários qubits.Multiple qubits can be entangled. Quando fazemos a medição de um qubit entrelaçado, o nosso conhecimento do estado do(s) outro(s) também é atualizado.When we make a measurement of one entangled qubit, our knowledge of the state of the other(s) is updated as well.

Estamos prontos para demonstrar como Q# expressa este comportamento.Now, we're ready to demonstrate how Q# expresses this behavior. Vai começar com o programa mais simples possível e compilá-lo para demonstrar a sobreposição quântica e o entrelaçamento quântico.You start with the simplest program possible and build it up to demonstrate quantum superposition and quantum entanglement.

Criar um Q# projetoCreating a Q# project

A primeira coisa a fazer é criar um novo Q# projeto.The first thing we have to do is to create a new Q# project. Neste tutorial vamos utilizar o ambiente com base em Q# aplicações com o Código VS.In this tutorial we are going to use the environment based on Q# applications with VS Code.

Para criar um novo projeto, em Código VS:To create a new project, in VS Code:

  1. Clique em View (Ver) -> Command Palette (Paleta de Comandos) e selecione Q#: Create New Project (Criar Novo Projeto).Click View -> Command Palette and select Q#: Create New Project .
  2. Clique em Standalone console application (Aplicação de consola autónoma).Click Standalone console application .
  3. Navegue para a localização para guardar o projeto e clique em Create Project (Criar Projeto).Navigate to the location to save the project and click Create Project .
  4. Após a criação do projeto, clique em Open new project... (Abrir novo projeto...) no canto inferior direito.When the project is successfully created, click Open new project... in the lower right.

Neste caso, chamámos o Bell projeto.In this case we called the project Bell. Isto gera dois ficheiros: Bell.csproj o ficheiro do projeto Program.qs e, um modelo de uma Q# aplicação que usaremos para escrever a nossa aplicação.This generates two files: Bell.csproj, the project file and Program.qs, a template of a Q# application that we will use to write our application. O conteúdo Program.qs deve ser:The content of Program.qs should be:

   namespace Bell {

      open Microsoft.Quantum.Canon;
      open Microsoft.Quantum.Intrinsic;
    

      @EntryPoint()
      operation HelloQ() : Unit {
          Message("Hello quantum world!");
      }
   }

Escreva a # aplicação QWrite the Q# application

O nosso objetivo é preparar dois qubits num estado quântico específico, demonstrando como operar em qubits Q# para mudar o seu estado e demonstrar os efeitos da sobreposição e do emaranhado.Our goal is to prepare two qubits in a specific quantum state, demonstrating how to operate on qubits with Q# to change their state and demonstrate the effects of superposition and entanglement. Vamos construir isto peça a peça para introduzir estados qubit, operações e medição.We will build this up piece by piece to introduce qubit states, operations, and measurement.

Inicialize o qubit usando a mediçãoInitialize qubit using measurement

No primeiro corte de código abaixo, mostramos-lhe como trabalhar com qubits em Q# .In the first code snippet below, we show you how to work with qubits in Q#. Vamos introduzir duas operações, M e X que transformam o estado de um qubit.We’ll introduce two operations, M and X that transform the state of a qubit. Neste fragmento de código, é definida uma operação SetQubitState, que utiliza um qubit como parâmetro e outro parâmetro, desired, que representa o estado em que queremos que o qubit esteja.In this code snippet, an operation SetQubitState is defined that takes as a parameter a qubit and another parameter, desired, representing the state that we would like the qubit to be in. A operação SetQubitState executa uma medição no qubit através da operação M.The operation SetQubitState performs a measurement on the qubit using the operation M. Em Q# , uma medição de qubit sempre retorna ou Zero . One .In Q#, a qubit measurement always returns either Zero or One. Se a medição devolver um valor não igual ao valor pretendido, SetQubitState "inverte" o qubit; ou seja, executa uma X operação, que altera o estado qubit para um novo estado em que as probabilidades de uma medição regressam Zero e são One invertidas.If the measurement returns a value not equal to the desired value, SetQubitState “flips” the qubit; that is, it runs an X operation, which changes the qubit state to a new state in which the probabilities of a measurement returning Zero and One are reversed. Desta forma, SetQubitState coloca sempre o qubit alvo no estado desejado.This way, SetQubitState always puts the target qubit in the desired state.

Substitua o conteúdo do Program.qs seguinte código:Replace the contents of Program.qs with the following code:

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Canon;

       operation SetQubitState(desired : Result, q1 : Qubit) : Unit {
           if (desired != M(q1)) {
               X(q1);
           }
       }
   }

Esta operação agora pode ser chamada para definir um qubit para um estado clássico, ao devolver Zero ou One 100% do tempo.This operation may now be called to set a qubit to a classical state, either returning Zero 100% of the time or returning One 100% of the time. Zero e One são constantes que representam os dois únicos resultados possíveis da medição de um qubit.Zero and One are constants that represent the only two possible results of a measurement of a qubit.

A operação SetQubitState mede o qubit.The operation SetQubitState measures the qubit. Se o qubit está no estado que SetQubitState queremos, deixa-o em paz; caso contrário, ao executar a X operação, mudamos o estado qubit para o estado desejado.If the qubit is in the state we want, SetQubitState leaves it alone; otherwise, by running the X operation, we change the qubit state to the desired state.

Sobre Q# operaçõesAbout Q# operations

Uma Q# operação é uma sub-rotina quântica.A Q# operation is a quantum subroutine. Ou seja, é uma rotina callable que contém chamadas para outras operações quânticas.That is, it is a callable routine that contains calls to other quantum operations.

Os argumentos para uma operação são especificados como uma cadeia de identificação, entre parênteses.The arguments to an operation are specified as a tuple, within parentheses.

O tipo de retorno da operação é especificado após os dois pontos.The return type of the operation is specified after a colon. Neste caso, a SetQubitState operação não tem tipo de retorno, pelo que está marcada como devolução Unit .In this case, the SetQubitState operation has no return type, so it is marked as returning Unit. Este é o Q# equivalente unit a em F#, que é aproximadamente análogo a void em C#, e um tuple vazio em Python () (, representado pelo tipo de sugestão). Tuple[()]This is the Q# equivalent of unit in F#, which is roughly analogous to void in C#, and an empty tuple in Python ((), represented by the type hint Tuple[()]).

Usaste duas operações quânticas na tua primeira Q# operação:You have used two quantum operations in your first Q# operation:

  • A M operação, que mede o estado do qubitThe M operation, which measures the state of the qubit
  • A X operação, que inverte o estado de um qubitThe X operation, which flips the state of a qubit

Uma operação quântica transforma o estado de um qubit.A quantum operation transforms the state of a qubit. Por vezes, as pessoas falam sobre portas quânticas em vez de operações, em analogia às portas de lógica clássicas eSometime people talk about quantum gates instead of operations, in analogy to classical logic gates. que tem origem nos primórdios da computação quântica quando os algoritmos eram meramente uma construção teórica e visualizados como diagramas da mesma forma que os diagramas de circuito na computação clássica.This is rooted in the early days of quantum computing when algorithms were merely a theoretical construct and visualized as diagrams similarly to circuit diagrams in classical computing.

Contagem dos resultados da mediçãoCounting measurement outcomes

Para demonstrar o efeito da operação SetQubitState, é adicionada uma operação TestBellState.To demonstrate the effect of the SetQubitState operation, a TestBellState operation is then added. Esta operação utiliza como entrada Zero ou One, chama a operação SetQubitState várias vezes com essa entrada e contabiliza o número de vezes que Zero foi devolvido pela medição do qubit e o número de vezes que One foi devolvido.This operation takes as input a Zero or One, and calls the SetQubitState operation some number of times with that input, and counts the number of times that Zero was returned from the measurement of the qubit and the number of times that One was returned. Como é óbvio, nesta primeira simulação da operação TestBellState, esperamos que o resultado mostre que todas as medições do conjunto de qubits com Zero como entrada de parâmetro devolva Zero e todas as medições de um conjunto de qubits com One como entrada de parâmetro devolva One.Of course, in this first simulation of the TestBellState operation, we expect that the output will show that all measurements of the qubit set with Zero as the parameter input will return Zero, and all measurements of a qubit set with One as the parameter input will return One. Mais à frente, vamos adicionar código TestBellState para demonstrar superposição e emaranhamento.Further on, we’ll add code to TestBellState to demonstrate superposition and entanglement.

Adicione a seguinte operação ao ficheiro Program.qs, dentro do espaço de nomes, após o fim da operação SetQubitState:Add the following operation to the Program.qs file, inside the namespace, after the end of the SetQubitState operation:

   operation TestBellState(count : Int, initial : Result) : (Int, Int) {

       mutable numOnes = 0;
       using (qubit = Qubit()) {

           for (test in 1..count) {
               SetQubitState(initial, qubit);
               let res = M(qubit);

               // Count the number of ones we saw:
               if (res == One) {
                   set numOnes += 1;
               }
           }
            
           SetQubitState(Zero, qubit);
       }

       // Return number of times we saw a |0> and number of times we saw a |1>
       Message("Test results (# of 0s, # of 1s): ");
       return (count - numOnes, numOnes);
   }

Note que adicionámos uma linha antes de return imprimir uma mensagem explicativa na consola com a função Message ()[microsoft.quantum.intrínseca.message]Note that we added a line before the return to print an explanatory message in the console with the function (Message)[microsoft.quantum.intrinsic.message]

Esta operação (TestBellState) vai gerar um ciclo de count iterações, definir um valor initial especificado num qubit e, em seguida, medir (M) o resultado.This operation (TestBellState) will loop for count iterations, set a specified initial value on a qubit and then measure (M) the result. Vai recolher estatísticas sobre quantos zeros e uns foram medidos e devolvê-los ao autor da chamada.It will gather statistics on how many zeros and ones we've measured and return them to the caller. E, executa ainda outra operação necessária.It performs one other necessary operation. Redefine o qubit para um estado conhecido (Zero) antes de o devolver, o que permitirá que outros aloquem este qubit num estado conhecido.It resets the qubit to a known state (Zero) before returning it allowing others to allocate this qubit in a known state. Esta operação é exigida pela instrução using.This is required by the using statement.

Sobre variáveis em Q#About variables in Q#

Por predefinição, as variáveis Q# são imutáveis; o seu valor não pode ser alterado após o seu limite.By default, variables in Q# are immutable; their value may not be changed after they are bound. A palavra-chave let é utilizada para indicar a vinculação de uma variável imutável.The let keyword is used to indicate the binding of an immutable variable. Os argumentos da operação são sempre imutáveis.Operation arguments are always immutable.

Se precisar de uma variável cujo valor pode ser alterado, como numOnes, poderá declarar a variável com a palavra-chave mutable.If you need a variable whose value can change, such as numOnes in the example, you can declare the variable with the mutable keyword. Um valor de variável mutável pode ser alterado com uma instrução set.A mutable variable's value may be changed using a set statement.

Em ambos os casos, o tipo de variável é inferido pelo compilador.In both cases, the type of a variable is inferred by the compiler. Q# não requer qualquer tipo de anotação para variáveis.Q# doesn't require any type annotations for variables.

Sobre using declarações em Q#About using statements in Q#

A using declaração também é especial para Q# .The using statement is also special to Q#. É utilizada para alocar qubits para utilização num bloco de código.It is used to allocate qubits for use in a block of code. Em Q# , todos os qubits são dinamicamente alocados e libertados, em vez de serem recursos fixos que estão lá para toda a vida de um algoritmo complexo.In Q#, all qubits are dynamically allocated and released, rather than being fixed resources that are there for the entire lifetime of a complex algorithm. Uma instrução using aloca um conjunto de qubits no início e liberta esses qubits no final do bloco.A using statement allocates a set of qubits at the start, and releases those qubits at the end of the block.

Executar o código a partir da solicitação de comandoRun the code from the command prompt

Para executar o código, precisamos dizer ao compilador que pode ser executado quando fornenciamos o dotnet run comando.In order to run the code we need to tell the compiler which callable to run when we provide the dotnet run command. Isto é feito com uma simples alteração no Q# ficheiro, adicionando uma linha com @EntryPoint() a ligação diretamente anterior à chamada: a TestBellState operação neste caso.This is done with a simple change in the Q# file by adding a line with @EntryPoint() directly preceding the callable: the TestBellState operation in this case. O código completo deve ser:The full code should be:

namespace Bell {
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if (desired != M(target)) {
            X(target);
        }
    }

    @EntryPoint()
    operation TestBellState(count : Int, initial : Result) : (Int, Int) {

        mutable numOnes = 0;
        using (qubit = Qubit()) {

            for (test in 1..count) {
                SetQubitState(initial, qubit);
                let res = M(qubit);

                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }

            SetQubitState(Zero, qubit);
        }

    // Return number of times we saw a |0> and number of times we saw a |1>
    Message("Test results (# of 0s, # of 1s): ");
    return (count - numOnes, numOnes);
    }
}

Para executar o programa precisamos especificar count e argumentos a partir do pedido de initial comando.To run the program we need to specify count and initial arguments from the command prompt. Vamos escolher por exemplo count = 1000 initial = One e.Let's choose for example count = 1000 and initial = One. Introduza o seguinte comando:Enter the following command:

dotnet run --count 1000 --initial One

E deve observar a seguinte saída:And you should observe the following output:

Test results (# of 0s, # of 1s):
(0, 1000)

Se tentar initial = Zero com o seu deve observar:If you try with initial = Zero you should observe:

dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(1000, 0)

Preparar a sobreposiçãoPrepare superposition

Agora vamos ver como Q# expressa formas de colocar qubits em superposição.Now let’s look at how Q# expresses ways to put qubits in superposition. Lembre-se de que o estado de um qubit pode estar numa sobreposição de 0 e 1.Recall that the state of a qubit can be in a superposition of 0 and 1. Vamos utilizar a operação Hadamard para esta ação.We’ll use the Hadamard operation to accomplish this. Se o qubit estiver num dos estados clássicos (em que uma medição devolve sempre Zero ou One), a operação Hadamard ou H colocará o qubit num estado em que uma medição do qubit devolverá Zero e One 50% do tempo.If the qubit is in either of the classical states (where a measurement returns Zero always or One always), then the Hadamard or H operation will put the qubit in a state where a measurement of the qubit will return Zero 50% of the time and return One 50% of the time. Conceitualmente, o qubit pode ser pensado como estando entre Zero e One.Conceputually, the qubit can be thought of as halfway between the Zero and One. Agora, quando simularmos a operação TestBellState, veremos que os resultados vão devolver aproximadamente um número igual de Zero e One após a medição.Now, when we simulate the TestBellState operation, we will see the results will return roughly an equal number of Zero and One after measurement.

X flips qubit estadoX flips qubit state

Primeiro vamos tentar virar o qubit (se o qubit estiver no Zero estado, vai virar para One e vice-versa).First we'll just try to flip the qubit (if the qubit is in Zero state it will flip to One and vice versa). Esta inversão pode ser feita ao realizar uma operação X antes de o medir em TestBellState:This is accomplished by performing an X operation before we measure it in TestBellState:

X(qubit);
let res = M(qubit);

Agora os resultados são invertidos:Now the results are reversed:

dotnet run --count 1000 --initial One
Test results (# of 0s, # of 1s):
(1000, 0)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(0, 1000)

Agora vamos explorar as propriedades quânticas dos qubits.Now let's explore the quantum properties of the qubits.

H prepara superposiçãoH prepares superposition

Para tal, só precisamos de substituir a operação X na execução anterior por uma operação H ou Hadamard.All we need to do is replace the X operation in the previous run with an H or Hadamard operation. Em vez de inverter totalmente o qubit de 0 para 1, vamos invertê-lo apenas metade.Instead of flipping the qubit all the way from 0 to 1, we will only flip it halfway. As linhas substituídas em TestBellState agora são semelhantes ao seguinte:The replaced lines in TestBellState now look like:

H(qubit);
let res = M(qubit);

Os resultados começam a ficar mais interessantes:Now the results get more interesting:

dotnet run --count 1000 --initial One
Test results (# of 0s, # of 1s):
(496, 504)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(506, 494)

Sempre que medimos, pedimos um valor clássico, mas o qubit encontra-se a meio entre 0 e 1 e assim obtemos (estatisticamente) 0 metade das vezes e 1 metade das vezes,Every time we measure, we ask for a classical value, but the qubit is halfway between 0 and 1, so we get (statistically) 0 half the time and 1 half the time. o quer é conhecido como sobreposição e dá-nos a nossa primeira vista real de um estado quântico.This is known as superposition and gives us our first real view into a quantum state.

Preparar o entrelaçamentoPrepare entanglement

Agora vamos ver como Q# expressa formas de envolver qubits.Now let’s look at how Q# expresses ways to entangle qubits. Primeiro, definimos o primeiro qubit para o estado inicial e utilizamos a operação H para colocá-lo em sobreposição.First, we set the first qubit to the initial state and then use the H operation to put it into superposition. Depois, antes de medirmos o primeiro qubit, usamos uma nova operação ( CNOT , que significa Controlled-NOT .Then, before we measure the first qubit, we use a new operation (CNOT), which stands for Controlled-NOT . O resultado da execução desta operação em dois qubits é virar o segundo qubit se o primeiro qubit for One .The result of running this operation on two qubits is to flip the second qubit if the first qubit is One. Agora, os dois qubits estão entrelaçados.Now, the two qubits are entangled. As nossas estatísticas para o primeiro qubit não foram alteradas (uma probabilidade de 50-50 de um Zero ou de um One após a medição), mas quando medirmos o segundo qubit, este será sempre igual ao que medimos para o primeiro qubit.Our statistics for the first qubit haven't changed (50-50 chance of a Zero or a One after measurement), but now when we measure the second qubit, it is always the same as what we measured for the first qubit. O nosso CNOT entrelaçou os dois qubits, de modo a que aquilo que acontecer a um deles, aconteça também ao outro.Our CNOT has entangled the two qubits, so that whatever happens to one of them, happens to the other. Se as medições fossem invertidas (a medição do segundo qubit antes do primeiro), aconteceria a mesma coisa.If you reversed the measurements (did the second qubit before the first), the same thing would happen. A primeira medida seria aleatória e a segunda estaria num passo bloqueado para a medição que tivesse sido detetada primeiro.The first measurement would be random and the second would be in lock step with whatever was discovered for the first.

A primeira coisa que temos de fazer é alocar dois qubits em vez de um TestBellState em:The first thing we'll need to do is allocate two qubits instead of one in TestBellState:

using ((q0, q1) = (Qubit(), Qubit())) {

Este procedimento vai permitir adicionar uma nova operação (CNOT) antes de medir (M) em TestBellState:This will allow us to add a new operation (CNOT) before we measure (M) in TestBellState:

SetQubitState(initial, q0);
SetQubitState(Zero, q1);

H(q0);
CNOT(q0, q1);
let res = M(q0);

Adicionámos outra operação SetQubitState para inicializar o primeiro qubit para confirmar que está sempre no estado Zero quando começamos.We've added another SetQubitState operation to initialize the first qubit to make sure that it's always in the Zero state when we start.

Precisamos também de redefinir o segundo qubit antes de o libertar.We also need to reset the second qubit before releasing it.

SetQubitState(Zero, q0);
SetQubitState(Zero, q1);

A rotina completa é agora semelhante ao seguinte:The full routine now looks like this:

    operation TestBellState(count : Int, initial : Result) : (Int, Int) {

        mutable numOnes = 0;
        using ((q0, q1) = (Qubit(), Qubit())) {
            for (test in 1..count) {
                SetQubitState(initial, q0);
                SetQubitState(Zero, q1);

                H(q0);
                CNOT(q0,q1);
                let res = M(q0);

                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }

            SetQubitState(Zero, q0);
            SetQubitState(Zero, q1);
        }

        // Return number of times we saw a |0> and number of times we saw a |1>
        return (count-numOnes, numOnes);
    }

Se a executarmos, vamos obter exatamente o mesmo resultado de 50-50 que obtivemos anteriormente.If we run this, we'll get exactly the same 50-50 result we got before. No entanto, o que nos interessa é a forma como o segundo qubit reage à primeira medição.However, what we're interested in is how the second qubit reacts to the first being measured. Vamos adicionar esta estatística com a nova versão da operação TestBellState:We'll add this statistic with a new version of the TestBellState operation:

    operation TestBellState(count : Int, initial : Result) : (Int, Int, Int) {
        mutable numOnes = 0;
        mutable agree = 0;
        using ((q0, q1) = (Qubit(), Qubit())) {
            for (test in 1..count) {
                SetQubitState(initial, q0);
                SetQubitState(Zero, q1);

                H(q0);
                CNOT(q0, q1);
                let res = M(q0);

                if (M(q1) == res) {
                    set agree += 1;
                }

                // Count the number of ones we saw:
                if (res == One) {
                    set numOnes += 1;
                }
            }
            
            SetQubitState(Zero, q0);
            SetQubitState(Zero, q1);
        }

        // Return times we saw |0>, times we saw |1>, and times measurements agreed
        Message("Test results (# of 0s, # of 1s, # of agreements)");
        return (count-numOnes, numOnes, agree);
    }

O novo valor de retorno (agree) controla cada vez que a medição do primeiro qubit corresponde à medição do segundo qubit.The new return value (agree) keeps track of every time the measurement from the first qubit matches the measurement of the second qubit.

Executando o código que obtemos:Running the code we obtain:

dotnet run --count 1000 --initial One
(505, 495, 1000)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s, # of agreements)
(507, 493, 1000)

Conforme mencionado na descrição geral, as nossas estatísticas para o primeiro qubit não foram alteradas (uma probabilidade de 50-50 de um 0 ou de um 1), mas quando medirmos o segundo qubit, este será sempre igual ao que medimos para o primeiro qubit, uma vez que estão entrelaçados!As stated in the overview, our statistics for the first qubit haven't changed (50-50 chance of a 0 or a 1), but now when we measure the second qubit, it is always the same as what we measured for the first qubit, because they are entangled!

Passos seguintesNext steps

A pesquisa do tutorial Grover mostra-lhe como construir e executar a pesquisa grover, um dos algoritmos de computação quântica mais populares e oferece um bom exemplo de um Q# programa que pode ser usado para resolver problemas reais com computação quântica.The tutorial Grover’s search shows you how to build and run Grover search, one of the most popular quantum computing algorithms and offers a nice example of a Q# program that can be used to solve real problems with quantum computing.

Começar com o Kit de Desenvolvimento Quântico recomenda mais formas de aprender Q# e programação quântica.Get Started with the Quantum Development Kit recommends more ways to learn Q# and quantum programming.