Azure Quantum QIR perfis de destino no QDK

A computação quântica ainda é uma tecnologia emergente. Nem todo hardware quântico pode executar todos os programas quânticos. Por exemplo, apenas determinado hardware pode executar medidas de circuito médio, o que é necessário para executar programas com ramificações condicionais com base nos resultados da medida do qubit.

Quando você envia um programa para ser executado em Azure Quantum, seu programa é convertido para o formato de representação intermediária quântica (QIR). QIR não depende da linguagem de programação ou do tipo de hardware quântico em que o programa é executado. O MicrosoftQuantum Development Kit (QDK) dá suporte a vários QIR perfis de destino para diferentes funcionalidades de hardware.

Para obter mais informações sobre QIR, consulte Quantum - representação intermediária.

Visão geral dos perfis de destino

Azure Quantum e o QDK oferecem suporte a vários perfis de destino QIR. O tipo de perfil de destino escolhido determina quais dos constructos de programação a seguir seu programa pode usar.

  • Desvios condicionais com instruções if baseadas em resultados de medição de qubits
  • Operações aritméticas em números de ponto flutuante computados a partir de resultados de medição de qubit
  • Loops fixos e não limitados com base nos resultados da medição do qubit

A tabela a seguir lista todos os QIR perfis de destino no QDK e as construções de programação suportadas por esses perfis, em ordem da mais restritiva para a menos restritiva.

QIR perfil de destino Ramificações condicionais Operações de ponto flutuante Loops
Base ❌ ❌ ❌
Adaptive RI ✅ ❌ ❌
Adaptive RIF ✅ ✅ ❌
Adaptive ✅ ✅ ✅
Unrestricted ✅ ✅ ✅

Definir perfis de destino no QDK

Para executar um programa nos simuladores QDK ou no destino Azure Quantum, você precisa definir um perfil de destino QIR. Se você não definir manualmente um perfil de destino, o QDK tentará definir automaticamente o perfil adequado para o destino escolhido.

ao enviar programas para execução por meio do Azure Quantum serviço, tenta QDK selecionar automaticamente o perfil apropriado para o destino de execução escolhido.

Base QIR perfil

O perfil de destino base QIR é o mais restritivo. Use o perfil base para programas mais simples que não usam estruturas de programação clássicas, como branches e loops. Se o seu hardware quântico não puder realizar medições no meio do circuito, provavelmente você precisará usar o perfil base.

Os destinos Azure Quantum a seguir podem executar programas que usam o perfil base QIR .

Fornecedor Simulador QPU
IonQ ionq.simulator ionq.qpu.*
Rigetti rigetti.sim.* rigetti.qpu.*

Para saber mais sobre esses Azure Quantum provedores, consulte o provedor IonQ e o provedor Rigetti.

Definir o perfil base

Para definir o perfil de destino base QIR na QDK extensão para Visual Studio Code (VS Code), escolha uma das opções a seguir.

  • Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto.

    {
  "targetProfile": "base"
}

  • Se você estiver trabalhando em um .qs arquivo que não faz parte de um projeto Q#, defina o perfil de destino diretamente no código Q#. Para fazer isso, adicione @EntryPoint(Base) na linha antes da operação de ponto de entrada em seu programa.

    @EntryPoint(Base)
operation Main() : Unit {

...

}

Para definir o perfil de destino base na QDK biblioteca de Python, execute o código a seguir.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Base)

Limitações em programas Q# com perfil base

O perfil de destino base pode executar uma ampla variedade de programas Q#. A principal limitação é que os programas em Q# não podem realizar comparações lógicas com valores do tipo Result resultantes de operações de medição.

Por exemplo, você não pode executar a operação a seguir FlipQubitOnZero em um destino base porque o programa contém uma instrução if que usa um resultado de medida.

    @EntryPoint(Base)
    operation FlipQubitOnZero() : Unit {
        use q = Qubit();
        if M(q) == Zero {
            X(q);
        }
    }

Adaptive RI QIR perfil

O perfil de destino de RI adaptável pode executar uma variedade maior de programas do que o perfil base, mas ainda tem algumas limitações. Os destinos Adaptive RI permitem programas que usam medições no meio do circuito em instruções condicionais if. Se o seu hardware quântico puder realizar medições no meio do circuito e o seu programa usar instruções if baseadas em resultados de medição, provavelmente você precisará usar o perfil RI adaptativo.

Por exemplo, o programa Q# a seguir pode ser executado em um destino de RI adaptável.

@EntryPoint(Adaptive_RI)
operation MeasureQubit(q : Qubit) : Result { 
    return M(q); 
}

operation SetToZero(q : Qubit) : Unit {
     if MeasureQubit(q) == One { X(q); }
}

Os seguintes destinos Azure Quantum podem executar programas que usam o perfil de destino RI adaptativo.

Fornecedor Simulador QPU
Quantinuum quantinuum.sim.h2-1e quantinuum.qpu.h2-1
Quantinuum quantinuum.sim.h2-2e quantinuum.qpu.h2-2

