Share via

Novidades no Azure Quantum Development Kit (QDK Moderno)

  • Artigo

O QDK Moderno é a versão mais recente das ferramentas de programação e linguagem Q#. Com uma pegada mais pequena e um desempenho mais rápido, é uma extensão do Visual Studio Code de um só clique e apresenta melhoramentos de linguagem, suporte integrado do Python e Jupyter Notebook, realce de nova sintaxe, suporte de depurador, suporte de projetos com vários ficheiros, mensagens de erro e conectividade integrada do Azure. Ao eliminar as dependências do QDK Clássico anterior, é agora verdadeiramente independente da plataforma, em execução no Windows, Mac, Linux e na Web.

Integração do Visual Studio Code

O QDK Moderno está totalmente integrado no ambiente de desenvolvimento do Visual Studio Code. As novas funcionalidades incluem:

  • Um novo Avaliador de Recursos para o VS Code que pode executar localmente sem a necessidade de uma conta do Azure
  • Um depurador Q# para depuração integrada com pontos de interrupção, passo e vista de variáveis locais e quânticas
  • Suporte para projetos Q# com vários ficheiros
  • Melhorias no servidor de idiomas com mensagens de erro, realce de sintaxe, conclusões de código, informações sobre o cursor e ir para definições
  • Conectividade e submissão de tarefas da área de trabalho do Azure integrada
  • Um simulador disperso (sem ruído) incorporado
  • Jupyter Notebook integração com a codificação Q# em células e realce de sintaxe
  • Geração QIR para programas Q#

Em breve

  • A computação híbrida integrada com perfil adaptável ainda não é suportada com o QDK Moderno. Se precisar de executar projetos de computação híbrida, veja Continuar a trabalhar no QDK Clássico.

Funcionalidades preteridas

  • Suporte para Visual Studio
  • Suporte para idiomas e projetos .NET
  • O kernel do IQ# e os comandos mágicos do Jupyter Notebook. Para obter detalhes sobre como utilizar o Q# e o Jupyter Notebook, veja Jupyter Notebook integração e Migrar o código.

Atualizações de linguagem Q#

À medida que as descobertas quânticas e as inovações continuam a evoluir a um ritmo acelerado, a linguagem Q# e o Azure Quantum Development Kit continuam a evoluir para satisfazer as necessidades atuais e futuras de desenvolvimento quântico. As secções seguintes descrevem as alterações, atualizações e melhorias no QDK Moderno.

Atualizações de sintaxe de linguagem

Baseado em expressões

A linguagem Q# é agora baseada em expressões em vez de baseada em declarações. Isto permite uma nova utilização da sintaxe existente, como incorporar uma expressão if-expression noutra expressão:

let x = if check { 0 } else { 1 };

Devolução implícita

O exemplo anterior também tira partido da utilização de instruções sem um ponto e vírgula à direita no final de um bloco para devolver um valor desse bloco. Este padrão pode ser utilizado em vez de expressões de retorno explícitas num callable:

function ReturnsThree() : Int {
    return 3;
}

function AlsoReturnsThree() : Int {
    3
}

Expressões de bloco

O Q# suporta agora expressões de bloco que podem organizar múltiplas linhas, variáveis de âmbito e devolver um valor:

let flip = {
    use q = Qubit();
    H(q);
    if M(q) == One {
        X(q);
        "Heads"
    } else {
        "Tails"
    }
} ;

Itens como instruções

Itens como newtype, operationfunction e até open podem agora aparecer como instruções dentro de um âmbito local. Isto permite a definição de tipos de programa auxiliar local e de chamadas, bem como de âmbitos incluídos. Por exemplo, uma função auxiliar local pode ser definida imediatamente antes de ser necessária:

function ShowDecrement() : Unit {
    open Microsoft.Quantum.Arrays;
    let before = [1, 2, 3];

    function SubOne(in : Int) : Int {
        in - 1
    }

    let after = Mapped(SubOne, before);
    // after will be [0, 1, 2]
}

Tanto a função SubOne como a abertura do Microsoft.Quantum.Arrays espaço de nomes estão no âmbito da ShowDecrement função e não afetam o código fora dessa função.

Sombra de nomes

O Q# agora permite a sombra de nomes resolvidos em que isto não era permitido anteriormente. Isto permite uma reutilização mais fácil do código que inclui nomes variáveis ou callable sem a necessidade de uma variável mutável:

function Shadowing(input : Int) : Double {
    let input = 2 * input;
    let output = Calculate(input);
    let output = IntAsDouble(output);
    return output;
}

