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ê aprenderá sobre os componentes básicos de um programa Q#.

A operação Main

Cada programa Q# deve conter pelo menos uma operação. O compilador Q# começa a executar um programa a partir da operação de ponto de entrada, que é a operação Main 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);
}

O 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 fornece à operação anterior um nome MeasureOneQubitmais descritivo e define essa operação como o ponto de entrada para o 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á pode estar familiarizado, como Int, e DoubleBoolString. O Q# também fornece tipos específicos à computação quântica, como Qubit e Result.

Por exemplo, a MeasureOneQubit operação retorna um Result valor de tipo. O Result tipo representa o estado de um qubit quando o qubit é medido e pode ter um valor igual 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 Message função do Microsoft.Quantum.Intrinsic namespace na biblioteca quântica padrão, use 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 em Std 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 Q#, consulte a referência de API.

Alocação de qubits

Para alocar um qubit em Q#, use a palavra-chave use e o tipo Qubit. Os qubits que você aloca 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 qubits. 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 do qubit

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

Para executar uma medição na base computacional $\lbrace\ket{0},\ket{1}\rbrace$, você também pode usar a operação M. A M operação é equivalente à Measure operação na base Pauli-Z, portanto M([qubit]) , comporta-se 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.

Restaurar 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 redefinir o qubit no estado $\ket{0}$. Por exemplo, o código a seguir aloca um qubit, mede o estado do qubit e 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;
    }