Thuật toán lượng tử cho các hệ phương trình tuyến tính (HHL09): Bước 2 - Chuẩn bị các trạng thái ban đầu

^{Đây là sự tiếp nối của thuật toán lượng tử cho các hệ phương trình tuyến tính (HHL09): Bước 2 - gì? $|\Psi_0\rangle$}

Trong bài báo: Thuật toán lượng tử cho các hệ phương trình tuyến tính (Harrow, Hassidim & Lloyd, 2009) , các chi tiết về việc thực hiện thực tế của thuật toán không được đưa ra. Làm thế nào một cách chính xác các bang và được tạo ra, là loại một " hộp đen " (xem trang 2-3). $|\Psi_0\rangle$ $|b\rangle$

| Ψ_{0} ⟩ = = \sqrt{\frac{2}{T}} Σ_{τ = = 0}^{T - 1} tội \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$

và

| b ⟩ = = Σ_{1}^{N} b_{Tôi} | Tôi ⟩

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

trong đó là trạng thái ban đầu của thanh ghi đồng hồ và là trạng thái ban đầu của thanh ghi đầu vào. $|\Psi_0\rangle$ $|b\rangle$

(Nói) Tôi muốn thực hiện thuật toán của họ trên máy tính lượng tử bit của IBM . $16$ Và tôi muốn giải một phương trình nhất định trong đó là ma trận Hermiti với các mục thực và là một vectơ cột với các mục thực. $\mathbf{Ax=b}$ $\mathbf{A}$ $4\times 4$ $\mathbf{b}$ $4\times 1$

Hãy lấy một ví dụ:

Một = = [\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}$

và

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

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

Với các kích thước của và , chúng ta cần qubit cho thanh ghi đầu vào và qubit khác cho thanh ghi đồng hồ giả sử chúng ta muốn các giá trị riêng được biểu thị với độ chính xác và độ chính xác lên đến bit cho giá trị riêng (điều này đã được thảo luận ở đây trước đây). Vì vậy, tổng số qubit sẽ cần thiết cho mục đích này (thêm qubit là ancilla). $\mathbf{A}$ $\mathbf{b}$ $\lceil{\log_2 4\rceil}=2$ $6$ $90\%$ $3$ $2+6+1=9$ $1$

Câu hỏi:

Sử dụng thông tin này, có thể tạo các trạng thái ban đầu và trên phiên bản qubit của IBM không? $|\Psi_0\rangle$ $|b\rangle$ $16$
Nếu bạn nghĩ rằng quá lớn để thực hiện trên các máy tính lượng tử của IBM, bạn thậm chí có thể đưa ra một ví dụ về sự chuẩn bị trạng thái ban đầu cho ma trận Hermiti (hoặc chỉ đưa ra một tham chiếu đến một thí dụ). $4\times 4$ $2\times 2$ $\mathbf{A}$

Tôi chỉ đơn giản muốn có được một ý tưởng chung về việc liệu điều này có thể được thực hiện hay không (nghĩa là có thể thực hiện được) trên máy tính lượng tử 16 qubit của IBM hay không và điều đó sẽ cần đến cổng nào. Nếu không phải là máy tính lượng tử 16 qubit của IBM, trình giả lập QISKit có thể được sử dụng để tạo lại chuẩn bị trạng thái ban đầu của và trong thuật toán HHL không? Có cách nào khác tốt hơn để đi về điều này? $|\Psi_0\rangle$ $|b\rangle$

— Daya
nguồn

Theo như tôi biết thì IBM không thể làm HHL bởi vì nó liên quan đến việc thực hiện mọi thứ ở một thời điểm khác nhau, nhưng tôi sẽ không ngạc nhiên nếu tôi sai. @James Woottoon có thể biết câu trả lời tốt hơn.

— 1271772

@ user1271772 Tôi cũng nghĩ vậy, nhưng tôi hơi hoài nghi vì ai đó đã nói với tôi trong cuộc trò chuyện rằng họ đã mô phỏng HHL cho

sau điều này , trên IBM.

4 \times 4

$4\times 4$

— Sanchaya Dutta

