Quais são os principais componentes de um programa Q#?

Antes de escrever seus próprios programas quânticos, é importante entender a estrutura e os componentes da linguagem de programação Q#.

Nesta unidade, você aprende sobre os componentes básicos de um programa Q#.

A Main operação

Cada programa Q# deve conter pelo menos uma operação. O compilador Q# começa a executar um programa a partir da operação do ponto de entrada, que é a Main operação por padrão. Por exemplo, o seguinte programa Q# contém uma operação chamada Main que cria um qubit e retorna uma medida do estado do qubit:

// This operation is the entry point to your program because it's name is Main
operation Main() : Result {
    use q = Qubit();
    return M(q);
}

Seu código Q# não pode ser executado sem uma operação de ponto de entrada. Se você quiser usar uma operação diferente do Main ponto de entrada, use o @EntryPoint() atributo. Por exemplo, o código a seguir dá à operação anterior um nome MeasureOneQubitmais descritivo e define essa operação como o ponto de entrada para seu programa Q#:

// The @EntryPoint() attribute tells the compiler to start running your code from this operation
@EntryPoint()
operation MeasureOneQubit() : Result {
    use q = Qubit();
    return M(q);
}

Tipos

O Q# fornece muitos tipos de dados internos com os quais você já deve estar familiarizado, como Int, Double, Boole String. Q# também fornece tipos que são específicos para a computação quântica, como Qubit e Result.

Por exemplo, a MeasureOneQubit operação retorna um valor de Result tipo. O Result tipo representa o estado de um qubit quando o qubit é medido e pode ter um valor de Zero ou One.

Bibliotecas quânticas

O Q# vem com várias bibliotecas que contêm funções e operações para ajudá-lo a escrever programas quânticos. Para chamar uma função ou operação de uma biblioteca, use a import palavra-chave e especifique o namespace da biblioteca. Por exemplo, para usar a função Message do namespace Microsoft.Quantum.Intrinsic na biblioteca padrão quântica, utilize o seguinte código:

// import all functions and operations from Microsoft.Quantum.Intrinsic 
import Microsoft.Quantum.Intrinsic.*;

operation Main() : Unit {
    // call the Message function from Microsoft.Quantum.Intrinsic
    Message("Hello quantum world!");
}

O asterisco significa que você importa todas as funções do Microsoft.Quantum.Intrinsic namespace. Como alternativa, você pode importar apenas a Message função:

// import only the Message function from Microsoft.Quantum.Intrinsic 
import Microsoft.Quantum.Intrinsic.Message;

operation Main() : Unit {
    // call the Message function from Microsoft.Quantum.Intrinsic
    Message("Hello quantum world!");
}

Você pode importar namespaces na biblioteca padrão com Std em vez de Microsoft.Quantum. Por exemplo, o código a seguir importa todas as funções e operações do Microsoft.Quantum.Intrinsic namespace:

// import everything from Std.Intrinsic (Microsoft.Quantum.Intrinsic)
import Std.Intrinsic.*;

operation Main() : Unit {
    // call the Message function from Std.Intrinsic
    Message("Hello quantum world!");
}

Para explorar a biblioteca padrão do Q#, consulte a referência da API.

Alocação de Qubit

Para alocar um qubit em Q#, use a use palavra-chave e o Qubit tipo. Os qubits alocados com a use palavra-chave sempre começam no estado $\ket{0}$.

Você pode alocar um único qubit ou vários qubits em uma matriz de qubit. Aqui está um exemplo que aloca um único qubit na variável q1 e uma matriz de cinco qubits em q5:

use q1 = Qubit();  // Allocate one qubit
use q5 = Qubit[5]; // Allocate five qubits

Medição de Qubit

Em Q#, a Measure operação executa uma medição conjunta de um ou mais qubits nas bases Pauli especificadas, que podem ser PauliX, PauliYou PauliZ. A operação Measure retorna um tipo Result que pode ter um valor de Zero ou One.

Para realizar uma medição na base computacional $\lbrace\ket{0},\ket{1}\rbrace$, também pode usar a operação M. A M operação é equivalente à Measure operação na base Pauli-Z, portanto M([qubit]) , se comporta exatamente da mesma forma que Measure([PauliZ], [qubit]). No entanto, a M operação aceita apenas qubits únicos como entrada, não matrizes de qubit.

Redefinir qubits

Em Q#, os qubits devem estar no estado $\ket{0}$ para liberá-los. Quando terminar de usar um qubit, chame a operação Reset para reiniciar o qubit para o estado $\ket{0}$. Por exemplo, o código a seguir aloca um qubit, mede o estado do qubit e, em seguida, redefine o qubit:

operation Main() : Result {
    use q = Qubit();
    let result = M(q);

    // Reset the qubit so that you can release it
    Reset(q);

    return result;
    }