Các CNOT được phép vật lý cho chip 19 qubit của Rigetti và chip BristleCone 72 qubit của Google là gì?

Đối với mỗi chip lượng tử của IBM, người ta có thể viết một từ điển ánh xạ từng qubit điều khiển j vào danh sách các mục tiêu được phép vật lý của nó, giả sử j là điều khiển của CNOT. Ví dụ,

ibmqx4_c_to_tars = {
    0: [],
    1: [0],
    2: [0, 1, 4],
    3: [2, 4],
    4: []}  # 6 edges

cho chip ibmqx4 của họ.

Điều gì sẽ xảy ra với chip Bristlecone 72 qubit của Google. Bạn có thể viết dict như một sự hiểu biết. Câu hỏi tương tự cho chip 19 qubit của Rigetti.

Hoạt động tự nhiên của Bristlecone là CZ, không phải CNOT. Tuy nhiên, bạn có thể biến đổi giữa hai với cổng Hadamard vì vậy đây là một sự khác biệt nhỏ.

Bristlecone có thể thực hiện một CZ giữa bất kỳ cặp qubit liền kề nào trên lưới. Bạn có thể xem lưới bằng cách cài đặt cirq và in ra thiết bị Bristlecone:

$ pip install cirq
$ python
>>> import cirq
>>> print(cirq.google.Bristlecone)
                                             (0, 5)────(0, 6)
                                             │         │
                                             │         │
                                    (1, 4)───(1, 5)────(1, 6)────(1, 7)
                                    │        │         │         │
                                    │        │         │         │
                           (2, 3)───(2, 4)───(2, 5)────(2, 6)────(2, 7)───(2, 8)
                           │        │        │         │         │        │
                           │        │        │         │         │        │
                  (3, 2)───(3, 3)───(3, 4)───(3, 5)────(3, 6)────(3, 7)───(3, 8)───(3, 9)
                  │        │        │        │         │         │        │        │
                  │        │        │        │         │         │        │        │
         (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)────(4, 6)────(4, 7)───(4, 8)───(4, 9)───(4, 10)
         │        │        │        │        │         │         │        │        │        │
         │        │        │        │        │         │         │        │        │        │
(5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)────(5, 6)────(5, 7)───(5, 8)───(5, 9)───(5, 10)───(5, 11)
         │        │        │        │        │         │         │        │        │        │
         │        │        │        │        │         │         │        │        │        │
         (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)────(6, 6)────(6, 7)───(6, 8)───(6, 9)───(6, 10)
                  │        │        │        │         │         │        │        │
                  │        │        │        │         │         │        │        │
                  (7, 2)───(7, 3)───(7, 4)───(7, 5)────(7, 6)────(7, 7)───(7, 8)───(7, 9)
                           │        │        │         │         │        │
                           │        │        │         │         │        │
                           (8, 3)───(8, 4)───(8, 5)────(8, 6)────(8, 7)───(8, 8)
                                    │        │         │         │
                                    │        │         │         │
                                    (9, 4)───(9, 5)────(9, 6)────(9, 7)
                                             │         │
                                             │         │
                                             (10, 5)───(10, 6)

Dưới đây là cách bạn có thể nhận được một tập hợp có chứa các hoạt động CZ được phép:

qubits = cirq.google.Bristlecone.qubits
allowed = {cirq.CZ(a, b)
           for a in qubits
           for b in qubits
           if a.is_adjacent(b)}

Bộ này có 121 phần tử trong đó và hơi ngẫu nhiên cho dù bạn có được CZ (x, y) hay CZ (y, x) trong tập hợp, vì vậy tôi sẽ không bao gồm bản in của bộ ở đây.

Một hạn chế bổ sung cần lưu ý là bạn không thể thực hiện hai CZ bên cạnh nhau cùng một lúc. Cirq tính đến điều này khi tạo các mạch nhắm vào Bristlecone. Ví dụ:

import cirq
device = cirq.google.Bristlecone
a, b, c, d, e = device.col(6)[:5]
circuit = cirq.Circuit.from_ops(
    cirq.CZ(a, b),
    cirq.CZ(c, d),
    cirq.CZ(a, b),
    cirq.CZ(d, e),
    device=device)
print(circuit)
# (0, 6): ───@───────@───
#            │       │
# (1, 6): ───@───────@───
# 
# (2, 6): ───────@───────
#                │
# (3, 6): ───────@───@───
#                    │
# (4, 6): ───────────@───

Hai hoạt động đầu tiên được đặt so le vì chúng là các CZ liền kề, nhưng hai hoạt động thứ hai không phải vì chúng không hoạt động.

Từ bài đăng trên blog ban đầu giới thiệu chip lượng tử Bristlecone, đây là bản đồ kết nối của chip:

$0$

connectivity_map = {
    i : [i + offset
         for offset in (-6, -5, 5, 6) # values deduced by taking a qubit in the middle of
                                      # chip and computing the offsets between the choosen
                                      # qubit and it's 4 neighbours
         if ((0 <= i+offset < 72)             # the neighbour should be a valid qubit
             and ((i+offset) // 6 != i // 6)) # the neighbour should not be on the same line
    ]
    for i in range(72)
}

Cảnh báo : biểu thức trên hoàn toàn chưa được xác minh. Nó dường như hoạt động cho các qubit đầu tiên, nó có vẻ hợp lý với tôi, nhưng tùy thuộc vào bạn để kiểm tra xem bản đồ có chính xác 100% không.

Cảnh báo 2 : Bài đăng trên blog của Google không nói về định hướng của các kết nối giữa các qubit. Bản đồ kết nối được đưa ra ở trên giả định rằng các kết nối là song phương.

Phiên bản hiện tại của PyQuil cung cấp một đối tượng "ISA" chứa thông tin mà bạn muốn về bộ xử lý lượng tử của Rigetti, nhưng nó không được định dạng như bạn yêu cầu. Tôi là một lập trình viên Python kém, vì vậy bạn sẽ phải bào chữa cho tôi không phải là Pythonic-ness nhưng đây là một đoạn sẽ lấy device_namevà định dạng lại pyQuil ISA thành một trong những từ điển của bạn:

import pyquil.api as p

device_name = '19Q-Acorn'

isa = p.get_devices(as_dict=True)[device_name].isa
d = {}
for qubit in isa.qubits:
    l = []
    for edge in isa.edges:
        if qubit.id is edge.targets[0]:
            l += [edge.targets[1]]
        if qubit.id is edge.targets[1]:
            l += [edge.targets[0]]
    if not qubit.dead:
        d[qubit.id] = l

print(d)

Như trong trường hợp của Google, cổng hai qubit riêng thường có sẵn trên bộ xử lý lượng tử Rigetti là một CZ, trong đó (1) là hai chiều () theo nghĩa CZ q0 q1tương tự CZ q1 q0và (2) có thể dễ dàng chuyển đổi thành một trong hai mục ưa thích của bạn CNOTs bằng cách kẹp mục tiêu bằng cổng Hadamard.

- Việc thực hiện vật lý của một CZcổng trong kiến ​​trúc siêu dẫn được đưa ra, đó là lý do tại sao bạn thường thấy các mô tả kiến ​​trúc bao gồm CZ q0 q1nhưng không CZ q1 q0. Đó là một tốc ký mà qubit đang tham gia trong đó một nửa tương tác vật lý, ngay cả khi kết quả (bỏ qua các hiệu ứng nhiễu) là giống nhau khi đặt hàng.