Một chương trình lượng tử rất đơn giản sẽ trông như thế nào?

15

Sau khi đọc " chip quang tử lượng tử lập trình đầu tiên ". Tôi đã tự hỏi phần mềm cho một máy tính sử dụng sự vướng víu lượng tử sẽ như thế nào.

Có ví dụ nào về mã cho lập trình lượng tử cụ thể không? Giống như mã giả hoặc ngôn ngữ cấp cao? Cụ thể, chương trình ngắn nhất có thể được sử dụng để tạo trạng thái Chuông bắt đầu từ trạng thái được khởi tạo thành sử dụng cả mô phỏng và một trong các bộ xử lý Kinh nghiệm lượng tử của IBM , chẳng hạn như ibmqx4 ?

| ψ ⟩ = = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 11 ⟩)

$\left|\psi\right> = \frac{1}{\sqrt 2} \left(\left|00\right> + \left|11\right> \right)$

| ψ_{0} ⟩ = | 00 ⟩

$\left|\psi_0\right> = \left|00\right>$

Làm cho bước nhảy khái niệm từ lập trình truyền thống sang vướng víu không phải là dễ dàng.

Tôi đã tìm thấy C libquantum quá.

simulation ibm-q-experience programming

— DIDIx13
nguồn

12

Giả sử bạn đang xem xét một máy tính lượng tử dựa trên cổng, cách dễ nhất để tạo ra trạng thái vướng víu là tạo ra một trong các trạng thái Bell. Các mạch sau đây cho thấy trạng thái Bell . $\left| \Phi^+ \right>$

$\left| \psi_0 \right>$ $\left| \psi_1 \right>$ $\left| \psi_2 \right>$

$\left| \psi_0 \right>$

| ψ_{0} ⟩ = = | 00 ⟩

$\left| \psi_0 \right> = \left | 0 0 \right >$

$\left| \psi_1 \right>$

Cổng Hadamard áp dụng trên qubit đầu tiên dẫn đến kết quả như sau:

| ψ_{1} ⟩ = = (H \otimes Tôi) | 00 ⟩ = = H | 0 ⟩ \otimes | 0 ⟩ = = \frac{1}{\sqrt{2}} (| 0 ⟩ + | 1 ⟩) | 0 ⟩ = = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 10 ⟩)

$\left| \psi_1 \right> =(H \otimes I)\left | 0 0 \right > = H\left | 0 \right > \otimes \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 \right > + \left | 1 \right > \right ) \left | 0 \right > = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 0 \right > \right )$

$\left| \psi_2 \right>$

Bây giờ một cổng CNOT được áp dụng và lật qubit thứ hai nhưng chỉ khi cổng thứ nhất có giá trị 1. Kết quả là

| ψ_{2} ⟩ = = \frac{1}{\sqrt{2}} (| 00 ⟩ + | 11 ⟩)

$\left| \psi_2 \right> = \frac{1}{\sqrt 2} \left (\left | 0 0 \right > + \left | 1 1 \right > \right )$

$\left| \psi_2 \right>$

Mặc dù cách tiếp cận ở trên có vẻ không giống như lập trình với bạn theo nghĩa thông thường, nhưng áp dụng các cổng cho các trạng thái về cơ bản là cách lập trình một máy tính lượng tử dựa trên cổng hoạt động. Có các lớp trừu tượng cho phép bạn thực hiện lập trình cấp cao nhưng dịch các lệnh sang ứng dụng của cổng. Các IBM Quantum Kinh nghiệm giao diện cung cấp các tính năng như vậy.

Trong một ngôn ngữ như Q # của Microsoft, ví dụ trên có thể trông giống như thế này:

operation BellTest () : ()
{
    body
    {
        // Use two qubits
        using (qubits = Qubit[2])
        {
            Set (One, qubits[0]);
            Set (Zero, qubits[1]);

            // Apply Hadamard gate to the first qubit
            H(qubits[0]);

            // Apply CNOT gate
            CNOT(qubits[0],qubits[1]);
         }
     }
}

Có thể tìm thấy phiên bản chi tiết hơn (bao gồm đo lường) tại đây: Microsoft: Viết chương trình lượng tử .

— dtell
nguồn

14

Một cách viết chương trình lượng tử là với QISKit. Điều này có thể được sử dụng để chạy các chương trình trên các thiết bị của IBM. Các trang web QISKit cho thấy đoạn mã sau đây để giúp bạn đi, mà là một mạch vướng như bạn muốn. Nó cũng là quá trình tương tự như trong câu trả lời của datell. Tôi sẽ bình luận về nó từng dòng một.

# import and initialize the method used to store quantum programs
from qiskit import QuantumProgram
qp = QuantumProgram()
# initialize a quantum register of two qubits
qr = qp.create_quantum_register('qr',2) 
# and a classical register of two bits
cr = qp.create_classical_register('cr',2) 
# create a circuit with them which we call 'Bell'
qc = qp.create_circuit('Bell',[qr],[cr]) 
# apply a Hadamard to the first qubit
qc.h(qr[0]) 
# apply a controlled not with the first qubit as control
qc.cx(qr[0], qr[1]) 
# measure the first qubit and store its result on the first bit
qc.measure(qr[0], cr[0]) 
# the same for the second qubit and bit
qc.measure(qr[1], cr[1]) 
# run the circuit
result = qp.execute('Bell') 
# extract the results
print(result.get_counts('Bell'))

Lưu ý rằng lệnh 'thực thi' ở đây chỉ chỉ định chương trình sẽ chạy. Tất cả các cài đặt khác, chẳng hạn như thiết bị bạn muốn sử dụng, số lần bạn muốn lặp lại thiết bị để lấy số liệu thống kê, v.v. được đặt thành giá trị mặc định của chúng. Để chạy trên ibmqx4 cho 1024 ảnh, thay vào đó bạn có thể sử dụng

results = qp.execute(['Bell'], backend='ibmqx4', shots=1024)

— James Wootton
nguồn

4

Chương trình lượng tử đơn giản nhất tôi có thể nghĩ đến là một trình tạo số ngẫu nhiên thực (1 bit). Là một mạch lượng tử, nó trông như thế này:

$|0 \rangle$ $\frac{\sqrt{2}}{2} ( \left| 0 \right> + \left| 1 \right> )$ $|0\rangle$ $|1\rangle$

— kim tự tháp
nguồn