Was sind physikalisch erlaubte CNOTs für Rigettis 19-Qubit-Chip und Googles 72-Qubit-BristleCone-Chip?

Für jeden IBM-Quantenchip kann ein Wörterbuch geschrieben werden, das jedes Steuer-Qubit j auf eine Liste seiner physikalisch zulässigen Ziele abbildet, vorausgesetzt, j ist die Steuerung eines CNOT. Beispielsweise,

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

für ihren ibmqx4 chip.

Was würde das für Googles 72-Qubit-Bristlecone-Chip bedeuten? Sie können das Diktat als Verständnis schreiben. Dieselbe Frage für Rigettis 19-Qubit-Chip.

Bristlecone ist in der Tschechischen Republik ansässig, nicht in CNOTs. Sie können sich jedoch mit Hadamard-Toren zwischen den beiden verwandeln, sodass dies ein unbedeutender Unterschied ist.

Bristlecone kann eine CZ zwischen zwei benachbarten Qubits in einem Gitter durchführen. Sie können das Raster sehen, indem Sie cirq installieren und das Bristlecone-Gerät ausdrucken :

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

So erhalten Sie ein Set mit den erlaubten CZ-Operationen:

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

Das Set enthält 121 Elemente, und es ist etwas zufällig, ob Sie CZ (x, y) oder CZ (y, x) im Set haben, daher werde ich hier keinen Ausdruck des Sets einfügen.

Eine zusätzliche Einschränkung ist, dass Sie nicht zwei CZs gleichzeitig nebeneinander ausführen können. Cirq berücksichtigt dies bei der Erstellung von auf Bristlecone ausgerichteten Schaltkreisen. Beispielsweise:

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

Die ersten beiden Operationen waren gestaffelt, weil sie benachbarte CZs sind, aber die zweiten beiden waren nicht, weil sie nicht sind.

Aus dem ursprünglichen Blogbeitrag , in dem der Bristlecone-Quantenchip vorgestellt wird, ist hier die Konnektivitätskarte des Chips:

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

Warnung : Der obige Ausdruck ist vollständig unbestätigt. Es scheint für die ersten Qubits zu funktionieren, es erscheint mir logisch, aber es liegt an Ihnen, zu überprüfen, ob die Karte 100% korrekt ist.

Warnung 2 : In Googles Blogpost geht es nicht um die Ausrichtung der Verbindungen zwischen Qubits. In der oben angegebenen Konnektivitätsübersicht wird davon ausgegangen, dass die Verbindungen bilateral sind.

Die aktuelle Version von PyQuil enthält ein "ISA" -Objekt, das die gewünschten Informationen zu Rigettis Quantun-Prozessoren enthält, jedoch nicht nach Ihren Anforderungen formatiert ist. Ich bin ein armer Python-Programmierer, deshalb musst du meine Nicht-Python-Fähigkeit entschuldigen - aber hier ist ein Ausschnitt, der eine brauchtdevice_name und die pyQuil-ISA in eines Ihrer Wörterbücher umformatiert:

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)

Wie in Googles Fall ist das native Zwei-Qubit-Gatter, das typischerweise auf einem Rigetti-Quantenprozessor verfügbar ist, ein CZ, das (1) in dem Sinne bidirektional (†) istCZ q0 q1 es dasselbe ist CZ q1 q0und (2) leicht in eines Ihrer bevorzugten konvertiert werden kann CNOTs durch Einklemmen des Ziels mit Hadamard-Toren.

† - Die physikalische Implementierung eines CZGates in einer supraleitenden Architektur wird übergeben, weshalb Sie häufig Architekturbeschreibungen sehen, CZ q0 q1aber nicht einschließen CZ q1 q0. Es ist eine Kurzform, für die Qubit an welcher Hälfte der physischen Interaktion teilnimmt, auch wenn das Ergebnis (ohne Berücksichtigung von Rauscheffekten) bei beiden Ordnungen dasselbe ist.