Một ma trận cổng không được kiểm soát trông như thế này:

$$\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ \end{bmatrix}$$

Điều đó hoạt động rất tốt khi bạn chỉ có hai qubit và bạn muốn sử dụng qubit đầu tiên làm điều khiển và qubit thứ hai làm đầu vào được lật (hoặc không).

Có phương pháp nào để chuyển đổi ma trận này để sử dụng chẳng hạn nếu bạn có 3 qubit và muốn sử dụng qubit 1 làm điều khiển và qubit 3 làm đầu vào có thể được lật?

Nghĩ về nó một cách logic, tôi có thể nghĩ ra điều này:

$$\begin{bmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ \end{bmatrix}$$

Có cách nào tốt hơn, chính thức / tổng quát hơn để chuyển đổi nhiều cổng qubit để sử dụng bất kỳ qubit nào được chỉ định, thay vì đầu tiên trong mạch qubit không?$N$$N$

Mở rộng-n-Hoán đổi

Nếu bạn muốn áp dụng một cổng cho một tập hợp con của các qubit:

• Mở rộng hoạt động lên tới x với sản phẩm tenor / sản phẩm Kronecker .2 $2^n$$2^n$
• Sử dụng cổng trao đổi để thực hiện các qubit mục tiêu liên tiếp.
• Trao đổi với một đơn đặt hàng đơn giản, áp dụng, trao đổi trở lại.

Có thể tẻ nhạt để thực hiện tất cả các phép nhân ma trận lớn đó, nhưng ma trận hoán đổi rất thưa thớt và ý tưởng rất đơn giản.

Kiểm soát dễ dàng hơn

Trong trường hợp thêm các điều khiển vào một thao tác (áp dụng cho ví dụ cụ thể mà bạn đã đưa ra), có một mẹo dễ dàng hơn. Chỉ cần mở rộng hoạt động như bình thường, nhưng sau đó thay thế bất kỳ phần nào của ma trận tương ứng với các đầu vào không điều khiển bằng ma trận danh tính sẽ là gì.

Đây là một chút dễ dàng hơn để theo dõi nếu bạn giới thiệu một giả "giá trị kiểm soát" mà ghi đè hành vi thông thường sản phẩm tensor của$c$ , do đó thay vì , bạn có (nói cách khác: khi một mục nhập là bạn không gạch trên mục nhập và chia tỷ lệ theo mục nhập; bạn sử dụng thay vì ).[ c ] ⊗ U = c ⋅ tôi c U U tôi $\begin{bmatrix} c \end{bmatrix} \otimes U = c \cdot U$$\begin{bmatrix} c \end{bmatrix} \otimes U = c \cdot I$$c$$U$$U$$I$$U$

Xác định "hoạt động" của điều khiển qubit-must-be-ON là . Một không-op là , và không phải là . Sau đó, hoạt động từ câu hỏi của bạn có thể được tính như thế này (giả sử thứ tự lớn về cuối): I $C = \begin{bmatrix} c&0 \\ 0&1 \end{bmatrix}$$I$$X$

$CNOT_{3 \rightarrow 1} = C \otimes I \otimes X$

$= \begin{bmatrix} c&0 \\ 0&1 \end{bmatrix} \otimes \begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} c\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix}&0\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \\ 0\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix}&1\otimes\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} \begin{bmatrix} c&0 \\ 0&c \end{bmatrix} & \begin{bmatrix} 0&0 \\ 0&0 \end{bmatrix} \\ \begin{bmatrix} 0&0 \\ 0&0 \end{bmatrix}&\begin{bmatrix} 1&0 \\ 0&1 \end{bmatrix} \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

$= \begin{bmatrix} c&0&0&0 \\ 0&c&0&0 \\ 0&0&1&0 \\ 0&0&0&1 \end{bmatrix} \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}$

(lưu ý: sẽ sử dụng một số 0 duy nhất để mơ hồ có nghĩa là ma trận 2x2 zero khi thuận tiện)

$= \begin{bmatrix} c\otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} &0&0&0 \\ 0&c \otimes \begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0&0 \\ 0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0 \\ 0&0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} \end{bmatrix}$

$= \begin{bmatrix} \begin{bmatrix} c&0 \\ 0&c \end{bmatrix} &0&0&0 \\ 0&\begin{bmatrix} c&0 \\ 0&c \end{bmatrix}&0&0 \\ 0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix}&0 \\ 0&0&0&\begin{bmatrix} 0&1 \\ 1&0 \end{bmatrix} \end{bmatrix}$