Chà, có lẽ Hình 4 của bài báo của Yudong Cao (người bạn đã liên kết) là tất cả những gì bạn cần sau đó.

— 1271772

@ user1271772 Có, nhưng không may, điều đó sẽ chỉ làm việc cho rằng ma trận đặc biệt. Tôi đang tìm kiếm một kỹ thuật chung, mà tôi có lẽ nên đọc bài báo đó kỹ hơn.

— Sanchaya Dutta

Như John Watrous đã đưa nó vào một trong những bình luận của mình cho một câu hỏi mà ai đó đang yêu cầu một mạch cụ thể, "bạn đang yêu cầu mọi người thực hiện công việc tẻ nhạt nhưng không thú vị về mặt khái niệm". Yudong là một sinh viên kỹ thuật đại học khi anh thực hiện các mạch này. Anh ta không được đào tạo nhiều hơn bạn (thực tế dựa trên sự tiến bộ nhanh chóng của bạn, bạn có thể biết nhiều về điện toán lượng tử hơn anh ta đã làm tại thời điểm viết bài báo đó). Nếu anh ta có thể tạo ra mạch này, bạn sẽ có thể tạo mạch tương ứng cho bất kỳ ví dụ HHL nào xuất hiện trước mặt bạn.

— 1271772

Câu trả lời:

Không thể tạo các trạng thái ban đầu và trên phiên bản 16 qubit IBM. Mặt khác, có thể ước tính chúng với sai số thấp ¹ tùy ý vì các cổng được thực hiện bởi các chip IBM cung cấp khả năng này. $\left| \Psi_0\right>$ $\left|b\right>$

Ở đây bạn yêu cầu 2 trạng thái lượng tử khác nhau:

không bị hạn chế ở tất cả. Nhà nước được biểu diễn bởi một vector của số phức có thể được bất cứ điều gì (miễn là các vector có tiêu chuẩn đơn nhất). $\left| b \right>$ $\left| b \right>$ $N$
có thể được coi là một trường hợp đặc biệt của , nơi các hệ số thường bị hạn chế hơn. $\left| \Psi_0 \right>$ $\left| b \right>$ $b_i$

Với phân tích này, bất kỳ phương pháp nào có thể được sử dụng để tạo cũng có thể được sử dụng để tạo . Mặt khác, như là hạn chế hơn, chúng ta có thể hy vọng rằng có tồn tại các thuật toán hiệu quả hơn để sản . $\left|b\right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$

$\left|b\right>$ $\left|\Psi_0\right>$

$\left|\Psi_0\right>$ $\left|\Psi_0\right>$

Để triển khai trên QISKit, đây là một mẫu để khởi tạo trạng thái lượng tử nhất định:

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)

¹ Ở đây "lỗi" đề cập đến lỗi giữa trạng thái lý tưởng và xấp xỉ khi xử lý một máy tính lượng tử hoàn hảo (nghĩa là không có lỗi, không có lỗi cổng).

— Nensonee
nguồn

Thuật toán HHL với ma trận 4 x 4 A có thể lớn đối với máy tính IBM. Tôi đã thử một phiên bản đồ chơi nhỏ hơn của thuật toán theo liên kết arXiv 1302.1210 Giải các hệ phương trình tuyến tính

Tôi đã giải thích một chút về mạch này ở đây tại stackexchange: /cs/76525/could-a-quantum-computer-perform-linear-acheebra-faster-than-a- classical-computer / 77036 # 77036

Thật không may, nó chỉ là một đầu vào 1 qubit với ma trận A = 2 x 2, trong câu trả lời, một liên kết đến mạch IBM được đưa ra.

— Bram
nguồn

Vấn đề với việc triển khai HHL 4 x 4 không phải là số lượng qubit (cần 7 qubit) mà là tỷ lệ lỗi cổng lượng tử và thời gian trang trí. Việc triển khai hệ thống 4x4 sử dụng QISKit có sẵn tại đây . Việc thực hiện sau arxiv.org/abs/1110.2232v2 .

— Nensonee

Thực hiện tuyệt vời một HHL 4 x 4.

— Bram