Övning – Kom igång med Azure Quantum Resource Estimator

  • 8 minuter

Låt oss få lite övning med Azure Quantum Resource Estimator. I följande exempel beräknar du de fysiska resurserna i ett Shor-algoritmexempel.

Installera qsharp- och qsharp-widgetar

Installera först de senaste Azure Quantum qsharp och qsharp-widgets paketen.

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

Skapa kvantalgoritmen

  1. I Visual Studio Code väljer du Visa > kommandopalett och väljer Skapa: Ny Jupyter Notebook.

  2. Importera paketet i anteckningsbokens första cell qsharp :

    import qsharp
from qsharp_widgets import EstimateDetails

  3. Lägg till en ny cell och kopiera följande kod:

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

Beräkna kvantalgoritmen

  1. Beräkna nu de fysiska resurserna för RandomBit åtgärden med hjälp av standardantagandena. Lägg till en ny cell och kopiera följande kod:

    result = qsharp.estimate("RandomBit()")
result

    Funktionen qsharp.estimate skapar ett resultatobjekt som kan användas för att visa en tabell med det totala antalet fysiska resurser. Den första tabellen visar de viktigaste uppskattningarna av fysiska resurser. Åtgärden RandomBit kräver 300 kvantbitar och det tar två mikrosekunder att köras på en kvantdator.

    Uppskattningar av fysiska resurser Värde
    Körmiljö 2 mikrosek
    rQOPS 3,00 M
    Fysiska kvantbitar 300

  2. Du kan kontrollera kostnadsinformationen genom att komprimera grupperna, som har mer information. Dölj till exempel gruppen Logiska qubitparametrar för att se att kodavståndet är 5 och att antalet fysiska kvantbitar per logisk qubit är 50.

    Logisk qubit-parameter Värde
    QEC-schema surface_code
    Kodavstånd 5
    Fysiska kvantbitar 50
    Logisk cykeltid 2 mikrosek
    Felfrekvens för logisk kvantbit 3.00E-5
    Korsande förfaktor 0.03
    Tröskelvärde för felkorrigering 0.01
    Formel för logisk cykeltid (4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
    Formel för fysiska kvantbitar 2 * codeDistance * codeDistance

  3. Du kan använda fältet jobParams för att komma åt alla målparametrar som kan skickas till jobbkörningen och se vilka standardvärden som antogs:

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

    Du kan se att Resource Estimator tar qubit_gate_ns_e3 kvantbitsmodellen, felkorrigeringskoden surface_code och felbudgeten 0,001 som standardvärden för uppskattningen.

Ändra standardvärdena och uppskatta algoritmen

När du skickar en resursuppskattningsbegäran för ditt program kan du ange några valfria parametrar. Det här är de målparametrar som du kan anpassa:

  • errorBudget: Den övergripande tillåtna felbudgeten för algoritmen
  • qecScheme: QEC-schemat (Quantum Error Correction)
  • qubitParams: De fysiska kvantbitsparametrarna
  • constraints: Begränsningarna på komponentnivå
  • distillationUnitSpecifications: Specifikationerna för T-fabrikers destillationsalgoritmer
  • estimateType: Enkel eller gräns

Ändra qubitmodell

Du kan beräkna kostnaden för samma algoritm med hjälp av den Majorana-baserade qubitparametern , qubitParams. qubit_maj_ns_e6

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

Ändra korrigeringsschema för kvantfel

Du kan köra resursuppskattningsjobbet igen för samma exempel på de Majorana-baserade qubitparametrarna med ett floqued QEC-schema, qecScheme.

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

Budget för ändringsfel

Kör sedan om samma kvantkrets med errorBudget 10 %.

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