Algoritma kuantum untuk sistem persamaan linear (HHL09): Langkah 2 - Persiapan kondisi awal dan

^{Ini adalah kelanjutan dari algoritma Quantum untuk sistem persamaan linear (HHL09): Langkah 2 - Apa itu ? $|\Psi_0\rangle$}

Dalam makalah: Algoritma Quantum untuk sistem persamaan linear (Harrow, Hassidim & Lloyd, 2009) , rincian implementasi algoritma yang sebenarnya tidak diberikan. Bagaimana tepatnya state $|\Psi_0\rangle$ dan $|b\rangle$ dibuat, adalah semacam " kotak hitam " (lihat halaman 2-3).

| Ψ_{0} ⟩ = \sqrt{\frac{2}{T}} \sum_{τ = 0}^{T - 1} \sin \frac{π (τ + \frac{1}{2})}{T} | τ ⟩

$|\Psi_0\rangle = \sqrt{\frac{2}{T}}\sum_{\tau = 0}^{T-1}\sin \frac{\pi (\tau+\frac{1}{2})}{T}|\tau\rangle$

dan

| b ⟩ = \sum_{1}^{N} b_{i} | i ⟩

$|b\rangle = \sum_{1}^{N}b_i|i\rangle$

di mana $|\Psi_0\rangle$ adalah status awal register jam dan $|b\rangle$ adalah status awal register Input.

(Katakan) Saya ingin menjalankan algoritme mereka pada komputer kuantum IBM $16$ -qubit. Dan saya ingin menyelesaikan persamaan tertentu $\mathbf{Ax=b}$ mana $\mathbf{A}$ adalah $4\times 4$ matriks Hermitian dengan entri nyata dan $\mathbf{b}$ adalah vektor kolom $4\times 1$ dengan entri nyata.

Mari kita ambil contoh:

