A. pyQuil

pyQuil هي مكتبة Python مفتوحة المصدر تم تطويرها بواسطة Rigetti لإنشاء وتحليل وتنفيذ برامج الكم. وهي مبنية على أساس لغة كويل - لغة مفتوحة لتعليمات الكم (أو ببساطة لغة كمومية ) ، مصممة خصيصًا لأقرب أجهزة الكمبيوتر الكمومية الواعدة وتستند إلى نموذج ذاكرة كلاسيكية / كمومية مشتركة [24] (وهذا يعني أن كوبيتات و بت الكلاسيكية). pyQuil هي واحدة من المكتبات الأساسية التي تم تطويرها في Forest ، وهي المنصة الرئيسية لجميع برامج Rigetti. تشتمل Forest أيضًا على Grove و Reference QVM ، والتي سيتم وصفها لاحقًا.

أ. المتطلبات والتثبيت

يتطلب تثبيت واستخدام pyQuil إصدارات Python 2 أو 3 ، على الرغم من أن Python 3 موصى به بشدة ، لأن وظائف التطوير المستقبلية ستدعم Python 3. بالإضافة إلى ذلك ، يوصى بتوزيع Python Anaconda لمختلف تبعيات وحدة Python ، على الرغم من أن هذا ليس ضروريًا.

أسهل طريقة لتثبيت pyQuil هي استخدام الأمر Python package manager. في موجه أوامر Linux Ubuntu ، أدخل

 pip install pyquil 

لتثبيت البرامج بنجاح. بدلاً من ذلك ، إذا تم تثبيت Anaconda ، فيمكن تثبيت pyQuil عن طريق الكتابة

 conda install −c rigetti pyquil 

في سطر الأوامر. بديل آخر هو تنزيل شفرة المصدر من مستودع git وتثبيت البرنامج. للقيام بذلك ، أدخل الأوامر التالية:

 git clone https://github.com/rigetticomputing/pyquil cd pyquil pip install −e 

يوصى بهذه الطريقة الأخيرة لجميع المستخدمين الذين يمكنهم المساهمة في pyQuil. راجع دليل إيداع GitHub لمزيد من المعلومات.

ب. الوثائق والبرامج التعليمية

لدى pyQuil وثائق ممتازة منشورة على الإنترنت ، مع مقدمة للحوسبة الكمومية ، وتعليمات التثبيت ، والبرامج الأساسية وعمليات البوابة ، ومحاكاة تُعرف باسم الآلة الافتراضية الكمومية (QVM) ، وكمبيوتر كمومي حقيقي ، ولغة كويل مع مترجم. من خلال تنزيل شفرة مصدر pyQuil من GitHub ، ستحصل أيضًا على مجلد يحتوي على أمثلة في دفاتر Jupyter وأمثلة Python العادية وبرنامج$$ $ inline $ \ textf {run_quil.py} $ inline $ ، والتي يمكنها تشغيل مستندات نصية مكتوبة بلغة Quil باستخدام آلة افتراضية كمومية. أخيرًا ، أذكر غروف ، وهي مجموعة من خوارزميات الكم التي تم إنشاؤها باستخدام pyQuil وبيئة Rigetti Forest.

ج. بناء الجملة

بنية pyQuil بسيطة وعملية للغاية. العنصر الرئيسي لتسجيل الدوائر الكمومية هو البرنامج ويمكن استيراده منه $$$\ textf {pyquil.quil}$ . يمكن العثور على عمليات البوابة في $$$\ textf {pyquil.gates}$ . الوحدة $$$\ textf {api}$ يسمح لك بتشغيل دوائر الكم في آلة افتراضية. واحدة من الميزات اللطيفة لـ pyQuil هي أنه لا يجب تحديد السجلات qubit والسجلات الكلاسيكية بشكل مسبق ويمكن تخصيصها ديناميكيًا في الذاكرة. تتم الإشارة إلى Qubits في سجل qubit بواسطة الفهارس (0 ، 1 ، 2 ، ...) وبالمثل بالنسبة للبتات في السجل الكلاسيكي. وبالتالي ، يمكن كتابة دائرة المولد العشوائية على النحو التالي:

 # random number generator circuit in pyQuil from pyquil.quil import Program import pyquil.gates as gates from pyquil import api qprog = Program() qprog += [gates.H(0), gates.MEASURE(0, 0)] qvm = api.QVMConnection() print(qvm.run(qprog)) 

قائمة 2. رمز PyQuil لمولد رقم عشوائي.

