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 início rápido, irá:

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 Entanglement.qs. A extensão .qs denota um Q# programa.

Escreva o seu Q# código

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

Definir um namespace

Cada Q# programa começa com um namespace definido pelo usuário, que ajuda você a organizar a funcionalidade relacionada. Para este início rápido, seu namespace é BellPair:

namespace BellPair {
    // Your code goes here.
}

Abrir 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 abrir a biblioteca relevante.

Em seu BellPair namespace, use uma open instrução para importar a Microsoft.Quantum.Diagnostics biblioteca. Isso lhe dá acesso a todas as suas funções e operações, incluindo DumpMachine(), que você usa posteriormente para exibir o estado emaranhado.

    open Microsoft.Quantum.Diagnostics;

Definir uma operação

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

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

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

Alocar dois qubits

A EntangleQubits 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 (\ket{00}+\ket{{11}).${1}{\sqrt{2}}

Exibir o estado emaranhado

Antes de medir os qubits, é importante verificar se o código anterior os entrelaça com êxito. Você pode usar a DumpMachine operação, que faz parte da Microsoft.Quantum.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 colapsar seus estados quânticos em Zero ou One com probabilidade mesmo.

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 no final de cada Q# programa, os $\ket{0}$ qubits devem estar no estado. 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 EntangleQubits 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. Antes de executar o programa, use o @EntryPoint() atributo para informar ao compilador por onde começar a Q# executar o programa. Cada Q# programa deve conter um @EntryPoint()arquivo . Neste caso, coloque @EntryPoint() antes da EntangleQubits operação.

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

namespace BellPair {
    open Microsoft.Quantum.Diagnostics;
        
    @EntryPoint()
    operation EntangleQubits() : (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 em @EntryPoint() 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#o , consulte Tutorial: Explore o emaranhamento quântico com Q#o . 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.