Làm thế nào để một máy tính lượng tử làm toán cơ bản ở cấp độ phần cứng?

Khi đọc chủ đề Reddit này tôi nhận ra rằng ngay cả sau vài tháng tìm hiểu về điện toán lượng tử, tôi hoàn toàn không biết gì về cách một máy tính lượng tử thực sự hoạt động.

Để làm cho câu hỏi chính xác hơn, giả sử chúng ta có một máy tính lượng tử 5 qubit dựa trên siêu qubit (như máy tính lượng tử 5 qubit của IBM). Tôi gõ $2+3$ bằng bàn phím trên màn hình (giả sử trong ứng dụng máy tính cơ bản mà máy tính lượng tử có thể có). Sau đó nó sẽ trả lại cho tôi $5$ . Nhưng đang diễn ra ở cấp độ phần cứng? Có một số loại tín hiệu điện tương ứng với các đầu vào $2$ , và đi đến bộ xử lý của máy tính không? Điều đó bằng cách nào đó "khởi tạo" các cặp electron Cooper? Điều gì xảy ra với các qubit điện tử cặp Cooper sau đó (đoán chúng sẽ được xử lý bởi một số cổng lượng tử , lần lượt lại xuất hiện$3$$+$hộp đen )? Làm thế nào cuối cùng nó trả lại cho tôi đầu ra ?$5$

Tôi ngạc nhiên về việc tôi có thể nghĩ ra được bao nhiêu về hoạt động cơ bản của máy tính lượng tử bằng cách tìm kiếm trên mạng.

Thứ nhất, một máy tính cổ điển thực hiện các phép toán cơ bản ở cấp độ phần cứng trong đơn vị số học và logic (ALU). Các cổng logic có điện áp đầu vào thấp và cao và sử dụng CMOS để thực hiện các cổng logic cho phép các cổng riêng lẻ được thực hiện và xây dựng để thực hiện các hoạt động lớn hơn, phức tạp hơn. Theo nghĩa này, gõ trên bàn phím là gửi tín hiệu điện, cuối cùng kết thúc bằng một lệnh (dưới dạng nhiều tín hiệu điện hơn) được gửi đến ALU, các hoạt động chính xác được thực hiện và nhiều tín hiệu được gửi trở lại, được chuyển đổi thành hiển thị pixel theo hình dạng của một số trên màn hình của bạn.

Một máy tính lượng tử thì sao?

Có hai cách có thể mà bộ xử lý lượng tử được sử dụng: tự chúng hoặc kết hợp với bộ xử lý cổ điển. Tuy nhiên, hầu hết (bao gồm ví dụ về siêu dẫn) của bạn, bộ xử lý lượng tử không thực sự sử dụng tín hiệu điện, mặc dù đây vẫn là cách chuột, bàn phím và màn hình của bạn truyền tải và nhận thông tin. Vì vậy, cần có một cách để chuyển đổi tín hiệu điện thành bất kỳ tín hiệu nào mà bộ xử lý lượng tử sử dụng (mà tôi sẽ sử dụng sau này), cũng như một số cách để nói cho bộ xử lý biết bạn muốn làm gì. Cả hai vấn đề này có thể được giải quyết cùng một lúc bằng quá trình tiền xử lý và hậu xử lý cổ điển, như trong QISKit của IBM . Microsoft đang thực hiện thêm một chút cách tiếp cận từ trên xuống trong Q #, trong đó các chương trình cho bộ xử lý lượng tử được viết giống như chương trình 'cổ điển', trái ngược với kịch bản, sau đó được biên dịch và có khả năng tối ưu hóa cho phần cứng. Đó là, nếu bạn đã có một chức năng, nó có thể thực hiện các hoạt động cổ điển, cũng như thực hiện các cuộc gọi đến bộ xử lý lượng tử để thực hiện bất kỳ hoạt động lượng tử cần thiết nào. Điều này dẫn tôi đến điểm đầu tiên:

Nếu bạn định yêu cầu một máy tính có quyền truy cập vào bộ xử lý lượng tử để tính toán một cái gì đó như , một giải pháp rất hợp lệ là chỉ cần tính toán nó trên bộ xử lý cổ điển như bình thường.$2+3$

OK, giả sử rằng bạn đang buộc bộ xử lý cổ điển sử dụng bộ xử lý lượng tử, trong trường hợp này là một trong những chip siêu dẫn của IBM, sử dụng các qubit transmon , giả sử, QX4 của IBM . Điều này là quá nhỏ để sửa lỗi, vì vậy hãy bỏ qua điều đó. Có ba phần để sử dụng bộ xử lý mô hình mạch: khởi tạo, tiến hóa đơn vị và đo lường, được giải thích chi tiết hơn dưới đây. Trước đó,

Transmon là gì?

Đi một vòng siêu dẫn để cho phép cặp Cooper và thêm một hoặc hai lớp tiếp xúc Josephson để cung cấp cho một Cooper hộp cặp hòn đảo ở khu vực giữa hai nút giao với Josephson ghép năng lượng Josephson , nơi mà các từ thông lượng tử Φ 0 = h / 2 e và I c là dòng tới hạn của đường giao nhau. Áp dụng điện áp V g vào hộp này sẽ tạo ra 'điện dung cổng' C g và biến đây thành một qubit điện tích$E_J = I_c\Phi_0/2\pi$ $\Phi_0 = h/2e$$I_c$$V_g$$C_g$$E_C = \left(2e\right)^2/2C$$C$

