Az erőforrásbecslő futtatásának különböző módjai

A VS Code előfeltételei

• A Visual Studio Code legújabb verziója, vagy nyissa meg a VS Code-ot a weben.
• A Quantum Development Kit bővítmény legújabb verziója. A telepítés részleteiért lásd: QDK-bővítmény beállítása.

Új Q#-fájl létrehozása

1. Nyissa meg a Visual Studio Code-ot, és válassza a Fájl > új szövegfájlja lehetőséget egy új fájl létrehozásához.
2. Mentse a fájlt ShorRE.qs néven. Ez a fájl tartalmazza a program Q#-kódját.

A kvantum-algoritmus létrehozása

Másolja a következő kódot a ShorRE.qs fájlba:

    import Std.Arrays.*;
    import Std.Canon.*;
    import Std.Convert.*;
    import Std.Diagnostics.*;
    import Std.Math.*;
    import Std.Measurement.*;
    import Microsoft.Quantum.Unstable.Arithmetic.*;
    import Std.ResourceEstimation.*;

    operation Main() : Unit {
        let bitsize = 31;

        // When choosing parameters for `EstimateFrequency`, make sure that
        // generator and modules are not co-prime
        let _ = EstimateFrequency(11, 2^bitsize - 1, bitsize);
    }

    // In this sample we concentrate on costing the `EstimateFrequency`
    // operation, which is the core quantum operation in Shors algorithm, and
    // we omit the classical pre- and post-processing.

    /// # Summary
    /// Estimates the frequency of a generator
    /// in the residue ring Z mod `modulus`.
    ///
    /// # Input
    /// ## generator
    /// The unsigned integer multiplicative order (period)
    /// of which is being estimated. Must be co-prime to `modulus`.
    /// ## modulus
    /// The modulus which defines the residue ring Z mod `modulus`
    /// in which the multiplicative order of `generator` is being estimated.
    /// ## bitsize
    /// Number of bits needed to represent the modulus.
    ///
    /// # Output
    /// The numerator k of dyadic fraction k/2^bitsPrecision
    /// approximating s/r.
    operation EstimateFrequency(
        generator : Int,
        modulus : Int,
        bitsize : Int
    )
    : Int {
        mutable frequencyEstimate = 0;
        let bitsPrecision =  2 * bitsize + 1;

        // Allocate qubits for the superposition of eigenstates of
        // the oracle that is used in period finding.
        use eigenstateRegister = Qubit[bitsize];

        // Initialize eigenstateRegister to 1, which is a superposition of
        // the eigenstates we are estimating the phases of.
        // We first interpret the register as encoding an unsigned integer
        // in little endian encoding.
        ApplyXorInPlace(1, eigenstateRegister);
        let oracle = ApplyOrderFindingOracle(generator, modulus, _, _);

        // Use phase estimation with a semiclassical Fourier transform to
        // estimate the frequency.
        use c = Qubit();
        for idx in bitsPrecision - 1..-1..0 {
            within {
                H(c);
            } apply {
                // `BeginEstimateCaching` and `EndEstimateCaching` are the operations
                // exposed by Azure Quantum Resource Estimator. These will instruct
                // resource counting such that the if-block will be executed
                // only once, its resources will be cached, and appended in
                // every other iteration.
                if BeginEstimateCaching("ControlledOracle", SingleVariant()) {
                    Controlled oracle([c], (1 <<< idx, eigenstateRegister));
                    EndEstimateCaching();
                }
                R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);
            }
            if MResetZ(c) == One {
                frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);
            }
        }

        // Return all the qubits used for oracles eigenstate back to 0 state
        // using Microsoft.Quantum.Intrinsic.ResetAll.
        ResetAll(eigenstateRegister);

        return frequencyEstimate;
    }

    /// # Summary
    /// Interprets `target` as encoding unsigned little-endian integer k
    /// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where
    /// p is `power`, g is `generator` and N is `modulus`.
    ///
    /// # Input
    /// ## generator
    /// The unsigned integer multiplicative order ( period )
    /// of which is being estimated. Must be co-prime to `modulus`.
    /// ## modulus
    /// The modulus which defines the residue ring Z mod `modulus`
    /// in which the multiplicative order of `generator` is being estimated.
    /// ## power
    /// Power of `generator` by which `target` is multiplied.
    /// ## target
    /// Register interpreted as little endian encoded which is multiplied by
    /// given power of the generator. The multiplication is performed modulo
    /// `modulus`.
    internal operation ApplyOrderFindingOracle(
        generator : Int, modulus : Int, power : Int, target : Qubit[]
    )
    : Unit
    is Adj + Ctl {
        // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We
        // also use `ExpModI` to compute a by which x must be multiplied. Also
        // note that we interpret target as unsigned integer in little-endian
        // encoding.
        ModularMultiplyByConstant(modulus,
                                    ExpModI(generator, power, modulus),
                                    target);
    }

    /// # Summary
    /// Performs modular in-place multiplication by a classical constant.
    ///
    /// # Description
    /// Given the classical constants `c` and `modulus`, and an input
    /// quantum register  |𝑦⟩, this operation
    /// computes `(c*x) % modulus` into |𝑦⟩.
    ///
    /// # Input
    /// ## modulus
    /// Modulus to use for modular multiplication
    /// ## c
    /// Constant by which to multiply |𝑦⟩
    /// ## y
    /// Quantum register of target
    internal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[])
    : Unit is Adj + Ctl {
        use qs = Qubit[Length(y)];
        for (idx, yq) in Enumerated(y) {
            let shiftedC = (c <<< idx) % modulus;
            Controlled ModularAddConstant([yq], (modulus, shiftedC, qs));
        }
        ApplyToEachCA(SWAP, Zipped(y, qs));
        let invC = InverseModI(c, modulus);
        for (idx, yq) in Enumerated(y) {
            let shiftedC = (invC <<< idx) % modulus;
            Controlled ModularAddConstant([yq], (modulus, modulus - shiftedC, qs));
        }
    }

    /// # Summary
    /// Performs modular in-place addition of a classical constant into a
    /// quantum register.
    ///
    /// # Description
    /// Given the classical constants `c` and `modulus`, and an input
    /// quantum register  |𝑦⟩, this operation
    /// computes `(x+c) % modulus` into |𝑦⟩.
    ///
    /// # Input
    /// ## modulus
    /// Modulus to use for modular addition
    /// ## c
    /// Constant to add to |𝑦⟩
    /// ## y
    /// Quantum register of target
    internal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[])
    : Unit is Adj + Ctl {
        body (...) {
            Controlled ModularAddConstant([], (modulus, c, y));
        }
        controlled (ctrls, ...) {
            // We apply a custom strategy to control this operation instead of
            // letting the compiler create the controlled variant for us in which
            // the `Controlled` functor would be distributed over each operation
            // in the body.
            //
            // Here we can use some scratch memory to save ensure that at most one
            // control qubit is used for costly operations such as `AddConstant`
            // and `CompareGreaterThenOrEqualConstant`.
            if Length(ctrls) >= 2 {
                use control = Qubit();
                within {
                    Controlled X(ctrls, control);
                } apply {
                    Controlled ModularAddConstant([control], (modulus, c, y));
                }
            } else {
                use carry = Qubit();
                Controlled AddConstant(ctrls, (c, y + [carry]));
                Controlled Adjoint AddConstant(ctrls, (modulus, y + [carry]));
                Controlled AddConstant([carry], (modulus, y));
                Controlled CompareGreaterThanOrEqualConstant(ctrls, (c, y, carry));
            }
        }
    }

    /// # Summary
    /// Performs in-place addition of a constant into a quantum register.
    ///
    /// # Description
    /// Given a non-empty quantum register |𝑦⟩ of length 𝑛+1 and a positive
    /// constant 𝑐 < 2ⁿ, computes |𝑦 + c⟩ into |𝑦⟩.
    ///
    /// # Input
    /// ## c
    /// Constant number to add to |𝑦⟩.
    /// ## y
    /// Quantum register of second summand and target; must not be empty.
    internal operation AddConstant(c : Int, y : Qubit[]) : Unit is Adj + Ctl {
        // We are using this version instead of the library version that is based
        // on Fourier angles to show an advantage of sparse simulation in this sample.

        let n = Length(y);
        Fact(n > 0, "Bit width must be at least 1");

        Fact(c >= 0, "constant must not be negative");
        Fact(c < 2 ^ n, $"constant must be smaller than {2L ^ n}");

        if c != 0 {
            // If c has j trailing zeroes than the j least significant bits
            // of y won't be affected by the addition and can therefore be
            // ignored by applying the addition only to the other qubits and
            // shifting c accordingly.
            let j = NTrailingZeroes(c);
            use x = Qubit[n - j];
            within {
                ApplyXorInPlace(c >>> j, x);
            } apply {
                IncByLE(x, y[j...]);
            }
        }
    }

    /// # Summary
    /// Performs greater-than-or-equals comparison to a constant.
    ///
    /// # Description
    /// Toggles output qubit `target` if and only if input register `x`
    /// is greater than or equal to `c`.
    ///
    /// # Input
    /// ## c
    /// Constant value for comparison.
    /// ## x
    /// Quantum register to compare against.
    /// ## target
    /// Target qubit for comparison result.
    ///
    /// # Reference
    /// This construction is described in [Lemma 3, arXiv:2201.10200]
    internal operation CompareGreaterThanOrEqualConstant(c : Int, x : Qubit[], target : Qubit)
    : Unit is Adj+Ctl {
        let bitWidth = Length(x);

        if c == 0 {
            X(target);
        } elif c >= 2 ^ bitWidth {
            // do nothing
        } elif c == 2 ^ (bitWidth - 1) {
            ApplyLowTCNOT(Tail(x), target);
        } else {
            // normalize constant
            let l = NTrailingZeroes(c);

            let cNormalized = c >>> l;
            let xNormalized = x[l...];
            let bitWidthNormalized = Length(xNormalized);
            let gates = Rest(IntAsBoolArray(cNormalized, bitWidthNormalized));

            use qs = Qubit[bitWidthNormalized - 1];
            let cs1 = [Head(xNormalized)] + Most(qs);
            let cs2 = Rest(xNormalized);

            within {
                for i in IndexRange(gates) {
                    (gates[i] ? ApplyAnd | ApplyOr)(cs1[i], cs2[i], qs[i]);
                }
            } apply {
                ApplyLowTCNOT(Tail(qs), target);
            }
        }
    }

    /// # Summary
    /// Internal operation used in the implementation of GreaterThanOrEqualConstant.
    internal operation ApplyOr(control1 : Qubit, control2 : Qubit, target : Qubit) : Unit is Adj {
        within {
            ApplyToEachA(X, [control1, control2]);
        } apply {
            ApplyAnd(control1, control2, target);
            X(target);
        }
    }

    internal operation ApplyAnd(control1 : Qubit, control2 : Qubit, target : Qubit)
    : Unit is Adj {
        body (...) {
            CCNOT(control1, control2, target);
        }
        adjoint (...) {
            H(target);
            if (M(target) == One) {
                X(target);
                CZ(control1, control2);
            }
        }
    }


    /// # Summary
    /// Returns the number of trailing zeroes of a number
    ///
    /// ## Example
    /// ```qsharp
    /// let zeroes = NTrailingZeroes(21); // = NTrailingZeroes(0b1101) = 0
    /// let zeroes = NTrailingZeroes(20); // = NTrailingZeroes(0b1100) = 2
    /// ```
    internal function NTrailingZeroes(number : Int) : Int {
        mutable nZeroes = 0;
        mutable copy = number;
        while (copy % 2 == 0) {
            nZeroes += 1;
            copy /= 2;
        }
        return nZeroes;
    }

    /// # Summary
    /// An implementation for `CNOT` that when controlled using a single control uses
    /// a helper qubit and uses `ApplyAnd` to reduce the T-count to 4 instead of 7.
    internal operation ApplyLowTCNOT(a : Qubit, b : Qubit) : Unit is Adj+Ctl {
        body (...) {
            CNOT(a, b);
        }

        adjoint self;

        controlled (ctls, ...) {
            // In this application this operation is used in a way that
            // it is controlled by at most one qubit.
            Fact(Length(ctls) <= 1, "At most one control line allowed");

            if IsEmpty(ctls) {
                CNOT(a, b);
            } else {
                use q = Qubit();
                within {
                    ApplyAnd(Head(ctls), a, q);
                } apply {
                    CNOT(q, b);
                }
            }
        }

        controlled adjoint self;
    }

