Tutorial: explorar o emaranhamento quântico com o Q#

Neste tutorial, você escreve um Q# programa que prepara dois qubits em um estado quântico específico, opera nos qubits para emaranhá-los entre si e realiza medições para demonstrar os efeitos da superposição e do entrelaçamento. Você cria seu Q# programa peça a peça para introduzir estados qubit, operações quânticas e medidas.

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

Os bits clássicos contêm um único valor binário, como um 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.
Ao medir 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 da superposição quando você faz uma medição.
Vários qubits podem ser emaranhados de modo que você não possa descrevê-los independentemente uns dos outros. Ao medir um qubit em um par emaranhado, você também obtém informações sobre o outro qubit sem medi-lo.

Neste tutorial, você aprenderá como:

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

Dica

Se você quiser acelerar seu percurso de computação quântica, confira o Código com o Azure Quantum, um recurso exclusivo do site do Microsoft Quantum. Aqui, você pode executar exemplos internos 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 para a 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, você deve ter uma conta de email da Microsoft (MSA).

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

Inicializar um qubit para um estado conhecido

A primeira etapa é definir uma Q# operação que inicializa um qubit para um estado clássico desejado, 0 ou 1. Essa operação mede um qubit em um estado quântico geral, que retorna um valor do tipo Q#Result, sendo Zero ou One. Se o resultado da medida for diferente do estado desejado, a operação inverte o estado para que a operação retorne o estado desejado 100% do tempo.

Abra o Copilot para o Azure Quantum, desmarque o código padrão e copie o código a seguir na janela do editor de código. Você não pode executar esse código sozinho porque ele 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 apresenta duas operações Q# padrão M e Xque transformam o estado de um qubit.

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

Usa dois parâmetros: um parâmetro de tipo Result chamado desired que representa o estado desejado para o qubit estar em (Zero ou One) e um parâmetro do tipo Qubit.
Executa uma operação de medida, Mque mede o estado do qubit (Zero ou One) e compara o resultado com o valor que você passa para desired.
Se o resultado da medida não corresponder ao valor desired, uma X operação será aplicada ao qubit. Esta operação inverte o estado do qubit de modo que as probabilidades de medição para Zero e One sejam trocadas.

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

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

Copie o código a seguir 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. Isso inicializa o primeiro qubit para One e mede cada qubit 1.000 vezes.

A Main operação faz o seguinte:

Define variáveis para o número de capturas (count) e o estado do qubit inicial (One).
Chama a instrução use para inicializar dois qubits.
Faz loops sobre o experimento count vezes.
No loop, chama SetQubitState para definir o valor especificado initial no primeiro qubit e, em seguida, chama SetQubitState novamente para definir o segundo qubit para o Zero estado.
No loop, aplica a M operação para medir cada qubit e armazena o número de medidas para cada qubit retornado One.
Depois que o loop for concluído, chamará SetQubitState novamente para redefinir os qubits para um estado conhecido (Zero). Você deve redefinir os qubits alocados com a instrução use .
Chama a Message função para imprimir seus resultados na janela de saída.

Executar o código no Copilot para Azure Quantum

Antes de escrever código para sobreposição e emaranhamento, teste seu programa atual para ver a inicialização e a medida dos qubits.

Para executar seu código como um programa autônomo, o Q# compilador no Copilot precisa saber onde iniciar o programa. Como você não especificou 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.

Seu Q# programa agora tem esta aparência:

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 do Copilot para Azure Quantum , defina o controle deslizante para o número de capturas como "1" e 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

Seu programa ainda não modifica os estados do qubit, portanto, a medida do primeiro qubit sempre retorna Onee o segundo qubit sempre retorna Zero.

Se você alterar o valor de initial para Zero e executar o programa novamente, o primeiro qubit também sempre retornará Zero.

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

Colocar um qubit em um estado de superposição

Atualmente, os qubits em seu programa estão em um estado clássico, 1 ou 0, assim como os bits em um computador normal. Para emaranhar os qubits, você deve primeiro colocar um dos qubits em um estado de superposição equivalente. A medida de um qubit em um estado de superposição igual tem 50% para retornar Zero e 50% chance de retornar One.

Para colocar um qubit em um estado de superposição, use a operação Q#, ou HadamardH. A H operação converte um qubit que está em um estado puro Zero ou One em uma espécie de estado de meio caminho entre Zero e One.

