Rigetti'nin 19 qubit yongası ve Google'ın 72 qubit BristleCone yongası için fiziksel olarak izin verilen CNOT'lar nelerdir?

Her bir IBM kuantum yongası için, j'nin bir CNOT'un kontrolü olduğu varsayılarak, her bir kontrol qubit j'sini fiziksel olarak izin verilen hedefleri listesine eşleyen bir sözlük yazılabilir. Örneğin,

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

ibmqx4 çipleri için.

Google'ın 72 qubit Bristlecone çipi için bu dikte ne olurdu? Anlayışı bir anlayış olarak yazabilirsiniz. Aynı soru Rigetti'nin 19 kübit yongası için de geçerli.

Bristlecone'nun yerel operasyonu CNOT'lar değil CZ'dir. Bununla birlikte, Hadamard kapıları ile ikisi arasında dönüşüm yapabilirsiniz, bu yüzden bu önemsiz bir farktır.

Bristlecone, bir ızgara üzerindeki herhangi bir bitişik kubit çifti arasında bir CZ gerçekleştirebilir. Izgarayı cirq yükleyip Bristlecone aygıtını yazdırarak görebilirsiniz :

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

İzin verilen CZ işlemlerini içeren bir seti şu şekilde alabilirsiniz:

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

Setin içinde 121 öğe var ve sette CZ (x, y) veya CZ (y, x) almanız biraz rastgele, bu yüzden setin bir çıktısını buraya eklemeyeceğim.

Akılda tutulması gereken ek bir kısıtlama, aynı anda yan yana iki CZ gerçekleştiremezsiniz. Cirq, Bristlecone'u hedefleyen devreler oluştururken bunu dikkate alır. Örneğin:

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

İlk iki operasyon, komşu CZ'ler oldukları için sendelendi, ancak ikincisi olmadığı için değil.

Gönderen orijinal blog post Bristlecone kuantum çipini sunulması, burada yonganın bağlantı haritasıdır:

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

Uyarı : Yukarıdaki ifade tamamen doğrulanmamış. İlk kubitler için çalışıyor gibi görünüyor, bana mantıklı geliyor, ancak haritanın% 100 doğru olup olmadığını kontrol etmek size kalmış.

Uyarı 2 : Google'ın blog yazısı, kubitler arasındaki bağlantıların yönü hakkında konuşmuyor. Yukarıda verilen bağlantı haritası, bağlantıların iki taraflı olduğunu varsayar.

PyQuil'in mevcut sürümü, Rigetti'nin kuantun işlemcileri hakkında istediğiniz bilgileri barındıran bir "ISA" nesnesi sağlar, ancak istediğiniz gibi biçimlendirilmez. Ben fakir bir Python programcısıyım, bu yüzden Pythonic olmayanlığımı mazur göstermelisin - ama burada device_namepyQuil ISA'yı sözlüklerinden birine dönüştürecek bir pasaj:

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)

Google'ın durumunda olduğu gibi, bir Rigetti kuantum işlemcisinde tipik olarak bulunan yerel iki-kubit kapısı CZ, (1) ile CZ q0 q1aynı anlamda çift yönlü (†) CZ q1 q0ve (2) ile tercih ettiğiniz herhangi birine kolayca dönüştürülebilen bir CNOTHadamard kapıları ile hedef sandviç.

† - Bir fiziksel uygulama CZsüperiletken mimaride kapısı olan genellikle mimari açıklamaları şunlardır bakın neden olan, teslim CZ q0 q1ancak CZ q1 q0. Sonuç (gürültü efektlerini göz ardı ederek) her iki sıralamayla da aynı olsa bile, kübitin fiziksel etkileşimin yarısına katıldığı bir kestirme yol.