Komputasi hibrid terintegrasi

Artikel
12/07/2023

Komputasi hibrid terintegrasi menyatukan proses klasik dan kuantum, memungkinkan kode klasik mengontrol eksekusi operasi kuantum berdasarkan pengukuran pertengahan sirkuit sementara qubit fisik tetap hidup. Menggunakan teknik pemrograman umum, seperti kondisional berlapis, perulangan, dan panggilan fungsi, satu program kuantum dapat menjalankan masalah kompleks, mengurangi jumlah bidikan yang diperlukan. Menggunakan teknik penggunaan kembali qubit, program yang lebih besar dapat berjalan pada mesin yang menggunakan jumlah qubit yang lebih kecil.

Penting

Komputasi kuantum hibrid terintegrasi saat ini tidak didukung oleh ekstensi Modern (Modern Quantum Development Kit QDK) untuk Visual Studio Code, bersama dengan komponen lain dalam contoh di halaman ini, seperti kernel IQ#, %azure perintah ajaib, atau qsharp.azure modul. Untuk menjalankan pekerjaan hibrid terintegrasi, gunakan Microsoft Quantum Development Kit (QDK Klasik). Untuk informasi selengkapnya, lihat Lanjutkan bekerja di QDK Klasik.

Untuk diskusi selengkapnya, lihat:

Komputasi kuantum hibrid terintegrasi

Didukung targets

Saat ini, model komputasi hibrid terintegrasi di Azure Quantum didukung di Quantinuumtargets.

Quantinuum

Fitur yang didukung	Catatan
Perulangan klasik	Perulangan terikat saja
Alur kontrol arbitrer	Penggunaan percabangan if/else
Pengukuran pertengahan sirkuit	Menggunakan sumber daya register klasik
Penggunaan kembali qubit	T/A
Komputasi klasik real time	Aritmatika bilangan bulat tidak bertanda 32-bit Menggunakan sumber daya register klasik

Mulai

Untuk mulai menjelajahi pemrograman hibrid terintegrasi, sebaiknya telusuri sampel dalam artikel ini, atau jelajahi tab komputasi kuantum Hibrid di galeri Sampel portal Azure Quantum.

Mengirimkan pekerjaan hibrid terintegrasi

Saat mengirimkan pekerjaan hibrid terintegrasi, Anda perlu menambahkan target parameter kemampuan setelah menentukan target. Selain itu, program hibrid terintegrasi di Azure Quantum dijalankan dan dikelola sama seperti pekerjaan kuantum reguler. Setiap pekerjaan memiliki SATU ID pekerjaan dan hasilnya adalah satu histogram.

Penting

I Q#

Saat menggunakan kernel IQ# di Jupyter Notebook, gunakan %azure.target-perintah ajaib kemampuan dengan AdaptiveExecution parameter .

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

Python + Q#

Saat menggunakan paket python qsharp , gunakan qsharp.azure.target_capability fungsi dengan AdaptiveExecution parameter .

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

Azure CLI

Saat menggunakan Azure CLI untuk mengirimkan pekerjaan, tambahkan --target-capability parameter dengan nilai AdaptiveExecution.

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

Mengirimkan pekerjaan hibrid terintegrasi dalam sesi

Anda dapat menggabungkan beberapa pekerjaan hibrid terintegrasi dalam sesi menggunakan Q# dan Python. Saat mengirimkan sesi, tambahkan targetCapability parameter input dengan nilai 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

Untuk informasi selengkapnya, lihat Mulai menggunakan sesi.

Catatan

Meskipun sesi tersedia untuk semua penyedia perangkat keras komputasi kuantum, perhatikan bahwa pekerjaan komputasi kuantum hibrid terintegrasi saat ini didukung di Quantinuum targets.

Memperkirakan biaya pekerjaan hibrid terintegrasi

Anda dapat memperkirakan biaya menjalankan pekerjaan hibrid terintegrasi pada perangkat keras Quantinuum dengan menjalankannya di emulator terlebih dahulu.

Setelah berhasil berjalan di emulator:

