Zintegrowane przetwarzanie hybrydowe

Zintegrowane przetwarzanie hybrydowe łączy ze sobą klasyczne i kwantowe procesy, dzięki czemu klasyczny kod może kontrolować wykonywanie operacji kwantowych na podstawie pomiarów obwodu środkowego, podczas gdy fizyczne kubity pozostają aktywne. Korzystając z typowych technik programowania, takich jak zagnieżdżone warunkowe, pętle i wywołania funkcji, pojedynczy program kwantowy może uruchamiać złożone problemy, zmniejszając liczbę potrzebnych zdjęć. Korzystając z technik ponownego użycia kubitu, większe programy mogą być uruchamiane na maszynach z mniejszą liczbą kubitów.

Ważne

Zintegrowane hybrydowe obliczenia kwantowe nie są obecnie obsługiwane przez rozszerzenie Modern Quantum Development Kit (Modern QDK) dla Visual Studio Code, wraz z innymi składnikami w przykładach na tej stronie, takich jak jądro IQ#, %azure polecenie magic lub qsharp.azure moduł. Aby uruchomić zintegrowane zadania hybrydowe, użyj zestawu Microsoft Quantum Development Kit (klasyczny zestaw QDK). Aby uzyskać więcej informacji, zobacz Kontynuuj pracę w klasycznym zestawie QDK.

Aby uzyskać więcej informacji, zobacz:

• Granade & Weibe, "Używanie losowych spacerów na potrzeby iteracyjnego szacowania fazy".
• Lubinski, et al., "Postęp hybrydowych obliczeń kwantowych–klasycznych przy użyciu Real-Time wykonywania"

Obsługiwane targets

Obecnie zintegrowany hybrydowy model obliczeniowy w usłudze Azure Quantum jest obsługiwany w aplikacji Quantinuumtargets.

Quantinuum

Obsługiwana funkcja	Uwagi
Pętle klasyczne	Tylko ograniczone pętle
Dowolny przepływ sterowania	Użycie rozgałęziania if/else
Pomiar w obwodzie środkowym	Korzysta z klasycznych zasobów rejestru
Ponowne użycie kubitu	Nie dotyczy
Obliczenia klasyczne w czasie rzeczywistym	32-bitowa arytmetyka niepodpisanej liczby całkowitej Korzysta z klasycznych zasobów rejestru

Wprowadzenie

Aby rozpocząć eksplorowanie zintegrowanego programowania hybrydowego, zalecamy zapoznanie się z przykładami w tym artykule lub zapoznanie się z kartą Hybrydowe obliczenia kwantowe w galerii Przykłady w witrynie Azure Quantum Portal.

Przesyłanie zintegrowanych zadań hybrydowych

Podczas przesyłania zintegrowanego zadania hybrydowego należy dodać target parametr możliwości po określeniu elementu target. Poza tym zintegrowane programy hybrydowe w usłudze Azure Quantum są uruchamiane i zarządzane tak samo jak zwykłe zadania kwantowe. Każde zadanie ma jeden identyfikator zadania, a wynik jest pojedynczym histogramem.

Ważne

Zintegrowane hybrydowe obliczenia kwantowe nie są obecnie obsługiwane przez rozszerzenie Modern Quantum Development Kit (Modern QDK) dla Visual Studio Code, wraz z innymi składnikami w przykładach na tej stronie, takich jak jądro IQ#, %azure polecenie magic lub qsharp.azure moduł. Aby uruchomić zintegrowane zadania hybrydowe, użyj zestawu Microsoft Quantum Development Kit (klasyczny zestaw QDK). Aby uzyskać więcej informacji, zobacz Kontynuuj pracę w klasycznym zestawie QDK.

I Q#

W przypadku korzystania z jądra IQ# w Jupyter Notebook użyj %azure.target-capability magic polecenia z parametrem AdaptiveExecution .

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

Python + Q#

W przypadku korzystania z pakietu języka Python qsharp użyj qsharp.azure.target_capability funkcji z parametrem AdaptiveExecution .

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

Interfejs wiersza polecenia platformy Azure

W przypadku przesyłania zadania przy użyciu interfejsu wiersza polecenia platformy Azure dodaj --target-capability parametr z wartością AdaptiveExecution.

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

