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).

dan

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:

dan

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).b ⌈ log 2 4 ⌉ = 2 6 90 % 3 2 + 6 + 1 = $\mathbf{A}$$\mathbf{b}$$\lceil{\log_2 4\rceil}=2$$6$$90\%$$3$$2+6+1=9$$1$

Pertanyaan:

1. Dengan menggunakan informasi ini, apakah mungkin untuk membuat status awal dan pada IBM versi qubit?| $|\Psi_0\rangle$$|b\rangle$$16$

2. 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).2 × 2 $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?| b $|\Psi_0\rangle$$|b\rangle$

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.| b $\left| \Psi_0\right>$$\left|b\right>$

Di sini Anda meminta 2 status kuantum yang berbeda:

1. $\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$
2. $\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).

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.