Di ruang kerja Azure Quantum Anda, pilih Manajemen pekerjaan.
Pilih pekerjaan yang Anda kirimkan.
Di popup Detail pekerjaan , pilih Estimasi Biaya untuk melihat berapa banyak eHQC (kredit emulator Quantinuum) yang digunakan. Jumlah ini diterjemahkan langsung ke jumlah HQC (kredit kuantum Quantinuum) yang diperlukan untuk menjalankan pekerjaan pada perangkat keras Quantinuum.

Estimasi biaya

Catatan

Quantinuum membuka seluruh sirkuit dan menghitung biaya pada semua jalur kode, baik dijalankan secara kondisional atau tidak.

Sampel hibrid terintegrasi

Sampel berikut menunjukkan kumpulan fitur saat ini untuk komputasi hibrid terintegrasi.

Memverifikasi status GHZ yang terjerat
Pengulangan tiga kubit
Estimasi fase berulang

Prasyarat

Jika Anda baru menggunakan Azure Quantum, Anda memerlukan langganan Azure dan ruang kerja Azure Quantum untuk menjalankan sampel terhadap perangkat keras kuantum. Untuk informasi selengkapnya, lihat Buat ruang kerja Azure Quantum.
Visual Studio Code dan Quantum Development Kit pengaturan di lingkungan lokal Anda. Untuk informasi selengkapnya, lihat Menyiapkan Quantum Development Kit.
Pastikan visual Studio Code memiliki versi terbaru ( Quantum Development Kit 0.27.258160).
- Di Visual Studio Code, pilih Ctrl + Shift + X dan cari "Microsoft Quantum Development Kit".

Sampel dalam artikel ini disiapkan untuk dijalankan di Visual Studio (VS) Code dan menggunakan antarmuka baris perintah (CLI) Azure bawaan untuk mengirimkan pekerjaan ke Azure Quantum. Untuk menjalankan versi Jupyter Notebook dari sampel ini dan sampel lainnya, masuk ke ruang kerja portal Azure Anda dan lihat sampel dari tab komputasi kuantum Hibrid di galeri Sampel. Anda dapat menjalankan notebook di cloud atau mengunduhnya dan menjalankannya secara lokal.

Untuk memecahkan masalah dengan program hibrid terintegrasi, lihat Pemecahan masalah hibrid terintegrasi.

Dalam sampel ini, Anda akan menemukan cara memadukan instruksi klasik dan kuantum dalam program yang sama, semuanya sepenuhnya diproses oleh backend komputasi kuantum.

Fitur yang perlu diperhatikan tentang sampel ini:

Pengukuran loop dan qubit terjadi sementara qubit tetap koheren.
Rutinitas ini mencampur operasi komputasi klasik dan kuantum.
Anda tidak perlu belajar memprogram perangkat keras berkinerja tinggi khusus yang berjalan di samping QPU (seperti FPGA).
Menjalankan program yang setara tanpa fitur hibrid terintegrasi akan memerlukan pengembalian setiap hasil pengukuran menengah dan kemudian menjalankan pasca-pemrosesan pada data.

Membuat proyek Visual Studio Code

Di Visual Studio Code, buat proyek aplikasi konsol mandiri baru Q# bernama CheckGHZ.
1. Pilih Lihat > Perintah Pallete >Q#: Buat aplikasi konsol Mandiri proyek > baru

Ganti konfigurasi di CheckGHZ.csproj dengan yang berikut:

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

Ganti kode di Program.qs dengan yang berikut:

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

Dari jendela terminal di Visual Studio Code, sambungkan ke ruang kerja Azure Quantum Anda dan atur sumber daya default.
```
az login
```
Catatan

