Simulador cuántico disperso

El simulador disperso utiliza una representación dispersa de vectores de estado cuántico. Un estado cuántico disperso es un estado donde la mayoría de los coeficientes de amplitud son cero. Las representaciones dispersas permiten al simulador disperso minimizar la superficie de memoria necesaria para representar estados cuánticos, lo que permite simulaciones en un mayor número de cúbits. El simulador disperso es eficaz para programas con estados cuánticos dispersos en la base computacional. El simulador disperso permite a los usuarios explorar aplicaciones más grandes que un simulador de estado completo porque los simuladores de estado completo pierden memoria y tiempo en un número exponencialmente grande de amplitudes cero.

Para obtener más información sobre el simulador disperso, vea Jaques y Häner (arXiv:2105.01533).

Llamada al simulador disperso

El simulador disperso es el simulador local predeterminado en la extensión MicrosoftQuantum Development Kit (QDK) para Visual Studio Code (VS Code). El modo de usar el simulador disperso varía según el entorno de desarrollo.

Entorno de desarrollo Cómo ejecutar el simulador disperso
En un programa Q# o OpenQASM en VS Code Ejecutar el archivo Q# o OpenQASM
En un programa de Python con la biblioteca de qdk qsharp.run
o
openqasm.run
o
qiskit.QSharpBackend
En una celda del %%qsharp cuaderno Llame a la función de inicio del programa, por ejemplo:
Main()

Agregar Pauli ruido al simulador disperso en VS Code

El simulador disperso admite la adición de Pauli ruido a las simulaciones de sus programas Q# con la extensión VS Code. Esta característica permite simular los efectos del ruido en las operaciones cuánticas y las medidas. Para especificar un modelo de ruido en el programa Q#, use la función ConfigurePauliNoise. La función establece las probabilidades de que se produzcan Pauli los operadores X, Y, Z y ruido. También puede configurar modelos globales de ruido en la configuración de la extensión.

Añadir Pauli ruido utilizando la VS Code configuración

Para establecer el ruido global Pauli para Q# los programas de VS Code, configure la Q#> configuración de usuario Simulation:Pauli Noise para la QDK extensión.

Captura de pantalla que muestra la configuración de ruido global Q# de la QDK extensión en VS Code.

La configuración de ruido se aplica a los resultados del histograma para todas las puertas, medidas y cúbits en todos los Q# programas de VS Code.

Por ejemplo, un histograma para el siguiente programa de ejemplo de GHz sin ruido configurado muestra un resultado de $\ket{00000}$ durante aproximadamente la mitad de las mediciones y $\ket{11111}$ para la otra mitad.

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 pantalla que muestra los resultados sin ruido.

Si agrega incluso una tasa de ruido por volteo de bits del 1%, los resultados comienzan a difundirse. Con un 25% de ruido de volteo de bits, el histograma se vuelve indistinguible del ruido puro.

Captura de pantalla de QDK en VS Code que muestra los resultados del histograma para un programa con tasas de ruido de giro de bits del 1% y 25%.

Agregar Pauli ruido a Q# programas individuales

Use la ConfigurePauliNoise función para establecer o modificar el modelo de ruido para programas individuales Q# . La ConfigurePauliNoise función le proporciona control sobre cuándo y dónde se produce ruido en los Q# programas.

Nota:

Si configura ruido en la VS Code configuración, el ruido se aplica a todos los Q# programas. Sin embargo, la ConfigurePauliNoise función invalida la configuración de ruido de VS Code del programa que llama a la función.

Por ejemplo, en el programa anterior puede agregar ruido inmediatamente después de la asignación de cúbits.

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

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

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

Captura de pantalla que muestra los resultados de histogramas con ruido agregado después de la asignación de cúbits.

O bien, puede agregar ruido solo a la operación de medición.

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

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

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

Captura de pantalla que muestra los resultados del histograma con ruido agregado justo antes de la medición.

Para modificar o borrar configuraciones de ruido en diferentes puntos del programa, llame varias ConfigurePauliNoise veces. Por ejemplo, puede establecer un ruido de volteo de bits del 5% en la puerta Hadamard y luego no establecer ruido para el resto del 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;
}

Otras funciones de ruido Q#

La función ConfigureNoiseFunction es suficiente para modelar cualquier tipo de Pauli ruido en su programa, pero Q# tiene otras funciones de ruido que también puede usar. Las siguientes funciones están disponibles en la Std.Diagnostics biblioteca para configurar el ruido en Q# programas:

Función Description Example
ConfigurePauliNoise Pauli Configura el ruido de una ejecución del simulador. Los parámetros representan las probabilidades de ruido de las puertas X, Y y Z Pauli. La configuración de ruido se aplica a todas las puertas, mediciones y qubits posteriores en un programa Q#. Sobrescribe los ajustes de ruido de la extensión VS Code. Las llamadas posteriores a ConfigurePauliNoise sobrescriben el ruido establecido por llamadas anteriores. ConfigurePauliNoise(0.1, 0.0, 0.5)
o
ConfigurePauliNoise(BitFlipNoise(0.1))
BitFlipNoise Configura solo el ruido de la puerta X con la probabilidad especificada. 10% ruido de volteo de bits:
ConfigurePauliNoise(BitFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.1, 0.0, 0.0)
PhaseFlipNoise Configura solo el ruido de la puerta Z con la probabilidad especificada. 10% ruido de volteo por fase:
ConfigurePauliNoise(PhaseFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.1)
DepolarizingNoise Configura el ruido para que sea la puerta X, Y o Z con probabilidades iguales. 6% ruido despolarizante
ConfigurePauliNoise(DepolarizingNoise(0.06)) $\equiv$ ConfigurePauliNoise(0.2, 0.2, 0.2)
NoNoise Restablece el modelo de ruido para que no tenga ruido. ConfigurePauliNoise(NoNoise()) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.0)
ApplyIdleNoise Aplica el ruido configurado a un solo cúbit durante la simulación. ...
use q = Qubit[2];
ConfigurePauliNoise(0.1, 0.0, 0.0);
ApplyIdleNoise(q[0]);
...
  • Last updated on