$= \begin{bmatrix} c&0&0&0&0&0&0&0 \\ 0&c&0&0&0&0&0&0 \\ 0&0&c&0&0&0&0&0 \\ 0&0&0&c&0&0&0&0 \\ 0&0&0&0&0&1&0&0 \\ 0&0&0&0&1&0&0&0 \\ 0&0&0&0&0&0&0&1 \\ 0&0&0&0&0&0&1&0 \end{bmatrix}$

(bây giờ chúng tôi đã hoàn thành với các sản phẩm tenor và không cần nữa)$c$

$\rightarrow \begin{bmatrix} 1&0&0&0&0&0&0&0 \\ 0&1&0&0&0&0&0&0 \\ 0&0&1&0&0&0&0&0 \\ 0&0&0&1&0&0&0&0 \\ 0&0&0&0&0&1&0&0 \\ 0&0&0&0&1&0&0&0 \\ 0&0&0&0&0&0&0&1 \\ 0&0&0&0&0&0&1&0 \end{bmatrix}$

Có lý?

Đừng sử dụng phương pháp trao đổi, nó rất không hiệu quả. Và câu trả lời của người khác là dành riêng cho cổng CNOT, và thẳng thắn, quá phức tạp hóa mọi thứ.

Đây là một thuật toán rất đơn giản giúp giải quyết vấn đề của bạn cho mọi trường hợp, không chỉ là cổng CNOT, cho bất kỳ bit tùy ý nào.

Thuật toán:

let sys = matrix representing the current state of the system
let n = number of qubits being simulated
let lgm = logic gate matrix of size 2^n by 2^n
let f = our logic gate transformation function
for i = 0 to (2^n) - 1:
    lgm[column = i] = f(i)
sys = sys × lgg

Trong các máy tính cổ điển, có một cái gì đó gọi là "bộ giải mã". Giả sử tôi chỉ có 3 dây, hiệu quả, 3 bit. Nhưng tôi muốn điều khiển 8 dây. Điều đó có thể được thực hiện? Có, vì 3 bit có 8 khả năng khác nhau: 000, 001, 010, 011, 100, 101, 110, 111. Vì vậy, chúng tôi có thể gán từng khả năng cho một trong 8 dây đầu ra của chúng tôi. Điều này được gọi là "giải mã".

Nếu tôi chuyển vào số 101 và chúng tôi có 3 bit, chúng tôi biết 101 = 5, vì vậy tôi sẽ đặt dây đầu ra 5 thành điện áp cao và 7 dây đầu ra khác sẽ là 0, chúng tôi có thể biểu diễn như thế này: giải mã (101) = [0, 0, 0, 0, 0, 1, 0, 0].

Trong thuật toán này, tôi đề cập đến "hàm biến đổi" được gọi là "f". Đối với máy tính cổ điển, chức năng chuyển đổi chỉ cần lấy một giá trị đầu vào và trả về phiên bản "giải mã" của giá trị đầu ra. Vì vậy, nếu chúng ta có 3 bit và đầu ra là 4, thì chúng ta sẽ trả về [0, 0, 0, 0, 1, 0, 0, 0]. Sau đó, chúng tôi chỉ định đó là cột của ma trận của chúng tôi cho giá trị đó.

Chúng ta hãy nghĩ về "giải mã" về các qubit. Làm thế nào chúng ta có thể giải mã các qubit | 101>?

Chúng tôi biết rằng đối với các vectơ xác suất qubit của chúng tôi, | 0> là [1, 0] và | 1> là [0, 1]. Giải mã qubit sau đó có thể được thực hiện cái được gọi là sản phẩm Kronecker.

Vì vậy, nếu chúng ta chuyển đổi từng bit thành vectơ xác suất và lấy sản phẩm Kronecker của tất cả chúng, chúng ta sẽ nhận được ...

|101> = |1> ⊗ |0> ⊗ |1> = [0, 1] ⊗ [1, 0] ⊗ [0, 1] = [0, 0, 0, 0, 0, 1, 0, 0]

Đây là cách chúng tôi muốn giải mã qubit. Thuật toán này có thể được áp dụng cho các qubit giống như vậy bằng cách sử dụng này.

Hãy thử thuật toán này cho một vấn đề đơn giản hơn.

Giả sử chúng ta có một hệ thống chỉ có 2 qubit. Nếu chúng ta muốn áp dụng cổng Hadamard chỉ với 1 qubit, chúng ta có thể tạo cổng logic cho cả hai qubit chỉ áp dụng cổng Hadamard cho một qubit duy nhất. Giả sử một qubit duy nhất mà chúng tôi muốn áp dụng nó là qubit quan trọng nhất của chúng tôi và ít quan trọng nhất sẽ không bị ảnh hưởng.