ID langganan Azure, grup sumber daya, dan nama ruang kerja Anda dapat dicantumkan di jendela terminal setelah masuk dengan menjalankan daftar ruang kerja kuantum az. Secara bergantian, Anda dapat menemukannya di portal Azure di halaman Gambaran Umum ruang kerja Azure Quantum Anda.
```
az account set --subscription <MySubscriptionID>

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

Kirim pekerjaan dan lihat hasilnya. Eksekusi ini menggunakan sekitar 10,65 eHQC (unit penagihan emulator 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]

Output GHZ

Sampel ini menunjukkan cara membuat kode pengulangan 3 kubit yang dapat digunakan untuk mendeteksi dan memperbaiki kesalahan flip bit.

Ini memanfaatkan fitur komputasi hibrid terintegrasi untuk menghitung berapa kali koreksi kesalahan dilakukan sementara status register qubit logis koheren.

Membuat proyek Visual Studio Code

Di Visual Studio Code, buat proyek aplikasi konsol mandiri baru Q# bernama ThreeQubit.
1. Pilih Lihat > Perintah Pallete >Q#: Buat aplikasi konsol Mandiri proyek > baru

Ganti konfigurasi di ThreeQubit.csproj dengan yang berikut:

<Project Sdk="Microsoft.Quantum.Sdk/0.27.258160">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum</ExecutionTarget>
    <TargetCapability>AdaptiveExecution</TargetCapability>
  </PropertyGroup>

</Project>

Ganti kode di Program.qs dengan yang berikut:

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

Dari jendela terminal di Visual Studio Code, sambungkan ke ruang kerja Azure Quantum Anda dan atur sumber daya default.
```
az login
```
Catatan

ID langganan Azure, grup sumber daya, dan nama ruang kerja Anda dapat dicantumkan di jendela terminal setelah masuk dengan menjalankan daftar ruang kerja kuantum az. Secara bergantian, Anda dapat menemukannya di portal Azure di halaman Gambaran Umum ruang kerja Azure Quantum Anda.
```
az account set --subscription <MySubscriptionID>

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

Kirim pekerjaan dan lihat hasilnya. Eksekusi ini menggunakan sekitar 11.31 eHQCs (unit penagihan emulator 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]

Kode sampel ini ditulis oleh anggota tim KPMG Quantum di Australia dan termasuk dalam Lisensi MIT. Ini bertujuan untuk menunjukkan kemampuan Basic Measurement Feedbacktargets yang diperluas dan menggunakan perulangan terikat, panggilan fungsi klasik pada durasi, pernyataan kondisional berlapis jika, pengukuran sirkuit tengah, dan menghentikan penggunaan kembali.

Perhitungan produk dalam dua dimensi menggunakan estimasi fase iteratif pada tiga kubit

Program sampel ini menunjukkan estimasi fase iteratif dalam Q#. Ini menggunakan estimasi fase iteratif untuk menghitung produk dalam antara dua vektor 2 dimensi yang dikodekan pada target qubit dan ancilla qubit. Kubit kontrol tambahan juga diinisialisasi yang akan menjadi satu-satunya kubit yang digunakan untuk pengukuran.

Sirkuit dimulai dengan mengodekan pasangan vektor pada target qubit dan ancilla qubit. Kemudian menerapkan operator Oracle ke seluruh register, dikontrol dari kontrol qubit, yang diatur dalam status $\ket +$. Operator Oracle yang dikontrol menghasilkan fase pada status $\ket 1$ dari qubit kontrol. Ini kemudian dapat dibaca dengan menerapkan gerbang H ke kubit kontrol untuk membuat fase dapat diamati saat mengukur.

Membuat proyek Visual Studio Code

Di Visual Studio Code, buat proyek aplikasi konsol mandiri baru Q# bernama IPE.
1. Pilih Lihat > Perintah Pallete >Q#: Buat aplikasi konsol Mandiri proyek > baru

Ganti konfigurasi di IPE.csproj dengan yang berikut:

<Project Sdk="Microsoft.Quantum.Sdk/0.27.253010">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
    <ExecutionTarget>quantinuum.sim.h1-1e</ExecutionTarget>
  </PropertyGroup>

</Project>

Ganti kode di Program.qs dengan yang berikut:

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


}

Vektor pengodean

