Simulador quântico esparso

O simulador esparso é o simulador local padrão para ambientes de desenvolvimento do Azure Quantum e utiliza uma representação esparsa de vetores de estado quântico. Esse recurso permite que o simulador esparso minimize o volume de memória usado para representar estados do Quantum, assim viabilizando simulações em um número maior de qubits. O simulador esparso é eficiente para representar estados do Quantum que são esparsos na base computacional, ou seja, estados para os quais a maioria dos coeficientes de amplitude são iguais a zero na base computacional. Dessa forma, o simulador esparso permite que os usuários explorem aplicativos maiores do que aqueles que podem ser representados usando um simulador de estado completo, que desperdiçará memória e tempo em um número exponencialmente grande de amplitudes nulas.

Para obter mais informações sobre o simulador esparso, confira Jaques e Häner (arXiv:2105.01533).

Chamando o simulador esparso

O simulador esparso é o simulador local padrão no Visual Studio Code com a extensão do Azure Quantum Development Kit instalada.

Adicionando ruído Pauli ao simulador esparso

O simulador esparso dá suporte à adição de ruído Pauli à simulação. Esse recurso permite que você simule os efeitos do ruído em operações e medidas quânticas. O modelo de ruído é especificado usando um dicionário de probabilidades de ruído Pauli, em que as chaves são os operadores XPauli, Ye Zos valores são as probabilidades de aplicar o operador Pauli correspondente. O modelo de ruído pode ser usado em Q# programas, programas Python ou configurado nas definições do VS Code.

Adicionando ruído Pauli usando as configurações do VS Code

O ruído Pauli pode ser configurado globalmente no Visual Studio Code através da configuração do usuário Q#> Simulation:Pauli Noise.

As configurações se aplicam aos resultados do histograma para todos os Q# programas executados no VS Code e a todos os portões, medidas e qubits referenciados no programa. As configurações são idênticas ao uso da ConfigurePauliNoise() função.

Executar um histograma do seguinte programa de exemplo em GHz sem ruído configurado retornaria $\ket{00000}$ aproximadamente metade do tempo e $\ket{11111}$ na 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;
}

No entanto, a adição de 1% de ruído de inversão de bit mostra que o estado começa a se difundir e, com 25% de ruído, o estado é indistinguível do ruído.

Adicionando ruído Pauli aos Q# programas

Você pode usar a ConfigurePauliNoise() função para definir ou modificar o modelo de ruído para programas individuais Q# . Usando ConfigurePauliNoise(), você pode controlar granularmente onde o ruído é aplicado em seus Q# programas.

Por exemplo, no programa anterior, você pode adicionar ruído imediatamente após a alocação de qubit:

...
operation GHzSample(n: Int) : Result[] {
    use qs = Qubit[n];
    ConfigurePauliNoise(0.05, 0.0, 0.0); // 5% bit-flip noise applies to all operations
    H(qs[0]);
...

ou logo antes da operação de medição.

    ...
    use qs = Qubit[n];
    H(qs[0]);

    ApplyCNOTChain(qs);
    ConfigurePauliNoise(0.05, 0.0, 0.0); // noise applies only to measurement operation 
    let results = MeasureEachZ(qs);
    ...

Você também pode usar ConfigurePauliNoise() para redefinir ou limpar as configurações de ruído. Neste exemplo, as configurações de ruído são definidas após a alocação de qubit e, em seguida, removidas imediatamente após a operação Hadamard, de forma que o ruído seja aplicado apenas à operação H();.

...
operation GHzSample(n: Int) : Result[] {
    use qs = Qubit[n];
    ConfigurePauliNoise(0.05, 0.0, 0.0); // noise applies to H() operation
    H(qs[0]);
    ConfigurePauliNoise(0.0, 0.0, 0.0); // clear noise settings
...

Estão disponíveis as seguintes funções na biblioteca Std.Diagnostics para ajustar o ruído em programas Q#:

Adicionando ruído de Pauli a programas Python ou Jupyter Notebooks

A configuração de ruído Pauli está disponível com o pacote Python qdk.qsharp e a funcionalidade de histograma com o pacote qdk.widgets. O ruído é adicionado como um parâmetro ao qsharp.run método.

• qsharp.BitFlipNoise
• qsharp.PhaseFlipNoise
• qsharp.DepolarizingNoise

O exemplo a seguir mostra o efeito do ruído despolarizante de 10% em uma medida de estado de Bell.

from qdk import qsharp
from qdk import widgets

%%qsharp

operation BellPair() : Result[] {
    use q = Qubit[2];
    H(q[0]);
    CNOT(q[0], q[1]);
    MResetEachZ(q)
}

results = qsharp.run("BellPair()", 20, noise=qsharp.DepolarizingNoise(0.1))
results

O ruído arbitrário de Pauli pode ser adicionado ao modelo de ruído especificando as probabilidades de cada operador Pauli. Vamos usar o programa de exemplo GHz anterior:

%%qsharp

operation GHzSample() : Result[] {
    use q = Qubit[5];
    H(q[0]);
    ApplyCNOTChain(q);
    MResetEachZ(q)
}

Essa execução do programa aplica ruído com probabilidade de 20% (flip de bit metade do tempo e flip de fase metade do tempo),

result = qsharp.run("GHzSample()", 20, noise=(0.1, 0.0, 0.1))
display(widgets.Histogram(result))

e essa execução aplica ruído Pauli-Y com probabilidade de 10%.

result = qsharp.run("GHzSample()", 20, noise=(0.0, 0.1, 0.0))
display(widgets.Histogram(result))