Integrované hybridní výpočetní prostředí

Integrované hybridní výpočetní prostředí spojuje klasické a kvantové procesy a umožňuje klasickému kódu řídit provádění kvantových operací na základě měření mezi okruhy, zatímco fyzické qubity zůstanou aktivní. Pomocí běžných programovacích technik, jako jsou vnořené podmínky, smyčky a volání funkcí, může jeden kvantový program spouštět složité problémy, což snižuje počet potřebných snímků. Pomocí technik opětovného použití qubitu můžou větší programy běžet na počítačích s menším počtem qubitů.

Důležité

Integrované hybridní kvantové výpočty v současné době nepodporuje moderní Quantum Development Kit rozšíření (moderní sada QDK) pro Visual Studio Code ani další komponenty v příkladech na této stránce, jako je jádro IQ# , %azure příkaz Magic nebo qsharp.azure modul. Ke spouštění integrovaných hybridních úloh použijte sadu Microsoft Quantum Development Kit (Classic QDK). Další informace najdete v tématu Pokračování práce v klasické sadě QDK.

Další informace najdete tady:

• Granade & Weibe, "Using Random Walks for Iterative Phase Estimation" (Použití náhodných procházek k odhadu iterativní fáze).
• Lubinski a kol., "Rozvoj hybridních kvantových a klasických výpočtů s Real-Time prováděním"

Podporovány targets

V současné době se integrovaný model hybridního výpočetního prostředí v Azure Quantum podporuje ve službě Quantinuumtargets.

Quantinuum

Podporovaná funkce	Poznámky
Klasické smyčky	Pouze ohraničené smyčky
Tok libovolného řízení	Použití větvení if/else
Měření středního okruhu	Využívá prostředky klasické registrace.
Opakované použití Qubitu	–
Klasické výpočetní prostředky v reálném čase	32bitová celočíselná aritmetika bez znaménka Využívá prostředky klasické registrace.

Začínáme

Pokud chcete začít zkoumat integrované hybridní programování, doporučujeme projít si ukázky v tomto článku nebo prozkoumat kartu Hybridní kvantové výpočty v galerii ukázek portálu Azure Quantum.

Odesílání integrovaných hybridních úloh

Když odesíláte integrovanou hybridní úlohu, musíte target po zadání targetpřidat parametr schopnosti . Kromě toho se integrované hybridní programy v Azure Quantum spouštějí a spravují stejně jako běžné kvantové úlohy. Každá úloha má jedno ID úlohy a výsledkem je jeden histogram.

Důležité

Integrované hybridní kvantové výpočty v současné době nepodporuje moderní Quantum Development Kit rozšíření (moderní sada QDK) pro Visual Studio Code ani další komponenty v příkladech na této stránce, jako je jádro IQ# , %azure příkaz Magic nebo qsharp.azure modul. Ke spouštění integrovaných hybridních úloh použijte sadu Microsoft Quantum Development Kit (Classic QDK). Další informace najdete v tématu Pokračování práce v klasické sadě QDK.

IQ#

Při použití jádra IQ# v Jupyter Notebook použijte %azure.targetPříkaz magic -capability s parametrem AdaptiveExecution .

%azure.target quantinuum.sim.h1-1e
%azure.target-capability AdaptiveExecution

Python + Q#

Při použití balíčku Python qsharp použijte qsharp.azure.target_capability funkci s parametrem AdaptiveExecution .

qsharp.azure.target("quantinuum.sim.h1-1e")
qsharp.azure.target_capability("AdaptiveExecution")

Azure CLI

Pokud k odeslání úlohy používáte Azure CLI, přidejte --target-capability parametr s hodnotou AdaptiveExecution.

az quantum job submit \
    --target-capability AdaptiveExecution \
    --target-id quantinuum.sim.h1-1e \
    --job-name IterativePhaseEstimation \
    --shots 100 \
    --output table

Odesílání integrovaných hybridních úloh v rámci relace

V rámci relace můžete kombinovat několik integrovaných hybridních úloh pomocí Q# a Pythonu. Při odesílání relace přidejte targetCapability vstupní parametr s hodnotou AdaptiveExecution.

with target.open_session(name="Q# session") as session:
    target.submit(input_data=QuantumOperation, name="Job 1", input_params={"count":100, "targetCapability":"AdaptiveExecution"}) # First job submission
    target.submit(input_data=QuantumOperation, name="Job 2", input_params={"count":200, "targetCapability":"AdaptiveExecution"}) # Second job submission
    target.submit(input_data=QuantumOperation, name="Job 3", input_params={"count":300, "targetCapability":"AdaptiveExecution"}) # Third job submission

Další informace najdete v tématu Začínáme s relacemi.

Poznámka

Přestože jsou relace k dispozici pro všechny poskytovatele hardwaru kvantových výpočtů, všimněte si, že integrované hybridní úlohy kvantových výpočtů jsou v současné době podporovány v Quantinuum targets.

Odhad nákladů na integrovanou hybridní úlohu

Náklady na spuštění integrované hybridní úlohy na hardwaru Quantinuum můžete odhadnout tak, že ji nejprve spustíte v emulátoru.

Po úspěšném spuštění emulátoru:

1. V pracovním prostoru Azure Quantum vyberte Správa úloh.
2. Vyberte úlohu, kterou jste odeslali.
3. V místní nabídce Podrobnosti o úloze vyberte Odhad nákladů a zobrazte, kolik účtů eHQCs (kredity emulátoru Quantinuum) se použilo. Toto číslo se překládá přímo na počet HQC (kvantové kredity Quantinuum), které jsou potřeba ke spuštění úlohy na hardwaru Quantinuum.

Poznámka

Quantinuum zruší registraci celého okruhu a vypočítá náklady na všechny cesty kódu bez ohledu na to, jestli se spouštějí podmíněně, nebo ne.

Integrované hybridní ukázky

Následující ukázky ukazují aktuální sadu funkcí pro integrovaný hybridní computing.

• Ověření stavu propletené GHZ
• Opakování tří qubitů
• Odhad iterativní fáze

Požadavky

• Pokud se službou Azure Quantum začínáte, budete potřebovat předplatné Azure a pracovní prostor Azure Quantum, abyste mohli spouštět ukázky na kvantovém hardwaru. Další informace najdete v tématu Vytvoření pracovního prostoru Azure Quantum.
• VS Code a Quantum Development Kit nastavení v místním prostředí. Další informace najdete v tématu Nastavení .Quantum Development Kit
• Ujistěte se, že VS Code obsahuje nejnovější verzi Quantum Development Kit (0.27.258160).
  • Ve VS Code vyberte Ctrl + Shift + X a vyhledejte "Microsoft Quantum Development Kit".

Ukázky v tomto článku jsou nastavené tak, aby běžely v sadě Visual Studio (VS) Code a k odeslání úlohy do Azure Quantum se používají integrované rozhraní příkazového řádku Azure (CLI). Pokud chcete spustit Jupyter Notebook verzi těchto a dalších ukázek, přihlaste se ke svému pracovnímu prostoru Azure Portal a prohlédněte si ukázky na kartě Hybridní kvantové výpočty v galerii ukázek. Poznámkový blok můžete spustit v cloudu nebo si ho stáhnout a spustit místně.

Informace o řešení potíží s integrovanými hybridními programy najdete v tématu Řešení potíží s integrovaným hybridním nasazením.

Kontrola stavu GHZ

V této ukázce zjistíte, jak kombinovat klasické a kvantové instrukce ve stejném programu, všechny plně zpracované back-endem kvantových výpočtů.

Funkce, které je potřeba si všimnout o této ukázce:

• Měření smyčky a qubitu probíhá v době, kdy qubity zůstávají koherentní.
• Rutina kombinuje klasické a kvantové výpočetní operace.
• Nemusíte se učit programovat pro specializovaný vysoce výkonný hardware spuštěný vedle QPU (například FPGA).
• Spuštění ekvivalentního programu bez integrovaných hybridních funkcí by vyžadovalo vrácení všech průběžných výsledků měření a následné zpracování dat.

