Rigetti의 19 큐 비트 칩과 Google의 72 큐 비트 BristleCone 칩에 대해 실제로 허용되는 CNOT는 무엇입니까?

각 IBM 퀀텀 칩에 대해 j가 CNOT의 제어라고 가정하면 각 제어 큐 비트 j를 물리적으로 허용되는 대상 목록에 매핑하는 사전을 작성할 수 있습니다. 예를 들어

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

그들의 ibmqx4 칩을 위해.

구글의 72 큐 비트 브리스톨 론 칩에 대한 그 지시는 무엇인가? dict을 이해력으로 작성할 수 있습니다. Rigetti의 19 qubit 칩에 대해서도 같은 질문입니다.

Bristlecone의 기본 운영은 CNOT가 아닌 CZ입니다. 그러나 Hadamard 게이트로 둘 사이를 변환 할 수 있으므로 사소한 차이가 있습니다.

Bristlecone은 그리드에서 인접한 큐빗 쌍 사이에서 CZ를 수행 할 수 있습니다. cirq 를 설치 하고 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)

허용 된 CZ 작업이 포함 된 집합을 얻는 방법은 다음과 같습니다.

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

세트에는 121 개의 요소가 있으며 세트에 CZ (x, y) 또는 CZ (y, x)가 있는지 여부는 다소 임의적이므로 여기에 세트의 출력물을 포함하지 않습니다.

명심해야 할 또 다른 제약은 두 개의 CZ를 동시에 나란히 수행 할 수 없다는 것입니다. Cirq는 Bristlecone을 대상으로하는 회로를 만들 때이를 고려합니다. 예를 들면 다음과 같습니다.

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

처음 두 작업은 CZ에 인접 해 있기 때문에 엇갈 렸지만 두 번째 작업은 그렇지 않은 것이 아닙니다.

Bristlecone 양자 칩을 제공 하는 최초의 블로그 게시물 에서 다음은 칩의 연결 맵입니다.

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

경고 : 위의 표현은 완전히 검증되지 않았습니다. 그것은 첫 번째 큐빗에서 작동하는 것 같습니다. 나에게 논리적 인 것처럼 보이지만지도가 100 % 정확한지 확인하는 것은 당신에게 달려 있습니다.

경고 2 : Google의 블로그 게시물은 큐빗 간의 연결 방향에 대해 이야기하지 않습니다. 위에 제공된 연결 맵은 연결이 양방향이라고 가정합니다.

PyQuil의 현재 버전은 Rigetti의 퀀턴 프로세서에 대해 원하는 정보를 담고있는 "ISA"객체를 제공하지만 요청에 따라 포맷되지는 않습니다. 저는 가난한 파이썬 프로그래머이므로 비 Pythonic-ness를 변명해야합니다. 그러나 다음 device_name은 pyQuil ISA를 가져 와서 사전 중 하나로 다시 포맷 하는 스 니펫입니다 .

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의 경우와 같이 Rigetti 양자 프로세서에서 일반적으로 사용할 수있는 기본 2 큐 비트 게이트는 CZ(1) 과 CZ q0 q1동일한 의미에서 양방향 (†) CZ q1 q0이며 (2) 원하는대로 쉽게 변환됩니다. CNOT대상을 Hadamard gates에 끼워 넣습니다.

†- CZ초전도 아키텍처에서 게이트 의 물리적 구현 이 제공 되므로 아키텍처 설명에 종종 포함 CZ q0 q1되지만 그렇지 않은 이유가 있습니다 CZ q1 q0. 결과 (소음 효과 무시)가 어느 순서와 동일하더라도 qubit이 물리적 상호 작용의 절반에 참여하는 약칭입니다.