Vektor v dan c akan dikodekan ke target qubit dan ancilla qubit. Vektor $v = (cos(\frac{\theta_1}{2}),sin(\frac{\theta_1}{2})))$ dapat diwakili oleh status kuantum $\ket v = cos(\frac{\theta_1}{2})\ket 0 + sin(\frac{\theta_1}{2})\ket 1$, demikian pula $c$ dapat dibangun menggunakan $\theta_2$.

Rotasi Y diterapkan ke target qubit dalam status $\ket 0$:

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

Catatan

Faktor 2 hadir di sini pada theta. Aplikasi gerbang $RY(2\pi)$ pada $\ket 0$ memberikan status $-\ket 0$ dan akan mengodekan vektor $(-1,0)$. Fase ini tidak dapat dianggap sebagai fase global dan dihapus karena seluruh register akan terjerat.

Daftar target qubit dan ancilla qubit adalah

$$\ket \Psi = \ket {\Psi_\text{Target qubit}}\ket {\Psi_\text{Ancilla qubit}}$$

Status yang akan dibuat ada di target qubit dan ancilla qubit adalah

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

yang juga mengambil formulir

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

Tambahkan operasi berikut ke file 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

Oracle G perlu dibangun sed sehingga menghasilkan eigenphase pada status yang dikodekan pada target qubit dan ancilla qubit. Pembangunan oracle ini tidak penting untuk demonstrasi dalam contoh ini, tetapi operasi yang diterapkannya adalah

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

di mana produk dalam $\braket {v|c}$ terkandung dalam fase $\phi$, yang terikat antara [0,1]. Ketika diterapkan dikontrol pada qubit kontrol yang dimulai dalam status $\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}$$

Sekarang qubit kontrol berisi fase yang berkaitan dengan produk dalam $\braket {v|c}$

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

Tambahkan operasi berikut ke file 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);
        }
    }

Iterasi

Sekarang untuk bagian berulang dari sirkuit. Untuk pengukuran n, pertimbangkan bahwa fase dapat direpresentasikan sebagai nilai biner $\phi$, dan yang menerapkan oracles $2^n$ membuat titik biner ke-n dari fase dapat diamati (melalui perkalian biner sederhana, dan modulus $2\pi$). Nilai qubit kontrol dapat dibaca, ditempatkan dalam register klasik dan reset qubit untuk digunakan dalam iterasi berikutnya. Perulangan berikutnya menerapkan oracles $2^{n-1}$, mengoreksi fase pada kubit kontrol tergantung pada pengukuran ke-n. Status pada qubit kontrol dapat direpresentasikan sebagai

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

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

Menerapkan oracles terkontrol $2^n$ memberikan status pada qubit kontrol

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

Pertimbangkan bahwa fase tidak memiliki istilah yang lebih dalam dari $\phi_n$ (yaitu, istilah $\phi_{n+1},\phi_{n+2}, \text{etc}$)

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

Sekarang nilai $\phi_n$ dapat diamati dengan gerbang H dan pengukuran yang memproyeksikan di sepanjang sumbu Z. Mereset kubit kontrol dan menerapkan oracle $2^{n-1}$ kali

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

Menggunakan nilai terukur sebelumnya untuk $\phi_n$, titik biner tambahan dapat diputar

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

Proses ini secara berulang diterapkan untuk beberapa presisi bit n untuk mendapatkan fase $0.\phi_0\phi_1\phi_2...\phi_{n}$. Nilai disimpan sebagai nilai biner $x = \phi_0\phi_1\phi_2...\phi_{n}$, karena hanya bilangan bulat yang dapat dimanipulasi saat runtime saat ini.

Karena readout tidak memberi tahu apa pun tentang vektor, hanya produk dalam di antara mereka, status pada target qubit dan ancilla qubit tetap dalam keadaan yang sama sepanjang proses!

Tambahkan operasi berikut ke file 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;
}

Menghitung produk dalam

Terakhir, hitung produk dalam dari nilai yang diukur

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

where $x = \phi_0\phi_1\phi_2...\phi_{n}$. Denominator dalam fungsi kosinus adalah untuk menggeser titik biner agar sesuai dengan nilai asli $\phi$.

Catatan

