Partilhar via

Introdução à linguagem de programação quântica Q#

Q# é uma linguagem de programação de código aberto de alto nível, desenvolvida pela Microsoft para escrever programas quânticos. Q# está incluído no Kit de Desenvolvimento Quântico (QDK). Para obter mais informações, consulte Configurar o Quantum Development Kit.

Como uma linguagem de programação quântica, Q# atende aos seguintes requisitos de linguagem, compilador e tempo de execução:

  • Agnóstico de hardware: Qubits em algoritmos quânticos não estão vinculados a um hardware ou layout quântico específico. O compilador Q# e o tempo de execução lidam com o mapeamento de qubits de programa para qubits físicos, permitindo que o mesmo código seja executado em diferentes processadores quânticos.
  • Integração da computação quântica e clássica:Q# permite a integração de cálculos quânticos e clássicos, o que é essencial para a computação quântica universal.
  • Gestão de qubit:Q# fornece operações e funções integradas para gerenciar qubits, incluindo criar estados de superposição, emaranhar qubits e realizar medições quânticas.
  • Respeite as leis da física:Q# e algoritmos quânticos devem seguir as regras da física quântica. Por exemplo, você não pode copiar ou acessar diretamente o estado do qubit no Q#.

Para obter mais informações sobre as origens do Q#, consulte a postagem do blog Por que precisamos de Q#?.

Estrutura de um Q# programa

Antes de começar a escrever os programas Q#, é importante entender a sua estrutura e os seus componentes. Considere o seguinte Q# programa, chamado Superposition, que cria um estado de superposição:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

Com base nos comentários (//), o Q# programa primeiro aloca um qubit, aplica uma operação para colocar o qubit em superposição, mede o estado do qubit, redefine o qubit e, finalmente, retorna o resultado.

Vamos dividir este programa Q# em seus componentes.

Namespaces de usuário

Q# programas podem, opcionalmente, começar com um namespace definido pelo usuário, como:

namespace Superposition {
    // Your code goes here.
}

Os namespaces podem ajudá-lo a organizar a funcionalidade relacionada. Os namespaces são opcionais em Q# programas, o que significa que você pode escrever um programa sem definir um namespace.

Por exemplo, o programa de Superposição do exemplo pode também ser escrito sem namespace, assim:

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Nota

Cada Q# programa pode ter apenas um namespace. Se você não especificar um namespace, o compilador Q# usará o nome do arquivo como namespace.

Pontos de entrada

Cada programa Q# deve ter um ponto de entrada, que é o ponto de partida do programa. Por padrão, o compilador começa a executar Q# um programa Main() a partir da operação, se disponível, que pode ser localizada em qualquer lugar no programa. Opcionalmente, você pode usar o @EntryPoint() atributo para especificar qualquer operação no programa como o ponto de execução.

Por exemplo, no programa Superposição, a operação MeasureOneQubit() é o ponto de entrada do programa porque tem o atributo @EntryPoint() antes da definição da operação.

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...
}

No entanto, o programa também pode ser escrito sem o atributo @EntryPoint(), renomeando a operação MeasureOneQubit() para Main(), como:

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Tipos

Os tipos são essenciais em qualquer linguagem de programação porque definem os dados com os quais um programa pode trabalhar. Q# fornece tipos internos que são comuns à maioria dos idiomas, incluindo Int, Double, Boole String, e tipos que definem intervalos, matrizes e tuplas.

Q# também fornece tipos específicos para a computação quântica. Por exemplo, o tipo Result representa o resultado de uma medição de qubit e pode ter dois valores: Zero ou One.

No programa Superposition, a operação MeasureOneQubit() retorna um tipo Result, que corresponde ao tipo de retorno da operação M. O resultado da medição é armazenado em uma nova variável que é definida usando a let instrução:

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...
}

Outro exemplo de um tipo específico quântico é o tipo Qubit, que representa um bit quântico.

Q# também permite que você defina seus próprios tipos personalizados. Para mais informações, consulte as declarações de tipo .

Atribuição de qubits

No Q#, você aloca qubits usando a palavra-chave use e o tipo Qubit. Qubits são sempre alocados no estado $\ket{0}$.