Tipos explícitos para variáveis locais

As variáveis locais podem agora ser escritas explicitamente com a mesma sintaxe que os tipos para declarações de argumentos callable:

let x : Int[] = [];

Os tipos explícitos não são necessários, mas podem, por vezes, ser úteis ao resolver a ambiguidade do tipo para funções que aceitam genéricos, como Length. O padrão anterior para lidar com isto - adicionar tipos concretos a uma invocação de função genérica com sintaxe como Length<Int[]>([]); , já não é suportado.

Prelúdio implícito do espaço de nomes

A resolução de nomes incorpora agora um prelúdio implícito que é um conjunto de espaços de nomes que são tratados como se tivessem sido abertos, desde que nenhum outro nome resolvido os substitua. Os espaços de nomes que são tratados desta forma são Microsoft.Quantum.Core, Microsoft.Quantum.Canone Microsoft.Quantum.Intrinsic. Estes não precisam de ser abertos explicitamente, exceto quando utilizar aliases ou diferenciar de outro modo de potenciais conflitos.

Biblioteca padrão

A biblioteca padrão Q# está agora alojada no mesmo repositório que o compilador e o runtime e pode ser encontrada na pasta de biblioteca de nível superior. Nem todas as funcionalidades e funcionalidades foram migradas a partir das bibliotecas Q# Clássicas, que ainda podem ser acedidas em https://github.com/microsoft/QuantumLibraries. Se for necessário um item da biblioteca anterior para um programa, esse item e quaisquer dependências podem ser copiados para o programa de origem. Se alguma funcionalidade de biblioteca for fundamental para um fluxo de trabalho e deve ser considerada para inclusão na nova biblioteca padrão, submeta um problema do GitHub com os detalhes.

Simulação

Simulação dispersa por predefinição

O QDK Moderno utiliza um simulador quântico de estado disperso incorporado como a predefinição target para simulação local. Este simulador é escrito em Rust e provém do repositório QIR Runner , permitindo-lhe compilar para WASM e executar em vários ambientes. Atualmente, este é o único back-end de simulação disponível no QDK, embora estejam a ser considerados outros back-ends para integração futura. Para obter mais informações sobre o design de simulação dispersa, veja Testing large quantum algorithms using sparse simulation (Testar algoritmos quânticos grandes com simulações dispersas).

Verificações mais rigorosas na versão do qubit

O QDK Clássico tinha historicamente flexívedo a exigência de que os qubits estejam no solo ou |0⟩ estado antes de serem libertados no final do âmbito, de modo a que um qubit que tenha sido medido e não operado em mais nenhum estado também fosse seguro para ser libertado, uma vez que o simulador reporia automaticamente o qubit. No entanto, isto causou confusão quando o mesmo programa foi executado num hardware quântico real em que essa reposição automática não está presente e os qubits podem ser reutilizados num estado inesperado. Para o QDK Moderno, voltámos ao comportamento mais rigoroso de impor que os qubits têm de estar no estado de base no lançamento. Isto ajuda os autores de algoritmos a verificar o comportamento do respetivo algoritmo quanto à correção em preparação para execução no hardware.

Portas multicontroladas decompostas

O QDK Moderno utiliza agora estratégias de decomposição para portas multicontroladas. Embora isto não tire partido dos atalhos disponíveis para simulação em que as portas multicontroladas são facilmente implementadas, corresponde mais estreitamente ao comportamento dos sistemas quânticos físicos. Isto significa que executar uma porta com um grande número de qubits de controlo irá incorrer em alocações de qubit adicionais e portas de preparação, da mesma forma que faria quando compilado para execução no hardware. Para obter mais detalhes sobre os algoritmos de decomposição utilizados, veja a implementação na biblioteca padrão.

Geração QIR

O QDK Moderno produz QIR ao gerar a representação textual de LLVM (.ll) em vez de utilizar o bitcode (.bc). A maioria e as targets ferramentas que aceitam código bit também podem analisar LLVM textuais, incluindo ferramentas como PyQIR e QIR Runner.

Atualmente, o QDK Moderno está limitado à geração de QIR para programas compatíveis com o Perfil Base qir. Quando a compilação do Perfil Base está configurada, o compilador e a extensão VSCode produzem erros para padrões que não são compatíveis com o target. O compilador também pode ignorar condicionalmente a compilação de itens que têm atributos que indicam que são específicos de uma compilação específica targets:

@Config(Unrestricted)
function ResultAsBool(input : Result) : Bool {
    input == One
}