Exercício - Introdução ao Azure Quantum Resource Estimator

  • 8 minutos

Na unidade anterior, você aprendeu que o Azure Quantum Resource Estimator funciona usando três entradas principais: os parâmetros de qubit físico, o esquema de correção de erro quântico (QEC) e o orçamento de erro.

Vamos obter alguma prática com o Azure Quantum Resource Estimator. Nesta unidade, você estima os recursos físicos de um programa simples usando o Azure Quantum Resource Estimator.

Instale os pacotes necessários

Primeiro, instale o Azure Quantum qsharp e qsharp-widgets os pacotes mais recentes.

python -m pip install --upgrade qsharp qsharp-widgets

Criar o algoritmo quântico em um bloco de anotações Jupyter

Para começar a usar o Estimador de Recursos, você estima os recursos necessários para um algoritmo quântico simples que gera um bit aleatório.

  1. Abra o Visual Studio Code.

  2. Selecione a paleta de comandos Exibir > e selecione Criar: Novo Notebook Jupyter.

  3. Na primeira célula do bloco de anotações, importe o qsharp pacote:

    import qsharp
from qsharp_widgets import EstimateDetails

  4. Adicione uma nova célula e copie o seguinte código:

    %%qsharp
/// # Sample
/// Random Bit
///
/// # Description
/// This Q# program generates a random bit by setting a qubit in a superposition
/// of the computational basis states |0〉 and |1〉, and returning the measurement
/// result.

    operation RandomBit() : Result {
        // Qubits are only accesible for the duration of the scope where they
        // are allocated and are automatically released at the end of the scope.
        use qubit = Qubit();

        // Set the qubit in superposition by applying a Hadamard transformation.
        H(qubit);

        // Measure the qubit. There is a 50% probability of measuring either 
        // `Zero` or `One`.
        let result = M(qubit);

        // Reset the qubit so it can be safely released.
        Reset(qubit);
        return result;
    }

Estimar o algoritmo quântico

Agora, execute o Resource Estimator para estimar os recursos físicos para a operação RandomBit. Se você não especificar nada, o Estimador de Recursos usará as suposições padrão, ou seja, o modelo de qubit qubit_gate_ns_e3, o código de correção de erro surface_code e o orçamento de erro 0,001.

  1. Adicione uma nova célula e copie o seguinte código:

    result = qsharp.estimate("RandomBit()")
result

    A qsharp.estimate função cria um objeto de resultado, que pode ser usado para exibir uma tabela com as contagens gerais de recursos físicos. A primeira tabela mostra as principais estimativas de recursos físicos. A RandomBit operação requer 300 qubits e leva dois microssegundos para ser executada em um computador quântico.

    Estimativas de recursos físicos Value
    Runtime 2 microssegundos
    rQOPS 3.00M
    Qubits físicos 300

  2. Você pode inspecionar os detalhes de custo recolhendo os grupos, que têm mais informações. Por exemplo, recolha o grupo de parâmetros de qubit lógico para ver que a distância de código é 5 e o número de qubits físicos por qubit lógico é 50.

    Parâmetro qubit lógico Value
    Regime QEC surface_code
    Distância do código 5
    Qubits físicos 50
    Tempo de ciclo lógico 2 microssegundos
    Taxa de erro de qubit lógico 3,00E-5
    Pré-fator de cruzamento 0.03
    Limite de correção de erros 0,01
    Fórmula de tempo de ciclo lógico (4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
    Fórmula de qubits físicos 2 * codeDistance * codeDistance

  3. Você pode usar o jobParams campo para acessar todos os parâmetros de destino que podem ser passados para a execução do trabalho e ver quais valores padrão foram assumidos:

    result['jobParams']

    {'errorBudget': 0.001,
 'qecScheme': {'crossingPrefactor': 0.03,
  'errorCorrectionThreshold': 0.01,
  'logicalCycleTime': '(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance',
  'name': 'surface_code',
  'physicalQubitsPerLogicalQubit': '2 * codeDistance * codeDistance'},
 'qubitParams': {'instructionSet': 'GateBased',
  'name': 'qubit_gate_ns_e3',
  'oneQubitGateErrorRate': 0.001,
  'oneQubitGateTime': '50 ns',
  'oneQubitMeasurementErrorRate': 0.001,
  'oneQubitMeasurementTime': '100 ns',
  'tGateErrorRate': 0.001,
  'tGateTime': '50 ns',
  'twoQubitGateErrorRate': 0.001,
  'twoQubitGateTime': '50 ns'}}

    Você pode ver que o Resource Estimator usa o modelo de qubit qubit_gate_ns_e3, o código de correção de erro surface_code e o orçamento de erro 0,001, que são os valores padrão para a estimativa.

Alterar os valores padrão e estimar o algoritmo

Se não quiser usar os valores padrão, especifique parâmetros opcionais. Vamos mudar o modelo de qubit, o esquema QEC e o orçamento de erro.

Alterar modelo de qubit

Você estima o custo para o mesmo algoritmo usando o parâmetro qubit baseado em Majorana, qubit_maj_ns_e6. Para fazer isso, você precisa passar o parâmetro qubitParams com o campo name definido como qubit_maj_ns_e6.

Em uma nova célula, copie e execute o seguinte código:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})
EstimateDetails(result_maj)

Alterar o esquema de correção de erros quânticos

Você estima o custo para o mesmo algoritmo usando os parâmetros de qubit baseados em Majorana com um esquema QEC floqued, qecScheme. Para fazer isso, você também precisa passar o parâmetro qecScheme com o campo name definido como floquet_code.

Em uma nova célula, copie e execute o seguinte código:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})
EstimateDetails(result_maj)

Alterar orçamento de erro

Em seguida, estime o custo para os mesmos parâmetros, usando um errorBudget de 10%. Para fazer isso, você precisa passar o parâmetro errorBudget com o valor definido como 0.1.

Em uma nova célula, copie e execute o seguinte código:

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})
EstimateDetails(result_maj)

Parabéns;! Você estimou com êxito os recursos físicos para um algoritmo quântico simples usando o Quantum Resource Estimator do Azure e personalizou os parâmetros para ver como eles afetam as estimativas de recursos.

Na próxima unidade, você aumentará o nível de dificuldade e estimará os recursos para o algoritmo do Shor usando o Azure Quantum Resource Estimator.