$$H = E_C\left(n - n_g\right)^2 - E_J\cos\phi,$$ $n$$\phi$$n_g = C_gV_g/2e$$\left|n\right\rangle = \left|0\right\rangle$$\left|n\right\rangle = \left|1\right\rangle$$E_0 =\hbar\omega_0$$E_1 = \hbar\omega_1$$\omega = \omega_1-\omega_0$$E_C = 5E_J$$E_J\gg E_C$ and we have a transmon. This has the advantage of longer coherence times, at a cost of reduced anharmonicity (where energy levels beyond the first two are closer together, potentially causing leakage).

Finally, we get to the main question:

How do we initialise, evolve and measure a transmon?

• Single qubit unitary evolution: Applying a microwave pulse $\mathcal E\left(t\right) = \mathcal E_x\left(t\right)\cos\left(\omega_dt\right) + \mathcal E_y\left(t\right)\sin\left(\omega_dt\right)$ for $0<t<t_g$ of frequency $\omega_d$ and making the rotating wave approximation gives the Hamiltonian of the qubit states (in the ideal case) as $$H =\hbar \begin{pmatrix}\omega_1-\omega_d && \frac 12\mathcal E_x\left(t\right) - \frac i2\mathcal E_y\left(t\right)\\ \frac 12\mathcal E_x\left(t\right) + \frac i2\mathcal E_y\left(t\right) && \omega_2-2\omega_d\end{pmatrix}$$ However, due to lower anharmonicity, the microwave pulses have to be shaped to reduce leakage to higher energy levels in a process known as Derivative Removal by Adiabatic Gate (DRAG). By varying the pulse, different Hamiltonians can be achieved, which, depending on the time of the pulse can be used to implement different unitary operations on a single qubit.
• Measurement/readout: A microwave resonator, with resonance frequency $\omega_r$, can be coupled to the transmon using a capacitor. This interaction causes (decaying) Rabi oscillations to occur in the transmon-resonator system. When the coupling strength of cavity and qubit, $g \ll \omega-\omega_r$, this is known as the dispersive regime. In this regime, the transmittance spectrum of the cavity is shifted by $\pm g^2/\left(\omega-\omega_r\right)$ depending on the state of the qubit, so applying a microwave pulse and analysing the transmittance and reflectance (by computer) can then be used to measure the qubit.
• Multiple qubit unitary evolution: This idea of coupling a qubit to a microwave resonator can be extended by coupling the resonator to another qubit. As in the single qubit gate case, timings of the coupling as well as microwave pulses can be used allow the first qubit to couple to the cavity, which is then coupled to the second qubit and perform certain 2-qubit gates. Higher energy levels can also be used to make certain gates easier to implement due to interactions between higher levels caused by the cavity. One such example is shown here, where the cavity causes an interaction between the states of $\left|2\right>\left|0\right>$ and $\left|1\right>\left|1\right>$. An avoided crossing between these states means that a 2-qubit phase gate can be implemented, although in general 2-qubit gates are implemented less well (have a lower fidelity) than single qubit ones.
• Initialisation: Readout, potentially followed by a single qubit Pauli $X$ gate (on each qubit measured to be in state $\left|1\right\rangle$) to ensure that all qubits start in state $\left|0\right\rangle$.

Adding 2 and 3 is now a 'simple' matter of initialising the qubits, performing the gates equivalent to a classical reversible adder and measuring the result, all implemented automatically. The measurement result is then returned by a classical computer as per usual.

As a bonus, it seems a little pointless to go through all that in order to implement gates that could be done on a classical computer anyway, so it turns out that it's possible to approximately implement a quantum adder, which adds two quantum (as opposed to classical) states, with some error, on one of IBM's processors.

Here is my process for doing arithmetic on a quantum computer.

Step 1: Find a classical circuit that does the thing you're interested in.

In this example, a full adder.

Step 2: Convert each classical gate into a reversible gate.

Have your output bits present from the start, and initialize them with CNOTs, CCNOTs, etc.

Step 3: Use temporary outputs.

If you were doing this addition to e.g. control whether a Grover oracle phases by -1 or not, now is the time to apply a Z gate to your output qubit.

Step 4: Get rid of intermediate values by doing exactly the opposite of what you did to compute them.

This may or may not include getting rid of the output bits, depending on how the circuit fits into your overall algorithm.

Step 5: (Sometimes) for each output bit you keep, get rid of an input bit.

And I don't mean "drop them on the floor", I mean apply operations that cause them to become 0 for sure.

When you compute c+=a, leaving behind a copy of the original value of c tends to be bad. It destroys coherence. So you must look at your adder circuit (or whatever), and think hard about if there's a way to use your output bits to get rid of your input bits. For example, after computing c+a you could do a temporary out-of-place subtraction into a register r, xor r into the register storing the unwanted copy of c, then revert the temporary subtraction.

(A notable exception to "if you keep your output, don't keep so much of your input" is Shor's algorithm. Shor's algorithm decoheres its input on purpose, but in a very particular way that helps with period finding.)

Step 6: Be efficient

In step 5 I said you could uncompute the input of an inplace addition by doing an out of place addition followed by a temporary out-of-place subtraction. This is a bit silly. The overall adding process is going to span 4n qubits (n to hold a, n to hold c, n to hold c+a, n to hold (c+a)-a). If you are more clever, you can fit everything into 2n qubits or (slightly easier) into 2n+1 qubits: