Jakie fizycznie są dozwolone CNOT dla chipu Rigetti 19 qubit i 72 qubit Google firmy BristleCone?

Dla każdego układu kwantowego IBM można napisać słownik odwzorowujący każdy qubit kontrolny j na listę jego fizycznie dozwolonych celów, zakładając, że j jest kontrolą CNOT. Na przykład,

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

dla ich układu ibmqx4.

Co by to było za dyktando 72-kubitowego układu kostkowego Bristlecone firmy Google. Możesz napisać ten dykt jako zrozumienie. To samo pytanie dla 19 kubitowych układów Rigetti.

Natywną operacją Bristlecone jest CZ, a nie CNOT. Możesz jednak zmieniać się między nimi za pomocą bram Hadamarda, więc jest to trywialna różnica.

Szczecina może wykonać CZ pomiędzy dowolną sąsiadującą parą kubitów na siatce. Możesz zobaczyć siatkę, instalując cirq i drukując urządzenie 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)

Oto, w jaki sposób można uzyskać zestaw zawierający dozwolone operacje CZ:

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

Zestaw zawiera 121 elementów i jest dość losowy, czy dostajesz CZ (x, y) lub CZ (y, x) w zestawie, więc nie dołączę tutaj wydruku zestawu.

Dodatkowym ograniczeniem, o którym należy pamiętać, jest to, że nie można wykonać dwóch CZ jednocześnie obok siebie. Cirq bierze to pod uwagę przy tworzeniu obwodów ukierunkowanych na Bristlecone. Na przykład:

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

Pierwsze dwie operacje były rozłożone w czasie, ponieważ sąsiadują one z CZ, ale dwie pozostałe nie były, ponieważ nie są.

Z oryginalnego postu na blogu prezentującego układ kwantowy Bristlecone, oto mapa połączeń układu:

$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)
}

Ostrzeżenie : powyższe wyrażenie jest całkowicie niezweryfikowane. Wydaje się, że działa dla pierwszych kubitów, wydaje mi się to logiczne, ale to od ciebie zależy, czy mapa jest w 100% poprawna.

Ostrzeżenie 2 : post na blogu Google nie mówi o orientacji połączeń między kubitami. Podana powyżej mapa połączeń zakłada, że ​​połączenia są dwustronne.

Obecna wersja PyQuil zawiera obiekt „ISA”, który zawiera potrzebne informacje o procesorach kwantowych Rigetti, ale nie jest formatowany zgodnie z twoją prośbą. Jestem kiepskim programistą w języku Python, więc musisz usprawiedliwić moją nie- device_namePythońską osobowość - ale oto fragment, który weźmie i sformatuje pyQuil ISA w jednym ze swoich słowników:

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)

Podobnie jak w przypadku Google, rodzimy dwóch qubit brama zazwyczaj dostępne na Rigetti procesor kwantowy to CZ, co (1) jest dwukierunkowe (†) w tym sensie, że CZ q0 q1jest taka sama jak CZ q1 q0i (2) jest łatwo przekształcić jeden z preferowany CNOTs, umieszczając cel za pomocą bram Hadamarda.

† - Fizyczna implementacja CZbramy w architekturze nadprzewodzącej jest przekazywana, dlatego często widzisz opisy architektoniczne, CZ q0 q1ale nie CZ q1 q0. Jest to skrót, dla którego qubit bierze udział, w którym połowa interakcji fizycznej, nawet jeśli wynik (ignorowanie efektów szumu) jest taki sam przy każdej kolejności.