Chúng tôi muốn một hàm biến đổi cho mỗi đầu vào có thể của chúng tôi, tạo ra đầu ra chính xác. Chúng tôi có hai qubit, điều này có nghĩa là có bốn đầu ra có thể.

f(|00>) = ?
f(|01>) = ?
f(|10>) = ?
f(|11>) = ?

Chúng tôi biết rằng qubit ít quan trọng nhất sẽ không bị ảnh hưởng, vì vậy chúng tôi có thể điền vào đó.

f(|00>) = ? ⊗ |0>
f(|01>) = ? ⊗ |1>
f(|10>) = ? ⊗ |0>
f(|11>) = ? ⊗ |1>

Chúng ta cũng biết Hadamard làm gì với một qubit, như vậy:

H(|0>) = 1/sqrt(2)|0> + 1/sqrt(2)|1>
H(|1>) = 1/sqrt(2)|0> - 1/sqrt(2)|1>

Vì vậy, chức năng chuyển đổi của chúng tôi chỉ đơn giản là:

f(|00>) = (1/sqrt(2)|0> + 1/sqrt(2)|1>) ⊗ |0>
f(|01>) = (1/sqrt(2)|0> + 1/sqrt(2)|1>) ⊗ |1>
f(|10>) = (1/sqrt(2)|0> - 1/sqrt(2)|1>) ⊗ |0>
f(|11>) = (1/sqrt(2)|0> - 1/sqrt(2)|1>) ⊗ |1>

Mở rộng điều này ra dạng vector xác suất chuẩn hóa của chúng tôi ...

f(|00>) = [ 1/sqrt(2), 1/sqrt(2) ] ⊗ [ 1, 0 ]
f(|01>) = [ 1/sqrt(2), 1/sqrt(2) ] ⊗ [ 0, 1 ]
f(|10>) = [ 1/sqrt(2), -1/sqrt(2) ] ⊗ [ 1, 0 ]
f(|11>) = [ 1/sqrt(2), -1/sqrt(2) ] ⊗ [ 0, 1 ]

Bây giờ hãy thực sự giải quyết điều này ...

f(|00>) = [ 1/sqrt(2), 0, 1/sqrt(2), 0 ]
f(|01>) = [ 0, 1/sqrt(2), 0, 1/sqrt(2) ]
f(|10>) = [ 1/sqrt(2), 0, -1/sqrt(2), 0 ]
f(|11>) = [ 0, 1/sqrt(2), 0, -1/sqrt(2) ]

Đó là chức năng biến đổi của chúng tôi.

Ma trận cổng logic của chúng tôi, "lgm", có kích thước 2 ^ n bằng 2 ^ n trong đó n = số lượng qubit được mô phỏng, vì vậy trong trường hợp này là 2 ^ 2 by 2 ^ 2 hoặc 4x4. Thuật toán của chúng tôi cho chúng tôi biết rằng với mỗi cột i, hãy đặt cột bằng f (i). Chúng tôi đã xác định hàm chuyển đổi xác suất của mình, vì vậy chúng tôi có thể dễ dàng điền vào các cột này.

lgm = 
    |00>       |01>        |10>        |11>
[ 1/sqrt(2),         0,  1/sqrt(2),          0 ] 
[         0, 1/sqrt(2),          0,  1/sqrt(2) ]
[ 1/sqrt(2),         0, -1/sqrt(2),          0 ]
[         0, 1/sqrt(2),          0, -1/sqrt(2) ]

Bây giờ bước cuối cùng trong thuật toán của chúng tôi chỉ đơn giản là nhân ma trận nhân ma trận của chúng tôi đại diện cho toàn bộ hệ lượng tử, sys, bằng cổng logic này, lgm.

Và đó là những gì chúng ta muốn. Nó sẽ chỉ áp dụng cổng hadamard cho hầu hết các qubit và để lại các qubit ít quan trọng nhất. Nếu bạn không tin tôi, bạn có thể tự mình thử và thấy rằng nó hoạt động.

Lý do này rất mạnh là vì nó áp dụng cho mọi trường hợp.

Hãy thử thuật toán này về vấn đề của bạn.

