Що фізично дозволено CNOT для 19-кубітного мікросхеми Rigetti та 72-кубітового чіпа BristleCone від Google?

Для кожного квантового мікросхеми 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-ти кубітного мікросхеми Rigetti.

Рідною операцією 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", в якому зберігається потрібна інформація про квантові процесори Rigetti, але вона не відформатована під час запиту. Я поганий програміст Python, тому вам доведеться вибачити мою не-Pythonic-ness - але ось фрагмент, який візьме device_nameі переформатує ISQ 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) легко перетворюються в будь-який з ваших бажаних CNOTs, сендвічуючи ціль воротами Адамара.

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