Diferentes tipos de perfis de target no Azure Quantum

Os dispositivos quânticos ainda são uma tecnologia emergente e, infelizmente, nem todos eles podem executar todos os programas Q#. Como tal, você precisa ter algumas restrições em mente enquanto desenvolve programas quânticos. Os target tipos de perfil definem os recursos dos dispositivos quânticos que você target com seus programas Q#. O Quantum Development Kit (QDK) tem um conjunto de diferentes target tipos de perfil, que juntos suportam todos os recursos dos dispositivos quânticos atuais que estão disponíveis no Azure Quantum.

Este artigo discute os diferentes tipos de target perfis no Azure Quantum, suas limitações e como configurá-los no QDK.

Perfis alvo e suas limitações

Atualmente, o Azure Quantum e o QDK gerenciam perfis diferentestarget, dependendo de sua capacidade de executar programas de representação intermediária quântica (QIR).

• Unrestricted: Este perfil pode executar qualquer QIR programa e, portanto, qualquer programa Q#, dentro dos limites de memória para simuladores ou o número de qubits para computadores quânticos físicos.
• Base: Este perfil pode executar qualquer programa Q# que não exija o uso dos resultados de medições de qubit para controlar o fluxo do programa. Dentro de um programa Q# direcionado para esse tipo de QPU, valores do tipo Result não suportam comparação de igualdade.
• Adaptive RI: Este perfil tem capacidade limitada de usar os resultados de medições de qubit para controlar o fluxo do programa. Dentro de um programa Q# direcionado para este tipo de QPU, é possível comparar valores do tipo Result como parte das condições em instruções if de operações, permitindo a medição intermédia no circuito.
• Adaptive RIF: Este perfil tem as mesmas capacidades que o Adaptive RI perfil, mas também suporta operações de ponto flutuante.

Criar e executar programas para o perfil Unrestrictedtarget

Unrestricted target perfis podem executar todos os programas Q#, para que você possa escrever código Q# sem a necessidade de considerar restrições de funcionalidade. O Azure Quantum não fornece nenhum dispositivo targets real que ofereça suporte a esse perfil. No entanto, você pode executar Unrestricted programas Q# que têm esse perfil nos simuladores que são fornecidos com o QDK.

Configurar Unrestrictedtarget perfil

Se você não definir manualmente seu QIRtarget perfil, o compilador definirá automaticamente o target perfil para você. O compilador escolhe o perfil mais restritivo que ainda permite que seu programa seja executado no dispositivo target Azure Quantum que você escolher.

Para definir manualmente o QIRtarget perfil como Sem restrições, escolha uma das seguintes opções:

• 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 target perfil diretamente no código Q#. Para fazer isso, inclua @EntryPoint(Unrestricted) logo antes da operação de ponto de entrada em seu programa, mesmo quando essa operação é o padrão Main.

• Em Python, chame o método qdk.init para definir o perfil target.

  from qdk import init, TargetProfile
  
  init(target_profile=TargetProfile.Unrestricted) 
  

Criar e executar programas para o perfil Basetarget

Base target perfis podem executar uma grande variedade de aplicações Q#, com a restrição de que não podem usar resultados de medições de qubits para controlar o percurso do programa. Mais especificamente, valores do tipo Result não suportam comparação de igualdade.

Por exemplo, você não pode executar a seguinte FlipQubitOnZero operação em um Basetarget:

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

A FlipQubitOnZero operação falha quando você executa esse código em um Basetarget porque o target dispositivo não pode usar o resultado de uma medição de qubit para executar lógica condicional enquanto o algoritmo quântico está em execução. Se você planeja executar algoritmos em um Basetarget dispositivo, certifique-se de que seu código não contenha blocos if para ramificação condicional que dependem de qubits medidos para avaliar uma condição lógica.

Configurar Basetarget perfil

Para definir manualmente o QIRtarget perfil como Base, escolha uma das seguintes opções:

• 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 target perfil diretamente no código Q#. Para fazer isso, inclua @EntryPoint(Base) logo antes da operação de ponto de entrada em seu programa, mesmo quando essa operação é o padrão Main.

• Em Python, chame o método qdk.init para definir o perfil target.

  from qdk import init, TargetProfile
  
  init(target_profile=TargetProfile.Base) 
  

targets suportado para Baseperfiltarget

Por enquanto, o Azure Quantum fornece acesso ao seguinte Basetargets:

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

Criar e executar programas para o perfil Adaptive RItarget

Adaptive RI target perfis podem executar uma variedade maior de aplicações Q# do que Base perfis, mas ainda possuem algumas limitações. Ao contrário dos Basetarget perfis, Adaptive RItargets suporta medições de circuito médio.

Com medições no meio do circuito, você pode medir seletivamente qubits em qualquer ponto do programa quântico, não apenas no final. Em seguida, você pode usar os resultados da medição para outras operações em seu programa, como ramificação condicional com if blocos. Os qubits que você mede no meio do circuito colapsam para um estado clássico (zero ou um), mas os qubits não medidos permanecem em seu estado quântico.

Quando você mede um qubit em Q#, um valor de tipo Result é retornado. Se você quiser usar esse resultado em uma instrução condicional, você terá que comparar diretamente na instrução condicional. Os blocos condicionais correspondentes não podem conter instruções return ou set.

Por exemplo, o seguinte código Q# é permitido em um Adaptive RItarget:

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

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

Configurar Adaptive RItarget perfil

Para definir manualmente o QIRtarget perfil como Adaptive RI, escolha uma das seguintes opções:

• 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 target perfil diretamente no código Q#. Para fazer isso, inclua @EntryPoint(Adaptive_RI) logo antes da operação de ponto de entrada em seu programa, mesmo quando essa operação é o padrão Main.

• Em Python, chame o método qdk.init para definir o perfil target.

  from qdk import init, TargetProfile
  
  init(target_profile=TargetProfile.Adaptive_RI) 
  

targets suportado para Adaptive RIperfiltarget

Por enquanto, Quantinuum é o único provedor no Azure Quantum que possui Adaptive RItargets.

• Emuladores:quantinuum.sim.h2-1e e ainda quantinuum.sim.h2-2e
• QPUs:quantinuum.qpu.h2-1 e ainda quantinuum.qpu.h2-2

Para obter mais informações sobre as ofertas do Quantinuum no Azure Quantum, consulte Emuladores Quantinuum.

Criar e executar programas para o perfil Adaptive RIFtarget

Adaptive RIF target perfis têm todos os recursos de Adaptive RI perfis, mas também suportam programas Q# que contêm cálculos em ponto flutuante.

Por exemplo, o seguinte código Q# é permitido em um Adaptive RIFtarget:

@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;
}

Configurar Adaptive RIFtarget perfil

Para definir manualmente o QIRtarget perfil como Adaptive RIF, escolha uma das seguintes opções:

• 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 target perfil diretamente no código Q#. Para fazer isso, inclua @EntryPoint(Adaptive_RIF) logo antes da operação de ponto de entrada em seu programa, mesmo quando essa operação é o padrão Main.

• Em Python, chame o método qdk.init para definir o perfil target.

  from qdk import init, TargetProfile
  
  init(target_profile=TargetProfile.Adaptive_RIF) 
  

targets suportado para Adaptive RIFperfiltarget

Por enquanto, o Azure Quantum não tem Adaptive RIFtargets. No entanto, você pode executar programas para Adaptive RIFtargets no simulador local no QDK.