Какие физически разрешены CNOT для чипа Rigetti 19 кубитов и 72 кубита Google BristleCone?

Для каждого квантового чипа IBM можно написать словарь, отображающий каждый управляющий кубит j в список его физически разрешенных целей, предполагая, что j - это элемент управления CNOT. Например,

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

для их чипа ibmqx4.

Что бы это диктовало для 72-битного чипа Bristlecone от Google. Вы можете написать диктат как понимание. Тот же вопрос для 19-битного чипа Ригетти.

Родной операцией Bristlecone является CZ, а не CNOT. Тем не менее, вы можете трансформироваться между ними с помощью ворот Адамара, так что это своего рода тривиальное различие.

Bristlecone может выполнять CZ между любой соседней парой кубитов в сетке. Вы можете увидеть сетку, установив cirq и распечатав устройство 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)

Вот как вы можете получить набор, содержащий разрешенные операции CZ:

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

В наборе есть 121 элемент, и это довольно случайно, получаете ли вы CZ (x, y) или CZ (y, x) в наборе, поэтому я не буду включать распечатку набора здесь.

Дополнительное ограничение, которое следует иметь в виду, заключается в том, что вы не можете выполнять два CZ рядом друг с другом одновременно. Cirq учитывает это при создании цепей, нацеленных на Bristlecone. Например:

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): ───────────@───

Первые две операции были смещены, потому что они являются смежными CZ, но вторые две не были, потому что они не.

Из оригинального сообщения в блоге, представляющего квантовый чип Bristlecone, приведена карта подключения чипа:

Каждый крест представляет кубит с возможностью соединения ближайшего соседа. Если вы пронумеруете кубиты слева направо, сверху вниз (точно так же, как вы читаете по-английски), начиная с тогда карта связности будет иметь вид:$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)
}

Предупреждение : приведенное выше выражение полностью не проверено. Кажется, это работает для первых кубитов, мне кажется логичным, но вы должны проверить, что карта на 100% верна.

Предупреждение 2 : в блоге Google не говорится об ориентации связей между кубитами. Карта соединений, приведенная выше, предполагает, что соединения являются двусторонними.

Текущая версия PyQuil предоставляет объект «ISA», в котором хранится нужная вам информация о процессорах Quantun Rigetti, но она не отформатирована по вашему запросу. Я плохой программист на Python, поэтому вам придется извинить меня за непифонизм - но вот фрагмент device_nameкода , который возьмет и переформатирует ISA pyQuil в один из ваших словарей:

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)

Как и в случае Google, нативный двухкубитовой ворота , как правило , доступны на Rigetti квантового процессора является CZ, что (1) является двунаправленным (†) в том смысле , что CZ q0 q1такое же , как CZ q1 q0и (2) легко преобразуются в любой из ваших предпочтительных CNOTс помощью сэндвича с воротами Адамара.

† - Физическая реализация CZворот в сверхпроводящей архитектуре будет передана, поэтому вы часто видите архитектурные описания включают , CZ q0 q1но не CZ q1 q0. Это сокращение, для которого участвует кубит, в котором половина физического взаимодействия, даже если результат (игнорируя шумовые эффекты), одинаков с любым порядком.