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

12

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.

rrtucci
la source
Peut-être pourriez-vous ajouter un lien vers la description des puces dans la question? Je n'ai pas trouvé les spécifications des puces de Regitti.
Nelimee
Jim Wootton devrait savoir
rrtucci

Réponses:

12

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.

Craig Gidney
la source
Bonne utilisation de l'API! Votre solution est meilleure que la mienne! :)
Nelimee
Nelimee, votre solution est correcte aussi, et chancelle. Circ a choisi de faire pivoter le réseau rectangulaire de 45 degrés, ce qui est quelque peu pervers
rrtucci
1
Oh je vois. Ils l'ont fait à cause des limitations du dessin ascii
rrtucci
Google a un ordinateur quantique?
user1271772
@rrtucci ASCII comprend des lignes diagonales (/, \). Le choix des coordonnées allait plutôt dans le sens de la minimisation de la difficulté de diverses tâches, telles que deviner si qubit (a, b) est présent ou non. Pour ces tâches, la forme du diamant n'est délicate que près de la frontière, tandis que le motif en damier est délicat partout.
Craig Gidney
9

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

Carte de connectivité Bristlecone

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.

Nelimee
la source
3

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.

Eric Peterson
la source