Hãy tưởng tượng chúng ta có một hệ thống 3 qubit và chúng ta muốn áp dụng một cổng CNOT cho qubit [0] và qubit [2]. Nếu bạn tra cứu ma trận CNOT trên Wikipedia, ma trận đó chỉ áp dụng cho hệ thống 2 qubit. Một giải pháp ngây thơ sẽ là nối các ma trận danh tính cho nó bằng cách sử dụng sản phẩm Kronecker để làm cho nó hoạt động trên các hệ thống có ba qubit. Nhưng điều này không thành công ở đây: qubit [0] và qubit [2] không liền kề nhau, vì vậy việc gắn thêm ma trận danh tính sẽ không hoạt động.

Chúng ta có thể trao đổi qubit [0] với qubit [1], áp dụng cổng CNOT, sau đó hoán đổi chúng trở lại. Nhưng đó là chậm. Thay vào đó, chúng tôi chỉ đơn giản có thể tạo ra một cổng CNOT không liền kề cho vấn đề của chúng tôi bằng thuật toán ở trên.

Trước tiên chúng ta cần đưa ra một hàm biến đổi cho từng trường hợp.

f(|000>) = |0> ⊗ |0> ⊗ |0>
f(|001>) = |0> ⊗ |0> ⊗ |1>
f(|010>) = |0> ⊗ |1> ⊗ |0>
f(|011>) = |0> ⊗ |1> ⊗ |1>
f(|100>) = |1> ⊗ |0> ⊗ |1>
f(|101>) = |1> ⊗ |0> ⊗ |0>
f(|110>) = |1> ⊗ |1> ⊗ |1>
f(|111>) = |1> ⊗ |1> ⊗ |0>

Nếu bạn hiểu cổng CNOT, bạn có thể hiểu tại sao đây là chức năng của chúng tôi. Hãy nghĩ về điều này giống như một bảng sự thật. Vì qubit kiểm soát của chúng tôi là qubit có ý nghĩa nhất, nên qubit [2], chỉ khi qubit đó là | 1> thì qubit ít nhất, qubit [0] mới bị loại bỏ.

Mở rộng điều này ra dạng vector xác suất chuẩn hóa của chúng tôi ...

f(|000>) = [ 1, 0 ] ⊗ [ 1, 0 ] ⊗ [ 1, 0 ]
f(|001>) = [ 1, 0 ] ⊗ [ 1, 0 ] ⊗ [ 0, 1 ]
f(|010>) = [ 1, 0 ] ⊗ [ 0, 1 ] ⊗ [ 1, 0 ]
f(|011>) = [ 1, 0 ] ⊗ [ 0, 1 ] ⊗ [ 0, 1 ]
f(|100>) = [ 0, 1 ] ⊗ [ 1, 0 ] ⊗ [ 0, 1 ]
f(|101>) = [ 0, 1 ] ⊗ [ 1, 0 ] ⊗ [ 1, 0 ]
f(|110>) = [ 0, 1 ] ⊗ [ 0, 1 ] ⊗ [ 0, 1 ]
f(|111>) = [ 0, 1 ] ⊗ [ 0, 1 ] ⊗ [ 1, 0 ]

Bây giờ hãy thực sự giải quyết điều này ...

f(|000>) = [ 1, 0, 0, 0, 0, 0, 0, 0 ]
f(|001>) = [ 0, 1, 0, 0, 0, 0, 0, 0 ]
f(|010>) = [ 0, 0, 1, 0, 0, 0, 0, 0 ]
f(|011>) = [ 0, 0, 0, 1, 0, 0, 0, 0 ]
f(|100>) = [ 0, 0, 0, 0, 0, 1, 0, 0 ]
f(|101>) = [ 0, 0, 0, 0, 1, 0, 0, 0 ]
f(|110>) = [ 0, 0, 0, 0, 0, 0, 0, 1 ]
f(|111>) = [ 0, 0, 0, 0, 0, 0, 1, 0 ]

Hãy tạo các cột trong ma trận lgm của chúng tôi.

lgm =
[ 1, 0, 0, 0, 0, 0, 0, 0 ]
[ 0, 1, 0, 0, 0, 0, 0, 0 ]
[ 0, 0, 1, 0, 0, 0, 0, 0 ]
[ 0, 0, 0, 1, 0, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 1, 0, 0 ]
[ 0, 0, 0, 0, 1, 0, 0, 0 ]
[ 0, 0, 0, 0, 0, 0, 0, 1 ]
[ 0, 0, 0, 0, 0, 0, 1, 0 ]

Bây giờ nếu ma trận nhân toàn bộ ma trận hệ thống của chúng tôi, sys, bằng ma trận cổng logic, lgm, kết quả của chúng tôi sẽ là hiệu ứng của việc áp dụng cổng CNOT cho qubit [2] và qubit [0] trong đó qubit [2] là điều khiển qubit.