Tutorial: Explore o emaranhamento quântico com Q#

Neste tutorial, escreves um Q# programa que prepara dois qubits num estado quântico específico, opera sobre os qubits para os entrelaçar entre si e realiza medições para demonstrar os efeitos da superposição e do emaranhamento. Constróis o teu Q# programa peça a peça para introduzir estados de qubits, operações quânticas e medições.

Antes de começar, reveja os seguintes conceitos de computação quântica:

Os bits clássicos possuem um único valor binário, como 0 ou 1, mas os qubits podem estar em uma superposição dos dois estados, 0 e 1. Cada estado de qubit possível é descrito por um conjunto de amplitudes de probabilidade.
Quando você mede o estado de um qubit, você sempre obtém 0 ou 1. A probabilidade de cada resultado é determinada pelas amplitudes de probabilidade que definem o estado de superposição quando você faz uma medição.
Vários qubits podem ser emaranhados de tal forma que você não pode descrevê-los independentemente uns dos outros. Quando você mede um qubit em um par emaranhado, você também obtém informações sobre o outro qubit sem medi-lo.

Neste tutorial, aprenderás como:

Crie Q# operações para inicializar um qubit para um estado desejado.
Coloque um qubit em um estado de superposição.
Enredar um par de qubits.
Meça um qubit e observe os resultados.

Gorjeta

Se você quiser acelerar sua jornada de computação quântica, confira Code with Azure Quantum, um recurso exclusivo do site Microsoft Quantum. Aqui, você pode executar amostras internas Q# ou seus próprios Q# programas, gerar novo Q# código a partir de seus prompts, abrir e executar seu código no VS Code for the Web com um clique e fazer perguntas ao Copilot sobre computação quântica.

Pré-requisitos

Para executar o exemplo de código com o Copilot para Azure Quantum, tens de ter uma conta de email da Microsoft (MSA).

Para obter mais informações sobre o Copilot para Azure Quantum, consulte Explore Azure Quantum.

Inicializar um qubit para um estado conhecido

O primeiro passo é definir uma Q# operação que inicializa um qubit para um estado clássico desejado, seja 0 ou 1. Esta operação mede um qubit num estado quântico geral, que devolve um Q#Result valor de tipo igual Zero a ou One. Se o resultado da medição for diferente do estado desejado, então a operação inverte o estado para que a operação devolva o estado desejado 100% do tempo.

Abre o Copilot para Azure Quantum, limpa o código padrão e depois copia o código seguinte para a janela do editor de código. Não consegues executar este código sozinho porque ainda não é um programa completo Q# .

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

O exemplo de código introduz duas operações padrão Q# , M e X, que transformam o estado de um qubit.

Aqui está uma descrição detalhada de como funciona a SetQubitState operação:

Utiliza dois parâmetros: um Result parâmetro tipo chamado desired que representa o estado desejado para o qubit estar em (Zero ou One), e um Qubit parâmetro tipo.
Realiza uma operação de medição, M, que mede o estado do qubit (Zero ou One) e compara o resultado com o valor que passa para desired.
Se o resultado da medição não corresponder ao valor para desired, então uma X operação é aplicada ao qubit. Esta operação inverte o estado do qubit de modo que as probabilidades de medição para Zero e One são invertidas.

Escrever uma operação de teste para testar o estado Bell

Para chamar a SetQubitState operação no seu Q# programa, crie outra operação chamada Main. Esta operação aloca dois qubits, chama SetQubitState para definir o primeiro qubit para um estado conhecido e depois mede os qubits para ver os resultados.

Copie o código seguinte para a janela do editor de código, após a SetQubitState operação.

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

No código, as count variáveis e initial são definidas como 1000 e One respectivamente. Isto inicializa o primeiro qubit para One e mede cada qubit 1000 vezes.

A Main operação faz o seguinte:

Define variáveis para o número de disparos (count) e o estado inicial do qubit (One).
Chama a use instrução para inicializar dois qubits.
Repete o experimento count vezes.
No ciclo, chama-se SetQubitState para definir o valor especificado initial no primeiro qubit, e depois chama-se SetQubitState novamente para definir o segundo qubit no estado Zero.
No ciclo, aplica a M operação para medir cada qubit e depois armazena o número de medições para cada qubit que retorna One.
Depois de o ciclo terminar, chama SetQubitState novamente para reiniciar os qubits para um estado conhecido (Zero). Deve redefinir os qubits que aloca com a use instrução.
Chama a função Message para imprimir os seus resultados na janela de saída.

Execute o código no Copilot para Azure Quantum

Antes de escreveres código para superposição e emaranhamento, testa o teu programa atual para ver a inicialização e medição dos qubits.

Para correr o teu código como um programa autónomo, o Q# compilador no Copilot precisa de saber por onde começar o programa. Como não especificaste um namespace, o compilador reconhece o ponto de entrada padrão como a Main operação. Para obter mais informações, consulte Projetos e namespaces implícitos.

O teu Q# programa agora é assim:

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

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Copie e cole o exemplo de código completo na janela de código Copilot for Azure Quantum , defina o slider para o número de disparos em "1" e depois escolha Executar. Os resultados são exibidos no histograma e nos campos Resultados .

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

O seu programa ainda não modifica os estados do qubit, por isso a medição do primeiro qubit retorna Onesempre , e o segundo qubit retorna Zerosempre .

Se mudares o valor de initial para Zero e executares o programa novamente, então o primeiro qubit também devolve Zerosempre .

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Colocar um qubit num estado de superposição

Atualmente, os qubits no teu programa estão num estado clássico, seja 1 ou 0, tal como os bits num computador normal. Para entrelaçar os qubits, deves primeiro colocar um dos qubits num estado de superposição igual. A medição de um qubit num estado de superposição igual tem 50% de devolver Zero e 50% de probabilidade de devolver One.

Para colocar um qubit num estado de superposição, use a Q#Hoperação , ou Hadamard. A H operação converte um qubit que está num estado puro Zero ou One numa espécie de estado intermédio entre Zero e One.

Modifica o teu código na Main operação. Redefina o valor inicial para One e insira uma linha para a H operação:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);  // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Executa o teu programa novamente. Como o primeiro qubit está numa superposição igual quando se mede, obtém-se um resultado próximo de 50/50 para Zero e One. Por exemplo, o seu resultado é semelhante a este:

Q1 - Zeros: 523
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Cada vez que executa o programa, os resultados do primeiro qubit variam ligeiramente, mas aproximam-se de 50% One e 50% Zero, enquanto os resultados do segundo qubit são sempre Zero.

Inicialize o primeiro qubit em Zero vez de One e execute o programa novamente. Obtém-se resultados semelhantes porque a H operação transforma tanto um estado puro Zero como um estado puro One num estado de superposição igual.

Nota

Para ver como os resultados da superposição variam ao longo da distribuição das fotos, mova o controle deslizante no Copilot para Azure Quantum e aumente o número de disparos.

Emaranhar dois qubits

Os qubits emaranhados estão correlacionados de tal forma que não podem ser descritos independentemente uns dos outros. Quando medes o estado de um qubit emaranhado, também conheces o estado do outro qubit sem o medir. Este tutorial usa um exemplo com dois qubits emaranhados, mas também podes entrelaçar três ou mais qubits.

Para criar um estado emaranhado, use a operação Q#CNOT, ou Controlled-NOT. Quando se aplica CNOT a dois qubits, um qubit é o qubit de controlo e o outro é o qubit alvo. Se o estado do qubit de controlo for One, então a CNOT operação inverte o estado do qubit alvo. Caso contrário, CNOT não faz nada aos qubits.

Adicione a CNOT operação ao seu programa imediatamente após a H operação. O teu programa completo é assim:

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

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
 }

Executa o programa e vê o resultado. Os teus resultados variam ligeiramente cada vez que executas o programa.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

As estatísticas para o primeiro qubit ainda mostram cerca de 50% de probabilidade de medir tanto One como Zero, mas os resultados da medição para o segundo qubit já não são sempre Zero. Cada qubit tem o mesmo número de Zero resultados e One resultados. O resultado da medição para o segundo qubit é sempre o mesmo que para o primeiro qubit porque os dois qubits estão entrelaçados. Se o primeiro qubit for medido como Zero, então o qubit emaranhado também deve ser Zero. Se o primeiro qubit for medido como One, então o qubit emaranhado também deve ser One.

Pré-requisitos

Para desenvolver e executar o exemplo de código no seu ambiente de desenvolvimento local, instale as seguintes ferramentas:

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

Criar um novo Q# ficheiro

No VS Code, abra o menu Ficheiro e escolha Novo Ficheiro de Texto para criar um novo ficheiro.
Guarde o ficheiro como CreateBellStates.qs. É neste ficheiro que escreves o Q# código do teu programa.

Inicializar um qubit para um estado conhecido

Abra CreateBellStates.qs e copie o seguinte código:

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

O exemplo de código introduz duas operações padrão Q# , M e X, que transformam o estado de um qubit.

Aqui está uma descrição detalhada de como funciona a SetQubitState operação:

Utiliza dois parâmetros: um Result parâmetro tipo chamado desired que representa o estado desejado para o qubit estar em (Zero ou One), e um Qubit parâmetro tipo.
Realiza uma operação de medição, M, que mede o estado do qubit (Zero ou One) e compara o resultado com o valor que passa para desired.
Se o resultado da medição não corresponder ao valor para desired, então uma X operação é aplicada ao qubit. Esta operação inverte o estado do qubit de modo que as probabilidades de medição para Zero e One são invertidas.

Escrever uma operação de teste para testar o estado Bell

Adicione a seguinte operação ao seu CreateBellStates.qs arquivo após a SetQubitState operação:

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

No código, as count variáveis e initial são definidas como 1000 e One respectivamente. Isto inicializa o primeiro qubit para One e mede cada qubit 1000 vezes.