Przesyłanie zintegrowanych zadań hybrydowych w ramach sesji

W ramach sesji można połączyć wiele zintegrowanych zadań hybrydowych przy użyciu języków Q# i Python. Podczas przesyłania sesji dodaj targetCapability parametr wejściowy z wartością 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

Aby uzyskać więcej informacji, zobacz Wprowadzenie do sesji.

Uwaga

Mimo że sesje są dostępne dla wszystkich dostawców sprzętu obliczeń kwantowych, zwróć uwagę, że zintegrowane hybrydowe zadania obliczeń kwantowych są obecnie obsługiwane w aplikacji Quantinuum targets.

Szacowanie kosztów zintegrowanego zadania hybrydowego

Koszty uruchamiania zintegrowanego zadania hybrydowego na sprzęcie Firmy Quantinuum można oszacować, uruchamiając je najpierw w emulatorze.

Po pomyślnym uruchomieniu w emulatorze:

1. W obszarze roboczym usługi Azure Quantum wybierz pozycję Zarządzanie zadaniami.
2. Wybierz przesłane zadanie.
3. W oknie podręcznym Szczegóły zadania wybierz pozycję Szacowanie kosztów , aby wyświetlić liczbę używanych jednostek eHQC (środki emulatora Quantinuum). Ta liczba przekłada się bezpośrednio na liczbę HQC (kwantowych kredytów kwantowych Quantinuum), które są potrzebne do uruchomienia zadania na sprzęcie Firmy Quantinuum.

Uwaga

Firma Quantinuum wyrejestruje cały obwód i oblicza koszt dla wszystkich ścieżek kodu, niezależnie od tego, czy są one wykonywane warunkowo, czy nie.

Zintegrowane przykłady hybrydowe

W poniższych przykładach pokazano bieżący zestaw funkcji dla zintegrowanego przetwarzania hybrydowego.

• Weryfikowanie splątanego stanu GHZ
• Powtórzenie z trzema kubitami
• Iteracyjne szacowanie fazy

Wymagania wstępne

• Jeśli jesteś nowym użytkownikiem usługi Azure Quantum, potrzebujesz subskrypcji platformy Azure i obszaru roboczego usługi Azure Quantum, aby uruchomić przykłady na sprzęcie kwantowym. Aby uzyskać więcej informacji, zobacz Tworzenie obszaru roboczego usługi Azure Quantum.
• Program VS Code i Quantum Development Kit konfiguracja w środowisku lokalnym. Aby uzyskać więcej informacji, zobacz Konfigurowanie elementu Quantum Development Kit.
• Upewnij się, że program VS Code ma najnowszą wersję Quantum Development Kit (0.27.258160).
  • W programie VS Code wybierz klawisze Ctrl + Shift + X i wyszukaj ciąg "Microsoft Quantum Development Kit".

Przykłady w tym artykule są skonfigurowane do uruchamiania w programie Visual Studio (VS) Code i używają wbudowanego interfejsu wiersza polecenia platformy Azure w celu przesłania zadania do usługi Azure Quantum. Aby uruchomić Jupyter Notebook wersję tych i innych przykładów, zaloguj się do obszaru roboczego Azure Portal i wyświetl przykłady z karty Hybrydowe obliczenia kwantowe w galerii Przykłady. Możesz uruchomić notes w chmurze lub pobrać go i uruchomić lokalnie.

Aby rozwiązać problemy ze zintegrowanymi programami hybrydowymi, zobacz Rozwiązywanie problemów ze zintegrowanym hybrydowym rozwiązaniem.

Sprawdzanie stanu GHZ

W tym przykładzie dowiesz się, jak mieszać instrukcje klasyczne i kwantowe w tym samym programie, wszystkie w pełni przetwarzane przez zaplecze obliczeń kwantowych.

Funkcje, które należy zwrócić uwagę na ten przykład:

• Pętla i pomiary kubitów odbywają się, podczas gdy kubity pozostają spójne.
• Procedura łączy klasyczne i kwantowe operacje obliczeniowe.
• Nie musisz uczyć się programowania dla wyspecjalizowanego sprzętu o wysokiej wydajności działającego obok QPU (np. układów FPGA).
• Uruchomienie równoważnego programu bez zintegrowanych funkcji hybrydowych wymagałoby zwrócenia wszystkich wyników pomiaru pośredniego, a następnie uruchomienia przetwarzania końcowego na danych.

