Quali sono i CNOT fisicamente consentiti per il chip Rigetti da 19 qubit e il chip BristleCone di Google da 72 qubit?

Per ogni chip quantistico IBM, si può scrivere un dizionario che associa ciascun qubit di controllo j a un elenco dei suoi target fisicamente ammessi, supponendo che j sia il controllo di un CNOT. Per esempio,

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

per il loro chip ibmqx4.

Quale sarebbe il detto per il chip Bristlecone di Google a 72 qubit. Puoi scrivere il dict come una comprensione. Stessa domanda per il chip Rigetti a 19 qubit.

L'operazione nativa di Bristlecone è la CZ, non i CNOT. Tuttavia, puoi trasformarti tra i due con le porte Hadamard, quindi questa è una sorta di banale differenza.

Bristlecone può eseguire una CZ tra qualsiasi coppia adiacente di qubit su una griglia. Puoi vedere la griglia installando cirq e stampando il dispositivo 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)

Ecco come è possibile ottenere un set contenente le operazioni CZ consentite:

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

Il set contiene 121 elementi ed è in qualche modo casuale se si ottengono CZ (x, y) o CZ (y, x) nel set, quindi non includerò una stampa del set qui.

Un ulteriore vincolo da tenere a mente è che non è possibile eseguire contemporaneamente due CZ uno accanto all'altro. Cirq tiene conto di ciò nella creazione di circuiti destinati a Bristlecone. Per esempio:

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

Le prime due operazioni sono state scaglionate perché sono CZ adiacenti, ma le seconde non lo erano perché non lo sono.

Dal post originale del blog che presenta il chip quantistico Bristlecone, ecco la mappa di connettività del chip:

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

Attenzione : l'espressione sopra è completamente non verificata. Sembra funzionare per i primi qubit, mi sembra logico, ma spetta a te verificare che la mappa sia corretta al 100%.

Avviso 2 : il post sul blog di Google non parla dell'orientamento delle connessioni tra qubit. La mappa di connettività fornita sopra presuppone che le connessioni siano bilaterali.

La versione corrente di PyQuil fornisce un oggetto "ISA" che contiene le informazioni desiderate sui processori quantici di Rigetti, ma non è formattato come richiesto. Sono un povero programmatore Python, quindi dovrai scusare la mia non-Pythonic-ness — ma ecco uno snippet che prenderà a device_namee riformatterà il pyQuil ISA in uno dei tuoi dizionari:

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)

Come nel caso di Google, il gate nativo a due qubit normalmente disponibile su un processore quantico Rigetti è a CZ, che (1) è bidirezionale (†) nel senso che CZ q0 q1è uguale a CZ q1 q0e (2) è facilmente convertito in uno dei preferiti CNOTs ostacolando il bersaglio con cancelli Hadamard.

† - Viene implementata l'implementazione fisica di un CZcancello in un'architettura superconduttiva , motivo per cui spesso vedi descrizioni architettoniche che includono ma non . È una scorciatoia a cui partecipa il qubit a cui metà dell'interazione fisica, anche se il risultato (ignorando gli effetti del rumore) è lo stesso con entrambi gli ordini.CZ q0 q1CZ q1 q0