A Main operação faz o seguinte:

Define variáveis para o número de disparos (count) e o estado inicial do qubit (One).
Chama a use instrução para inicializar dois qubits.
Repete o experimento count vezes.
No ciclo, chama-se SetQubitState para definir o valor especificado initial no primeiro qubit, e depois chama-se SetQubitState novamente para definir o segundo qubit no estado Zero.
No ciclo, aplica a M operação para medir cada qubit e depois armazena o número de medições para cada qubit que retorna One.
Depois de o ciclo terminar, chama SetQubitState novamente para reiniciar os qubits para um estado conhecido (Zero). Deve redefinir os qubits que aloca com a use instrução.
Chama a função Message para imprimir os seus resultados na consola.

Executar o código

Antes de escreveres código para superposição e emaranhamento, testa o teu programa atual para ver a inicialização e medição dos qubits.

Para executar o código como um programa autónomo, o Q# compilador precisa de saber por onde iniciar o programa. Como não especificaste um namespace, o compilador reconhece o ponto de entrada padrão como a Main operação. Para obter mais informações, consulte Projetos e namespaces implícitos.

O seu CreateBellStates.qs ficheiro agora está assim:

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

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Para executar o programa, escolha o comando Run da lente de código que precede a Main operação, ou introduza Ctrl + F5. O programa executa a Main operação no simulador padrão.

A tua saída aparece no console de resolução de problemas.

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

O seu programa ainda não modifica os estados do qubit, por isso a medição do primeiro qubit retorna Onesempre , e o segundo qubit retorna Zerosempre .

Se mudares o valor de initial para Zero e executares o programa novamente, então o primeiro qubit também devolve Zerosempre .

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Colocar um qubit num estado de superposição

Modifica o teu código na Main operação. Redefina o valor inicial para One e insira uma linha para a H operação:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);  // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Q1 - Zeros: 523
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Cada vez que executa o programa, os resultados do primeiro qubit variam ligeiramente, mas aproximam-se de 50% One e 50% Zero, enquanto os resultados do segundo qubit são sempre Zero.

Emaranhar dois qubits

Adicione a CNOT operação ao seu programa imediatamente após a H operação. O teu programa completo é assim:

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

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Executa o programa e vê o resultado. Os teus resultados variam ligeiramente cada vez que executas o programa.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Traçar o histograma de frequência

Para representar um histograma de frequência que mostre a distribuição dos resultados quando executa o seu programa várias vezes, complete os seguintes passos:

Abra o seu CreateBellStates.qs ficheiro no VS Code.
Abra o menu Exibir e escolha Paleta de comandos.
Introduza histograma para abrir a opção QDK: Executar ficheiro e mostrar histograma . Ou, escolha o comando Histogram na opção de lente de códigos que precede a operação Main. Depois, introduza um número de disparos (por exemplo, 100). O Q# histograma abre-se numa nova aba.

Cada barra no histograma corresponde a um possível resultado quando o circuito de emaranhamento funciona 1000 vezes. A altura de uma barra representa o número de vezes que esse resultado ocorre. Por exemplo, o histograma seguinte mostra uma distribuição com 50 resultados únicos. Note-se que para cada resultado, os resultados das medições para o primeiro e o segundo qubit são sempre os mesmos.

Gorjeta

Para ampliar o histograma, use a roda do rato ou um gesto do trackpad. Para mover o gráfico quando estiveres a aproximar, mantém pressionado Alt enquanto fazes scroll.
Escolha uma barra para mostrar a percentagem de remates totais que produziram esse resultado.
Escolha o ícone de definições no canto superior esquerdo para mostrar as opções de visualização.
Executa o código outra vez, mas desta vez com 1000 disparos. À medida que o número de disparos aumenta, a distribuição dos resultados aproxima-se de uma distribuição normal.

Explore outros Q# tutoriais:

O algoritmo de pesquisa de Grover mostra como escrever um Q# programa que usa o algoritmo de pesquisa de Grover.
Quantum Fourier Transform explora como escrever um Q# programa que aborda diretamente qubits específicos.
Os Katas Quânticos são tutoriais e exercícios de programação auto-ritmados que ensinam os elementos da computação quântica e Q# da programação ao mesmo tempo.

Feedback

Esta página foi útil?

Last updated on 2025-12-03

Partilhar via

Tutorial: Explore o emaranhamento quântico com Q#

Pré-requisitos

Inicializar um qubit para um estado conhecido

Escrever uma operação de teste para testar o estado Bell

Execute o código no Copilot para Azure Quantum

Colocar um qubit num estado de superposição

Emaranhar dois qubits

Pré-requisitos

Criar um novo Q# ficheiro

Inicializar um qubit para um estado conhecido

Escrever uma operação de teste para testar o estado Bell

Executar o código

Colocar um qubit num estado de superposição

Emaranhar dois qubits

Traçar o histograma de frequência

Conteúdos relacionados

Feedback

Recursos adicionais