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

Artigo
10/29/2024

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 emaranhados, 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 de Bell. Em um par de Bell, se você medir um qubit no $\ket{0}$ estado, saberá 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, você:

Crie um arquivo do Q# .
Aloque um par de qubits.
Emaranhar os qubits.

Pré-requisitos

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

Criar um arquivo Q#

Abra o Visual Studio Code.
Selecione Arquivo>Novo arquivo de texto.
Salve o arquivo como Main.qs. A extensão .qs denota um Q# programa.

Escreva seu Q# código

Em seu Main.qs arquivo, siga estas etapas para emaranhar 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.

Em seu programa, use uma import instrução para abrir 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.

    import Microsoft.Quantum.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 início rápido, 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, ou 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á vazia no momento, portanto, q1 a próxima etapa é alocar dois qubits 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());

Observação

Em Q#, os qubits são sempre alocados no $\ket{0}$ estado.

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 par de $\ket{0}$ e $\ket{{1}$.

Emaranhar os qubits

Agora você está pronto para emaranhar os qubits usando a operação control-NOT, CNOT. CNOT é uma operação de controle que usa dois qubits, um atuando como controle e o outro como destino.

Para este início rápido, você define q1 como o qubit de controle e q2 como o qubit de destino. Isso significa inverte CNOT 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{de Bell (\ket{00}+\ket{{11}).${1}{\sqrt{2}}

Dica

Se você quiser saber como as operações Hadamard e CNOT transformam o estado dos qubits, consulte Criando emaranhamento com operações quânticas.

Exibir o estado emaranhado

Antes de medir os qubits, é importante verificar se o código anterior os enreda com êxito. Você pode usar a DumpMachine operação, que faz parte da Microsoft.Quantum.Diagnostics biblioteca, para gerar o estado atual do seu Q# programa:

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

Medir os qubits

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

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 liberados no final de cada Q# programa, os qubits devem estar no $\ket{0}$ estado. Você faz isso usando a Reset operação:

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

Retornar 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);

Dica

Se você quiser saber mais sobre uma Q# função ou operação, passe o mouse sobre ela.

Captura de tela dos detalhes que aparecem quando você passa o mouse sobre a operação 'H' no Visual Studio Code.

Executar seu Q# código

Parabéns! Você escreveu um Q# programa que emaranha dois qubits e cria um par de Bell.

Seu programa final Q# deve ficar assim:

import Microsoft.Quantum.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 exibir o resultado de ambos os qubits, selecione Executar acima da Main operação ou pressione Ctrl+F5

Captura de tela do Q# arquivo no Visual Studio Code mostrando onde encontrar o comando 'Executar'.

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 deve 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óxima etapa

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

Compartilhar via