Por exemplo, o programa Superposition define um único qubit e o armazena na variável q:

// Allocate a qubit.
use q = Qubit();

Você também pode alocar vários qubits e acessar cada um através de seu índice:

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Operações quânticas

Depois de alocar um qubit, você pode passá-lo para operações e funções. As operações são os blocos de construção básicos de um programa de Q#. Uma Q# operação é uma sub-rotina quântica, ou uma rotina chamável que contém operações quânticas que alteram o estado do registro de qubit.

Para definir uma Q# operação, especifique um nome para a operação, suas entradas e saídas. No programa Superposition, a operação MeasureOneQubit() não usa parâmetros e retorna um tipo Result:

operation MeasureOneQubit() : Result {
    ...
}

Aqui está um exemplo básico que não usa parâmetros e não espera nenhum valor de retorno. O Unit valor é equivalente a NULL em outras línguas:

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

A Q# biblioteca padrão também fornece operações que você pode usar em programas quânticos, como a operação Hadamard, H, no Superposition programa. Dado um qubit na base Z, H coloca o qubit em uma superposição uniforme, onde tem 50% de chance de ser medido como Zero ou One.

Medição de qubits

Embora existam muitos tipos de medições quânticas, Q# concentra-se em medições projetivas em qubits únicos, também conhecidas como medições de Pauli.

Em Q#, a operação mede Measure um ou mais qubits na base Pauli especificada, que pode ser PauliX, PauliYou PauliZ. Measure retorna um Result do tipo Zero ou One.

Para implementar uma medição na base computacional $\lbrace\ket{0},\ket{1}\rbrace$, pode também usar a operação M, que mede um qubit na base de Pauli Z. Isto equivale M a Measure([PauliZ], [qubit]).

Por exemplo, o programa Superposition usa a operação M:

// Measure the qubit in the Z-basis.
let result = M(q);

Redefinindo qubits

Em Q#, os qubits devem estar no estado $\ket{0}$ quando forem libertados para evitar erros no hardware quântico. Você pode redefinir um qubit para o estado $\ket{0}$ usando a operação Reset no final do programa. A falha em redefinir um qubit resulta em um erro de execução.

// Reset a qubit.
Reset(q);

Namespaces de biblioteca padrão

A Q# biblioteca padrão tem namespaces internos que contêm funções e operações que você pode usar em programas quânticos. Por exemplo, o Microsoft.Quantum.Intrinsic namespace contém operações e funções comumente usadas, como M para medir resultados e Message exibir mensagens do usuário em qualquer lugar do programa.

Para chamar uma função ou operação, você pode especificar o namespace completo ou usar uma import instrução, que torna todas as funções e operações para esse namespace disponíveis e torna seu código mais legível. Os exemplos a seguir chamam a mesma operação:

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Nota

O programa Superposition não tem nenhuma instrução import ou chamadas com namespaces completos. Isso ocorre porque o Q# ambiente de desenvolvimento carrega automaticamente dois namespaces: Microsoft.Quantum.Core e Microsoft.Quantum.Intrinsic, que contêm funções e operações comumente usadas.

Você pode tirar partido do namespace Microsoft.Quantum.Measurement usando a operação MResetZ para otimizar o programa Superposition . MResetZ combina as operações de medição e redefinição em uma única etapa, como no exemplo a seguir:

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Aprenda a desenvolver programas quânticos com o Q# e o Azure Quantum

Q# e o Azure Quantum são uma combinação poderosa para desenvolver e executar programas quânticos. Com Q# o Azure Quantum, você pode escrever programas quânticos, simular seu comportamento, estimar os requisitos de recursos e executá-los em hardware quântico real. Esta integração permite-lhe explorar o potencial da computação quântica e desenvolver soluções inovadoras para problemas complexos. Quer seja um principiante ou um programador quântico experiente, Q# o Azure Quantum fornece as ferramentas e os recursos de que necessita para desbloquear o poder da computação quântica.

O diagrama a seguir mostra os estágios pelos quais um programa quântico passa quando você o desenvolve com Q# o Azure Quantum. Seu programa começa com o ambiente de desenvolvimento e termina com o envio do trabalho para hardware quântico real.