Az erőforrásbecslő futtatása

A Resource Estimator hat előre definiált qubitparamétert kínál, amelyek közül négy kapualapú utasításkészlettel, kettő pedig Majorana-utasításkészlettel rendelkezik. Emellett két surface_codeés .

Ebben a példában az erőforrásbecslőt a qubit paraméterrel és a qubit_gate_us_e3surface_code kvantumhiba-korrekciós kóddal futtatja.

1. Válassza a Nézet –> Parancskatalógus lehetőséget, és írja be az "erőforrás" kifejezést, amely a Q#: Resource Estimates (Erőforrásbecslések kiszámítása) lehetőséget jeleníti meg. A Művelet előtt megjelenő parancsok listájában a BecslésMain. Ezt a lehetőséget választva nyissa meg az Erőforrás-becslés ablakát.

   

2. Egy vagy több Qubit paraméter + Hibajavítás kódtípus kiválasztásával megbecsülheti az erőforrásokat. Ebben a példában válassza a qubit_gate_us_e3, majd kattintson az OK gombra.

   

3. Adja meg a hibakeretet , vagy fogadja el az alapértelmezett 0,001 értéket. Ebben a példában hagyja meg az alapértelmezett értéket, és nyomja le az Enter billentyűt.

4. Az Enter billentyűt lenyomva fogadja el az alapértelmezett eredménynevet a fájlnév, ebben az esetben a ShorRE alapján.

