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. Este recurso permite que o simulador esparso minimize a pegada de memória usada para representar estados quânticos, permitindo simulações sobre um número maior de qubits. O simulador esparso é eficiente para representar estados quânticos que são esparsos na base computacional, ou seja, estados quânticos para os quais a maioria dos coeficientes de amplitude são zero na base computacional. Como tal, o simulador esparso permite que os usuários explorem aplicações maiores do que o que pode ser representado usando um simulador de estado completo que desperdiçará memória e tempo em um número exponencialmente grande de amplitudes zero.

Para obter mais informações sobre o simulador esparso, consulte 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 suporta a adição de ruído Pauli à simulação. Este recurso permite simular os efeitos do ruído em operações e medições quânticas. O modelo de ruído é especificado usando um dicionário de probabilidades de ruído de Pauli, onde as chaves são os operadores Xde Pauli , Ye Z, e os valores são as probabilidades de aplicar o operador de Pauli correspondente. O modelo de ruído pode ser usado em Q# programas, programas Python ou configurado nas configuraçõ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 ajustando a definição do utilizador Q#> Simulation:Pauli Noise.

As configurações se aplicam aos resultados do histograma para todos os Q# programas executados no VS Code e a todas as portas, 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 amostra GHz sem ruído configurado retornaria $\ket{00000}$ aproximadamente metade do tempo e $\ket{11111}$ 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;
}

No entanto, adicionar 1% de ruído bit-flip mostra que o estado começa a difundir-se, 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# . Utilizando ConfigurePauliNoise(), é possível controlar detalhadamente onde o ruído é aplicado nos programas Q#.

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 imediatamente 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 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, limpas imediatamente após a operação Hadamard, para 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
...

As seguintes funções estão disponíveis na biblioteca Std.Diagnostics para configurar ruído em programas Q#.

Como adicionar ruído de Pauli a programas em Python ou Jupyter Notebooks

A configuração de ruído Pauli está disponível com o qdk.qsharp pacote Python, e a capacidade de histograma com o qdk.widgets pacote. 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 medição do 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 de Pauli. Vamos usar o programa de exemplo GHz anterior:

%%qsharp

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

Esta execução do programa aplica ruído com probabilidade de 20% ("bit-flip" metade do tempo e "phase-flip" metade do tempo),

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

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

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