Guia de início rápido: crie seu primeiro Q# programa

Aprenda a escrever um programa básico Q# que demonstre o emaranhamento, um conceito-chave da computação quântica.

Quando dois ou mais qubits estão entrelaçados, eles compartilham informações quânticas, o que significa que o que acontece com um qubit também acontece com o outro. Neste início rápido, você cria um estado emaranhado de dois qubits específico chamado par Bell. Em um par de Bell, se você medir um qubit no $\ket{0}$ estado, você sabe que o outro qubit também está no $\ket{0}$ estado sem medi-lo. Para obter mais informações, consulte Emaranhamento quântico.

Neste tutorial rápido, você:

Pré-requisitos

• A versão mais recente do Visual Studio Code.
• A extensão do Azure Quantum Development Kit (QDK). Para obter detalhes da instalação, consulte Configurar o Quantum Development Kit.

Criar um Q# ficheiro

1. Abra o Visual Studio Code.
2. Selecione Arquivo>Novo Arquivo de Texto.
3. Guarde o ficheiro como Main.qs. A extensão .qs denota um Q# programa.

Escreva o seu Q# código

No seu Main.qs ficheiro, siga estes passos para entrelaçar e medir um par de qubits.

Importar uma biblioteca quântica

O QDK inclui a Q# biblioteca padrão com funções e operações predefinidas para seus programas quânticos. Para usá-los, você deve primeiro importar a biblioteca relevante.

No seu programa, utilize a instrução import para abrir a biblioteca Std.Diagnostics. Isso lhe dá acesso a todas as funções e operações da biblioteca, incluindo DumpMachine, que você usa posteriormente para exibir o estado emaranhado.

import Std.Diagnostics.*;

Definir uma operação

Depois de importar as bibliotecas relevantes, defina sua operação quântica e seus valores de entrada e saída. Para este arranque rápido, a sua operação é Main. É aqui que você escreverá o código restante Q# para alocar, manipular e medir dois qubits.

Main não usa parâmetros e retorna dois Result valores, um Zero ou One, que representam os resultados das medições de qubit:

    operation Main() : (Result, Result) {
        // Your entanglement code goes here.
}

Alocar dois qubits

A Main operação está atualmente vazia, então a próxima etapa é alocar dois qubits, q1 e q2. No Q#, você aloca qubits usando a use palavra-chave:

        // Allocate two qubits, q1 and q2, in the 0 state.
        use (q1, q2) = (Qubit(), Qubit());

Coloque um qubit em superposição

Os qubits q1 e q2 estão no $\ket{0}$ estado. Para preparar os qubits para o emaranhamento, você deve colocar um deles em uma superposição uniforme, onde tem 50% de chance de ser medido como $\ket{0}$ ou $\ket{1}$.

Você coloca um qubit em superposição aplicando a operação Hadamard, H, :

        // Put q1 into an even superposition.
        H(q1);

O estado resultante de q1 é $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1}),$ que é uma superposição uniforme de $\ket{0}$ e $\ket{{1}$.

Emaranhar os qubits

Agora você está pronto para entrelaçar os qubits usando a operação controlled-NOT, CNOT, . CNOT é uma operação de controle que leva dois qubits, um atuando como o controle e o outro como o alvo.

Para este início rápido, você define q1 como o qubit de controle e q2 como o qubit de destino. Isso significa CNOT inverter o estado de q2 quando o estado de q1 é $\ket{1}$.

        // Entangle q1 and q2, making q2 depend on q1.
        CNOT(q1, q2);

O estado resultante de ambos os qubits é o par $\frac{Bell ({1}{\sqrt{2}}+\ket{00}\ket{).{11}$

Exibir o estado emaranhado

Antes de medir os qubits, é importante verificar se o código anterior os entrelaça com êxito. Use a DumpMachine operação, que faz parte da Std.Diagnostics biblioteca, para produzir o estado atual do seu Q# programa:

    // Show the entangled state of the qubits.
    DumpMachine();

Meça os qubits

Agora que você verificou que os qubits estão entrelaçados, você pode usar a M operação para medi-los. Medir q1 e q2 colapsa os seus estados quânticos em Zero ou One com a mesma probabilidade.

No Q#, você usa a let palavra-chave para declarar uma nova variável. Para armazenar os resultados da medição de q1 e q2, declare as variáveis m1 e m2, respectivamente:

        // Measure q1 and q2 and store the results in m1 and m2.
        let (m1, m2) = (M(q1), M(q2));

Redefinir os qubits

Antes de serem lançados, os qubits devem estar no estado Q# no final de cada programa $\ket{0}$. Você faz isso usando a Reset operação:

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

Devolver os resultados da medição

Finalmente, para concluir a Main operação e observar o estado emaranhado, retorne os resultados da medição de m1 e m2:

        // Return the measurement results.
        return (m1, m2);

Execute o seu Q# código

Parabéns! Você escreveu um Q# programa que entrelaça dois qubits e cria um par Bell.

O seu programa final Q# deve ter o seguinte aspeto:

import Std.Diagnostics.*;

operation Main() : (Result, Result) {  
    // Allocate two qubits, q1 and q2, in the 0 state.
    use (q1, q2) = (Qubit(), Qubit());
    
    // Put q1 into an even superposition.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q1);
    
    // Entangle q1 and q2, making q2 depend on q1.
    CNOT(q1, q2);
    
    // Show the entangled state of the qubits.
    DumpMachine();
    
    // Measure q1 and q2 and store the results in m1 and m2.
    let (m1, m2) = (M(q1), M(q2));
    
    // Reset q1 and q2 to the 0 state.
    Reset(q1);
    Reset(q2);
    
    // Return the measurement results.
    return (m1, m2);
}

Para executar o programa e visualizar o resultado de ambos os qubits, selecione Executar acima da Main operação ou pressione Ctrl+F5

Você pode executar o programa várias vezes, cada uma com um resultado diferente no console de depuração. Isso demonstra a natureza probabilística das medições quânticas e o emaranhamento dos qubits.

Por exemplo, se o resultado for Zero, seu console de depuração deverá ter esta aparência:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
  |11⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

Result: "(Zero, Zero)"

Próximo passo

Para saber mais sobre o emaranhamento quântico com Q#, consulte Tutorial: Explore o emaranhamento quântico com Q#. Este tutorial expande os conceitos abordados neste guia de início rápido e ajuda você a escrever um programa de emaranhamento mais avançado.