Az eredmények megtekintése

Az Erőforrás-becslés több becslést is biztosít ugyanahhoz az algoritmushoz, amelyek mindegyike a qubitek száma és a futtatókörnyezet közötti kompromisszumokat jeleníti meg. Az erőforrás-becslés egyik legfontosabb aspektusa a futtatókörnyezet és a rendszerméret közötti kompromisszum megértése.

Az erőforrás-becslés eredménye a Q#Becslés ablakban jelenik meg.

1. Az Eredmények lap az erőforrás-becslés összegzését jeleníti meg. Kattintson az első sor melletti ikonra a megjeleníteni kívánt oszlopok kijelöléséhez. A futtatás neve, a becslés típusa, a qubit típusa, a qec-séma, a hibakeret, a logikai qubitek, a logikai mélység, a kód távolsága, a T-állapotok, a T-gyárak, a T-gyárak, a futtatókörnyezet, az rQOPS és a fizikai qubitek közül választhat.

   

   Az eredménytábla Becslés típusú oszlopában láthatja az algoritmus {qubitek, futtatókörnyezet} optimális kombinációinak számát. Ezek a kombinációk a téridő diagramon láthatók.

2. A téridő diagram a fizikai qubitek száma és az algoritmus futtatókörnyezete közötti kompromisszumot mutatja be. Ebben az esetben az erőforrásbecslő több ezer lehetséges kombinációból 13 különböző optimális kombinációt talál. Az egyes {qubitek száma, futtatókörnyezet} pontok fölé rámutatva megtekintheti az adott pont erőforrás-becslésének részleteit.

   

   További információ: Téridő diagram.

   Feljegyzés

   A téridő-diagram egy pontjára, azaz {több qubitre, futtatókörnyezet} párra kell kattintania a térdiagram megtekintéséhez és az adott pontnak megfelelő erőforrás-becslés részleteinek megtekintéséhez.

3. A Space diagram az algoritmushoz és a T-gyárakhoz használt fizikai qubitek eloszlását mutatja, amely {több qubit, futtatókörnyezet} párnak felel meg. Ha például a téridő diagram bal szélső pontját választja ki, az algoritmus futtatásához szükséges fizikai qubitek száma 427726, amelyek közül 196686 algoritmus qubitek, és 231040, amelyek közül t gyári qubitek.

   

