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.

Cenário	Método
Em um Q# programa no VS Code	Selecione Executar Q# arquivo
Em uma célula de bloco de anotações Python	`result=qsharp.eval("Program_Entry_Operation()")` ou `result=qsharp.run("Program_Entry_Operation()", shots=##)`
Numa célula do `%%qsharp` bloco de notas	`Program_Entry_Operation()`

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.

Captura de tela mostrando as configurações para Q# simulador barulhento.

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

Captura de tela mostrando resultados sem ruído.

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.

Captura de tela mostrando resultados com 1% de ruído e 25% de 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#.

Observação

Se você configurar o ruído nas configurações do VS Code, o ruído será aplicado a todos os Q# programas. Se configurar o ruído num programa Q# usando ConfigurePauliNoise, esse ruído irá sobrepor as configurações de ruído do VS Code durante a execução desse programa.

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]);
...

Captura de tela mostrando resultados com ruído adicionado após a alocação de qubit.

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);
    ...

Captura de tela mostrando resultados com ruído adicionado pouco antes da medição.

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#.

Função	Description	Example
`ConfigurePauliNoise()`	Configura o ruído Pauli para uma execução de simulador, com os parâmetros representando as probabilidades dos portões X, Y e Z. A configuração de ruído aplica-se a todas as portas, medições e qubits subsequentes de um programa Q#. Ignora quaisquer configurações de ruído no VS Code e pode ser redefinido por chamadas subsequentes `ConfigurePauliNoise()` .	`ConfigurePauliNoise(0.1, 0.0, 0.5)` ou `ConfigurePauliNoise(BitFlipNoise(0.1))`
`BitFlipNoise()`	Configura o ruído para ser a porta X somente com probabilidade especificada. A configuração de ruído aplica-se a todas as portas, medições e qubits subsequentes de um programa Q#.	10% de ruído de inversão de bits: `ConfigurePauliNoise(BitFlipNoise(0.1))` $\equiv$ `ConfigurePauliNoise(0.1, 0.0, 0.0)`
`PhaseFlipNoise()`	Configura o ruído para ser a porta Z somente com probabilidade especificada. A configuração de ruído aplica-se a todas as portas, medições e qubits subsequentes de um programa Q#.	10% ruído de inversão de fase `ConfigurePauliNoise(PhaseFlipNoise(0.1))` $\equiv$ `ConfigurePauliNoise(0.0, 0.0, 0.1)`
`DepolarizingNoise()`	Configura o ruído como porta X, Y ou Z com probabilidades iguais.	6% ruído despolarizante: `ConfigurePauliNoise(DepolarizingNoise(0.06))` $\equiv$ `ConfigurePauliNoise(0.2, 0.2, 0.2)`
`NoNoise()`	Configura o modelo de ruído para nenhum ruído.	`ConfigurePauliNoise(NoNoise())` $\equiv$ `ConfigurePauliNoise(0.0, 0.0, 0.0)`
`ApplyIdleNoise`	Aplica 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]);` `...`

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))

Feedback

Esta página foi útil?

Last updated on 2025-10-17