Tworzenie projektu programu VS Code

1. W programie VS Code utwórz nowy Q# autonomiczny projekt aplikacji konsolowej o nazwie CheckGHZ.

   1. Wybierz pozycję Wyświetl > paletę >Q#poleceń: Utwórz nowy projekt > Autonomiczna aplikacja konsolowa

2. Zastąp konfigurację w pliku CheckGHZ.csproj następującym kodem:

   <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. Zastąp kod w pliku Program.qs następującym kodem:

   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. W oknie terminalu w programie VS Code połącz się z obszarem roboczym usługi Azure Quantum i ustaw domyślne zasoby.

   az login
   

   Uwaga

   Identyfikator subskrypcji platformy Azure, grupa zasobów i nazwa obszaru roboczego można wyświetlić w oknie terminalu po zalogowaniu się, uruchamiając polecenie az quantum workspace list. Alternatywnie można je znaleźć w Azure Portal na stronie Przegląd obszaru roboczego usługi Azure Quantum.

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

5. Prześlij zadanie i wyświetl wyniki. W tym przebiegu jest używanych około 10,65 eHQC (jednostki rozliczeniowe emulatora firmy 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]
   

Kod powtórzenia z trzema kubitami

W tym przykładzie pokazano, jak utworzyć 3-kubitowy kod powtórzeń, który może służyć do wykrywania i poprawiania błędów przerzucania bitów.

Wykorzystuje zintegrowane funkcje przetwarzania hybrydowego w celu zliczania liczby wykonanych poprawek błędów, gdy stan rejestru kubitów logicznych jest spójny.

Tworzenie projektu programu VS Code

1. W programie VS Code utwórz nowy Q# autonomiczny projekt aplikacji konsolowej o nazwie ThreeQubit.

   1. Wybierz pozycję Wyświetl > paletę >Q#poleceń: Tworzenie nowej aplikacji konsolowej autonomicznej projektu >

2. Zastąp konfigurację pliku ThreeQubit.csproj następującym kodem:

   <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. Zastąp kod w pliku Program.qs następującym kodem:

   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. W oknie terminalu w programie VS Code połącz się z obszarem roboczym usługi Azure Quantum i ustaw domyślne zasoby.

   az login
   

   Uwaga

   Identyfikator subskrypcji platformy Azure, grupa zasobów i nazwa obszaru roboczego można wyświetlić w oknie terminalu po zalogowaniu się, uruchamiając polecenie az quantum workspace list. Alternatywnie można je znaleźć w Azure Portal na stronie Przegląd obszaru roboczego usługi Azure Quantum.

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

5. Prześlij zadanie i wyświetl wyniki. Ten przebieg używa około 11.31 eHQC (jednostki rozliczeniowe emulatora 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]
   

Iteracyjne szacowanie fazy

Ten przykładowy kod został napisany przez członków zespołu KPMG Quantum w Australii i znajduje się w ramach licencji MIT. Ma ona na celu zademonstrowanie rozszerzonych możliwości Basic Measurement Feedbacktargets i wykorzystanie ograniczonych pętli, klasycznych wywołań funkcji w czasie wykonywania, zagnieżdżonych instrukcji if, pomiarów obwodu środkowego i ponownego użycia kubitu.

Dwuwymiarowe obliczenie produktu wewnętrznego przy użyciu iteracyjnego szacowania fazy na trzech kubitach

Ten przykładowy program demonstruje iteracyjne oszacowanie fazy w ramach programu Q#. Używa iteracyjnego szacowania fazy do obliczania produktu wewnętrznego między dwoma dwuwymiarowymi wektorami zakodowanymi na kubitie target i kubitem ancilla. Zostanie również zainicjowany dodatkowy kubit kontrolny, który będzie jedynym kubitem używanym do pomiaru.

Obwód zaczyna się od kodowania pary wektorów na kubitie target i kubitu ancilla. Następnie stosuje operator Oracle do całego rejestru, kontrolowanego od kubitu sterującego, który jest skonfigurowany w stanie $\ket +$. Kontrolowany operator Oracle generuje fazę stanu $\ket 1$ kubitu sterującego. Następnie można to odczytać, stosując bramę H do kubitu sterującego, aby faza mogła być zauważalna podczas pomiaru.