4. Végül az Erőforrásbecslések lapon megjelenik az erőforrásbecslő kimeneti adatainak teljes listája, amely egy {számú qubit, futtatókörnyezet} párnak felel meg. A költségadatokat a csoportok összecsukásával vizsgálhatja meg, amelyek további információkkal rendelkeznek. Válassza ki például a téridő diagram bal szélső pontját, és csukja össze a Logikai qubit paraméterei csoportot.

   Logikai qubitparaméter	Érték
   QEC-séma	surface_code
   Kód távolsága	21
   Fizikai qubitek	882
   Logikai ciklus ideje	13 ezredmásodperc
   Logikai qubit hibaaránya	3.00E-13
   Keresztezés előtagja	0.03
   Hibajavítási küszöbérték	0,01
   Logikai ciklusidő képlete	(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance
   Fizikai qubitek képlete	2 * codeDistance * codeDistance

   Tipp.

   A részletes sorok megjelenítése gombra kattintva megjelenítheti a jelentésadatok egyes kimeneteinek leírását.

   További információkért tekintse meg az erőforrásbecslő teljes jelentésadatait.

Paraméterek target módosítása

Ugyanannak a Q#-programnak a költségeit más qubittípussal, hibajavítási kóddal és hibaköltségvetéssel becsülheti meg. Nyissa meg az Erőforrás-becslés ablakát a Nézet – Parancskatalógus>, és írja be a kívánt parancsot.Q#: Calculate Resource Estimates

Válasszon más konfigurációt, például a Majorana-alapú qubit paramétert. qubit_maj_ns_e6 Fogadja el az alapértelmezett hiba tervezett értékét, vagy adjon meg egy újat, majd nyomja le az Enter billentyűt. Az erőforrásbecslő újrafuttatja a becslést az új target paraméterekkel.

További információkért tekintse meg Target az erőforrásbecslő paramétereit .

Paraméterek több konfigurációjának futtatása

Az Azure Quantum Resource Estimator több paraméterkonfigurációt target is futtathat, és összehasonlíthatja az erőforrás-becslés eredményeit.

1. Válassza a Nézet –> Parancskatalógus

2. Válassza qubit_gate_us_e3, qubit_gate_us_e4, qubit_maj_ns_e4 + floquet_code és qubit_maj_ns_e6 + floquet_code lehetőséget, majd kattintson az OK gombra.

3. Fogadja el az alapértelmezett 0,001-es hibakeretértéket, és nyomja le az Enter billentyűt.

4. Az Enter billentyűt lenyomva fogadja el a bemeneti fájlt, ebben az esetben a ShorRE.qs fájlt.

5. Több paraméterkonfiguráció esetén az eredmények különböző sorokban jelennek meg az Eredmények lapon.

6. A téridő diagram a paraméterek összes konfigurációjának eredményeit mutatja. Az eredménytábla első oszlopa megjeleníti a paraméterek minden konfigurációjának jelmagyarázatát. Az egyes pontokra rámutatva megtekintheti az adott pont erőforrás-becslésének részleteit.

   

7. Kattintson a téridő diagram {számú qubit, futtatókörnyezet} pontjára a megfelelő térdiagram és jelentésadatok megjelenítéséhez.

A Jupyter Notebook előfeltételei a VS Code-ban

• Python-környezet, amelyen telepítve van a Python és a Pip .

• A Visual Studio Code legújabb verziója, vagy nyissa meg a VS Code-ot a weben.

• VS Code a Quantum Development Kit, a Pythonés a Jupyter bővítményekkel telepítve.

• A legújabb Azure Quantum qsharp és qsharp_widgets csomagok.

  python -m pip install --upgrade qsharp qsharp_widgets 
  

  vagy

  !pip install --upgrade qsharp qsharp_widgets
  

A kvantum-algoritmus létrehozása

1. A VS Code-ban válassza a > megtekintése lehetőséget, majd a Létrehozás: Új Jupyter-jegyzetfüzet lehetőséget.

2. A jobb felső sarokban a VS Code észleli és megjeleníti a Python verzióját és a jegyzetfüzethez kiválasztott virtuális Python-környezetet. Ha több Python-környezettel rendelkezik, előfordulhat, hogy ki kell választania egy kernelt a jobb felső sarokban található kernelválasztóval. Ha nem észlelt környezetet, a beállítási információkért tekintse meg a VS Code Jupyter-jegyzetfüzeteit.

3. Importálja qsharp a csomagot a jegyzetfüzet első cellájába.

   import qsharp
   

4. Adjon hozzá egy új cellát, és másolja a következő kódot.

   %%qsharp
   import Std.Arrays.*;
   import Std.Canon.*;
   import Std.Convert.*;
   import Std.Diagnostics.*;
   import Std.Math.*;
   import Std.Measurement.*;
   import Microsoft.Quantum.Unstable.Arithmetic.*;
   import Std.ResourceEstimation.*;
   
   operation RunProgram() : Unit {
       let bitsize = 31;
   
       // When choosing parameters for `EstimateFrequency`, make sure that
       // generator and modules are not co-prime
       let _ = EstimateFrequency(11, 2^bitsize - 1, bitsize);
   }
   
   
   // In this sample we concentrate on costing the `EstimateFrequency`
   // operation, which is the core quantum operation in Shors algorithm, and
   // we omit the classical pre- and post-processing.
   
   /// # Summary
   /// Estimates the frequency of a generator
   /// in the residue ring Z mod `modulus`.
   ///
   /// # Input
   /// ## generator
   /// The unsigned integer multiplicative order (period)
   /// of which is being estimated. Must be co-prime to `modulus`.
   /// ## modulus
   /// The modulus which defines the residue ring Z mod `modulus`
   /// in which the multiplicative order of `generator` is being estimated.
   /// ## bitsize
   /// Number of bits needed to represent the modulus.
   ///
   /// # Output
   /// The numerator k of dyadic fraction k/2^bitsPrecision
   /// approximating s/r.
   operation EstimateFrequency(
       generator : Int,
       modulus : Int,
       bitsize : Int
   )
   : Int {
       mutable frequencyEstimate = 0;
       let bitsPrecision =  2 * bitsize + 1;
   
       // Allocate qubits for the superposition of eigenstates of
       // the oracle that is used in period finding.
       use eigenstateRegister = Qubit[bitsize];
   
       // Initialize eigenstateRegister to 1, which is a superposition of
       // the eigenstates we are estimating the phases of.
       // We first interpret the register as encoding an unsigned integer
       // in little endian encoding.
       ApplyXorInPlace(1, eigenstateRegister);
       let oracle = ApplyOrderFindingOracle(generator, modulus, _, _);
   
       // Use phase estimation with a semiclassical Fourier transform to
       // estimate the frequency.
       use c = Qubit();
       for idx in bitsPrecision - 1..-1..0 {
           within {
               H(c);
           } apply {
               // `BeginEstimateCaching` and `EndEstimateCaching` are the operations
               // exposed by Azure Quantum Resource Estimator. These will instruct
               // resource counting such that the if-block will be executed
               // only once, its resources will be cached, and appended in
               // every other iteration.
               if BeginEstimateCaching("ControlledOracle", SingleVariant()) {
                   Controlled oracle([c], (1 <<< idx, eigenstateRegister));
                   EndEstimateCaching();
               }
               R1Frac(frequencyEstimate, bitsPrecision - 1 - idx, c);
           }
           if MResetZ(c) == One {
               frequencyEstimate += 1 <<< (bitsPrecision - 1 - idx);
           }
       }
   
       // Return all the qubits used for oracle eigenstate back to 0 state
       // using Microsoft.Quantum.Intrinsic.ResetAll.
       ResetAll(eigenstateRegister);
   
       return frequencyEstimate;
   }
   
   /// # Summary
   /// Interprets `target` as encoding unsigned little-endian integer k
   /// and performs transformation |k⟩ ↦ |gᵖ⋅k mod N ⟩ where
   /// p is `power`, g is `generator` and N is `modulus`.
   ///
   /// # Input
   /// ## generator
   /// The unsigned integer multiplicative order ( period )
   /// of which is being estimated. Must be co-prime to `modulus`.
   /// ## modulus
   /// The modulus which defines the residue ring Z mod `modulus`
   /// in which the multiplicative order of `generator` is being estimated.
   /// ## power
   /// Power of `generator` by which `target` is multiplied.
   /// ## target
   /// Register interpreted as little endian encoded which is multiplied by
   /// given power of the generator. The multiplication is performed modulo
   /// `modulus`.
   internal operation ApplyOrderFindingOracle(
       generator : Int, modulus : Int, power : Int, target : Qubit[]
   )
   : Unit
   is Adj + Ctl {
       // The oracle we use for order finding implements |x⟩ ↦ |x⋅a mod N⟩. We
       // also use `ExpModI` to compute a by which x must be multiplied. Also
       // note that we interpret target as unsigned integer in little-endian
       // encoding.
       ModularMultiplyByConstant(modulus,
                                   ExpModI(generator, power, modulus),
                                   target);
   }
   
   /// # Summary
   /// Performs modular in-place multiplication by a classical constant.
   ///
   /// # Description
   /// Given the classical constants `c` and `modulus`, and an input
   /// quantum register |𝑦⟩, this operation
   /// computes `(c*x) % modulus` into |𝑦⟩.
   ///
   /// # Input
   /// ## modulus
   /// Modulus to use for modular multiplication
   /// ## c
   /// Constant by which to multiply |𝑦⟩
   /// ## y
   /// Quantum register of target
   internal operation ModularMultiplyByConstant(modulus : Int, c : Int, y : Qubit[])
   : Unit is Adj + Ctl {
       use qs = Qubit[Length(y)];
       for (idx, yq) in Enumerated(y) {
           let shiftedC = (c <<< idx) % modulus;
           Controlled ModularAddConstant([yq], (modulus, shiftedC, qs));
       }
       ApplyToEachCA(SWAP, Zipped(y, qs));
       let invC = InverseModI(c, modulus);
       for (idx, yq) in Enumerated(y) {
           let shiftedC = (invC <<< idx) % modulus;
           Controlled ModularAddConstant([yq], (modulus, modulus - shiftedC, qs));
       }
   }
   
   /// # Summary
   /// Performs modular in-place addition of a classical constant into a
   /// quantum register.
   ///
   /// # Description
   /// Given the classical constants `c` and `modulus`, and an input
   /// quantum register  |𝑦⟩, this operation
   /// computes `(x+c) % modulus` into |𝑦⟩.
   ///
   /// # Input
   /// ## modulus
   /// Modulus to use for modular addition
   /// ## c
   /// Constant to add to |𝑦⟩
   /// ## y
   /// Quantum register of target
   internal operation ModularAddConstant(modulus : Int, c : Int, y : Qubit[])
   : Unit is Adj + Ctl {
       body (...) {
           Controlled ModularAddConstant([], (modulus, c, y));
       }
       controlled (ctrls, ...) {
           // We apply a custom strategy to control this operation instead of
           // letting the compiler create the controlled variant for us in which
           // the `Controlled` functor would be distributed over each operation
           // in the body.
           //
           // Here we can use some scratch memory to save ensure that at most one
           // control qubit is used for costly operations such as `AddConstant`
           // and `CompareGreaterThenOrEqualConstant`.
           if Length(ctrls) >= 2 {
               use control = Qubit();
               within {
                   Controlled X(ctrls, control);
               } apply {
                   Controlled ModularAddConstant([control], (modulus, c, y));
               }
           } else {
               use carry = Qubit();
               Controlled AddConstant(ctrls, (c, y + [carry]));
               Controlled Adjoint AddConstant(ctrls, (modulus, y + [carry]));
               Controlled AddConstant([carry], (modulus, y));
               Controlled CompareGreaterThanOrEqualConstant(ctrls, (c, y, carry));
           }
       }
   }
   
   /// # Summary
   /// Performs in-place addition of a constant into a quantum register.
   ///
   /// # Description
   /// Given a non-empty quantum register |𝑦⟩ of length 𝑛+1 and a positive
   /// constant 𝑐 < 2ⁿ, computes |𝑦 + c⟩ into |𝑦⟩.
   ///
   /// # Input
   /// ## c
   /// Constant number to add to |𝑦⟩.
   /// ## y
   /// Quantum register of second summand and target; must not be empty.
   internal operation AddConstant(c : Int, y : Qubit[]) : Unit is Adj + Ctl {
       // We are using this version instead of the library version that is based
       // on Fourier angles to show an advantage of sparse simulation in this sample.
   
       let n = Length(y);
       Fact(n > 0, "Bit width must be at least 1");
   
       Fact(c >= 0, "constant must not be negative");
       Fact(c < 2 ^ n, $"constant must be smaller than {2L ^ n}");
   
       if c != 0 {
           // If c has j trailing zeroes than the j least significant bits
           // of y will not be affected by the addition and can therefore be
           // ignored by applying the addition only to the other qubits and
           // shifting c accordingly.
           let j = NTrailingZeroes(c);
           use x = Qubit[n - j];
           within {
               ApplyXorInPlace(c >>> j, x);
           } apply {
               IncByLE(x, y[j...]);
           }
       }
   }
   
   /// # Summary
   /// Performs greater-than-or-equals comparison to a constant.
   ///
   /// # Description
   /// Toggles output qubit `target` if and only if input register `x`
   /// is greater than or equal to `c`.
   ///
   /// # Input
   /// ## c
   /// Constant value for comparison.
   /// ## x
   /// Quantum register to compare against.
   /// ## target
   /// Target qubit for comparison result.
   ///
   /// # Reference
   /// This construction is described in [Lemma 3, arXiv:2201.10200]
   internal operation CompareGreaterThanOrEqualConstant(c : Int, x : Qubit[], target : Qubit)
   : Unit is Adj+Ctl {
       let bitWidth = Length(x);
   
       if c == 0 {
           X(target);
       } elif c >= 2 ^ bitWidth {
           // do nothing
       } elif c == 2 ^ (bitWidth - 1) {
           ApplyLowTCNOT(Tail(x), target);
       } else {
           // normalize constant
           let l = NTrailingZeroes(c);
   
           let cNormalized = c >>> l;
           let xNormalized = x[l...];
           let bitWidthNormalized = Length(xNormalized);
           let gates = Rest(IntAsBoolArray(cNormalized, bitWidthNormalized));
   
           use qs = Qubit[bitWidthNormalized - 1];
           let cs1 = [Head(xNormalized)] + Most(qs);
           let cs2 = Rest(xNormalized);
   
           within {
               for i in IndexRange(gates) {
                   (gates[i] ? ApplyAnd | ApplyOr)(cs1[i], cs2[i], qs[i]);
               }
           } apply {
               ApplyLowTCNOT(Tail(qs), target);
           }
       }
   }
   
   /// # Summary
   /// Internal operation used in the implementation of GreaterThanOrEqualConstant.
   internal operation ApplyOr(control1 : Qubit, control2 : Qubit, target : Qubit) : Unit is Adj {
       within {
           ApplyToEachA(X, [control1, control2]);
       } apply {
           ApplyAnd(control1, control2, target);
           X(target);
       }
   }
   
   internal operation ApplyAnd(control1 : Qubit, control2 : Qubit, target : Qubit)
   : Unit is Adj {
       body (...) {
           CCNOT(control1, control2, target);
       }
       adjoint (...) {
           H(target);
           if (M(target) == One) {
               X(target);
               CZ(control1, control2);
           }
       }
   }
   
   
   /// # Summary
   /// Returns the number of trailing zeroes of a number
   ///
   /// ## Example
   /// ```qsharp
   /// let zeroes = NTrailingZeroes(21); // = NTrailingZeroes(0b1101) = 0
   /// let zeroes = NTrailingZeroes(20); // = NTrailingZeroes(0b1100) = 2
   /// ```
   internal function NTrailingZeroes(number : Int) : Int {
       mutable nZeroes = 0;
       mutable copy = number;
       while (copy % 2 == 0) {
           nZeroes += 1;
           copy /= 2;
       }
       return nZeroes;
   }
   
   /// # Summary
   /// An implementation for `CNOT` that when controlled using a single control uses
   /// a helper qubit and uses `ApplyAnd` to reduce the T-count to 4 instead of 7.
   internal operation ApplyLowTCNOT(a : Qubit, b : Qubit) : Unit is Adj+Ctl {
       body (...) {
           CNOT(a, b);
       }
   
       adjoint self;
   
       controlled (ctls, ...) {
           // In this application this operation is used in a way that
           // it is controlled by at most one qubit.
           Fact(Length(ctls) <= 1, "At most one control line allowed");
   
           if IsEmpty(ctls) {
               CNOT(a, b);
           } else {
               use q = Qubit();
               within {
                   ApplyAnd(Head(ctls), a, q);
               } apply {
                   CNOT(q, b);
               }
           }
       }
   
       controlled adjoint self;
   }
   

A kvantum-algoritmus becslése

Most az alapértelmezett feltételezések alapján megbecsülheti a RunProgram művelet fizikai erőforrásait. Adjon hozzá egy új cellát, és másolja a következő kódot.

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

A qsharp.estimate függvény létrehoz egy eredményobjektumot, amely a teljes fizikai erőforrásszámmal rendelkező táblázat megjelenítésére használható. A költségadatok vizsgálatához bontsa ki a csoportokat, amelyek további információkkal rendelkeznek. További információkért tekintse meg az erőforrásbecslő teljes jelentésadatait.

Bontsa ki például a logikai qubitparamétereket csoportot annak megtekintéséhez, hogy a kód távolsága 21, a fizikai qubitek száma pedig 882.

Térdiagram

Az algoritmushoz és a T-gyárakhoz használt fizikai qubitek eloszlása olyan tényező, amely befolyásolhatja az algoritmus kialakítását. A csomag segítségével vizualizálhatja ezt az qsharp-widgets eloszlást, hogy jobban megértse az algoritmus becsült helyigényét.

from qsharp-widgets import SpaceChart, EstimateDetails
SpaceChart(result)

Ebben a példában az algoritmus futtatásához szükséges fizikai qubitek száma 829766, amelyek közül 196686 algoritmus qubitek, amelyek közül 633080 pedig T-gyári qubit.

Az alapértelmezett értékek módosítása és az algoritmus becslése

Amikor erőforrás-becslési kérelmet küld a programnak, megadhat néhány választható paramétert. A mező használatával jobParams elérheti a target feladat végrehajtásának átadható összes paramétert, és megtekintheti, hogy mely alapértelmezett értékeket feltételezték:

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

Láthatja, hogy az erőforrás-becslés a qubit_gate_ns_e3 qubitmodellt, a hibajavítási kódot és a surface_code 0,001 hibakeretet veszi a becslés alapértelmezett értékeiként.

Ezek a target testre szabható paraméterek:

• errorBudget - az algoritmus általánosan engedélyezett hibakerete
• qecScheme - a kvantumhiba-korrekciós (QEC) séma
• qubitParams - a fizikai qubit paraméterei
• constraints - az összetevő szintjén megkötések
• distillationUnitSpecifications - a T-gyárak desztillációs algoritmusainak specifikációi
• estimateType - egy- vagy határ

További információkért tekintse meg Target az erőforrásbecslő paramétereit .

Qubitmodell módosítása

Ugyanannak az algoritmusnak a költségét a Majorana-alapú qubitparaméter , qubitParams,qubit_maj_ns_e6" használatával becsülheti meg.

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

Kvantumhiba-korrekciós séma módosítása

Az erőforrás-becslési feladatot újrafuttathatja ugyanahhoz a példához a Majorana-alapú qubitparamétereken egy floqued QEC-sémával. qecScheme

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

Hibakeret módosítása

Ezután futtassa újra ugyanazt a kvantumköröket errorBudget 10%-os egységgel.

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

Kötegelés az erőforrásbecslővel

Az Azure Quantum Resource Estimator lehetővé teszi a paraméterek több konfigurációjának target futtatását és az eredmények összehasonlítását. Ez akkor hasznos, ha össze szeretné hasonlítani a különböző qubitmodellek, QEC-sémák vagy hibakeretek költségeit.

1. Kötegelt becslést úgy hajthat végre, hogy átadja a paraméterek listáját target a paramsqsharp.estimate függvény paraméterének. Futtassa például ugyanazt az algoritmust az alapértelmezett paraméterekkel és a Majorana-alapú qubitparaméterekkel egy floquet QEC-sémával.

   result_batch = qsharp.estimate("RunProgram()", params=
                   [{}, # Default parameters
                   {
                       "qubitParams": {
                           "name": "qubit_maj_ns_e6"
                       },
                       "qecScheme": {
                           "name": "floquet_code"
                       }
                   }])
   result_batch.summary_data_frame(labels=["Gate-based ns, 10⁻³", "Majorana ns, 10⁻⁶"])
   

   Modell	Logikai qubitek	Logikai mélység	T állapotok	Kód távolsága	T gyárak	T gyári tört	Fizikai qubitek	rQOPS	Fizikai futtatókörnyezet
   Kapualapú ns, 10⁻³	223	3,64 M	4,70 M	21	19	76.30 %	829,77k	26,55 M	31 másodperc
   Majorana ns, 10⁻⁶	223	3,64 M	4,70 M	5	19	63.02 %	79,60k	148,67 M	5 másodperc

2. A becslési paraméterek listáját az EstimatorParams osztály használatával is létrehozhatja.

   from qsharp.estimator import EstimatorParams, QubitParams, QECScheme, LogicalCounts
   
   labels = ["Gate-based µs, 10⁻³", "Gate-based µs, 10⁻⁴", "Gate-based ns, 10⁻³", "Gate-based ns, 10⁻⁴", "Majorana ns, 10⁻⁴", "Majorana ns, 10⁻⁶"]
   
   params = EstimatorParams(num_items=6)
   params.error_budget = 0.333
   params.items[0].qubit_params.name = QubitParams.GATE_US_E3
   params.items[1].qubit_params.name = QubitParams.GATE_US_E4
   params.items[2].qubit_params.name = QubitParams.GATE_NS_E3
   params.items[3].qubit_params.name = QubitParams.GATE_NS_E4
   params.items[4].qubit_params.name = QubitParams.MAJ_NS_E4
   params.items[4].qec_scheme.name = QECScheme.FLOQUET_CODE
   params.items[5].qubit_params.name = QubitParams.MAJ_NS_E6
   params.items[5].qec_scheme.name = QECScheme.FLOQUET_CODE
   

   qsharp.estimate("RunProgram()", params=params).summary_data_frame(labels=labels)
   

   Modell	Logikai qubitek	Logikai mélység	T állapotok	Kód távolsága	T gyárak	T gyári tört	Fizikai qubitek	rQOPS	Fizikai futtatókörnyezet
   Kapualapú μs, 10⁻³	223 3,64M	4,70 M	17	13	40.54 %	216,77k	21,86k	10 óra
   Kapualapú μs, 10⁻⁴	223	3,64 M	4,70 M	9	14	43.17 %	63,57k	41,30k	5 óra
   Kapualapú ns, 10⁻³	223 3,64M	4,70 M	17	16	69.08 %	416,89k	32,79 M	25 másodperc
   Kapualapú ns, 10⁻⁴	223 3,64M	4,70 M	9	14	43.17 %	63,57k	61,94 M	13 másodperc
   Majorana ns, 10⁻⁴	223 3,64M	4,70 M	9	19	82.75 %	501,48k	82,59 M	10 másodperc
   Majorana ns, 10⁻⁶	223 3,64M	4,70 M	5	13	31.47 %	42,96k	148,67 M	5 másodperc

Pareto-határbecslés futtatása

Egy algoritmus erőforrásainak becslésekor fontos figyelembe venni a fizikai qubitek száma és az algoritmus futtatókörnyezete közötti kompromisszumot. Az algoritmus futásidejének csökkentése érdekében fontolja meg a lehető legtöbb fizikai qubit lefoglalását. A fizikai qubitek számát azonban a kvantumhardverben elérhető fizikai qubitek száma korlátozza.

A Pareto-határbecslés több becslést is biztosít ugyanahhoz az algoritmushoz, és mindegyiknek meg kell egyeznie a qubitek száma és a futtatókörnyezet között.

1. Az Erőforrás-becslés Pareto-határbecsléssel való futtatásához a paramétert "estimateType"a target"frontier" következőképpen kell megadnia: . Futtassa például ugyanazt az algoritmust a Majorana-alapú qubitparaméterekkel egy felületkóddal Pareto-határbecslés használatával.

   result = qsharp.estimate("RunProgram()", params=
                               {"qubitParams": { "name": "qubit_maj_ns_e4" },
                               "qecScheme": { "name": "surface_code" },
                               "estimateType": "frontier", # frontier estimation
                               }
                           )
   

2. A függvény használatával EstimatesOverview megjeleníthet egy táblázatot, amely tartalmazza a fizikai erőforrások összesített számát. Kattintson az első sor melletti ikonra a megjeleníteni kívánt oszlopok kijelöléséhez. A futtatás neve, a becslés típusa, a qubit típusa, a qec-séma, a hibakeret, a logikai qubitek, a logikai mélység, a kód távolsága, a T-állapotok, a T-gyárak, a T-gyárak, a futtatókörnyezet, az rQOPS és a fizikai qubitek közül választhat.

   from qsharp_widgets import EstimatesOverview
   EstimatesOverview(result)
   

Az eredménytábla Becslés típusú oszlopában láthatja a(z) {number of qubits, runtime} különböző kombinációinak számát az algoritmushoz. Ebben az esetben az erőforrásbecslő több ezer lehetséges kombinációból 22 különböző optimális kombinációt talál.

Téridő diagram

A EstimatesOverview függvény megjeleníti az erőforrásbecslő téridő-diagramját is.

A téridő diagram a fizikai qubitek számát és az algoritmus futásidejét jeleníti meg minden {qubit, runtime} pár esetében. Az egyes pontokra rámutatva megtekintheti az adott pont erőforrás-becslésének részleteit.

Kötegelés Pareto-határbecsléssel

1. Ha több paraméterkonfigurációt target szeretne megbecsülni és összehasonlítani a határbecsléssel, adja hozzá "estimateType": "frontier", a paramétereket.

   result = qsharp.estimate(
       "RunProgram()",
       [
           {
           "qubitParams": { "name": "qubit_maj_ns_e4" },
           "qecScheme": { "name": "surface_code" },
           "estimateType": "frontier", # Pareto frontier estimation
           },
           {
           "qubitParams": { "name": "qubit_maj_ns_e6" },
           "qecScheme": { "name": "floquet_code" },
           "estimateType": "frontier", # Pareto frontier estimation
           },
       ]
   )
   
   EstimatesOverview(result, colors=["#1f77b4", "#ff7f0e"], runNames=["e4 Surface Code", "e6 Floquet Code"])
   

   

   Feljegyzés

   A függvény használatával színeket és futtatási neveket határozhat meg a qubit-idő diagramhoz EstimatesOverview .

2. Ha több paraméterkonfigurációt target futtat a Pareto-határbecslés használatával, láthatja a téridő diagram egy adott pontjára vonatkozó erőforrás-becsléseket, azaz minden {qubitszám, futtatókörnyezet} pár esetében. Az alábbi kód például a második (becslési index=0) futtatás becsült adatait és a negyedik (pontindex=3) legrövidebb futásidejét mutatja be.

   EstimateDetails(result[1], 4)
   

3. A téridő diagram egy adott pontjára vonatkozó térdiagramot is megtekintheti. Az alábbi kód például a kombinációk első futtatásához (becslési index=0) és a harmadik legrövidebb futtatókörnyezethez (pontindex=2) tartozó térdiagramot mutatja.

   SpaceChart(result[0], 2)
   

A Qiskit előfeltételei a VS Code-ban

• Python-környezet, amelyen telepítve van a Python és a Pip .

• A Visual Studio Code legújabb verziója vagy nyissa meg Visual Studio Code-ot a webes.

• VS Code a Quantum Development Kit, a Pythonés a Jupyter bővítményekkel telepítve.

• A legújabb Azure Quantum qsharp és qsharp_widgets, valamint qiskit csomagok.

  python -m pip install --upgrade qsharp qsharp_widgets qiskit
  

  vagy

  !pip install --upgrade qsharp qsharp_widgets qiskit
  

Új Jupyter Notebook létrehozása

1. A VS Code-ban válassza a > megtekintése lehetőséget, majd a Létrehozás: Új Jupyter-jegyzetfüzet lehetőséget.
2. A jobb felső sarokban a VS Code észleli és megjeleníti a Python verzióját és a jegyzetfüzethez kiválasztott virtuális Python-környezetet. Ha több Python-környezettel rendelkezik, előfordulhat, hogy ki kell választania egy kernelt a jobb felső sarokban található kernelválasztóval. Ha nem észlelt környezetet, a beállítási információkért tekintse meg a VS Code Jupyter-jegyzetfüzeteit.

A kvantum-algoritmus létrehozása

Ebben a példában a Ruiz-Perezben és a Garcia-Escartinban (arXiv:1411.5949) bemutatott szerkezet alapján létrehoz egy kvantum-áramkört egy szorzóhoz, amely a Quantum Fourier Transform használatával implementálja az aritmetikai műveletet.

A szorzó méretét a változó módosításával módosíthatja bitwidth . A kapcsolatcsoport létrehozása egy függvénybe van csomagolva, amely a bitwidth szorzó értékével hívható meg. A művelet két bemeneti regisztert fog tartalmazni, amelyek mindegyike a megadott bitwidthméretű, és egy kimeneti regiszter, amely a megadott bitwidthméret kétszerese. A függvény a közvetlenül a kvantumkörökből kinyert szorzó logikai erőforrás-számát is kinyomtatja.

from qiskit.circuit.library import RGQFTMultiplier 

def create_algorithm(bitwidth):
    print(f"[INFO] Create a QFT-based multiplier with bitwidth {bitwidth}")

    circ = RGQFTMultiplier(num_state_qubits=bitwidth)

    return circ

A kvantum-algoritmus becslése

Hozza létre az algoritmus egy példányát a create_algorithm függvény használatával. A szorzó méretét a változó módosításával módosíthatja bitwidth .

bitwidth = 4

circ = create_algorithm(bitwidth)

Becsülje meg a művelet fizikai erőforrásait az alapértelmezett feltételezések alapján. Használhatja a estimate hívást, amely túlterhelt egy QuantumCircuit objektum elfogadásához a Qiskitből.

from qsharp.estimator import EstimatorParams
from qsharp.interop.qiskit import estimate

params = EstimatorParams()
result = estimate(circ, params)

Másik lehetőségként használhatja a ResourceEstimatorBackend a becslés végrehajtására, ahogyan a meglévő háttérrendszer teszi.

from qsharp.interop.qiskit import ResourceEstimatorBackend
from qsharp.estimator import EstimatorParams

params = EstimatorParams()
backend = ResourceEstimatorBackend()

job = backend.run(circ, params)
result = job.result()

A result objektum tartalmazza az erőforrás-becslési feladat kimenetét. A EstimateDetails függvénnyel olvashatóbb formátumban jelenítheti meg az eredményeket.

from qsharp_widgets import EstimateDetails
EstimateDetails(result)

EstimateDetails függvény megjelenít egy táblát, amely a fizikai erőforrások összesített számát tartalmazza. A költségadatok vizsgálatához bontsa ki a csoportokat, amelyek további információkkal rendelkeznek. További információkért tekintse meg az erőforrásbecslő teljes jelentésadatait.

Ha például kibontja a logikai qubit paraméterek csoportját, jobban láthatja, hogy a hibajavító kód távolsága 15.

A Fizikai qubit paraméterek csoportjában láthatja a becsléshez feltételezett fizikai qubit-tulajdonságokat. Az egy qubites mérés és az egy qubites kapu végrehajtásának ideje például 100 ns, illetve 50 ns.

Térdiagramok

Az algoritmushoz és a T-gyárakhoz használt fizikai qubitek eloszlása olyan tényező, amely befolyásolhatja az algoritmus kialakítását. Ezt a eloszlást vizualizálhatja, hogy jobban megértse az algoritmus becsült helyigényét.

from qsharp_widgets import SpaceChart

SpaceChart(result)

A térdiagram az algoritmus qubitjeinek és a T-gyári qubiteknek az arányát mutatja. Vegye figyelembe, hogy a T gyárak száma, 19, hozzájárul a T gyárakhoz tartozó fizikai qubitek számához, mivel $\text{T gyárak} \cdot \text{fizikai qubit egy T gyárra} = 19 \cdot 18 000 = 342 000$.

További információ: T factory physical becslés.

Az alapértelmezett értékek módosítása és az algoritmus becslése

Amikor erőforrás-becslési kérelmet küld a programnak, megadhat néhány választható paramétert. A mezővel jobParams elérheti a feladat végrehajtásának átadható összes értéket, és megtekintheti, hogy mely alapértelmezett értékeket feltételezték:

result.data()["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'}}

Ezek a target testre szabható paraméterek:

• errorBudget - az általánosan megengedett hibakeret
• qecScheme - a kvantumhiba-korrekciós (QEC) séma
• qubitParams - a fizikai qubit paraméterei
• constraints - az összetevő szintjén megkötések
• distillationUnitSpecifications - a T-gyárak desztillációs algoritmusainak specifikációi

További információkért tekintse meg Target az erőforrásbecslő paramétereit .

Qubitmodell módosítása

Ezután becsülje meg ugyanannak az algoritmusnak a költségét a Majorana-alapú qubitparaméter használatával qubit_maj_ns_e6

qubitParams = {
    "name": "qubit_maj_ns_e6"
}

result = backend.run(circ, qubitParams).result()

A fizikai számokat programozott módon is megvizsgálhatja. Megismerheti például az algoritmus végrehajtásához létrehozott T-gyár részleteit.

result.data()["tfactory"]

{'eccDistancePerRound': [1, 1, 5],
 'logicalErrorRate': 1.6833177305222897e-10,
 'moduleNamePerRound': ['15-to-1 space efficient physical',
  '15-to-1 RM prep physical',
  '15-to-1 RM prep logical'],
 'numInputTstates': 20520,
 'numModulesPerRound': [1368, 20, 1],
 'numRounds': 3,
 'numTstates': 1,
 'physicalQubits': 16416,
 'physicalQubitsPerRound': [12, 31, 1550],
 'runtime': 116900.0,
 'runtimePerRound': [4500.0, 2400.0, 110000.0]}

Ezekkel az adatokkal magyarázatokat készíthet arról, hogy a T-gyárak hogyan állítják elő a szükséges T-állapotokat.

data = result.data()
tfactory = data["tfactory"]
breakdown = data["physicalCounts"]["breakdown"]
producedTstates = breakdown["numTfactories"] * breakdown["numTfactoryRuns"] * tfactory["numTstates"]

print(f"""A single T factory produces {tfactory["logicalErrorRate"]:.2e} T states with an error rate of (required T state error rate is {breakdown["requiredLogicalTstateErrorRate"]:.2e}).""")
print(f"""{breakdown["numTfactories"]} copie(s) of a T factory are executed {breakdown["numTfactoryRuns"]} time(s) to produce {producedTstates} T states ({breakdown["numTstates"]} are required by the algorithm).""")
print(f"""A single T factory is composed of {tfactory["numRounds"]} rounds of distillation:""")
for round in range(tfactory["numRounds"]):
    print(f"""- {tfactory["numUnitsPerRound"][round]} {tfactory["unitNamePerRound"][round]} unit(s)""")

A single T factory produces 1.68e-10 T states with an error rate of (required T state error rate is 2.77e-08).
23 copies of a T factory are executed 523 time(s) to produce 12029 T states (12017 are required by the algorithm).
A single T factory is composed of 3 rounds of distillation:
- 1368 15-to-1 space efficient physical unit(s)
- 20 15-to-1 RM prep physical unit(s)
- 1 15-to-1 RM prep logical unit(s)

Kvantumhiba-korrekciós séma módosítása

Most futtassa újra az erőforrás-becslési feladatot ugyanazzal a példával a Majorana-alapú qubitparamétereken egy floqued QEC-sémával. qecScheme

params = {
    "qubitParams": {"name": "qubit_maj_ns_e6"},
    "qecScheme": {"name": "floquet_code"}
}

result_maj_floquet = backend.run(circ, params).result()
EstimateDetails(result_maj_floquet)

Hibakeret módosítása

Futtassuk újra ugyanazt a kvantumköröket errorBudget egy 10%-os szinttel.

params = {
    "errorBudget": 0.01,
    "qubitParams": {"name": "qubit_maj_ns_e6"},
    "qecScheme": {"name": "floquet_code"},
}
result_maj_floquet_e1 = backend.run(circ, params).result()
EstimateDetails(result_maj_floquet_e1)