Diagrama mostrando o fluxo de trabalho de desenvolvimento de programação quântica.

Vamos detalhar as etapas no diagrama.

Escolha o ambiente de desenvolvimento

Execute seus programas quânticos em seu ambiente de desenvolvimento preferido. Você pode usar o editor de código online no site do Azure Quantum, os Blocos de Anotações Jupyter hospedados em seu espaço de trabalho do Azure Quantum no portal do Azure ou um ambiente de desenvolvimento local com o Visual Studio Code. Para obter mais informações, consulte Diferentes maneiras de executar Q# programas.

Escreva o seu programa quântico

Você pode escrever programas quânticos no Q# usando o Quantum Development Kit (QDK). Para começar, consulte Guia de início rápido: criar seu primeiro Q# programa.

Além disso Q#, o QDK oferece suporte para outras linguagens para computação quântica, como Qiskit e Cirq.

Integração com Python

Você pode usar Q# sozinho ou em conjunto com Python em vários IDEs. Por exemplo, podes usar um projeto Q# com um programa anfitrião Python para chamar operações de Q# ou integrar Q# com Python em Jupyter Notebooks. Para obter mais informações, consulte Integração de Q# e Python.

O comando %%qsharp

Por padrão, programas nos Jupyter Notebooks usam o pacote Python. Para adicionar Q# código a uma célula de um notebook, use o comando %%qsharp, que é ativado com o pacote qsharp Python, seguido pelo seu código Q#.

Ao utilizar %%qsharp, tenha em mente o seguinte:

  • Você deve primeiro executar import qsharp para habilitar %%qsharp.
  • %%qsharp aplica-se à célula do bloco de notas e muda o tipo de célula de Python para Q#.
  • Não é possível colocar uma instrução Python antes ou depois de %%qsharp.
  • Q# o código que se segue a %%qsharp deve respeitar a Q# sintaxe. Por exemplo, use // em vez de # para denotar comentários e ; para terminar linhas de código.

Estimar recursos

Antes de executar em hardware quântico real, você precisa descobrir se seu programa pode ser executado em hardware existente e quantos recursos ele consumirá.

O Azure Quantum Resource Estimator permite avaliar decisões arquitetônicas, comparar tecnologias de qubit e determinar os recursos necessários para executar um determinado algoritmo quântico. Você pode escolher entre protocolos tolerantes a falhas predefinidos e especificar suposições do modelo de qubit físico subjacente.

Para obter mais informações, consulte Executar sua primeira estimativa de recursos.

Nota

O Azure Quantum Resources Estimator é gratuito e não requer uma conta do Azure.

Execute o seu programa em simulação

Quando você compila e executa um programa quântico, o QDK cria uma instância do simulador quântico e passa o Q# código para ele. O simulador utiliza o código Q# para criar qubits (simulações de partículas quânticas) e aplica as transformações para modificar o estado dos mesmos. Os resultados das operações quânticas no simulador são, depois, devolvidos ao programa. Isolar o código Q# no simulador garante que os algoritmos seguem as leis da física quântica e que podem ser executados corretamente em computadores quânticos.

Envie seu programa para hardware quântico real

Depois de testar seu programa em simulação, você pode executá-lo em hardware quântico real. Ao executar um programa quântico no Azure Quantum, você cria e executa um trabalho . Para enviar um trabalho para os provedores do Azure Quantum, você precisa de uma conta do Azure e um espaço de trabalho quântico. Se você não tiver um espaço de trabalho quântico, consulte Criar um espaço de trabalho do Azure Quantum.

O Azure Quantum oferece alguns dos hardwares quânticos mais atraentes e diversificados. Consulte Provedores de computação quântica para obter a lista atual de provedores de hardware suportados.

Depois de enviar seu trabalho, o Azure Quantum gerencia o ciclo de vida do trabalho, incluindo agendamento, execução e monitoramento de trabalho. Você pode acompanhar o status do seu trabalho e exibir os resultados no portal do Azure Quantum.

Conteúdos relacionados