Rigetti की 19 qubit चिप और Google की 72 qubit BristleCone चिप के लिए शारीरिक रूप से स्वीकृत CNOT क्या हैं?

Question

प्रत्येक आईबीएम क्वांटम चिप के लिए, एक शब्दकोश एक नियंत्रण मैपिंग लिख सकता है जिसमें प्रत्येक नियंत्रण qu j को उसके शारीरिक रूप से अनुमत लक्ष्यों की सूची में रखा गया है, मान लें कि j एक CNOT का नियंत्रण है। उदाहरण के लिए,

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

उनके ibmqx4 चिप के लिए।

Google की 72 qubit Bristlecone चिप के लिए यह कितना बड़ा होगा। आप समझ के रूप में हुकुम लिख सकते हैं। रिगेटी की 19 क्विट चिप के लिए एक ही सवाल।

Comments

शायद आप प्रश्न में चिप्स के वर्णन के लिए एक लिंक जोड़ सकते हैं? मैं Regitti के चिप विनिर्देशों को खोजने में विफल रहा।

— नेल्लीमे

जिम वूटन को पता होना चाहिए

— rrtucci

Answer 1

ब्रिसलकोन का मूल संचालन सीजेड है, न कि सीएनओटी। हालाँकि, आप दोनों के बीच हडामर्ड गेट्स से रूपांतरण कर सकते हैं, इसलिए यह एक तुच्छ अंतर है।

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)

यहां बताया गया है कि आप किस तरह से अनुमत सीजेड ऑपरेशंस वाले सेट प्राप्त कर सकते हैं:

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

सेट में 121 तत्व हैं, और यह कुछ हद तक यादृच्छिक है कि क्या आपको सेट में सीजेड (एक्स, वाई) या सीजेड (वाई, एक्स) मिलता है, इसलिए मैं यहां सेट का प्रिंटआउट शामिल नहीं करूंगा।

ध्यान रखने के लिए एक अतिरिक्त बाधा यह है कि आप एक ही समय में एक दूसरे के बगल में दो सीजेड नहीं कर सकते। ब्रिस्टलकोन पर लक्षित सर्किट बनाते समय Cirq इसे ध्यान में रखता है। उदाहरण के लिए:

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

पहले दो ऑपरेशन कंपित थे क्योंकि वे निकटवर्ती सीज़ेड हैं, लेकिन दूसरे दो नहीं थे क्योंकि वे नहीं हैं।

Comments

एपीआई का अच्छा उपयोग! तेरा समाधान मुझसे बेहतर है! :)

— नीलिमे

Nelimee, आपका समाधान भी सही है, और निडर है। सर्किल ने आयताकार सरणी को 45 डिग्री तक घुमाने के लिए चुना है जो कि कुछ हद तक विकृत है

— rrtucci

ओह मैं समझा। उन्होंने

— एससीआई

Google के पास क्वांटम कंप्यूटर है?

— user1271772

@rrtucci ASCII में विकर्ण रेखाएं (/, \) शामिल हैं। समन्वित पसंद विभिन्न कार्यों की कठिनाई को कम करने की रेखाओं के साथ अधिक थी, जैसे कि अनुमान लगाना कि क्या qubit (a, b) मौजूद है या नहीं। उन कार्यों के लिए हीरे की आकृति सीमा के पास केवल मुश्किल है, जबकि बिसात पैटर्न पूरी तरह से मुश्किल है।

— क्रेग गिदनी

Answer 2

Bristlecone क्वांटम चिप को प्रस्तुत करने वाले मूल ब्लॉग पोस्ट से , यहाँ चिप का कनेक्टिविटी मानचित्र है:

प्रत्येक क्रॉस निकटतम-पड़ोसी कनेक्टिविटी के साथ, एक qubit का प्रतिनिधित्व करता है। यदि आप बटनों को बाएं से दाएं, ऊपर से नीचे (जैसे आप अंग्रेजी में कैसे पढ़ते हैं) को शुरू करते हैं, तो कनेक्टिविटी मैप द्वारा दिया जाएगा:$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 का ब्लॉग पोस्ट, क्वैब के बीच कनेक्शन के उन्मुखीकरण के बारे में बात नहीं करता है। ऊपर दिया गया कनेक्टिविटी मानचित्र मानता है कि कनेक्शन द्विपक्षीय हैं।

Answer 3

PyQuil का वर्तमान संस्करण एक "ISA" ऑब्जेक्ट प्रदान करता है, जो कि रिगेटी के क्वांटन प्रोसेसर के बारे में आपके द्वारा वांछित जानकारी रखता है, लेकिन यह आपके अनुरोध के अनुसार स्वरूपित नहीं है। मैं एक गरीब पायथन प्रोग्रामर हूं, इसलिए आपको मेरे गैर-पायथन-नेस को बहाना होगा- लेकिन यहां एक ऐसा स्निपेट है जो 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 के मामले में, मूल रूप से रिगेटी क्वांटम प्रोसेसर पर उपलब्ध दो-क्विट गेट एक है CZ, जो (1) इस अर्थ में द्विदिश (†) CZ q0 q1है जो समान है CZ q1 q0और (2) आसानी से आपके पसंदीदा में परिवर्तित हो जाता है। CNOTहैडमार्ड गेट्स के साथ लक्ष्य को सैंडविच करके।

† - एक के भौतिक कार्यान्वयन CZएक अतिचालक वास्तुकला में गेट है सौंप दिया, जिसके कारण आप अक्सर वास्तु विवरण शामिल CZ q0 q1नहीं बल्कि CZ q1 q0। यह एक आशुलिपि है जिसके लिए qubit भाग ले रहा है जिसमें आधी शारीरिक बातचीत होती है, भले ही परिणाम (शोर प्रभावों की अनदेखी) या तो आदेश देने के समान हो।