Para obter mais informações sobre o Quantinuum, Azure Quantumconsulte o provedor Quantinuum.

Definir o perfil de RI adaptável

Para definir o perfil de destino de RI QIR adaptável na QDK extensão do VS Code, escolha uma das opções a seguir.

  • Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:

    {
  "targetProfile": "adaptive_ri"
}

  • Se você estiver trabalhando em um .qs arquivo que não faz parte de um projeto Q#, defina o perfil de destino diretamente no código Q#. Para fazer isso, adicione @EntryPoint(Adaptive_RI) na linha antes da operação de ponto de entrada em seu programa.

    @EntryPoint(Adaptive_RI)
operation Main() : Unit {

...

}

Para definir o perfil de destino de RI adaptável na QDK biblioteca de Python, execute o código a seguir.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RI)

Adaptive RIF QIR perfil

O perfil de destino RIF adaptável tem os mesmos recursos que o perfil de RI adaptável, mas também dá suporte a programas que contêm operações aritméticas de ponto flutuante. Se o seu hardware quântico puder realizar medições no meio do circuito, e o seu programa usar instruções if e números de ponto flutuante calculados a partir de resultados de medições, então você provavelmente precisará usar o perfil RIF adaptativo.

Por exemplo, o programa Q# a seguir pode ser executado em um destino RIF adaptável.

@EntryPoint(Adaptive_RIF)
operation DynamicFloat() : Double {
    use q = Qubit();
    H(q);
    mutable f = 0.0;
    if M(q) == One {
        f = 0.5;
    }
    Reset(q);
    return f;
}

Azure Quantum não tem destinos RIF adaptáveis no momento, mas você pode executar programas para destinos RIF adaptáveis nos simuladores locais QDK . Para obter mais informações sobre simuladores no QDK, consulte Visão geral dos simuladores quânticos no QDK.

Definir o perfil RIF adaptável

Para definir o perfil de destino RIF QIR adaptável na QDK extensão do VS Code, escolha uma das opções a seguir.

  • Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:

    {
  "targetProfile": "adaptive_rif"
}

  • Se você estiver trabalhando em um .qs arquivo que não faz parte de um projeto Q#, defina o perfil de destino diretamente no código Q#. Para fazer isso, adicione @EntryPoint(Adaptive_RIF) na linha antes da operação de ponto de entrada em seu programa.

    @EntryPoint(Adaptive_RIF)
operation Main() : Unit {

...

}

Para definir o perfil de destino do RIF adaptável na QDK biblioteca de Python, execute o código a seguir.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive_RIF)

Adaptive QIR perfil

O perfil de destino adaptável tem os mesmos recursos que o perfil RIF adaptável, mas também dá suporte a programas que usam loops com base nos resultados da medição. Os programas Adaptive podem usar loops com um número definido de iterações e loops de repetição até o sucesso (RUS).

Azure Quantum não tem destinos adaptáveis no momento, mas você pode executar programas para destinos adaptáveis nos simuladores locais QDK . Para obter mais informações sobre simuladores no QDK, consulte Visão geral dos simuladores quânticos no QDK.

Definir o perfil adaptável

Para definir o perfil de destino adaptável QIR na QDK extensão do VS Code, escolha uma das opções a seguir.

  • Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:

    {
  "targetProfile": "adaptive"
}

  • Se você estiver trabalhando em um .qs arquivo que não faz parte de um projeto Q#, defina o perfil de destino diretamente no código Q#. Para fazer isso, adicione @EntryPoint(Adaptive) na linha antes da operação de ponto de entrada em seu programa.

    @EntryPoint(Adaptive)
operation Main() : Unit {

...

}

Para definir o perfil de destino adaptável na QDK biblioteca de Python, execute o código a seguir.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Adaptive)

Unrestricted QIR perfil

O perfil de destino irrestrito pode executar todos os programas quânticos. Nenhum destino quântico atual permite QIR irrestrito, mas você pode usar o perfil irrestrito para executar programas complexos nos simuladores QDK para desenvolvimento quântico.

Definir o perfil irrestrito

Para definir o perfil de destino irrestrito QIR na QDK extensão do VS Code, escolha uma das opções a seguir.

  • Se você configurar um projeto Q#, adicione o seguinte comando ao arquivo do qsharp.json projeto:

    {
  "targetProfile": "unrestricted"
}

  • Se você estiver trabalhando em um .qs arquivo que não faz parte de um projeto Q#, defina o perfil de destino diretamente no código Q#. Para fazer isso, adicione @EntryPoint(Unrestricted) na linha antes da operação de ponto de entrada em seu programa.

    @EntryPoint(Unrestricted)
operation Main() : Unit {

...

}

Para definir o perfil de destino irrestrito na QDK biblioteca de Python, execute o código a seguir.

from qdk import init, TargetProfile

init(target_profile=TargetProfile.Unrestricted)
  • Last updated on