Tworzenie projektu programu VS Code

1. W programie VS Code utwórz nowy Q# autonomiczny projekt aplikacji konsolowej o nazwie IPE.

   1. Wybierz pozycję Wyświetl > paletę >Q#poleceń: Tworzenie nowej aplikacji konsolowej autonomicznej projektu >

2. Zastąp konfigurację w pliku IPE.csproj następującym kodem:

   <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. Zastąp kod w pliku Program.qs następującym kodem:

   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
   
   
   }
   

Wektory kodowania

Wektory v i c mają być zakodowane na kubitie target i kubitie ancilla. Wektor $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2}))$$ może być reprezentowany przez stan kwantowy $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, podobnie $c$ można skonstruować przy użyciu $\theta_2$.

Rotacja Y zastosowana do kubitu target w stanie $\ket 0$:

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

Uwaga

Czynnik 2 jest obecny tutaj w tecie. Zastosowanie bramy $RY(2\pi)$ na $\ket 0$ daje stan $-\ket 0$ i koduje wektor $(-1,0)$. Nie można uznać tej fazy za fazę globalną i zostanie usunięta, ponieważ cały rejestr zostanie splątane.

Rejestr kubitu target i kubitu ancilla to

$$\ket \Psi = \ket {\Psi_\text{kubit target}}\ket {\Psi_\text{kubit Ancilla}}$$

Stan do utworzenia znajduje się na kubitie target , a kubit ancilla to

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

które również przyjmuje postać

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

Dodaj następującą operację do pliku Program.qs .

//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

Wyrocznia G musi być skonstruowana tak, że generuje eigenphase na stanie zakodowanym na kubitie target i kubitie ancilla. Budowa tej wyroczni jest nieważna dla demonstracji w tym przykładzie, ale operacja, która ma zastosowanie, jest

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

gdzie produkt wewnętrzny $\braket {v|c}$ znajduje się w fazie $\phi$, która jest powiązana między [0,1]. Po zastosowaniu kontroli na kubitie sterującym rozpoczynającym się w tym stanie $\ket{\Psi_\text{Kubit sterowania}} = \ket +$

$$\begin{aligned} \text{Controlled }G \ket{\Psi_\text{Control Kubit}} \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{wyrównane}$$

Teraz kubit kontrolny zawiera fazę, która odnosi się do produktu wewnętrznego $\braket {v|c}$

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

Dodaj następującą operację do pliku Program.qs .

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

Iteracja

Teraz dla iteracyjnej części obwodu. W przypadku n pomiarów należy wziąć pod uwagę, że faza może być reprezentowana jako wartość binarna $\phi$, a zastosowanie wyroczni $2^n$ sprawia, że nth punkt binarny fazy obserwowalny (poprzez proste mnożenie binarne i modulus $2\pi$). Wartość kubitu sterującego można odczytać, umieścić w klasycznym rejestrze i zresetować kubit do użycia w następnej iteracji. Następna iteracja dotyczy wyroczni $2^{n-1}$, korygując fazę kubitu kontrolnego zależną od pomiaru nth. Stan kubitu sterującego może być reprezentowany jako

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

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

Zastosowanie kontrolowanych wyroczni $2^n$ daje stan kubitu kontrolnego

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

Należy wziąć pod uwagę, że faza nie zawiera terminów głębszych niż $\phi_n$ (tj. terminy $\phi_{n+1},\phi_{n+2}, \text{etc}$)

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

Teraz wartość $\phi_n$ można zaobserwować za pomocą bramy H i pomiaru przewidywanej wzdłuż osi Z. Zresetowanie kubitu kontrolki i zastosowanie wyroczni $2^{n-1}$ razy

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

Przy użyciu poprzedniej zmierzonej wartości $\phi_n$, można obrócić dodatkowy punkt binarny

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

Ten proces jest iteracyjny stosowany dla pewnej dokładności bitowej n w celu uzyskania fazy $0.\phi_0\phi_1\phi_2...\phi_{n}$. Wartość jest przechowywana jako wartość binarna $x = \phi_0\phi_1\phi_2...\phi_{n}$, ponieważ w czasie wykonywania można manipulować tylko liczbami całkowitymi.