Untuk produk dalam yang bukan -1 atau 1, solusi dipasangkan dengan perbedaan nilai $2^{n-1}$. Misalnya untuk pengukuran n=3, nilai bit 2 yang diukur juga akan memiliki larutan pasangan 6. Salah satu nilai ini menghasilkan nilai yang sama dari produk dalam ketika dimasukkan sebagai variabel ke kosinus fungsi genap (menghasilkan produk dalam 0 dalam contoh ini).

Untuk solusi produk dalam antara presisi bit diskrit, distribusi hasil akan diproduksi berdasarkan di mana produk dalam berada di antara nilai bit diskrit.

Tambahkan operasi berikut ke file 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)}");
}

Jalankan program

Sekarang, Anda dapat menguji program. Pertama, Anda akan menjalankan program menggunakan operasi simulasi secara lokal, lalu Anda akan terhubung ke Azure Quantum dan menjalankannya terhadap perangkat keras target.

Mensimulasikan estimasi fase iteratif

Q# program memerlukan @EntryPoint() untuk memberi tahu pengkompilasi tempat memulai eksekusi program. Tambahkan kode berikut ke Programs.qs untuk memulai program dengan SimulateInnerProduct() operasi. Versi operasi produk dalam ini menghasilkan informasi tambahan, termasuk manipulasi ganda yang outputnya ditampilkan di terminal.

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

Untuk menjalankan program, buka jendela terminal di Visual Studio Code dan jalankan

    dotnet run

Berjalan di Azure Quantum target

Untuk menjalankan terhadap perangkat keras target, ganti SimulateInnerProduct() operasi dengan operasi berikut HardwareInnerProduct() :

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

Selanjutnya, sambungkan ke ruang kerja Azure Quantum Anda dan atur sumber daya default.

az login

Catatan

ID langganan Azure, grup sumber daya, dan nama ruang kerja Anda dapat dicantumkan di jendela terminal setelah masuk dengan menjalankan daftar ruang kerja kuantum az. Secara bergantian, Anda dapat menemukannya di portal Azure di halaman Gambaran Umum ruang kerja Azure Quantum Anda.

az account set --subscription <MySubscriptionID>

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

Kirim pekerjaan dengan parameter berikut:

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

Catatan

Yang ditentukan target memerlukan target profil eksekusi yang mendukung Basic Measurement Feedback.

Penting

Tidak disarankan untuk meningkatkan nilai Measurements melebihi 3 saat berjalan di Azure targets karena eHQC dapat meningkat secara signifikan.

Anda dapat melihat status pekerjaan dengan

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

mengganti [job-id] dengan id pekerjaan yang ditampilkan. Hasilnya menunjukkan solusi dalam keadaan dengan populasi mayoritas. Produk dalam akhir dari hasil bilangan bulat dapat dihitung dengan $\braket {v|c} = -cos(2\pi x / 2^n)$, di mana n adalah jumlah pengukuran yang ditentukan dalam pekerjaan.

Catatan

Memilih parameter input yang hanya memiliki satu status solusi (produk dalam -1 atau 1) sangat ideal untuk visibilitas saat menggunakan jumlah bidikan yang rendah.

Langkah berikutnya

Komputasi hibrid terdistribusi

Share via

Komputasi hibrid terintegrasi

Didukung targets

Quantinuum

Mulai

Mengirimkan pekerjaan hibrid terintegrasi

I Q#

Python + Q#

Azure CLI

Mengirimkan pekerjaan hibrid terintegrasi dalam sesi

Memperkirakan biaya pekerjaan hibrid terintegrasi

Sampel hibrid terintegrasi

Prasyarat

Membuat proyek Visual Studio Code

Membuat proyek Visual Studio Code

Perhitungan produk dalam dua dimensi menggunakan estimasi fase iteratif pada tiga kubit

Membuat proyek Visual Studio Code

Vektor pengodean

The Oracle

Iterasi

Menghitung produk dalam

Jalankan program

Mensimulasikan estimasi fase iteratif

Berjalan di Azure Quantum target

Langkah berikutnya

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan: