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

Q#é uma linguagem de programação de alto nível, de código aberto, para desenvolver e executar algoritmos 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 Q# compilador e o tempo de execução lidam com o mapeamento de qubits de programa para qubits físicos.
• Integra computação quântica e clássica: A capacidade de realizar cálculos clássicos e quânticos é essencial em um computador quântico universal.
• Respeita as leis da física:Q# e os algoritmos quânticos seguem as regras da física quântica. Por exemplo, você não pode copiar ou acessar diretamente o estado do qubit no Q#.

Estrutura de um Q# programa

Antes de começar a escrever programas quânticos, é importante entender sua estrutura e componentes. Considere o seguinte Q# programa 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 Superposition 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 em seus componentes.

Namespaces de usuário

Q#Os programas começam com um namespace definido pelo usuário, como:

namespace Superposition {
    // Your code goes here.
}

Os espaços de nomes ajudam a organizar funcionalidades relacionadas. Cada Q# programa pode ter apenas um namespace.

A Q# biblioteca padrão tem namespaces predefinidos que contêm funções e operações que você pode usar em programas quânticos. Para obter mais informações, consulte Namespaces internos.

Pontos de entrada

O @EntryPoint() atributo informa ao Q# compilador por onde começar a executar o programa. Em um programa com várias funções e operações, você pode colocar @EntryPoint() antes de qualquer um deles para fazer o programa começar lá e continuar sequencialmente.

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

Tipos

Q# Fornece tipos internos que são comuns à maioria das linguagens, incluindo Int, Double, Boole , e Stringtipos que são específicos da computação quântica. Por exemplo, o Result tipo representa o resultado de uma medição de qubit e pode ter um de dois valores: Zero ou One.

No programa, a Superposition MeasureOneQubit() operação retorna um Result tipo, que corresponde ao tipo de retorno da M operação. 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);
    ...

Q# também fornece tipos que definem intervalos, matrizes e tuplas. Você pode até mesmo definir seus próprios tipos personalizados.

Atribuição de qubits

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

O Superposition programa define um único qubit:

// 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.

Para obter mais informações, consulte Instrução de uso.

Operações quânticas

Depois de alocar um qubit, você pode passá-lo para operações e funções, também conhecidas como chamáveis. As operações são os blocos de construção básicos de um Q# programa. 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, a Superposition MeasureOneQubit() operação é essencialmente todo o programa. Ele não usa parâmetros e retorna um Result tipo:

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 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 tipo de ou Zero One.

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

O Superposition programa usa a M operação:

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

Redefinindo qubits

No Q#, os $\ket{0}$ qubits devem estar no estado em que são liberados. Use a Reset operação para redefinir cada qubit para o $\ket{0}$ estado antes de liberá-lo no final do programa. A falha ao redefinir um qubit resulta em um erro de tempo de execução.

// Reset a qubit.
Reset(q);

Namespaces internos

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 open 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!");

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

O Superposition programa não tem nenhuma open instrução ou chamada 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 aproveitar o Microsoft.Quantum.Measurement namespace usando a MResetZ operação para otimizar o Superposition programa. MResetZ combina as operações de medição e redefinição em uma única etapa, como no exemplo a seguir:

namespace Superposition {
    // Open the namespace for the MResetZ operation.
    open 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);
    }
}

Desenvolva programas quânticos com Q# 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.

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 usando Q# 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, você pode usar um Q# projeto com um programa host Python para chamar Q# operações. Você também pode integrar Q# com Python em Jupyter Notebooks. Para obter mais informações, consulte Diferentes maneiras de executar Q# programas.

O comando %%qsharp

Por padrão, Q# os programas no Jupyter Notebooks usam o ipykernel pacote Python. Para adicionar Q# código a uma célula do bloco de anotações, use o %%qsharp comando, que é ativado com o qsharp pacote Python, seguido pelo seu Q# código.

Ao usar %%qsharpo , tenha em mente o seguinte:

• Você deve primeiro executar import qsharp para habilitar %%qsharpo .
• %%qsharp escopos para a célula do bloco de anotações em que ele aparece e altera o tipo de célula de Python para Q#.
• Não é possível colocar uma instrução Python antes ou depois %%qsharpdo .
• Q# código que se segue %%qsharp deve aderir à Q# sintaxe. Por exemplo, use // em vez de denotar comentários e ; terminar linhas de # código.

Estimar recursos

Antes de executar em hardware quântico real, você precisará 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.

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

Você pode enviar seus Q# programas (também conhecidos como trabalhos) para o Azure Quantum por meio de seu ambiente de desenvolvimento preferido, local e online. Para obter mais informações, consulte como enviar Q# trabalhos. Você também pode executar e enviar circuitos quânticos escritos nas linguagens Qiskit e Cirq.

O Azure Quantum oferece alguns dos hardwares quânticos mais atraentes e diversificados disponíveis atualmente dos líderes do setor. Consulte Provedores de computação quântica para obter a lista atual de provedores de hardware suportados.

O diagrama a seguir mostra o fluxo de trabalho básico depois de enviar seu trabalho:

Conteúdos relacionados

• Diferentes maneiras de executar Q# programas
• Configurar o Kit de Desenvolvimento Quântico
• Guia de início rápido: crie seu primeiro Q# programa