Esercizio - Iniziare a usare lo strumento di stima delle risorse di Azure Quantum

8 minuti

In questa unità si farà pratica con lo strumento di stima delle risorse di Azure Quantum. Nell'esempio seguente, si stimano le risorse fisiche dell'esempio di algoritmo di Shor.

Installare qsharp e qsharp-widgets

Prima di tutto, installare i pacchetti qsharp e qsharp-widgets di Azure Quantum più recenti.

python -m pip install --upgrade qsharp qsharp-widgets

Creare l'algoritmo quantistico

In Visual Studio Code, selezionare Visualizza > Riquadro comandi e selezionare Crea: Nuovo Jupyter Notebook.
Nella prima cella del notebook, importare il pacchetto qsharp:
```
import qsharp
from qsharp_widgets import EstimateDetails
```

Aggiungere una nuova cella e copiare il codice seguente:

%%qsharp
/// # Sample
/// Random Bit
///
/// # Description
/// This Q# program generates a random bit by setting a qubit in a superposition
/// of the computational basis states |0〉 and |1〉, and returning the measurement
/// result.

    operation RandomBit() : Result {
        // Qubits are only accesible for the duration of the scope where they
        // are allocated and are automatically released at the end of the scope.
        use qubit = Qubit();

        // Set the qubit in superposition by applying a Hadamard transformation.
        H(qubit);

        // Measure the qubit. There is a 50% probability of measuring either 
        // `Zero` or `One`.
        let result = M(qubit);

        // Reset the qubit so it can be safely released.
        Reset(qubit);
        return result;
    }

Stimare l'algoritmo quantistico

Stimare ora le risorse fisiche per l'operazione RandomBit usando le ipotesi predefinite. Aggiungere una nuova cella e copiare il codice seguente:
```
result = qsharp.estimate("RandomBit()")
result
```
La funzione qsharp.estimate crea un oggetto risultato, che può essere usato per visualizzare una tabella con il conto complessivo delle risorse fisiche. La prima tabella mostra le principali stime delle risorse fisiche. L'operazione RandomBit richiede 300 qubit e due microsecondi per l'esecuzione in un computer quantistico.

Stime delle risorse fisiche Valore

esecuzione 2 microsec

rQOPS 3.00M

Qubit fisici 300

Stime delle risorse fisiche	Valore
esecuzione	2 microsec
rQOPS	3.00M
Qubit fisici	300

È possibile controllare i dettagli dei costi comprimendo i gruppi, che includono altre informazioni. Ad esempio, comprimere il gruppo di Parametri qubit logici per vedere che la distanza del codice è 5 e il numero di qubit fisici per qubit logico è 50.

Parametro qubit logico	Valore
Schema Correzione degli errori quantistici	surface_code
Distanza di codice	5
Qubit fisici	50
Durata ciclo logico	2 microsec
Frequenza di errore del qubit logico	3.00E-5
Prefactoring di incrocio	0.03
Soglia di correzione degli errori	0,01
Formula tempo del ciclo logico	(4 * `twoQubitGateTime` + 2 * `oneQubitMeasurementTime`) * `codeDistance`
Formula qubit fisici	2 * `codeDistance` * `codeDistance`

È possibile usare il campo jobParams per accedere a tutti i parametri di destinazione che possono essere passati all'esecuzione del processo e verificare quali valori predefiniti sono stati considerati:

result['jobParams']

{'errorBudget': 0.001,
 'qecScheme': {'crossingPrefactor': 0.03,
  'errorCorrectionThreshold': 0.01,
  'logicalCycleTime': '(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance',
  'name': 'surface_code',
  'physicalQubitsPerLogicalQubit': '2 * codeDistance * codeDistance'},
 'qubitParams': {'instructionSet': 'GateBased',
  'name': 'qubit_gate_ns_e3',
  'oneQubitGateErrorRate': 0.001,
  'oneQubitGateTime': '50 ns',
  'oneQubitMeasurementErrorRate': 0.001,
  'oneQubitMeasurementTime': '100 ns',
  'tGateErrorRate': 0.001,
  'tGateTime': '50 ns',
  'twoQubitGateErrorRate': 0.001,
  'twoQubitGateTime': '50 ns'}}

È possibile notare che l'oggetto Strumento di stima delle risorse accetta il modello qubit qubit_gate_ns_e3, il codice di correzione degli errori surface_code e il budget degli errori 0,001 come valori predefiniti per la stima.

Modificare i valori predefiniti e stimare l'algoritmo

Quando si invia una richiesta di stima delle risorse per il programma, è possibile specificare alcuni parametri facoltativi. Questi sono i parametri di destinazione che possono essere personalizzati:

errorBudget: il budget complessivo degli errori consentito per l'algoritmo
qecScheme: schema di correzione di errori quantistici (QEC)
qubitParams: parametri qubit fisici
constraints: i vincoli a livello di componente
distillationUnitSpecifications: le specifiche per gli algoritmi di crittografia delle factory T
estimateType: singola o frontiera

Modificare il modello qubit

È possibile stimare il costo per lo stesso algoritmo usando il parametro qubit basato su Majorana, qubitParams, qubit_maj_ns_e6.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                }})
EstimateDetails(result_maj)

Modificare lo schema di correzione degli errori quantistici

È possibile rieseguire il processo di stima delle risorse per lo stesso esempio nei parametri qubit basati su Majorana con uno schema QEC floqued, qecScheme.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                }})
EstimateDetails(result_maj)

Modificare il budget degli errori

Eseguire quindi di nuovo lo stesso circuito quantistico con un valore errorBudget pari al 10%.

result_maj = qsharp.estimate("RandomBit()", params={
                "qubitParams": {
                    "name": "qubit_maj_ns_e6"
                },
                "qecScheme": {
                    "name": "floquet_code"
                },
                "errorBudget": 0.1})
EstimateDetails(result_maj)