Simulatore quantistico sparso

Il simulatore di tipo sparse usa una rappresentazione di tipo sparse dei vettori di stato quantistico. Uno stato quantistico sparse è uno stato in cui la maggior parte dei coefficienti di ampiezza è zero. Le rappresentazioni di tipo sparse consentono al simulatore di tipo sparse di ridurre al minimo il footprint di memoria necessario per rappresentare gli stati quantistici, consentendo le simulazioni su un numero maggiore di qubit. Il simulatore di tipo sparse è efficiente per i programmi con stati quantistici che sono rari nella base computazionale. Il simulatore di tipo sparse consente agli utenti di esplorare applicazioni di dimensioni maggiori rispetto a un simulatore di stato completo perché i simulatori di stato completo sprecano memoria e tempo in un numero esponenzialmente elevato di ampiezze zero.

Per altre informazioni sul simulatore sparso, vedere Jaques e Häner (arXiv:2105.01533).

Chiamare il simulatore di tipo sparse

Il simulatore sparse è il simulatore locale predefinito nell'estensione MicrosoftQuantum Development Kit (QDK) per Visual Studio Code (VS Code). La modalità di utilizzo del simulatore di tipo sparse dipende dall'ambiente di sviluppo.

Ambiente di sviluppo	Come chiamare il simulatore di tipo sparse
In un programma Q# o OpenQASM in VS Code	Eseguire il file Q# o OpenQASM
In un Python programma con la qdk libreria	qsharp.run o openqasm.run o qiskit.QSharpBackend
In una %%qsharp cella del notebook	Chiama l'operazione di avvio del programma, ad esempio: Main()

Aggiungere Pauli rumore al simulatore sparso in VS Code

Il simulatore sparso supporta l'aggiunta di Pauli rumore alle simulazioni dei tuoi Q# programmi con l'estensione VS Code. Questa funzionalità consente di simulare gli effetti del rumore sulle operazioni quantistiche e sulle misurazioni. Nel programma Q#, usa la funzione ConfigurePauliNoise per specificare un modello di disturbo. La funzione imposta le probabilità per gli operatori Pauli, X, Y e Z, per l'occorrenza di rumore. È anche possibile configurare modelli di disturbo globale nelle impostazioni di estensione.

Aggiungere Pauli rumore usando VS Code impostazioni

Per impostare il rumore globale Pauli per i programmi Q# in VS Code, configurare l'impostazione utente Q#> Simulazione:Pauli Noise per l'estensione QDK.

Le impostazioni del rumore si applicano ai risultati dell'istogramma per tutti i gate, le misurazioni e i qubit in VS Code in tutti i Q# programmi.

Ad esempio, un istogramma per il seguente programma di esempio GHz senza rumore configurato mostra un risultato di $\ket{00000}$ per circa metà delle misurazioni e $\ket{11111}$ per l'altra metà.

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

Se si aggiunge anche un tasso di rumore di inversione dei bit dell'1%, i risultati iniziano a diversificarsi. Con il 25% di rumore di fluttuazione dei bit, l'istogramma è indistinguibile dal rumore puro.

Aggiungi Pauli rumore ai singoli Q# programmi

Usare la ConfigurePauliNoise funzione per impostare o modificare il modello di disturbo per i singoli Q# programmi. La ConfigurePauliNoise funzione consente di controllare quando e dove si verifica rumore nei Q# programmi.

Annotazioni

Se si configura il rumore nelle VS Code impostazioni, il rumore viene applicato a tutti i Q# programmi. Tuttavia, la funzione esegue l'override ConfigurePauliNoise delle VS Code impostazioni di disturbo per il programma che chiama la funzione.

Ad esempio, nel programma precedente è possibile aggiungere rumore immediatamente dopo l'allocazione di qubit.

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

In alternativa, è possibile aggiungere rumore solo all'operazione di misurazione.

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

Per modificare o eliminare configurazioni di rumore in punti diversi del programma, chiama ConfigurePauliNoise più volte. Ad esempio, è possibile impostare il 5% di rumore di capovolgimento di bit sulla porta di Hadamard e poi disattivare il rumore per il resto del programma.

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

Altre Q# funzioni di rumore

La funzione ConfigureNoiseFunction è sufficiente per modellare qualsiasi tipo di rumore Pauli nel programma, ma Q# dispone di altre funzioni di rumore che si possono usare. Nella libreria Std.Diagnostics sono disponibili le funzioni seguenti per configurare il rumore nei programmi Q#.

Funzione	Description	Example
ConfigurePauliNoise	Configura il Pauli disturbo per l'esecuzione di un simulatore. I parametri rappresentano le probabilità di rumore di cancello Pauli X, Y e Z. La configurazione del rumore si applica a tutte le porte, le misurazioni e i qubit successivi in un programma Q#. Sostituisce le impostazioni del rumore dell'estensione VS Code. Chiamate successive a ConfigurePauliNoise sovrascrivono il rumore impostato dalle chiamate precedenti.	ConfigurePauliNoise(0.1, 0.0, 0.5) o ConfigurePauliNoise(BitFlipNoise(0.1))
BitFlipNoise	Configura solo il rumore della porta X con la probabilità specificata.	10% rumore di inversione di bit: ConfigurePauliNoise(BitFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.1, 0.0, 0.0)
PhaseFlipNoise	Configura solo il rumore di cancello Z con la probabilità specificata.	10% rumore di inversione di fase: ConfigurePauliNoise(PhaseFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.1)
DepolarizingNoise	Configura il rumore come porta X, Y o Z a pari probabilità.	6% rumore depolarizzato: ConfigurePauliNoise(DepolarizingNoise(0.06)) $\equiv$ ConfigurePauliNoise(0.2, 0.2, 0.2)
NoNoise	Reimposta il modello di rumore in modo che non presenti rumore.	ConfigurePauliNoise(NoNoise()) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.0)
ApplyIdleNoise	Applica il rumore configurato a un singolo qubit durante la simulazione.	... use q = Qubit[2]; ConfigurePauliNoise(0.1, 0.0, 0.0); ApplyIdleNoise(q[0]); ...