O que são fisicamente permitidos CNOTs para o chip de 19 bits de Rigetti e o chip BristleCone de 72 bits do Google?

Para cada chip quântico da IBM, é possível escrever um dicionário mapeando cada qubit de controle j para uma lista de seus destinos fisicamente permitidos, assumindo que j é o controle de um CNOT. Por exemplo,

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

para o chip ibmqx4.

Qual seria o ditado para o chip Bristlecone de 72 bits do Google. Você pode escrever o ditado como uma compreensão. Mesma pergunta para o chip de 19 qubit de Rigetti.

A operação nativa do Bristlecone é a CZ, não os CNOTs. No entanto, você pode se transformar entre os dois com portões Hadamard, então essa é uma diferença trivial.

O Bristlecone pode executar uma CZ entre qualquer par adjacente de qubits em uma grade. Você pode ver a grade instalando cirq e imprimindo o 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)

Aqui está como você pode obter um conjunto contendo as operações 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)}

O conjunto possui 121 elementos, e é algo aleatório se você obtém CZ (x, y) ou CZ (y, x) no conjunto, então não incluirei uma impressão do conjunto aqui.

Uma restrição adicional a ter em mente é que você não pode executar duas CZs uma ao lado da outra ao mesmo tempo. O Cirq leva isso em consideração ao criar circuitos direcionados ao Bristlecone. Por exemplo:

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

As duas primeiras operações foram escalonadas porque são CZs adjacentes, mas as duas últimas não foram porque não são.

No post original do blog que apresenta o chip quântico Bristlecone, eis o mapa de conectividade do 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)
}

Aviso : a expressão acima não foi verificada completamente. Parece funcionar para os primeiros qubits, me parece lógico, mas cabe a você verificar se o mapa está 100% correto.

Aviso 2 : a postagem do blog do Google não fala sobre a orientação das conexões entre os qubits. O mapa de conectividade fornecido acima assume que as conexões são bilaterais.

A versão atual do PyQuil fornece um objeto "ISA" que hospeda as informações que você deseja sobre os processadores quânticos de Rigetti, mas não é formatado conforme solicitado. Sou um péssimo programador de Python, então você terá que desculpar minha não-Pythonic-ness - mas aqui está um trecho que fará uma device_namereformatação do pyQuil ISA em um de seus dicionários:

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 no caso do Google, o gate nativo de dois qubit normalmente disponível em um processador quântico Rigetti é a CZ, que (1) é bidirecional (†) no sentido CZ q0 q1igual ao CZ q1 q0e (2) é facilmente convertido em qualquer um dos CNOTs imprensando o alvo com portões Hadamard.

† - A implementação física de um CZportão em uma arquitetura supercondutora é entregue, e é por isso que você frequentemente vê descrições de arquitetura incluídas, CZ q0 q1mas não CZ q1 q0. É uma abreviação para a qual o qubit está participando da metade da interação física, mesmo que o resultado (ignorando os efeitos do ruído) seja o mesmo em qualquer um dos pedidos.