Ponieważ odczyt nie mówi nic o wektorze, tylko wewnętrzny produkt między nimi, stany kubitu target i kubitu ancilla pozostają w tym samym stanie w całym procesie!

Dodaj następującą operację do pliku Program.qs .

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

Obliczanie produktu wewnętrznego

Na koniec oblicz produkt wewnętrzny z zmierzonej wartości

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

gdzie $x = \phi_0\phi_1\phi_2...\phi_{n}$. Mianownik w funkcji cosine polega na przesunięciu punktu binarnego tak, aby był zgodny z oryginalną wartością $\phi$.

Uwaga

W przypadku produktu wewnętrznego, które nie są -1 lub 1, rozwiązania są sparowane z różnicą wartości $2^{n-1}$. Na przykład w przypadku pomiarów n=3 mierzona wartość bitowa 2 zawiera również rozwiązanie pary 6. Każda z tych wartości generuje tę samą wartość produktu wewnętrznego, gdy dane wejściowe cosinus funkcji parzysowej (cosinus funkcji), cosinus (w wyniku wewnętrznego produktu 0 w tym przykładzie).

W przypadku rozwiązań produktu wewnętrznego między dyskretną precyzją bitów rozkład wyników zostanie wygenerowany na podstawie miejsca, w którym produkt wewnętrzny znajduje się między dyskretną wartością bitu.

Dodaj następującą operację do pliku Program.qs .

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)}");
}

Uruchamianie programu

Teraz możesz przetestować program. Najpierw uruchomisz program przy użyciu operacji symulacji lokalnie, a następnie połączysz się z usługą Azure Quantum i uruchomisz go na sprzęcie target.

Symulowanie szacowania fazy iteracyjnej

Q# programy wymagają , @EntryPoint() aby poinformować kompilator, gdzie rozpocząć wykonywanie programu. Dodaj następujący kod do pliku Programs.qs , aby uruchomić program z operacją SimulateInnerProduct() . Ta wersja operacji produktu wewnętrznego generuje dodatkowe informacje, w tym manipulowanie podwójnymi danymi wyjściowymi wyświetlanymi w terminalu.

@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);
}

Aby uruchomić program, otwórz okno terminalu w programie VS Code i uruchom polecenie

    dotnet run

Uruchamianie w usłudze Azure Quantum target

Aby uruchomić na sprzęcie target, zastąp SimulateInnerProduct() operację następującą HardwareInnerProduct() operacją:

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

Następnie połącz się z obszarem roboczym usługi Azure Quantum i ustaw domyślne zasoby.

az login

Uwaga

Identyfikator subskrypcji platformy Azure, grupa zasobów i nazwa obszaru roboczego można wyświetlić w oknie terminalu po zalogowaniu się, uruchamiając polecenie az quantum workspace list. Alternatywnie można je znaleźć w Azure Portal na stronie Przegląd obszaru roboczego usługi Azure Quantum.

az account set --subscription <MySubscriptionID>

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

Prześlij zadanie przy użyciu następujących parametrów:

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

Uwaga

Określona wartość target wymaga profilu wykonywania, który obsługuje Basic Measurement Feedbackusługę target .

Ważne

Nie zaleca się zwiększenia wartości przekraczającej Measurements3 podczas pracy na platformie Azure targets , ponieważ kontrolery eHQC mogą znacznie wzrosnąć.

Stan zadania można wyświetlić za pomocą polecenia

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

zastępując ciąg [job-id] wyświetlonym identyfikatorem zadania. Wyniki pokazują rozwiązanie w stanie z większością populacji. Końcowy produkt wewnętrzny z wyników liczby całkowitej można obliczyć przez $\braket {v|c} = -cos(2\pi x / 2^n)$, gdzie n jest liczbą pomiarów określonych w zadaniu.

Uwaga

Wybieranie parametrów wejściowych, które mają tylko jeden stan rozwiązania (wewnętrzne produkty -1 lub 1) są idealne do widoczności podczas korzystania z niskiej liczby zdjęć.

Następne kroki

Rozproszone przetwarzanie hybrydowe