8 minuten

Laten we oefenen met de Azure Quantum Resource Estimator. In het volgende voorbeeld maakt u een schatting van de fysieke resources van het algoritmevoorbeeld van Shor.

qsharp en qsharp-widgets installeren

Installeer eerst de nieuwste Azure Quantum qsharp en qsharp-widgets pakketten.

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

Het kwantumalgoritmen maken

Selecteer in VS Code het opdrachtenpalet Weergeven > en selecteer Maken: Nieuw Jupyter Notebook.
Importeer het qsharp pakket in de eerste cel van het notebook.
```
import qsharp
from qsharp_widgets import EstimateDetails
```

Voeg een nieuwe cel toe en kopieer de volgende code.

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

Het kwantumalgoritmen schatten

Nu maakt u een schatting van de fysieke resources voor de RandomBit bewerking met behulp van de standaardveronderstellingen. Voeg een nieuwe cel toe en kopieer de volgende code.
```
result = qsharp.estimate("RandomBit()")
result
```
De qsharp.estimate functie maakt een resultaatobject, dat kan worden gebruikt om een tabel weer te geven met het totale aantal fysieke resources. In de eerste tabel ziet u de belangrijkste schattingen van fysieke resources. De RandomBit bewerking vereist 300 qubits en duurt 2 microseconden om op een kwantumcomputer uit te voeren.

Schattingen van fysieke resources Weergegeven als

Runtime 2 microsec

rQOPS 3.00M

Fysieke qubits 300

Schattingen van fysieke resources	Weergegeven als
Runtime	2 microsec
rQOPS	3.00M
Fysieke qubits	300

U kunt kostendetails inspecteren door de groepen samen te vouwen, die meer informatie hebben. Vouw bijvoorbeeld de groep logische qubitparameters samen om te zien dat de codeafstand 5 is en het aantal fysieke qubits per logische qubit 50 is.

Parameter logische qubit	Weergegeven als
QEC-schema	surface_code
Codeafstand	5
Fysieke qubits	50
Tijd van logische cyclus	2 microsec
Foutpercentage logische qubit	3.00E-5
Kruising vooraf	0.03
Drempelwaarde voor foutcorrectie	0,01
Formule voor tijd van logische cyclus	(4 * `twoQubitGateTime` + 2 * `oneQubitMeasurementTime`) * * `codeDistance`
Formule voor fysieke qubits	2 * `codeDistance` * `codeDistance`

U kunt het jobParams veld gebruiken voor toegang tot alle doelparameters die kunnen worden doorgegeven aan de taakuitvoering en om te zien welke standaardwaarden zijn aangenomen:

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

U kunt zien dat de Resource Estimator het qubit_gate_ns_e3 qubitmodel, de surface_code foutcode en het foutenbudget 0,001 als standaardwaarden voor de schatting gebruikt.

De standaardwaarden wijzigen en het algoritme schatten

Wanneer u een aanvraag voor een resourceraming voor uw programma indient, kunt u enkele optionele parameters opgeven. Dit zijn de doelparameters die kunnen worden aangepast:

errorBudget - het totale toegestane foutbudget voor het algoritme
qecScheme - het QEC-schema (kwantumfoutcorrectie)
qubitParams - de parameters van de fysieke qubit
constraints - de beperkingen op onderdeelniveau
distillationUnitSpecifications - de specificaties voor T factory's destillatiealgoritmen
estimateType - enkele of grens

Qubitmodel wijzigen

U kunt de kosten voor hetzelfde algoritme schatten met behulp van de op Majorana gebaseerde qubitparameter, qubitParams'qubit_maj_ns_e6'.

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

Kwantumfoutcorrectieschema wijzigen

U kunt de resourceramingstaak opnieuw uitvoeren voor hetzelfde voorbeeld op de qubitparameters op basis van Majorana met een floqued QEC-schema. qecScheme

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

Foutbudget wijzigen

Voer vervolgens hetzelfde kwantumcircuit opnieuw uit met een errorBudget van 10%.

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

Doorgaan

Oefening: aan de slag met de Azure Quantum Resource Estimator