Modifique seu código na operação Main. Redefina o valor inicial para One e insira uma linha para 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); 
        ...

Execute seu programa novamente. Como o primeiro qubit está em uma superposição igual ao medi-lo, você se aproxima de um resultado de 50/50 para Zero e One. Por exemplo, sua saída é semelhante a esta:

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

Toda vez que você executa o programa, os resultados do primeiro qubit variam ligeiramente, mas são próximos a 50% One e 50% Zero, enquanto os resultados do segundo qubit ainda são sempre Zero.

Inicialize o primeiro qubit para Zero , em vez de One e executar o programa novamente. Você obtém resultados semelhantes porque a H operação transforma um estado puro Zero e um estado puro One em um estado de superposição igual.

Observação

Para ver como os resultados da superposição variam em relação à distribuição das capturas, mova o controle deslizante no Copilot para o Azure Quantum e aumente o número de capturas.

Emaranhar dois qubits

Qubits emaranhados são correlacionados de modo que não possam ser descritos independentemente uns dos outros. Ao medir o estado de um qubit emaranhado, você também sabe o estado do outro qubit sem medi-lo. Este tutorial usa um exemplo com dois qubits emaranhados, mas você também pode emaranhar três ou mais qubits.

Para criar um estado emaranhado, use a Q#CNOToperação, ou Controlled-NOT. Quando você aplica CNOT a dois qubits, um qubit é o qubit de controle e o outro é o qubit de destino. Se o estado do qubit de controle for One, a CNOT operação inverte o estado do qubit de destino. Caso contrário, CNOT não fará nada com os qubits.

Adicione a operação CNOT ao programa imediatamente após a operação H. Seu programa completo tem esta aparência:

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

Execute o programa e exiba a saída. Seus resultados variam ligeiramente cada vez que você executa o programa.

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

As estatísticas do primeiro qubit ainda mostram uma chance de cerca de 50% de medir ambos One e Zero, mas os resultados da medida para o segundo qubit agora nem sempre são Zero. Cada qubit tem o mesmo número de Zero resultados e One resultados. O resultado da medida do segundo qubit é sempre o mesmo que o resultado do primeiro qubit porque os dois qubits estão emaranhados. Se o primeiro qubit for medido como sendo Zero, o qubit emaranhado também deverá ser Zero. Se o primeiro qubit for medido como sendo One, o qubit emaranhado também deverá ser One.

Pré-requisitos

Para desenvolver e executar o exemplo de código em 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 QDK (Azure Quantum Development Kit). Para obter detalhes da instalação, consulte Configurar a extensão do QDK.

Criar um novo Q# arquivo

No VS Code, abra o menu Arquivo e escolha Novo Arquivo de Texto para criar um novo arquivo.
Salve o arquivo como CreateBellStates.qs. Esse arquivo é onde você escreve o código para seu Q# 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 apresenta duas operações Q# padrão M e Xque transformam o estado de um qubit.

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

Usa dois parâmetros: um parâmetro de tipo Result chamado desired que representa o estado desejado para o qubit estar em (Zero ou One) e um parâmetro do tipo Qubit.
Executa uma operação de medida, Mque mede o estado do qubit (Zero ou One) e compara o resultado com o valor que você passa para desired.
Se o resultado da medida não corresponder ao valor desired, uma X operação será aplicada ao qubit. Esta operação inverte o estado do qubit de modo que as probabilidades de medição para Zero e One sejam trocadas.

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

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

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. Isso inicializa o primeiro qubit para One e mede cada qubit 1.000 vezes.

A Main operação faz o seguinte:

Define variáveis para o número de capturas (count) e o estado do qubit inicial (One).
Chama a instrução use para inicializar dois qubits.
Faz loops sobre o experimento count vezes.
No loop, chama SetQubitState para definir o valor especificado initial no primeiro qubit e, em seguida, chama SetQubitState novamente para definir o segundo qubit para o Zero estado.
No loop, aplica a M operação para medir cada qubit e armazena o número de medidas para cada qubit retornado One.
Depois que o loop for concluído, chamará SetQubitState novamente para redefinir os qubits para um estado conhecido (Zero). Você deve redefinir os qubits alocados com a instrução use .
Chama a Message função para imprimir seus resultados no console.

Executar o código

Antes de escrever código para sobreposição e emaranhamento, teste seu programa atual para ver a inicialização e a medida dos qubits.

Para executar o código como um programa autônomo, o Q# compilador precisa saber onde iniciar o programa. Como você não especificou 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.

Seu CreateBellStates.qs arquivo agora tem esta aparência:

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 Executar na lente de código que precede a Main operação ou insira Ctrl + F5. O programa executa a Main operação no simulador padrão.

Sua saída aparece no console de depuração.

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

Seu programa ainda não modifica os estados do qubit, portanto, a medida do primeiro qubit sempre retorna Onee o segundo qubit sempre retorna Zero.

Se você alterar o valor de initial para Zero e executar o programa novamente, o primeiro qubit também sempre retornará Zero.

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

Colocar um qubit em um estado de superposição

Modifique seu código na operação Main. Redefina o valor inicial para One e insira uma linha para 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

Emaranhar dois qubits

Para criar um estado emaranhado, use a Q#CNOT operação, ou Controlled-NOT. Quando você aplica CNOT a dois qubits, um qubit é o qubit de controle e o outro é o qubit de destino. Se o estado do qubit de controle for One, a CNOT operação inverte o estado do qubit de destino. Caso contrário, CNOT não fará nada com os qubits.

Adicione a operação CNOT ao programa imediatamente após a operação H. Seu programa completo tem esta aparência:

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

Execute o programa e exiba a saída. Seus resultados variam ligeiramente cada vez que você executa o programa.

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

As estatísticas do primeiro qubit ainda mostram cerca de 50% de chance de medir ambos One e Zero, mas os resultados da medição para o segundo qubit não são sempre Zero agora. Cada qubit tem o mesmo número de Zero resultados e One resultados. O resultado da medida do segundo qubit é sempre o mesmo que o resultado do primeiro qubit porque os dois qubits estão emaranhados. Se o primeiro qubit for medido como sendo Zero, o qubit emaranhado também deverá ser Zero. Se o primeiro qubit for medido como sendo One, o qubit emaranhado também deverá ser One.

Plotar o histograma de frequência

Para plotar um histograma de frequência que mostra a distribuição de resultados ao executar seu programa várias vezes, conclua as seguintes etapas:

Abra o CreateBellStates.qs arquivo no VS Code.
Abra o menu Exibir e escolha Paleta de Comandos.
Digite histogram para trazer a opção QDK: Executar arquivo e mostrar histograma. Ou escolha o comando Histograma na opção Code Lens que precede a operação Main. Em seguida, insira várias fotos (por exemplo, 100). O Q# histograma é aberto em uma nova guia.

Cada barra no histograma corresponde a um possível resultado quando o circuito de emaranhamento é executado 1000 vezes. A altura de uma barra representa o número de vezes que o resultado ocorre. Por exemplo, o histograma a seguir mostra uma distribuição com 50 resultados exclusivos. Observe que, para cada resultado, os resultados da medida para o primeiro e o segundo qubit são sempre os mesmos.

Dica

Para ampliar o histograma, use a roda de rolagem do mouse ou um gesto de trackpad. Para mover o gráfico quando estiver ampliado, segure Alt enquanto rola a tela.
Escolha uma barra para exibir a porcentagem de tentativas totais de disparos que produziram esse resultado.
Escolha o ícone de configurações no canto superior esquerdo para exibir as opções de visualização.
Execute o código novamente, mas desta vez com 1000 execuções. À medida que o número de capturas aumenta, a distribuição de resultados se aproxima de uma distribuição normal.

Explore outros tutoriais Q#:

O algoritmo de pesquisa de Grover mostra como escrever um Q# programa que usa o algoritmo de pesquisa de Grover.
A Transformada Quântica de Fourier explora como escrever um Q# programa que aborda diretamente qubits específicos.
Os Quantum Katas são tutoriais e exercícios de programação desenvolvidos para ensinar, ao mesmo tempo, os elementos da computação quântica e a programação.

Comentários

Esta página foi útil?

Last updated on 2025-12-03

Compartilhar via

Tutorial: explorar o emaranhamento quântico com o Q#

Pré-requisitos

Inicializar um qubit para um estado conhecido

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

Executar o código no Copilot para Azure Quantum

Colocar um qubit em um estado de superposição

Emaranhar dois qubits

Pré-requisitos

Criar um novo Q# arquivo

Inicializar um qubit para um estado conhecido

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

Executar o código

Colocar um qubit em um estado de superposição

Emaranhar dois qubits

Plotar o histograma de frequência

Conteúdo relacionado

Comentários

Recursos adicionais