Quels sont les CNOT physiquement autorisés pour la puce Rigetti 19 bits et la puce BristleCone 72 bits de Google?

Pour chaque puce IBM quantique, on peut écrire un dictionnaire mappant chaque qubit de contrôle j sur une liste de ses cibles physiquement autorisées, en supposant que j soit le contrôle d'un CNOT. Par exemple,

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

pour leur puce ibmqx4.

Quel serait ce dicton pour la puce Bristlecone de 72 qubit de Google. Vous pouvez écrire le dict comme une compréhension. Même question pour la puce 19 qubit de Rigetti.

L'opération native de Bristlecone est la CZ, pas les CNOT. Cependant, vous pouvez transformer entre les deux avec des portes Hadamard, donc c'est une sorte de différence triviale.

Bristlecone peut effectuer une CZ entre n'importe quelle paire adjacente de qubits sur une grille. Vous pouvez voir la grille en installant cirq et en imprimant le périphérique 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)

Voici comment obtenir un ensemble contenant les opérations CZ autorisées:

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

L'ensemble contient 121 éléments, et il est quelque peu aléatoire que vous obteniez CZ (x, y) ou CZ (y, x) dans l'ensemble, donc je n'inclurai pas d'imprimé de l'ensemble ici.

Une contrainte supplémentaire à garder à l'esprit est que vous ne pouvez pas effectuer deux CZ côte à côte en même temps. Cirq en tient compte lors de la création de circuits ciblant Bristlecone. Par exemple:

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

Les deux premières opérations ont été échelonnées parce qu'elles sont des ZC adjacentes, mais les deux autres ne l'ont pas été parce qu'elles ne le sont pas.

Du blog original présentant la puce quantique Bristlecone, voici la carte de connectivité de la puce:

Chaque croix représente un qubit, avec une connectivité au plus proche voisin. Si vous numérotez les qubits de gauche à droite, de haut en bas (tout comme la façon dont vous lisez l'anglais), en commençant par la carte de connectivité serait donnée par:$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)
}

Attention : l'expression ci-dessus n'est pas vérifiée. Cela semble fonctionner pour les premiers qubits, cela me semble logique, mais c'est à vous de vérifier que la carte est 100% correcte.

Avertissement 2 : le blog de Google ne parle pas de l'orientation des connexions entre les qubits. La carte de connectivité ci-dessus suppose que les connexions sont bilatérales.

La version actuelle de PyQuil fournit un objet "ISA" qui contient les informations que vous souhaitez sur les processeurs quantun de Rigetti, mais il n'est pas formaté comme vous le demandez. Je suis un pauvre programmeur Python, donc vous devrez excuser mon non-Pythonic-ness, mais voici un extrait qui va prendre device_nameet reformater le pyQuil ISA dans l'un de vos dictionnaires:

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)

Comme dans le cas de Google, la porte native à deux qubits généralement disponible sur un processeur quantique Rigetti est un CZ, qui (1) est bidirectionnel (†) dans le sens qui CZ q0 q1est le même que CZ q1 q0et (2) est facilement converti en l'un de vos préférés CNOTs en prenant la cible en sandwich avec des portes Hadamard.

† - L'implémentation physique d'une CZporte dans une architecture supraconductrice est remise, c'est pourquoi vous voyez souvent les descriptions architecturales inclure CZ q0 q1mais pas CZ q1 q0. C'est un raccourci pour lequel qubit participe à quelle moitié de l'interaction physique, même si le résultat (en ignorant les effets de bruit) est le même avec l'un ou l'autre ordre.