A = [\begin{matrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{matrix}]

$\mathbf{A} = \begin{bmatrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{bmatrix}$

dan

b = [\begin{matrix} 1 \\ 2 \\ 3 \\ 4 \end{matrix}]

$\mathbf{b}=\begin{bmatrix} 1 \\ 2 \\ 3 \\ 4 \end{bmatrix}$

Dengan dimensi dan , kita harus memerlukan qubit untuk register input dan qubit lain untuk register jam dengan asumsi kita menginginkan nilai eigen menjadi direpresentasikan dengan akurasi dan presisi hingga bit untuk nilai eigen (ini telah dibahas di sini sebelumnya). Jadi total qubit akan dibutuhkan untuk tujuan ini (tambahan qubit adalah ancilla). $\mathbf{A}$ $\mathbf{b}$ $\lceil{\log_2 4\rceil}=2$ $6$ $90\%$ $3$ $2+6+1=9$ $1$

Pertanyaan:

Dengan menggunakan informasi ini, apakah mungkin untuk membuat status awal dan pada IBM versi qubit? $|\Psi_0\rangle$ $|b\rangle$ $16$
Jika Anda berpikir terlalu besar untuk diterapkan pada komputer kuantum IBM, Anda bahkan dapat menunjukkan contoh persiapan keadaan awal untuk matriks Hermitian (atau hanya memberikan referensi ke contoh). $4\times 4$ $2\times 2$ $\mathbf{A}$

Saya hanya ingin mendapatkan ide umum tentang apakah ini dapat dilakukan (yaitu apakah mungkin) pada komputer kuantum IBM 16-qubit, dan untuk itu diperlukan gerbang mana. Jika bukan komputer kuantum IBM 16-qubit, dapatkah simulator QISKit digunakan untuk menciptakan kembali persiapan keadaan awal dan dalam algoritma HHL? Apakah ada alternatif lain yang lebih baik untuk melakukan ini? $|\Psi_0\rangle$ $|b\rangle$

— Sanchayan Dutta
sumber

Sejauh yang saya tahu IBM tidak dapat melakukan HHL karena melibatkan melakukan hal-hal di superposisi dari waktu yang berbeda, tetapi saya tidak akan terkejut jika saya salah. @ James Woottoon mungkin tahu jawabannya lebih baik.

— user1271772

@ user1271772 Saya pikir juga begitu, tapi saya agak skeptis karena seseorang mengatakan kepada saya dalam obrolan bahwa mereka mensimulasikan HHL selama setelah ini , di IBM.

4 \times 4

$4\times 4$

— Sanchayan Dutta

Yah, mungkin Gambar 4 dari kertas Yudong Cao (yang Anda tautkan) adalah yang Anda butuhkan.

— user1271772

@ user1271772 Ya, tapi sayangnya, itu hanya akan bekerja untuk itu matriks tertentu. Saya mencari teknik umum, yang saya mungkin harus membaca makalah itu lebih teliti.

— Sanchayan Dutta

Seperti yang dikatakan John Watrous dalam salah satu komentarnya pada pertanyaan di mana seseorang meminta rangkaian tertentu, "Anda meminta orang untuk melakukan pekerjaan yang membosankan namun secara konseptual tidak menarik". Yudong adalah seorang mahasiswa teknik sarjana ketika dia membuat sirkuit ini. Dia tidak memiliki pelatihan lebih dari Anda (sebenarnya berdasarkan kemajuan cepat Anda, Anda mungkin tahu lebih banyak tentang komputasi kuantum daripada dia pada saat menulis makalah itu). Jika ia dapat membuat sirkuit ini, Anda harus dapat membuat sirkuit yang sesuai untuk setiap contoh HHL yang ada di depan Anda.

— user1271772

Jawaban:

Tidak mungkin membuat status awal dan pada versi IBM 16 qubits. Di sisi lain, dimungkinkan untuk memperkirakannya dengan kesalahan rendah semaunya ¹ karena gerbang yang diimplementasikan oleh chip IBM menawarkan kemungkinan ini. $\left| \Psi_0\right>$ $\left|b\right>$

Di sini Anda meminta 2 status kuantum yang berbeda:

$\left| b \right>$ tidak dibatasi sama sekali. Status diwakili oleh vektor bilangan kompleks yang dapat berupa apa saja (selama vektor memiliki norma kesatuan). $\left| b \right>$ $N$
$\left| \Psi_0 \right>$ dapat dilihat sebagai kasus khusus dari , di mana koefisien lebih dibatasi. $\left| b \right>$ $b_i$

Dengan analisis ini, metode apa pun yang dapat digunakan untuk membuat juga dapat digunakan untuk membuat . Di sisi lain, sebagai lebih terbatas, kami dapat berharap bahwa ada algoritma yang lebih efisien untuk menghasilkan . $\left|b\right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$

Berguna untuk dan $\left|b\right>$ $\left|\Psi_0\right>$ : Berdasarkan Sintesis Sirkuit Logika Kuantum (Shende, Bullock & Markov, 2006) , QISKit Python SDK mengimplementasikan metode generik untuk menginisialisasi keadaan kuantum acak .

Berguna untuk $\left|\Psi_0\right>$ : Menciptakan superposisi yang sesuai dengan distribusi probabilitas yang dapat diintegrasikan secara efisien (Grover & Rudolph, 2002) menyajikan dengan cepat suatu algoritma untuk menginisialisasi keadaan yang amplitudnya mewakili distribusi probabilitas dengan menghormati beberapa kendala. Batasan-batasan ini dihormati untuk sesuai dengan algoritma Quantum untuk menyelesaikan sistem persamaan linear (Harrow, Hassidim & Lloyd, 2009) , baris terakhir dari halaman 5. $\left|\Psi_0\right>$

Untuk implementasi pada QISKit, berikut adalah contoh untuk menginisialisasi keadaan kuantum yang diberikan:

import qiskit

statevector_backend = qiskit.get_backend('local_statevector_simulator')

###############################################################
# Make a quantum program for state initialization.
###############################################################
qubit_number = 5
Q_SPECS = {
    "name": "StatePreparation",
    "circuits": [
        {
            "name": "initializerCirc",
            "quantum_registers": [{
                "name": "qr",
                "size": qubit_number
            }],
            "classical_registers": [{
                "name": "cr",
                "size": qubit_number
            }]},
    ],
}
Q_program = qiskit.QuantumProgram(specs=Q_SPECS)

## State preparation
import numpy as np
from qiskit.extensions.quantum_initializer import _initializer

def psi_0_coefficients(qubit_number: int):
    T = 2**qubit_number
    tau = np.arange(T)
    return np.sqrt(2 / T) * np.sin(np.pi * (tau + 1/2) / T)

def get_coeffs(qubit_number: int):
    # Can be changed to anything, the initialize function will take
    # care of the initialisation.
    return np.ones((2**qubit_number,)) / np.sqrt(2**qubit_number)
    #return psi_0_coefficients(qubit_number)

circuit_prep = Q_program.get_circuit("initializerCirc")
qr = Q_program.get_quantum_register("qr")
cr = Q_program.get_classical_register('cr')
coeffs = get_coeffs(qubit_number)
_initializer.initialize(circuit_prep, coeffs, [qr[i] for i in range(len(qr))])

res = qiskit.execute(circuit_prep, statevector_backend).result()
statevector = res.get_statevector("initializerCirc")
print(statevector)

¹ Di sini "kesalahan" mengacu pada kesalahan antara keadaan ideal dan perkiraan ketika berhadapan dengan komputer kuantum sempurna (yaitu tidak ada dekoherensi, tidak ada gerbang kesalahan).

— Awal
sumber

Algoritma HHL dengan matriks A 4 x 4 mungkin terlalu besar untuk komputer IBM. Saya mencoba versi mainan yang lebih kecil dari algoritma yang sesuai dengan tautan arXiv 1302.1210 Memecahkan sistem persamaan linear

Saya menjelaskan sedikit tentang sirkuit ini di sini di stackexchange: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-than-a-classical-computer/ 77036 # 77036

Sayangnya itu hanya input 1 qubit dengan matriks A = 2 x 2, dalam jawaban diberikan tautan ke sirkuit IBM.

— Bram
sumber

Masalah dengan implementasi HHL 4x4 bukanlah jumlah qubit (7 qubit diperlukan) tetapi tingkat kesalahan gerbang kuantum dan waktu dekoherensi. Implementasi sistem 4x4 menggunakan QISKit tersedia di sini . Implementasinya mengikuti arxiv.org/abs/1110.2232v2 .

— Nelimee

Implementasi HHL 4 x 4 yang luar biasa.

— Bram