Vytvoření projektu VS Code

1. Ve VS Code vytvořte nový Q# samostatný projekt konzolové aplikace s názvem CheckGHZ.

   1. Select View > Command Palete >Q#: Create new project > Standalone console application

2. Nahraďte konfiguraci v souboru CheckGHZ.csproj následujícím kódem:

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum</ExecutionTarget>
       <TargetCapability>AdaptiveExecution</TargetCapability>
     </PropertyGroup>
   </Project>
   

3. Nahraďte kód v souboru Program.qs následujícím kódem:

   namespace Microsoft.Quantum.Samples {
   
       open Microsoft.Quantum.Measurement;
       open Microsoft.Quantum.Intrinsic;
   
       /// # Summary
       /// Counts the number of times measurements of a prepared GHZ state did not match the expected correlations.
       @EntryPoint() // The EntryPoint attribute is used to mark that this operation is where a quantum program will start running.
       operation CheckGHZ() : Int {
           use q = Qubit[3];
           mutable mismatch = 0;
           for _ in 1..10 {
               // Prepare the GHZ state.
               H(q[0]);
               CNOT(q[0], q[1]);
               CNOT(q[1], q[2]);
   
               // Measures and resets the 3 qubits
               let (r0, r1, r2) = (MResetZ(q[0]), MResetZ(q[1]), MResetZ(q[2]));
   
               // Adjusts classical value based on qubit measurement results
               if not (r0 == r1 and r1 == r2) {
                   set mismatch += 1;
               }
           }
           return mismatch;
       }
   }
   

4. Z okna terminálu ve VS Code se připojte k pracovnímu prostoru Azure Quantum a nastavte výchozí prostředky.

   az login
   

   Poznámka

   ID předplatného Azure, skupinu prostředků a název pracovního prostoru můžete po přihlášení uvést v okně terminálu spuštěním příkazu az quantum workspace list. Případně je můžete najít v Azure Portal na stránce Přehled pracovního prostoru Azure Quantum.

   az account set --subscription <MySubscriptionID>
   
   az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
   

5. Odešlete úlohu a prohlédněte si výsledky. Toto spuštění používá přibližně 10,65 eHQCs (fakturační jednotky emulátoru Quantinuum).

   az quantum job submit \
     --target-id quantinuum.sim.h1-1e \
     --job-name CheckGHZ \
     --target-capability AdaptiveExecution \
     --shots 50
   

   az quantum job output \
     -o table \
     --job-id [job-id]
   

Tří qubitový opakující se kód

Tato ukázka ukazuje, jak vytvořit kód opakování 3 qubitů, který lze použít k detekci a opravě chyb překlopení bitů.

Využívá integrované funkce hybridního výpočetního prostředí k určení počtu provedení opravy chyb v době, kdy je stav logického registru qubitů konzistentní.

Vytvoření projektu VS Code

1. Ve VS Code vytvořte nový Q# samostatný projekt konzolové aplikace s názvem ThreeQubit.

   1. Vyberte Zobrazit > příkaz Paleta>Q#: Vytvořit nový projekt > Samostatná konzolová aplikace.

2. Nahraďte konfiguraci v souboru ThreeQubit.csproj následujícím kódem:

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum</ExecutionTarget>
       <TargetCapability>AdaptiveExecution</TargetCapability>
     </PropertyGroup>
   
   </Project>
   

3. Nahraďte kód v souboru Program.qs následujícím kódem:

   namespace Microsoft.Quantum.Samples {
   
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
       open Microsoft.Quantum.Measurement;
   
       @EntryPoint()
       operation ThreeQubitRepetitionCode() : (Bool, Int) {
           // Use two qubit registers, one for encoding and an auxiliary one for syndrome measurements.
           use encodedRegister = Qubit[3];
           use auxiliaryRegister = Qubit[2];
   
           // Initialize the first qubit in the register to a |-〉 state.
           H(encodedRegister[0]);
           Z(encodedRegister[0]);
   
           // Apply several unitary operations to the encoded qubits performing bit flip detection and correction between
           // each application.
           mutable bitFlipCount = 0;
           within {
               // The 3 qubit register is used as a repetition code.
               Encode(encodedRegister);
           }
           apply {
               let iterations = 5;
               for _ in 1 .. iterations {
                   // Apply a sequence of rotations to the encoded register that effectively perform an identity operation.
                   ApplyRotationalIdentity(encodedRegister);
   
                   // Measure the bit flip error syndrome, revert the bit flip if needed, and increase the count if a bit flip occurred.
                   let (parity01, parity12) = MeasureBitFlipSyndrome(encodedRegister, auxiliaryRegister);
                   let bitFlipReverted = RevertBitFlip(encodedRegister, parity01, parity12);
                   if (bitFlipReverted) {
                       set bitFlipCount += 1;
                   }
               }
           }
   
           // Transform the qubit to the |1〉 state and measure it in the computational basis.
           H(encodedRegister[0]);
           let result = MResetZ(encodedRegister[0]) == One;
           ResetAll(encodedRegister);
   
           // The output of the program is a boolean-integer tuple where the boolean represents whether the qubit
           // measurement result was the expected one and the integer represents the number of times bit flips occurred
           // throughout the program.
           return (result, bitFlipCount);
       }
   
       operation ApplyRotationalIdentity(register : Qubit[]) : Unit is Adj
       {
           // This operation implements an identity operation using rotations about the x-axis.
           // The Rx operation has a period of $2\pi$ (given that it is not possible to measure the difference between
           // states $|\\psi〉$ and $-|\\psi〉$). Using it to apply 4 $\frac{\pi}{2}$ rotations about the x-axis, effectively
           // leaves the qubit register in its original state.
           let theta = PI() * 0.5;
           for i in 1 .. 4 {
               for qubit in register
               {
                   Rx(theta, qubit);
               }
           }
       }
   
       operation RevertBitFlip(register : Qubit[], parity01 : Result, parity12 : Result) : Bool
       {
           if (parity01 == One and parity12 == Zero) {
               X(register[0]);
           }
           elif (parity01 == One and parity12 == One) {
               X(register[1]);
           }
           elif (parity01 == Zero and parity12 == One) {
               X(register[2]);
           }
   
           return parity01 == One or parity12 == One;
       }
   
       operation Encode(register : Qubit[]) : Unit is Adj
       {
           CNOT(register[0], register[1]);
           CNOT(register[0], register[2]);
       }
   
       operation MeasureBitFlipSyndrome(encodedRegister : Qubit[], auxiliaryRegister : Qubit[]) : (Result, Result)
       {
           // Measure the bit flip syndrome by checking the parities between qubits 0 and 1, and between qubits 1 and 2.
           ResetAll(auxiliaryRegister);
           CNOT(encodedRegister[0], auxiliaryRegister[0]);
           CNOT(encodedRegister[1], auxiliaryRegister[0]);
           CNOT(encodedRegister[1], auxiliaryRegister[1]);
           CNOT(encodedRegister[2], auxiliaryRegister[1]);
           let parity01 = MResetZ(auxiliaryRegister[0]);
           let parity12 = MResetZ(auxiliaryRegister[1]);
           return (parity01, parity12);
       }
   }
   

4. Z okna terminálu ve VS Code se připojte k pracovnímu prostoru Azure Quantum a nastavte výchozí prostředky.

   az login
   

   Poznámka

   Id předplatného Azure, skupinu prostředků a název pracovního prostoru můžete po přihlášení uvést v okně terminálu spuštěním příkazu az quantum workspace list. Případně je můžete najít v Azure Portal na stránce Přehled pracovního prostoru Azure Quantum.

   az account set --subscription <MySubscriptionID>
   
   az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>
   

5. Odešlete úlohu a zobrazí se výsledky. Toto spuštění používá přibližně 11,31 eHQCs (fakturační jednotky emulátoru Quantinuum).

   az quantum job submit \
       --target-id quantinuum.sim.h1-1e \
       --job-name ErrorCorrection \
       --target-capability AdaptiveExecution \
       --shots 50
   

   az quantum job output \
       -o table \
       --job-id [job-id]
   

Odhad iterativní fáze

Tento ukázkový kód napsali členové týmu KPMG Quantum v Austrálii a spadá pod licenci MIT. Jeho cílem je demonstrovat rozšířené možnosti a využívat ohraničené smyčky, volání klasických funkcí za běhu, vnořené příkazy podmíněného Basic Measurement Feedbacktargets if, měření středního okruhu a opakované použití qubitů.

Dvourozměrný vnitřní výpočet produktu pomocí odhadu iterativní fáze na třech qubitech

Tento ukázkový program demonstruje odhad iterativní fáze v rámci Q#. Iterativní odhad fáze používá k výpočtu vnitřního součinu mezi dvěma dvourozměrnými vektory kódovanými na qubitu target a qubitem ancily. Inicializuje se také další řídicí qubit, který bude jediným qubitem použitým pro měření.

Okruh začíná kódováním dvojice vektorů na qubitu target a qubitu ancilla. Pak použije operátor Oracle na celý registr řízený řídicím qubitem, který je nastaven ve stavu $\ket +$. Řízený operátor Oracle vygeneruje fázi ve stavu $\ket 1$ řídicího qubitu. To se pak dá přečíst tak, že na řídicí qubit použijete H hradlo, aby byla fáze při měření pozorovatelná.

Vytvoření projektu VS Code

1. Ve VS Code vytvořte nový Q# samostatný projekt konzolové aplikace s názvem IPE.

   1. Vyberte Zobrazit > příkaz Paleta>Q#: Vytvořit nový projekt > Samostatná konzolová aplikace.

2. Nahraďte konfiguraci v souboru IPE.csproj následujícím kódem:

   <Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">
   
     <PropertyGroup>
       <OutputType>Exe</OutputType>
       <TargetFramework>net6.0</TargetFramework>
       <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
     </PropertyGroup>
   
   </Project>
   

3. Nahraďte kód v souboru Program.qs následujícím kódem:

   namespace IPE {
   
       //IMPORT LIBRARIES
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
       open Microsoft.Quantum.Arrays;
       open Microsoft.Quantum.Measurement;
       open Microsoft.Quantum.Convert;
   
   
       // additional code added here
   
   
   }
   

Kódování vektorů

Vektory v a c se mají zakódovat do qubitu target a qubitu ancilla. Vektor $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$ může být reprezentován kvantovým stavem $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, podobně $c$ lze vytvořit pomocí $\theta_2$.

Otočení Y použité u qubitu target ve stavu $\ket 0$:

$$RY(\theta)\ket 0 = e^{iY\theta/2}\ket 0 = cos(\frac{\theta}{2})\ket 0 + sin(\frac{\theta}{2})\ket 1$$

Poznámka

Faktor 2 je zde na tetě. Aplikace brány $RY(2\pi)$ na $\ket 0$ poskytne stav $-\ket 0$ a zakóduje vektor $(-1,0)$. Tuto fázi nelze považovat za globální fázi a je odebrána, protože celý registr bude propletený.

Registr qubitu target a qubitu ancilla je

$$\ket \Psi = \ket {\Psi_\text{Cílový qubit}}\ket {\Psi_\text{Ancilla qubit}}$$

Stav, který se má vytvořit, je v qubitu target a qubit ancilla je

$$\ket{\Psi}=\frac{1}{\sqrt{2}}(\ket{v}\ket{+}+\ket{c}\ket{-}),$$

který má rovněž formu

$$\ket{\Psi} = \frac{1}{2}(\ket{v}+\ket{c})\ket{0}+\frac{1}{2}(\ket{v}-\ket{c})\ket{1}.$$

Do souboru Program.qs přidejte následující operaci.

//This is state preparation operator A for encoding the 2D vector
operation StateInitialisation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    H(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector v.
    Controlled R([AncilReg], (PauliY, theta_1, TargetReg));

    // X gate on ancilla to change from |+> to |->
    X(AncilReg);

    // Arbitray controlled rotation based on theta. This is vector c.
    Controlled R([AncilReg], (PauliY, theta_2, TargetReg));
    X(AncilReg);
    H(AncilReg);
}

The Oracle

Orákulum G musí být sestaveno tak, aby vygenerovalo eigenpházi na stav kódovaný v qubitu target a qubitu ancilla. Konstrukce tohoto orákula není pro demonstraci v tomto příkladu důležitá, ale operace, která se použije, je

$$G\ket \Psi = e^{2\pi i\phi} \ket \Psi.$$

kde vnitřní součin $\braket {v|c}$ je obsažen ve fázi $\phi$, která je vázána mezi [0,1]. Při použití ovládacího qubitu, který začíná v daném stavu $\ket{\Psi_\text{Control Qubit}} = \ket +$

$$\begin{aligned} \text{Controlled }G \ket{\Psi_\text{Control Qubit}} \ket \Psi & = \frac {1}{\sqrt{2}} (\ket 0 \ket \Psi + e^{2\pi i \phi}\ket 1 \ket \Psi )\ & =\frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1) \ket \Psi \end{aligned}$$

Řídicí qubit teď obsahuje fázi, která souvisí s vnitřním produktem $\braket {v|c}$

$$\ket{\Psi_\text{Qubit}} = \frac {1}{\sqrt{2}} (\ket 0 + e^{2\pi i\phi}\ket 1)$$

Do souboru Program.qs přidejte následující operaci.

operation GOracle(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double) : Unit is Adj + Ctl {
    Z(AncilReg);
        within {
            Adjoint StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);

            // Apply X gates individually here as currently ApplyAll is not Adj + Ctl
            X(AncilReg);
            X(TargetReg);
        }
        apply {
            Controlled Z([AncilReg],TargetReg);
        }
    }

Iterace

Teď pro iterativní část okruhu. U n měření zvažte, že fáze může být reprezentována jako binární hodnota $\phi$ a že použitím $2^n$ orákulum způsobí, že n. binární bod fáze je pozorovatelný (prostřednictvím jednoduchého binárního násobení a modulu $2\pi$). Hodnotu qubitu ovládacího prvku lze číst, umístit do klasického registru a resetovat qubit pro použití v další iteraci. Při další iteraci se použije $2^{n-1}$ orákulum a fáze opravy na qubitu ovládacího prvku v závislosti na n. měření. Stav v qubitu ovládacího prvku může být reprezentován jako

$$ \ket {\Psi_{\text{Qubit}} = \ket 0 + e^{2\pi i\phi}\ket 1 $$

where $\phi = 0.\phi_0\phi_1\phi_2\phi_3$...

Použití $2^n$ řízené orákulum dává stav na qubitu ovládacího prvku.

$$ G^{2^n}\ket {\Psi_{\text{Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_n\phi_{n+1}\phi_{n+2}\phi_{n+3}...} \ket 1 $$

Vezměte v úvahu, že fáze neobsahuje žádné termíny hlubší než $\phi_n$ (tj. termíny $\phi_{n+1},\phi_{n+2}, \text{etc}$).

$$ G^{2^n}\ket {\Psi_{\text{Qubit}} = \ket 0 + e^{2\pi i 0.\phi_n}\ket 1 $$

Nyní je možné pozorovat hodnotu $\phi_n$ s H hradlem a měřením, které se promítá podél osy Z. Resetování qubitu ovládacího prvku a použití orákulum $2^{n-1}$ krát

$$ G^{2^{n-1}}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}\phi_n}\ket 1 $$

Pomocí předchozí naměřené hodnoty pro $\phi_n$, lze další binární bod otočit ven.

$$ RZ(-2\pi \times 0,0\phi_n)G^{n-1}\ket {\Psi_{\text{Control Qubit}}} = \ket 0 + e^{2\pi i 0.\phi_{n-1}}\ket 1 $$

Tento proces se iterativně použije pro určitou bitovou přesnost n, aby se získala fáze $0.\phi_0\phi_1\phi_2...\phi_{n}$. Hodnota je uložena jako binární hodnota $x = \phi_0\phi_1\phi_2...\phi_{n}$, protože za běhu jsou v současné době manipulovatelná pouze celá čísla.

Vzhledem k tomu, že čtení neřekne nic o obou vektorech, pouze vnitřní součin mezi nimi, stavy qubitu target a qubitu ancilla zůstávají v průběhu procesu ve stejném stavu !

Do souboru Program.qs přidejte následující operaci.

operation IterativePhaseEstimation(TargetReg : Qubit, AncilReg : Qubit, theta_1 : Double, theta_2 : Double, Measurements : Int) : Int{
    use ControlReg = Qubit();
    mutable MeasureControlReg = [Zero, size = Measurements];
    mutable bitValue = 0;

    //Apply to initialise state, this is defined by the angles theta_1 and theta_2
    StateInitialisation(TargetReg, AncilReg, theta_1, theta_2);
    for index in 0 .. Measurements - 1{
        H(ControlReg);

        //Don't apply rotation on first set of oracles
        if index > 0 {

            //Loop through previous results
            for index2 in 0 .. index - 1{
                if MeasureControlReg[Measurements - 1 - index2] == One{
                    let angle = -IntAsDouble(2^(index2))*PI()/(2.0^IntAsDouble(index));

                    //Rotate control qubit dependent on previous measurements and number of measurements
                    R(PauliZ, angle, ControlReg);
                }
            }
        }
        let powerIndex = (1 <<< (Measurements - 1 - index));

        //Apply a number of oracles equal to 2^index, where index is the number or measurements left
        for _ in 1 .. powerIndex{
                Controlled GOracle([ControlReg],(TargetReg, AncilReg, theta_1, theta_2));
            }
        H(ControlReg);

        //Make a measurement mid circuit
        set MeasureControlReg w/= (Measurements - 1 - index) <- MResetZ(ControlReg);
        if MeasureControlReg[Measurements - 1 - index] == One{

            //Assign bitValue based on previous measurement
            set bitValue += 2^(index);

        }
    }
    return bitValue;
}

Výpočet vnitřního součinu

Nakonec vypočítejte vnitřní součin z naměřené hodnoty.

$$\braket {v|c} = -cos(2\pi x / 2^n)$$

where $x = \phi_0\phi_1\phi_2...\phi_{n}$. Jmenovatelem v rámci kosinusové funkce je posunout binární bod tak, aby odpovídal původní hodnotě $\phi$.

Poznámka

Pro vnitřní produkt, který není -1 nebo 1, jsou řešení spárována s rozdílem hodnot $2^{n-1}$. Například pro měření n=3 by naměřená bitová hodnota 2 měla také párové řešení 6. Jedna z těchto hodnot vytvoří stejnou hodnotu vnitřního součinu, když zadáte proměnnou do kosinus sudé funkce (výsledkem je vnitřní součin 0 v tomto příkladu).

U řešení vnitřního produktu mezi přesností diskrétního bitu se vytvoří rozdělení výsledků na základě toho, kde se vnitřní produkt nachází mezi diskrétní bitovou hodnotou.

Do souboru Program.qs přidejte následující operaci.

function CalculateInnerProduct(Results : Int, theta_1 : Double, theta_2 : Double, Measurements : Int): Unit{
    let DoubleVal = PI() * IntAsDouble(Results) / IntAsDouble(2 ^ (Measurements-1));

    //Convert to the final inner product
    let InnerProductValue = -Cos(DoubleVal);
    Message("The Bit Value measured is:");
    Message($"{Results}");
    Message("The Inner Product is:");
    Message($"{InnerProductValue}");
    Message("The True Inner Product is:");
    Message($"{Cos(theta_1/2.0)*Cos(theta_2/2.0)+Sin(theta_1/2.0)*Sin(theta_2/2.0)}");
}

Spuštění programu

Teď můžete program otestovat. Nejprve spustíte program pomocí operace simulace místně a pak se připojíte k Azure Quantum a spustíte ho na hardwaru target.

Simulace odhadu iterativní fáze

Q# programy vyžadují, @EntryPoint() aby kompilátoru řekl, kde má spustit provádění programu. Přidejte do souboru Programs.qs následující kód, který spustí program s SimulateInnerProduct() operací. Tato verze vnitřní operace produktu vypíše další informace, včetně manipulace s dvojníkem, jejichž výstup je zobrazen v terminálu.

@EntryPoint()

//Operation for calculating the inner product on local simulators
operation SimulateInnerProduct() : Unit{

    //This operation will output additional classical calculations
    let (Results, theta_1, theta_2, Measurements) = InnerProduct();
    CalculateInnerProduct(Results, theta_1, theta_2, Measurements);
}

operation InnerProduct() : (Int, Double, Double, Int){

    //Specify the angles for inner product
    let theta_1 = 0.0;
    let theta_2 = 0.0;
    let Measurements = 3;

    //Create target register
    use TargetReg = Qubit();

    //Create ancilla register
    use AncilReg = Qubit();

    //This runs iterative phase estimation
    let Results = IterativePhaseEstimation(TargetReg, AncilReg, theta_1, theta_2, Measurements);
    Reset(TargetReg);
    Reset(AncilReg);
    return (Results, theta_1, theta_2, Measurements);
}

Pokud chcete program spustit, otevřete okno terminálu v nástroji VS Code a spusťte příkaz

    dotnet run

Spuštění v Azure Quantum target

Chcete-li spustit na hardwaru target, nahraďte SimulateInnerProduct() operaci následující HardwareInnerProduct() operací:

//Operation for calculating the inner product on hardware or emulators
operation HardwareInnerProduct() : Int{
    let (Results,_,_,_) = InnerProduct();
    return Results;
}

Dále se připojte k pracovnímu prostoru Azure Quantum a nastavte výchozí prostředky.

az login

Poznámka

Id předplatného Azure, skupinu prostředků a název pracovního prostoru můžete po přihlášení uvést v okně terminálu spuštěním příkazu az quantum workspace list. Případně je můžete najít v Azure Portal na stránce Přehled pracovního prostoru Azure Quantum.

az account set --subscription <MySubscriptionID>

az quantum workspace set --resource-group <MyResourceGroup> --workspace <MyWorkspace> --location <MyLocation>

Odešlete úlohu s následujícími parametry:

az quantum job submit \
    --target-id quantinuum.sim.h1-1e \
    --target-capability AdaptiveExecution \
    --shots 50 \
    --job-name IterativePhaseEstimation

Poznámka

Zadaný target vyžaduje target profil spuštění, který podporuje Basic Measurement Feedback.

Důležité

Při spuštění v Azure targets se nedoporučuje zvyšovat hodnotu Measurements nad 3, protože eHQCs se může výrazně zvýšit.

Stav úlohy můžete zobrazit pomocí

az quantum job output \
    -o table \
    --job-id [job-id]

nahraďte [id_úlohy] zobrazeným ID úlohy. Výsledky ukazují řešení ve státě s většinovou populací. Konečný vnitřní součin z výsledků celého čísla lze vypočítat pomocí $\braket {v|c} = -cos(2\pi x / 2^n)$, kde n je počet měření zadaných v úloze.

Poznámka

Výběr vstupních parametrů, které mají pouze jeden stav řešení (vnitřní součin -1 nebo 1), je ideální pro viditelnost při použití nízkého počtu snímků.

Další kroky

Distribuované hybridní výpočetní prostředí