Executar simulações quânticas na QDK extensão para Visual Studio Code

A extensão MicrosoftQuantum Development Kit (QDK) para Visual Studio Code (VS Code) executa automaticamente programas Q# e OpenQASM em seu simulador esparso local.

Este artigo explica como executar programas no simulador local e como adicionar ruído Pauli às simulações Q#. Para usar os outros QDK simuladores de Python, consulte Executar simulações quânticas com o QDKPython pacote.

Como funciona o simulador local

O simulador esparso armazena apenas as amplitudes não zero de um estado quântico. Quando a maioria das amplitudes de base computacional são zero, essa representação usa menos memória e pode simular alguns programas com mais qubits do que um simulador de estado completo, que armazena cada amplitude.

O benefício de desempenho depende se o estado quântico permanece esparso na base computacional. Para obter mais informações, consulte Jaques e Häner (arXiv:2105.01533).

Executar um programa quântico em VS Code

  1. Instale a QDK extensão para VS Code.
  2. Abra um arquivo Q# (.qs) ou arquivo OpenQASM (.qasm).
  3. Selecione Executar na lente de código no início do arquivo ou acima da Q#Main operação.

A saída da simulação é exibida no VS Code terminal. Para programas Q#, selecione Depurar para inspecionar o estado quântico do programa conforme ele é executado.

Adicionar Pauli ruído a Q# simulações

O simulador esparso suporta ruído Pauli para programas Q# na extensão QDK. Use ConfigurePauliNoise para definir as probabilidades de erros de Pauli $X$, $Y$ e $Z$ em um programa. As configurações da QDK extensão também dão suporte a um Pauli modelo de ruído global.

Note

Não é possível adicionar um modelo de ruído a uma simulação OpenQASM na extensão QDK. Para criar modelos de ruído específicos de operação para programas Q# ou OpenQASM, use o PythonQDK pacote e a API NoiseConfig.

Adicionar Pauli ruído nas VS Code configurações

  • Em VS Code, defina o ruído global de Pauli para programas Q# na configuração do usuário Q#> Simulação:Pauli Ruído da extensão QDK.

Captura de tela das configurações de ruído global Q#Pauli para a extensão QDK em VS Code.

As configurações de ruído se aplicam aos resultados do histograma para todas as portas, medições e qubits em todos os Q# programas em VS Code.

Sem ruído, um histograma para este GHZ programa de exemplo mostra $\ket{00000}$ por cerca de metade das medidas e $\ket{11111}$ para a outra metade.

import Std.Diagnostics.*;
import Std.Measurement.*;

operation Main() : Result[] {
    let num = 5;
    return GHZSample(num);
}

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];
    H(qs[0]);
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Captura de tela de um histograma sem ruído e picos em que todos os qubits são zero ou todos os qubits são um.

A uma taxa de ruído de 1% bit-flip, os resultados começam a se espalhar. Aos 25%, o histograma é indistinguível do ruído puro.

Captura de tela de histogramas para um Q# programa com taxas de ruído por inversão de bits de 1% e 25%.

Adicione ruído individual a programas PauliQ#

Use ConfigurePauliNoise para definir ou alterar o modelo de ruído de um programa Q# e controlar quando e onde o ruído ocorre.

Note

As VS Code configurações aplicam ruído a todos os Q# programas, mas ConfigurePauliNoise substitui essas configurações para o programa que o chama.

No programa anterior, adicione ruído imediatamente após a alocação do qubit:

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    // 5% bit-flip noise applies to all subsequent operations.
    ConfigurePauliNoise(0.05, 0.0, 0.0);

    H(qs[0]);
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Captura de tela dos resultados do histograma quando o ruído de 5% bit-flip é iniciado após a alocação do qubit.

Para aplicar ruído somente à operação de medição, defina o modelo de ruído imediatamente antes da medição e remova-o em seguida:

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];
    H(qs[0]);
    ApplyCNOTChain(qs);

    // Noise applies only to the measurement operation.
    ConfigurePauliNoise(0.05, 0.0, 0.0);

    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Captura de tela dos resultados do histograma quando o ruído de inversão de bits de 5% começa imediatamente antes da medição.

Para alterar ou limpar a configuração de ruído em diferentes pontos do programa, chame ConfigurePauliNoise várias vezes. Por exemplo, aplique 5% de ruído de inversão de bits à porta Hadamard e, em seguida, remova a configuração de ruído para o restante do programa.

operation GHZSample(n: Int) : Result[] {
    use qs = Qubit[n];

    // Noise applies to the H operation.
    ConfigurePauliNoise(0.05, 0.0, 0.0);
    
    H(qs[0]);

    // Clear the noise settings.
    ConfigurePauliNoise(0.0, 0.0, 0.0);
    
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Outras Q# funções de ruído

ConfigurePauliNoise dá suporte a qualquer modelo de ruído Pauli. Use estas funções e operações do namespace Std.Diagnostics para configurar ou aplicar ruído:

Function Description Example
ConfigurePauliNoise Define Pauli o ruído para uma simulação. Informe as probabilidades de erro de Pauli $X$, $Y$ e $Z$ ou um Pauli modelo de ruído. A configuração se aplica a todos os portões, medidas e qubits subsequentes em um programa Q# e substitui as configurações de ruído da extensão VS Code. As chamadas subsequentes substituem as configurações anteriores. ConfigurePauliNoise(0.1, 0.0, 0.5)
ou
ConfigurePauliNoise(BitFlipNoise(0.1))
BitFlipNoise Retorna um modelo de ruído com apenas Pauli erros $X$ com a probabilidade especificada. 10% ruído de inversão de bits
ConfigurePauliNoise(BitFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.1, 0.0, 0.0)
PhaseFlipNoise Retorna um modelo de ruído com apenas Pauli erros $Z$ com a probabilidade especificada. 10% ruído de inversão de fase:
ConfigurePauliNoise(PhaseFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.1)
DepolarizingNoise Retorna um modelo de ruído com probabilidades iguais para Pauli erros de $X$, $Y$ e $Z$. Ruído despolarizante de 6%
ConfigurePauliNoise(DepolarizingNoise(0.06)) $\equiv$ ConfigurePauliNoise(0.02, 0.02, 0.02)
NoNoise Retorna um modelo com probabilidades de erro iguais a zero. Passe isso para ConfigurePauliNoise para limpar a configuração de ruído atual. ConfigurePauliNoise(NoNoise()) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.0)
ApplyIdleNoise Aplica o ruído configurado a um único qubit durante a simulação. ...
use q = Qubit[2];
ConfigurePauliNoise(0.1, 0.0, 0.0);
ApplyIdleNoise(q[0]);
...
  • Última atualização em