تستورد الخطوط الثلاثة الأولى الحد الأدنى اللازم لإعلان مخطط / برنامج كمومي (السطر 2) ، ولإجراء عمليات البوابة على الكيبات (الخط 3) [44] ولتنفيذ المخطط (السطر 4). في السطر 6 ، يتم إنشاء برنامج كمومي ، وفي الأسطر 7-8 ، يتم إرسال قائمة بالتعليمات إليه: أولاً ، التصرف على بوابة هادامارد $$$H$ فوق qubit في الفهرس 0 ، ثم نقيس نفس qubit إلى بتة كلاسيكية تحت الفهرس 0. ينشئ الخط 10 اتصالاً بـ QVM ، وعند 11 يتم تشغيل نتيجة دائرتنا وعرضها. يقوم هذا البرنامج بطباعة الإخراج القياسي لـ pyQuil كقائمة بقوائم الأعداد الصحيحة: في حالتنا - $$$\ textf {[[[0]]}$ أو $$$\ textf {[[[1]]}$ . بشكل عام ، عدد العناصر في قائمة خارجية هو عدد الاختبارات التي تم إجراؤها. الأرقام الصحيحة في القوائم الداخلية هي الأبعاد النهائية في السجل الكلاسيكي. بما أننا أجرينا اختبارًا واحدًا فقط (يشار إلى هذا كحجة في $$$\ textf {api.QVMConnection.run}$ ، والتي يتم تعيينها على الوحدة افتراضيًا) ، نحصل على قائمة داخلية واحدة فقط. نظرًا لأنه في السجل الكلاسيكي لم يكن لدينا سوى جزء واحد ، نحصل على عدد صحيح واحد فقط.

د. لغة كمومية

Quil هي لغة تعليمات كمومية ، أو ببساطة لغة كمومية تنقل الأوامر إلى جهاز كمبيوتر كمومي. هذا مشابه للمجمع على أجهزة الكمبيوتر الكلاسيكية. جوهر بناء Quil هو $$$\ textf {GATE index}$ أين $$$\ textf {GATE}$ هي بوابة كمية تنطبق على الكوبت المفهرسة $$$\ textf {index}$ (0 ، 1 ، 2 ، ...). لدى pyQuil وظيفة لإنشاء كود Quil من برنامج معين. على سبيل المثال ، في مولد العدد العشوائي الكمومي المذكور أعلاه ، يمكننا إضافة السطر:

 print(qprog) 

في النهاية للحصول على رمز مخطط كويل ، الذي يظهر أدناه:

 H 0 MEASURE 0 [0] 

قائمة 3. رمز لحاف لمولد رقم عشوائي.

ربما إذا بدأ شخص ما في فهم Quil ، اكتب دوائر الكم في محرر نص في Quil ، ثم نفذ الدائرة على QVM باستخدام البرنامج$$ $ inline $ \ textf {run_quil.py} $ inline $ . يمكنك أيضًا التعديل$$ $ inline $ \ textf {run_quil.py} $ inline $ لتشغيل الدائرة على QPU. لاحظ أن المترجم pyQuil (يسمى أيضًا مترجم Quil في الوثائق) يحول الدائرة المحددة إلى كود Quil الذي يمكن أن يفهمه الكمبيوتر الكمومي الحقيقي. سنناقش هذا بمزيد من التفصيل في القسم الثالث جيم.

و. أجهزة الكم

لدى Rigetti معالج كمومي يمكن استخدامه من قبل أولئك الذين يطلبون الوصول. لطلب الوصول ، يجب عليك زيارة موقع Rigetti على الويب وتقديم الاسم الكامل وعنوان البريد الإلكتروني واسم المؤسسة ووصفًا لسبب الوصول إلى QPU. بمجرد الانتهاء من ذلك ، سيتصل بك أحد ممثلي الشركة عبر البريد الإلكتروني لتحديد موعد لإعطاء المستخدم حق الوصول إلى QPU. ميزة عملية الجدولة هذه ، على النقيض من نظام قائمة انتظار QISKit ، الذي سيتم مناقشته لاحقًا ، هو أنه يمكن تنفيذ العديد من المهام في فترة زمنية موزعة مع أوقات تنفيذ حتمية ، وهو أمر أساسي للخوارزميات المتنوعة والمختلطة. ترسل هذه الأنواع من الخوارزميات البيانات ذهابًا وإيابًا بين أجهزة الكمبيوتر الكلاسيكية والكمومية - الحاجة إلى الانتظار في الطابور تجعل هذه العملية أطول بكثير. العيب (ربما) هو أنه لا يمكن أداء المهام في أي وقت عندما تكون وحدة QPU متاحة ومن الضروري الإشارة إلى وقت محدد والموافقة عليه.

وفقًا لتجربة المؤلف ، فإن الموظفين على استعداد للمساعدة ، وعادة ما تكون العملية ناجحة. يتكون الجهاز الفعلي ، الذي يظهر هيكله في الشكل 2 ، من 8 كيوبتات مع أقرب اتصال جار. سنلقي نظرة على هذا الكمبيوتر بمزيد من التفصيل في القسم الثالث ب.

ز. محاكي

الآلة الكمومية الافتراضية (QVM) هي الأداة الرئيسية المستخدمة لتنفيذ الدوائر الكمومية. يتلقى هذا البرنامج ، المكتوب للتشغيل على معالج كلاسيكي ، كود Quil ويحاكي تطوير عملية على كمبيوتر كمومي حقيقي. للاتصال بـ QVM ، تحتاج إلى تسجيل مفتاح API مجانًا على https://www.rigetti.com/forest باسم وعنوان بريد إلكتروني. ثم ستتلقى بريدًا إلكترونيًا يحتوي على مفتاح واجهة برمجة التطبيقات ومعرف المستخدم الذي يجب تكوينه عند بدء التشغيل:

 pyquil−config−setup 

في سطر الأوامر (بعد تثبيت pyQuil ، بالطبع). ثم سيُطلب منك إدخال المفاتيح من البريد الإلكتروني.

وفقًا للوثائق ، توفر معظم مفاتيح API الوصول إلى QVMs حتى 30 كيلو بت ، ويمكنك طلب الوصول إلى المزيد من وحدات البت. يتيح مفتاح واجهة برمجة تطبيقات المؤلف الوصول إلى 26 كيلوبايت (لم يتم طلب تحديثات).

بالإضافة إلى ذلك ، تحتوي مكتبة الغابة على جهاز محاكاة محلي مكتوب بلغة Python ومصدر مفتوح ، يُشار إليه باسم QVM المرجعي . إنها ليست منتجة مثل QVM ، ولكن يمكن للمستخدمين تشغيل الدوائر مع عدد وحدات البت التي تحددها مساحة الذاكرة على الأجهزة المحلية. عادة ، يمكن تشغيل الدوائر التي تحتوي على أقل من 20 كيلوبت على مجموعة واسعة من المعدات. يجب تثبيت QVM المرجعي بشكل منفصل ، والذي يمكن القيام به باستخدام $$$\ textf {pip}$ :

 pip install referenceqvm 

لاستخدام QVM المرجعي بدلاً من QVM ، ما عليك سوى الاستيراد $$$\ textf {api}$ من $$$\ textf {referenceqvm}$ بدلاً من pyQuil:

 import referenceapi.api as api 

B. QISKit

مجموعة برامج معلومات الكم ، أو QISKit ، هي مجموعة تطوير برمجيات مفتوحة المصدر (SDK) للعمل مع اللغة الكمومية OpenQASM ومعالجات الكم في منصة IBM Q. وهي متاحة للغات Python و JavaScript و Swift ، ولكن هنا نناقش فقط نسخة بايثون.

أ. المتطلبات والتثبيت

QISKit متاح على أنظمة التشغيل MacOS و Windows و Linux. يتطلب تثبيت QISKit استخدام Python 3.5+. مكونات إضافية مفيدة ، ولكنها غير مطلوبة هي Jupyter Notebooks للبرامج التعليمية وتوزيع Python Anaconda 3 ، الذي يحتوي على جميع التبعيات اللازمة.

أسهل طريقة لتثبيت QISKit هي استخدام مدير حزمة النقاط لـ Python. في موجه الأوامر ، لتثبيت البرنامج ، أدخل:

 pip install qiskit 

يرجى ملاحظة ذلك $$$\ textf {pip}$ يعالج تلقائيًا جميع التبعيات وسيعمل دائمًا على تثبيت أحدث إصدار. يمكن للمستخدمين المهتمين بالمساهمة في QISKit تثبيت شفرة المصدر بإدخال ما يلي في موجه الأوامر ، من المفترض أن git مثبتة:

 git clone https://github.com/QISKit/qiskit−core cd qiskit−core python −m pip install −e 

للحصول على معلومات حول الإيداعات ، راجع الوثائق الفورية لدليل الإيداع على GitHub.

ب. التوثيق ومواد التدريب

يمكن العثور على وثائق QISKit على الإنترنت على https://qiskit.org/documentation/ . يحتوي على تعليمات التثبيت والتكوين ، ونماذج البرامج والاتصال بالأجهزة الكمومية الحقيقية ، وتنظيم المشروع ، ومراجعة QISKit ، ووثائق المطور. يمكن أيضًا العثور على معلومات أساسية حول الحوسبة الكمومية للمستخدمين الجدد في هذا المجال. مورد جيد جدًا هو ارتباط إلى SDK ، حيث يمكن للمستخدمين العثور على معلومات حول وثائق التعليمات البرمجية المصدر.

يحتوي QISKit أيضًا على عدد كبير من البرامج التعليمية في مستودع GitHub منفصل (مشابه لـ pyQuil و Grove). وتشمل هذه الدول المتشابكة. الخوارزميات القياسية مثل Deutsch Jozh ، خوارزمية Grover ، تقدير المرحلة وتحويل فورييه الكمومي ؛ أيضًا خوارزميات أكثر تعقيدًا ، مثل حل مشكلة القيمة الذاتية المتغيرة الكمومية وتطبيقها على فرميتوني هاميلتون ؛ وحتى بعض الألعاب الممتعة ، مثل "معركة البحر" الكمومية. بالإضافة إلى ذلك ، تحتوي مكتبة ACQUA (الخوارزميات والدوائر لتطبيقات QUantum) على خوارزميات متعددة التخصصات للكيمياء والذكاء الاصطناعي مع العديد من الأمثلة.

هناك أيضًا وثائق مفصلة للغاية لكل من الخلفيات الخلفية الكمية التي تحتوي على معلومات حول الاتصال ووقت التماسك ووقت استخدام البوابة. أخيرًا ، اذكر موقع ويب IBM Q Experience وأدلة المستخدم. يحتوي موقع الويب على واجهة رسومية لدائرة كمية يمكن للمستخدمين من خلالها سحب البوابات إلى دائرة ، وهو أمر مفيد لاستكشاف الدوائر الكمومية. تحتوي أدلة المستخدم على مزيد من الإرشادات حول الحوسبة الكمية ولغة QISKit.

ج. بناء الجملة

يمكن عرض بناء جملة QISKit في نموذج البرنامج التالي. هنا ، على عكس pyQuil ، تحتاج إلى التمييز بوضوح بين السجلات الكمية والكلاسيكية. فيما يلي برنامج لنظام الأرقام العشوائية في QISKit:

 # random number generator circuit in QISKit from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute qreg = QuantumRegister(1) creg = ClassicalRegister(1) qcircuit = QuantumCircuit(qreg , creg) qcircuit.h(qreg[0]) qcircuit.measure(qreg[0], creg[0]) result = execute(qcircuit, 'local qasm simulator').result() print(result.get_counts()) 

القائمة 4. رمز QISKit لمولد رقم عشوائي.

يستورد السطر 2 أدوات لإنشاء تسجيلات كمية وكلاسيكية ودائرة كمية ووظائف لتنفيذ هذه الدائرة. ثم نقوم بإنشاء سجل كمومي مع كيلوبايت واحد (السطر 4) ، وسجل كلاسيكي مع بت واحد (السطر 5) ودائرة كمية مع كل من هذه السجلات (السطر 6). الآن بعد أن تم إنشاء الدائرة ، نبدأ في إعطاء التعليمات: في السطر 8 نطبق بوابة هادامارد على صفر كيلوبايت في سجل الكم (وهو الكيوبت الوحيد في السجل الكمي) ؛ في السطر 9 ، نقيس هذا الكيوبت في بتة كلاسيكية مفهرسة بصفر في سجلنا الكلاسيكي (وهو الوحيد في السجل الكلاسيكي) [45]. الآن بعد أن تم بناء الدارة الكمومية ، نفّذها في السطر 11 واطبع النتيجة في السطر 12. عن طريق الإخراج$$ $ inline $ \ textf {result.get_counts ()} $ inline $ نحصل على "حسابات" الدائرة ، أي قاموس بيانات المخرجات وعدد مرات تلقي كل نتيجة. لحالتنا ، المخرجات الوحيدة الممكنة هي 0 أو 1 ، ومثال على مخرجات البرنامج أعلاه $$$\ textf {{'' '': 532، '1': 492}}$ ، مما يشير إلى أننا حصلنا على 532 حالة من 0 و 492 حالة من 1. (بشكل افتراضي ، عدد الدورات لبدء الدائرة يسمى $$$\ textf {shots}$ في QISKit ، هو 1024.)

د. لغة كمومية

OpenQASM (لغة التجميع الكمومي المفتوحة [25] ، والتي يمكننا ببساطة تسميتها QASM) هي لغة كمومية توفر تعليمات للأجهزة الكمومية الحقيقية المشابهة للمجمع على أجهزة الكمبيوتر الكلاسيكية. أساس بناء جملة QASM هو $$$\ textf {gate qubit}$ أين $$$\ textf {gate}$ يضبط تشغيل البوابة الكمومية و $$$\ textf {qubit}$ - كيوبت. QISKit لديه وظيفة لإنشاء كود QASM من مخطط. في مخطط الأرقام العشوائية أعلاه ، يمكننا إضافة خط.

 print(qcircuit.qasm()) 

في النهاية للحصول على رمز QASM للدائرة الموضحة أدناه:

 OPENQASM 2.0; include ”qelib1.inc”; qreg q0[1]; creg c0[1]; h q0[0]; measure q0[0] −> c0[0]; 

القائمة 5. كود OpenQASM لمولد رقم عشوائي.

يتم تضمين السطرين الأولين في كل ملف QASM. ينشئ الخط 3 (4) سجلاً كمّيًا (كلاسيكيًا) ، ويعطي الخطان 5 و 6 تعليمات للدائرة. في OpenQASM ، يمكنك كتابة دوائر صغيرة مثل هذه ، ولكن بالنسبة للدوائر الأكبر ، من الأفضل استخدام الأدوات في QISKit للبرمجة المجانية والفعالة لأجهزة الكمبيوتر الكمومية.

ه. أجهزة الكم

هناك كمية كبيرة من الوثائق للخلفية الكمية المدعومة من QISKit. تتضمن هذه الأجهزة IBMQX2 (5 كيلوبايت) و IBMQX4 (5 كيلوبايت) و IBMQX5 (16 كيلوبايت) و QS1_1 (20 كيلوبايت ، متوفرة فقط لأعضاء شبكة IBM Q). الوثائق للجميع متاحة على جيثب. سنلقي نظرة فاحصة على IBMQX5 في القسم III B ، الذي يظهر طوبولوجيته في الشكل 3.

و. محاكي

IBM , . , 12 , , 25 . , III D.

C. ProjectQ

ProjectQ — IBM, . ProjectQ Thomas Häner Damien S. Steiger Matthias Troyer ETH Zurich, .

أ.

ProjectQ Python (2.7 3.4+). . $$$\textsf{pip}$ :

 python −m pip install −−user projectq 

( ). :

 git clone https://github.com/ProjectQ−Framework/ProjectQ cd projectq python −m pip install −−user 

, , . ProjectQ GitHub.

ب.

ProjectQ . , . - ( , ). — / , . [18, 19] , , - .

ج.

ProjectQ , . ProjectQ ( ProjectQ), — / . , :

 # random number generator circuit in ProjectQ from projectq import MainEngine import projectq.ops as ops eng = MainEngine() qbits = eng.allocate_qureg(1) ops.H | qbits[0] ops.Measure | qbits[0] eng.flush() print(int(qbits[0])) 

6. ProjectQ .

2 , 3 . 5 (engine) $$$\textsf{MainEngine}$ , 6 . 8 9 : 0, . « » . — $$$\textsf{operation | qubit}$ , $$$H|0>$ , . , /. pyQuil QISKit, ProjectQ . , $$$\textsf{qbits[0]}$ 9, , $$$\textsf{int}$ , 12.

د.

, ProjectQ . ProjectQ IBM, OpenQASM: IBM.

e.

ProjectQ . , IBM ProjectQ.

f.

ProjectQ , C++, , , Python. , ProjectQ $$$\textsf{ClassicalSimulator}$ (stabilizer circuits), . . , , , CNOT [26]. , , , , . , $$$\textsf{C++ Simulator}$ .

$$$\textsf{C++ Simulator}$ ProjectQ . [23]() (, ), 26 5 , 28 20 — . [III D]() 6.

h. ProjectQ

ProjectQ , , . , pyQuil ProjectQ [27], Microsoft QDK Thomas Häner Damian Steiger ETH Zurich [28], . ( , , QDK ProjectQ C++, .)

D. Quantum Development Kit

Rigetti IBM, Microsoft . [29] , , , . , Microsoft , Quantum Development Kit (QDK), , . , QDK «-» Q#, Visual Studio Visual Studio Code 30 . 2018 , -, MacOS, Windows Linux.

أ.

, Visual Studio Code , . ( VS Code, Visual Studio . - - , , VS Code.) , QDK , Bash:

 dotnet new −i "Microsoft.Quantum.ProjectTemplates::0.2 −*" 

QDK GitHub ( , QDK), :

 git clone https://github.com/Microsoft/Quantum.git cd Quantum code 

ب.

— Q#, - , , , Q# . ; , .

ج.

Q# . C#: , Python, , C#. , :

 // random number generator circuit in QDK operation random (count: Int, initial: Result) : (Int, Int) { body { mutable numOnes = 0; using ( qubits = Qubit[1]) { for (test in 1..count) { Set(initial, qubits[0]); H(qubits[0]); let res = M(qubits[0]); // count the number of ones if (res == One) { set numOnes = numOnes + 1; } } Set(Zero, qubits[0]); } // return statistics return (count − numOnes, numOnes); } } 

7. Q# .

, , /, , . . , , , . — $$$\textsf{.qs}$ Q#, $$$\textsf{Driver.cs}$ $$$\textsf{.qs}$ , $$$\textsf{.csproj}$ , . , 65 . -, , «Quickstart» .

, QDK , . , — $$$(a + b)$ , . QDK , , ( C , , , , .

د. /

, QDK . Q# / .

e.

QDK , 30 . , QDK ProjectQ, , ProjectQ. ( III D.) Azure , 40 . QDK , .

, QDK (trace simulator), , , , . , . , . , , - , . . . - QDK.

1. Bernhard Ömer, A procedural formalism for quantum computing , Master's thesis, Department of Theoretical Physics, Technical University of Vienna, 1998.
2. S. Bettelli, L. Serafini, T. Calarco, Toward an architecture for quantum programming , Eur. Phys. J. D, Vol. 25, No. 2, pp. 181-200 (2003).
3. Peter Selinger (2004), A brief survey of quantum programming languages , in: Kameyama Y., Stuckey PJ (eds) Functional and Logic Programming. FLOPS 2004. Lecture Notes in Computer Science, vol 2998. Springer, Berlin, Heidelberg.
4. Benjamin P. Lanyon, James D. Whitfield, Geoff G. Gillet, Michael E. Goggin, Marcelo P. Almeida, Ivan Kassal, Jacob D. Biamonte, Masoud Mohseni, Ben J. Powell, Marco Barbieri, Alaґn Aspuru-Guzik, Andrew G. White, Towards quantum chemistry on a quantum computer , Nature Chemistry 2 , pages 106-111 (2010), doi:10.1038/nchem.483.
5. Jonathan Olson, Yudong Cao, Jonathan Romero, Peter Johnson, Pierre-Luc Dallaire-Demers, Nicolas Sawaya, Prineha Narang, Ian Kivlichan, Michael Wasielewski, Alaґn Aspuru-Guzik, Quantum information and computation for chemistry , NSF Workshop Report, 2017.
6. Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, Seth Lloyd, Quantum machine learning , Nature volume 549 , pages 195-202 (14 September 2017).
7. Seth Lloyd, Masoud Mohseni, Patrick Rebentrost, Quantum principal component analysis , Nature Physics volume 10 , pages 631-633 (2014).
8. Vadim N. Smelyanskiy, Davide Venturelli, Alejandro Perdomo-Ortiz, Sergey Knysh, and Mark I. Dykman, Quantum annealing via environment-mediated quantum diffusion , Phys. Rev. Lett. 118 , 066802, 2017.
9. Patrick Rebentrost, Brajesh Gupt, Thomas R. Bromley, Quantum computational finance: Monte Carlo pricing of financial derivatives , arXiv preprint (arXiv:1805.00109v1), 2018.
10. IM Georgescu, S. Ashhab, Franco Nori, Quantum simulation , Rev. Mod. Phys. 86, 154 (2014), DOI: 10.1103/RevModPhys.86.153.
11. EF Dumitrescu, AJ McCaskey, G. Hagen, GR Jansen, TD Morris, T. Papenbrock, RC Pooser, DJ Dean, P. Lougovski, Cloud quantum computing of an atomic nucleus , Phys. Rev. Lett. 120 , 210501 (2018), DOI: 10.1103/PhysRevLett.120.210501.
12. Lukasz Cincio, Yigit Subasi, Andrew T. Sornborger, and Patrick J. Coles, Learning the quantum algorithm for state overlap , arXiv preprint (arXiv:1803.04114v1), 2018
13. Patrick J. Coles, Stephan Eidenbenz, Scott Pakin, et al., Quantum algorithm implementations for beginners , arXiv preprint (arXiv:1804.03719v1), 2018.
14. Mark Fingerhuth, Open-Source Quantum Software Projects , accessed May 12, 2018.
15. Quantiki: List of QC Simulators , accessed May 12, 2018
16. R. Smith, MJ Curtis and WJ Zeng, A practical quantum instruction set architecture , 2016.
17. QISKit, originally authored by Luciano Bello, Jim Challenger, Andrew Cross, Ismael Faro, Jay Gambetta, Juan Gomez, Ali Javadi-Abhari, Paco Martin, Diego Moreda, Jesus Perez, Erick Winston, and Chris Wood, https://github.com/QISKit/qiskit-sdk-py .
18. Damian S. Steiger, Thomas Häner, and Matthias Troyer ProjectQ: An open source software framework for quantum computing , 2016.
19. Thomas Häner, Damian S. Steiger, Krysta M. Svore, and Matthias Troyer A software methodology for compiling quantum programs , 2016.
20. The Quantum Development Kit by Microsoft, homepage: https://www.microsoft.com/en — us/quantum/development-kit, github: https://github.com/Microsoft/Quantum .
21. Michael A. Nielsen and Isaac L. Chuang, Quantum Computation and Quantum Information 10th Anniversary Edition, Cambridge University Press, 2011.
22. Doug Finke, Education , Quantum Computing Report, https://quantumcomputingreport.com/resources/education/ , accessed May 26, 2018.
23. All code in this paper was run and tested on a Dell XPS 13 Developer Edition laptop running 64 bit Ubuntu 16.04 LTS with 8 GB RAM and an Intel Core i7-8550U CPU at 1.80 GHz. Programs were run primarily from the command line but the Python developer environment Spyder was also used for Python programs and Visual Studio Code was used for C# (Q#) programs.
24. Forest: An API for quantum computing in the cloud, https://www.rigetti.com/index.php/forest , accessed May 14, 2018.
25. Andrew W. Cross, Lev S. Bishop, John A. Smolin, Jay M. Gambetta, Open quantum assembly language , 2017.
26. Scott Aaronson, Daniel Gottesman, Improved Simulation of Stabilizer Circuits , Phys. Rev. A 70 , 052328, 2004.
27. pyQuil Lisence, github.com/rigetticomputing/pyquil/blob/master/LICENSE#L204 , accessed June 7, 2018.
28. Microsoft Quantum Development Kit License, marketplace.visualstudio.com/items/quantum.DevKit/license , accessed June 7, 2018.
29. Hao Zhang, Chun-Xiao Liu, Sasa Gazibegovic, et al. Quantized Majorana conductance , Nature 556 , 74-79 (05 April 2018).
30. 16-qubit backend: IBM QX team, “ibmqx5 backend specification V1.1.0,” (2018). Retrieved from https://ibm.biz/qiskit-ibmqx5 and https://quantumexperience.ng.bluemix.net/qx/devices on May 23, 2018.
31. Talia Gershon, Celebrating the IBM Q Experience Community and Their Research , March 8, 2018.
32. M. Reck, A. Zeilinger, HJ Bernstein, and P. Bertani, Experimental realization of any discrete unitary operator , Physical Review Letters, 73, p. 58, 1994.
33. Ryan LaRose, Distributed memory techniques for classical simulation of quantum circuits , arXiv preprint (arXiv:1801.01037v1), 2018.
34. Thomas Haner, Damian S. Steiger, 0.5 petabyte simulation of a 45-qubit quantum circuit , arXiv preprint (arXiv:1704.01127v2), September 18, 2017.
35. Jianxin Chen, Fang Zhang, Cupjin Huang, Michael Newman, Yaoyun Shi, Classical simulation of intermediate-size quantum circuits , arXiv preprint (arXiv:1805.01450v2), 2018.
36. Alwin Zulehner, Robert Wille, Advanced simulation of quantum computations , arXiv preprint ( arXiv:1707.00865v2 ), November 7, 2017.
37. Jarrod R. McClean, Ian D. Kivlichan, Kevin J. Sung, et al., OpenFermion: The electronic structure package for quantum computers , arXiv:1710.07629, 2017.
38. Nathan Killoran, Josh Izaac, Nicols Quesada, Ville Bergholm, Matthew Amy, Christian Weedbrook, Strawberry Fields: A Software Platform for Photonic Quantum Computing , arXiv preprint (arXiv:1804.03159v1), 2018.
39. IonQ website, https://ionq.co/ , accessed June 15, 2018.
40. D-Wave: The quantum computing company, https://www.dwavesys.com/home , accessed June 20, 2018.
41. 4 2018 Rigetti 20- , . , 8- «- ». , 20- (, , ).
42. IBMQ Network , 2017 — JP Morgan Chase , Daimler , Samsung , Honda , Oak Ridge National Lab , — , 2018 — Zapata Computing , Strangeworks , QxBranch , Quantum Benchmark , QC Ware , Q-CTRL , Cambridge Quantum Computing (CQC) , 1QBit . North Carolina State University , IBM Q Hub, University of Oxford University of Melbourne . https://www.research.ibm.com/ibmq/network/ .
43. , - - . QISKit, ACQUA , pyQuil.
44. pyQuil : , $$$\textsf{from pyquil.gates import H, MEASURE}$ . $$$\textsf{pyquil.gates}$ , , , .
45. , () . , () , , .
46. IBM, 31 2018 , « » Python Cython, .

A.

, . Players Quantum Computing Report [22]. , , . / — .

أ. Strawberry Fields

Xanadu , , Strawberry Fields Python , [38]. Xanadu «qumodes» ( ), , , . Strawberry Fields Numpy TensorFlow, Blackbird. GitHub, , , , . , Xanadu https://www.xanadu.ai/ , .

ب. IonQ

IonQ — -, College Park , . IonQ , . $$$^{171}$ Yb , IonQ T2 () 15- , T2 1 . , T1 ( ) 20 000 , $$$10^{-4}$ . , -- - , «» . , .

IonQ , IonQ . . , - [39].

ج. D-Wave Systems

D-Wave [40], , . D-Wave, 1999 , , , ,

$$ $$\begin{equation*} H = \sum_{i} h_i \sigma_i^x + \sum_{i, j} J_{ij} \sigma_i^z \sigma_j^z . \end{equation*}$$

D-Wave , — 2048 , Matlab, C/C++ Python . /, D-Wave . D-Wave .

B.

ProjectQ C++. Dell XPS 13 Developer Edition 64- Ubuntu 16.04 LTS 8 Intel Core i7-8550U 1,80 .

 # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from projectq import MainEngine import projectq.ops as ops from projectq.backends import Simulator import sys import time # ------------------------------------------------------------------------------ # number of qubits and depth # ------------------------------------------------------------------------------ if len(sys.argv) > 1: n = int(sys.argv[1]) else: n = 16 if len(sys.argv) > 1: depth = int(sys.argv[2]) else: depth = 10 # ------------------------------------------------------------------------------ # engine and qubit register # ------------------------------------------------------------------------------ eng = MainEngine(backend=Simulator(gate_fusion=True), engine_list=[]) qbits = eng.allocate_qureg(n) # ------------------------------------------------------------------------------ # circuit # ------------------------------------------------------------------------------ # timing -- get the start time start = time.time() # random circuit for level in range(depth): for q in qbits: ops.H | q ops.SqrtX | q if q != qbits[0]: ops.CNOT | (q, qbits[0]) # measure for q in qbits: ops.Measure | q # flush the engine eng.flush() # timing -- get the end time runtime = time.time() - start # print out the runtime print(n, depth, runtime) 

, , 7. , QISKit — .

C. :

. , QDK , , . — , — — . . , , , — , .

, , . , QISKit.

pyQuil

 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # ============================================================================== # teleport.py # # Teleportation circuit in pyQuil. # ============================================================================== # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from pyquil.quil import Program from pyquil import api import pyquil.gates as gate # ------------------------------------------------------------------------------ # program and simulator # ------------------------------------------------------------------------------ qprog = Program() qvm = api.QVMConnection() # ------------------------------------------------------------------------------ # teleportation circuit # ------------------------------------------------------------------------------ # teleport |1> to qubit three qprog += gates.X(0) # main circuit qprog += [gates.H(1), gates.CNOT(1, 2), gates.CNOT(0, 1), gates.H(0), gates.MEASURE(0, 0), gates.MEASURE(1, 1)] # conditional operations qprog.if_then(0, gates.Z(2)) qprog.if_then(1, gates.X(2)) # measure qubit three qprog.measure(2, 2) # ------------------------------------------------------------------------------ # run the circuit and print the results # ------------------------------------------------------------------------------ print(qvm.run(qprog)) # optionally print the quil code print(qprog) 

QISKit

 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # ============================================================================== # teleport.py # # Teleportation circuit in QISKit. # ============================================================================== # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute # ------------------------------------------------------------------------------ # registers and quantum circuit # ------------------------------------------------------------------------------ qreg = QuantumRegister(3) creg = ClassicalRegister(3) qcircuit = QuantumCircuit(qreg, creg) # ------------------------------------------------------------------------------ # do the circuit # ------------------------------------------------------------------------------ # teleport |1> to qubit three qcircuit.x(qreg[0]) # main circuit qcircuit.h(qreg[0]) qcircuit.cx(qreg[1], qreg[2]) qcircuit.cx(qreg[0], qreg[1]) qcircuit.h(qreg[0]) qcircuit.measure(qreg[0], creg[0]) qcircuit.measure(qreg[1], creg[1]) # conditional operations qcircuit.z(qreg[2]).c_if(creg[0][0], 1) qcircuit.x(qreg[2]).c_if(creg[1][0], 1) # measure qubit three qcircuit.measure(qreg[2], creg[2]) # ------------------------------------------------------------------------------ # run the circuit and print the results # ------------------------------------------------------------------------------ result = execute(qcircuit, 'local_qasm_simulator').result() counts = result.get_counts() print(counts) # optionally print the qasm code print(qcircuit.qasm()) # optionally draw the circuit from qiskit.tools.visualization import circuit_drawer circuit_drawer(qcircuit) 

ProjectQ

 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # ============================================================================== # teleport.py # # Teleportation circuit in ProjectQ. # ============================================================================== # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from projectq import MainEngine from projectq.meta import Control import projectq.ops as ops # ------------------------------------------------------------------------------ # engine and qubit register # ------------------------------------------------------------------------------ # engine eng = MainEngine() # allocate qubit register qbits = eng.allocate_qureg(3) # ------------------------------------------------------------------------------ # teleportation circuit # ------------------------------------------------------------------------------ # teleport |1> to qubit three ops.X | qbits[0] # main circuit ops.H | qbits[1] ops.CNOT | (qbits[1], qbits[2]) ops.CNOT | (qbits[0], qbits[1]) ops.H | qbits[0] ops.Measure | (qbits[0], qbits[1]) # conditional operations with Control(eng, qbits[1]): ops.X | qbits[2] with Control(eng, qbits[1]): ops.Z | qbits[2] # measure qubit three ops.Measure | qbits[2] # ------------------------------------------------------------------------------ # run the circuit and print the results # ------------------------------------------------------------------------------ eng.flush() print("Measured:", int(qbits[2])) 

Quantum Developer Kit

 // ============================================================================= // teleport.qs // // Teleportation circuit in QDK. // ============================================================================= operation Teleport(msg : Qubit, there : Qubit) : () { body { using (register = Qubit[1]) { // get auxiliary qubit to prepare for teleportation let here = register[0]; // main circuit H(here); CNOT(here, there); CNOT(msg, here); H(msg); // conditional operations if (M(msg) == One) { Z(there); } if (M(here) == One) { X(there); } // reset the "here" qubit Reset(here); } } } operation TeleportClassicalMessage(message : Bool) : Bool { body { mutable measurement = false; using (register = Qubit[2]) { // two qubits let msg = register[0]; let there = register[1]; // encode message to send if (message) { X(msg); } // do the teleportation Teleport(msg, there); // check what message was sent if (M(there) == One) { set measurement = true; } // reset all qubits ResetAll(register); } return measurement; } }