¿Cuáles son los CNOT físicamente permitidos para el chip de 19 qubit de Rigetti y el chip BristleCone de 72 qubit de Google?

Para cada chip cuántico de IBM, se puede escribir un diccionario que asigna cada qubit de control j a una lista de sus objetivos físicamente permitidos, suponiendo que j es el control de un CNOT. Por ejemplo,

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

por su chip ibmqx4.

¿Cuál sería ese dict para el chip Bristlecone de 72 qubits de Google? Puedes escribir el dict como una comprensión. La misma pregunta para el chip de 19 qubit de Rigetti.

La operación nativa de Bristlecone es la CZ, no las CNOT. Sin embargo, puede transformarse entre los dos con puertas Hadamard, por lo que esta es una diferencia trivial.

Bristlecone puede realizar una CZ entre cualquier par de qubits adyacentes en una cuadrícula. Puede ver la cuadrícula instalando cirq e imprimiendo el 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)

Así es como puede obtener un conjunto que contenga las operaciones CZ permitidas:

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

El conjunto tiene 121 elementos, y es algo aleatorio si obtienes CZ (x, y) o CZ (y, x) en el conjunto, por lo que no incluiré una impresión del conjunto aquí.

Una restricción adicional a tener en cuenta es que no puede realizar dos CZ una al lado de la otra. Cirq tiene esto en cuenta al crear circuitos destinados a Bristlecone. Por ejemplo:

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

Las dos primeras operaciones fueron escalonadas porque son CZ adyacentes, pero las dos últimas no lo fueron porque no lo son.

De la publicación original del blog que presenta el chip cuántico Bristlecone, aquí está el mapa de conectividad 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)
}

Advertencia : la expresión anterior no está completamente verificada. Parece funcionar para los primeros qubits, me parece lógico, pero depende de usted verificar que el mapa sea 100% correcto.

Advertencia 2 : la publicación del blog de Google no habla sobre la orientación de las conexiones entre qubits. El mapa de conectividad dado anteriormente supone que las conexiones son bilaterales.

La versión actual de PyQuil proporciona un objeto "ISA" que contiene la información que desea sobre los procesadores cuánticos de Rigetti, pero no está formateada como lo solicita. Soy un pobre programador de Python, por lo que tendrá que disculpar mi falta de pitonismo, pero aquí hay un fragmento que tomará device_namey formateará el PyQuil ISA en uno de sus diccionarios:

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)

Como en el caso de Google, la puerta nativa de dos qubits típicamente disponible en un procesador cuántico Rigetti es un CZ, que (1) es bidireccional (†) en el sentido de que CZ q0 q1es el mismo CZ q1 q0y (2) se convierte fácilmente en cualquiera de sus preferidos CNOTs al emparedar el objetivo con las puertas Hadamard.

† - La implementación física de una CZpuerta en una arquitectura superconductor se entregó, por lo que a menudo se ve descripciones arquitectónicas incluyen CZ q0 q1, pero no CZ q1 q0. Es una forma abreviada de qué qubit participa en qué mitad de la interacción física, incluso si el resultado (ignorando los efectos de ruido) es el mismo con cualquier pedido.