From 1397abbf19aa99ca3a5727fed43d43f48f0e4a9e Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Sun, 2 Jun 2024 14:48:04 +0530 Subject: [PATCH 1/9] Create hw_aware_synthesis --- community/basic_examples/hw_aware_synthesis | 1 + 1 file changed, 1 insertion(+) create mode 100644 community/basic_examples/hw_aware_synthesis diff --git a/community/basic_examples/hw_aware_synthesis b/community/basic_examples/hw_aware_synthesis new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis @@ -0,0 +1 @@ + From bea4d83d4a0e64f88f089bedeac8c456ad8a5226 Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Sun, 2 Jun 2024 14:59:27 +0530 Subject: [PATCH 2/9] Delete community/basic_examples/hw_aware_synthesis --- community/basic_examples/hw_aware_synthesis | 1 - 1 file changed, 1 deletion(-) delete mode 100644 community/basic_examples/hw_aware_synthesis diff --git a/community/basic_examples/hw_aware_synthesis b/community/basic_examples/hw_aware_synthesis deleted file mode 100644 index 8b137891..00000000 --- a/community/basic_examples/hw_aware_synthesis +++ /dev/null @@ -1 +0,0 @@ - From bcb4eaa7cffd538cbaad0b8f33f99126e1c30b6c Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Sun, 2 Jun 2024 15:18:14 +0530 Subject: [PATCH 3/9] Add files via upload --- .../basic_examples/hw_aware_synthesis.ipynb | 601 ++++++++++++++++++ 1 file changed, 601 insertions(+) create mode 100644 community/basic_examples/hw_aware_synthesis.ipynb diff --git a/community/basic_examples/hw_aware_synthesis.ipynb b/community/basic_examples/hw_aware_synthesis.ipynb new file mode 100644 index 00000000..35b6543a --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis.ipynb @@ -0,0 +1,601 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "S5a8KVmhRyCm" + }, + "source": [ + "# HW-aware Synthesis of MCX\n", + "\n", + "This tutorial consists of two parts,\n", + "1. How to create a 10-CONTROL MCX gate with Classiq\n", + "2. Classiq's Hardware-Aware Synthesis capability\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AE1ksqSMC_MY" + }, + "source": [ + "## 1. How to create a 10-CONTROL MCX gate with Classiq" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Before diving into the tutorial, let us first install and authenticate classiq(connecting your notebook to classiq platform)" + ], + "metadata": { + "id": "mGbBn5_6D25t" + } + }, + { + "cell_type": "code", + "source": [ + "! pip install classiq" + ], + "metadata": { + "id": "-Rmw4wH2D9XF" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#Restart your runtime if you have any error here\n", + "import classiq\n", + "classiq.authenticate()" + ], + "metadata": { + "id": "3C--UrljEAJP" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CiCAjWxbC_Ma" + }, + "source": [ + "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called my_mcx, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "N55CY8rJo6nu" + }, + "outputs": [], + "source": [ + "#importing all the necessary libraries from classiq\n", + "\n", + "from math import pi\n", + "from classiq import (\n", + " Constraints,\n", + " CustomHardwareSettings,\n", + " OptimizationParameter,\n", + " Output,\n", + " Preferences,\n", + " QArray,\n", + " QBit,\n", + " QuantumProgram,\n", + " X,\n", + " allocate,\n", + " control,\n", + " create_model,\n", + " qfunc,\n", + " set_constraints,\n", + " set_preferences,\n", + " show,\n", + " synthesize,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8jxKs0RkpLqf" + }, + "outputs": [], + "source": [ + "# define MCX quantum function\n", + "@qfunc\n", + "def my_mcx(cntrl: QArray[QBit], target: QBit) -> None:\n", + " control(cntrl, lambda: X(target))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DxI88JO1C_Mh" + }, + "source": [ + "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our my_mcx function with 10 qubits allocated to the control argument." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NIxnhfOgpSSI" + }, + "outputs": [], + "source": [ + "# define the MCX parameters within the quantum 'main' function\n", + "@qfunc\n", + "def main(cntrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(10, cntrl)\n", + " allocate(1, target)\n", + " my_mcx(cntrl, target)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Iu8uortFC_Mi" + }, + "source": [ + "To build our model we will use the `create_model` function:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "iHVgE7SCpZBL" + }, + "outputs": [], + "source": [ + "# build a model\n", + "model = create_model(main)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CTi8GIBrC_Mk" + }, + "source": [ + "To constrain a circuit to only 20 qubits and optimize for circuit depth, we pass the max width and optimization parameter to a `Constraints` object and update our model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zbzL6MksC_Ml" + }, + "outputs": [], + "source": [ + "from classiq import write_qmod\n", + "\n", + "constraints = Constraints(\n", + " max_width=20, optimization_parameter=OptimizationParameter.DEPTH\n", + ")\n", + "model = set_constraints(model, constraints)\n", + "\n", + "write_qmod(model, \"mcx_14_ctrl_depth\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bpBmDJcBC_Mm" + }, + "source": [ + "We can now synthesize our model, create a quantum program and view it:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OebNdwj-C_Mn", + "outputId": "7b44a787-fd22-4392-e76a-804a6de89870" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/fd469125-c5d1-42e8-9d04-9cdba8b62f25?version=0.41.2\n" + ] + } + ], + "source": [ + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HDdeZAmNC_Mo" + }, + "source": [ + "Additionally, To get the transpiled circuit from our qprog object and print its depth:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4Ykj96NcC_Mp", + "outputId": "938cd55b-895f-47f5-ffab-99d29be7b4e0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized MCX depth is 52\n" + ] + } + ], + "source": [ + "circuit = QuantumProgram.from_qprog(qprog)\n", + "print(f\"Synthesized MCX depth is {circuit.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rF_sE_vHC_Mq" + }, + "source": [ + "# 2. Classiq's Hardware-Aware Synthesis capability" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "74aCfp3IC_Mq" + }, + "source": [ + "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. IN this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n", + "\n", + "The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.\n", + "\n", + "The two fictitious hardware created are using two different simulators: Classiq's Simulator and IonQ's Simulator. We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# define MCX quantum function\n", + "@qfunc\n", + "def my_mcx(cntrl: QArray[QBit], target: QBit) -> None:\n", + " control(cntrl, lambda: X(target))" + ], + "metadata": { + "id": "kDz3GbcKEwwB" + }, + "execution_count": 36, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# define the MCX parameters within the quantum 'main' function\n", + "@qfunc\n", + "def main(cntrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(12, cntrl)\n", + " allocate(1, target)\n", + " my_mcx(cntrl, target)" + ], + "metadata": { + "id": "yOzokSMZEw78" + }, + "execution_count": 37, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# build a model\n", + "model = create_model(main)" + ], + "metadata": { + "id": "5bGo7UFBEw_V" + }, + "execution_count": 38, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "id": "NlxS3xSTC_Mr" + }, + "outputs": [], + "source": [ + "# define the hardware parameters\n", + "max_width = 18\n", + "\n", + "#Grid Connectivity\n", + "grid_connectivity = [\n", + " [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], # Row 1\n", + " [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], # Row 2\n", + " [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], # Row 3\n", + " [0, 6], [6, 12], # Column 1\n", + " [1, 7], [7, 13], # Column 2\n", + " [2, 8], [8, 14], # Column 3\n", + " [3, 9], [9, 15], # Column 4\n", + " [4, 10], [10, 16], # Column 5\n", + " [5, 11], [11, 17] # Column 6\n", + "]\n", + "\n", + "#Star Connectivity\n", + "star_connectivity = [[0, i] for i in range(1, max_width-1)]" + ] + }, + { + "cell_type": "code", + "source": [ + "#Grid Preferences - Device:Classiq, backend:Simulator\n", + "preferences_grid = Preferences(\n", + " custom_hardware_settings=CustomHardwareSettings(\n", + " basis_gates=[\"cx\", \"u\"],\n", + " connectivity_map=grid_connectivity,\n", + " ),\n", + " backend_service_provider=\"Classiq\", #Feel free to change this to any provider classiq supports (IBM Quantum. Amazon Bracket, INOQ, etc)\n", + " backend_name=\"simulator\", #Change this according to backend_service_provider\n", + " random_seed=-1,\n", + ")\n", + "\n", + "\n", + "#Star Preferences - Device:IonQ, backend:Simulator\n", + "preferences_star = Preferences(\n", + " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"],\n", + " connectivity_map=star_connectivity,),\n", + " backend_service_provider=\"IonQ\", #Feel free to change this to any provider classiq supports (IBM Quantum. Amazon Bracket, INOQ, etc)\n", + " backend_name=\"simulator\", #Change this according to backend_service_provider\n", + " random_seed=-1,\n", + ")" + ], + "metadata": { + "id": "1ogjh7qTGJd3" + }, + "execution_count": 40, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "id": "_3KIstIjC_Ms" + }, + "outputs": [], + "source": [ + "# define synthesis engine constraints\n", + "constraints = Constraints(optimization_parameter=\"cx\", max_width=max_width)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "id": "wviSbVIqsavi" + }, + "outputs": [], + "source": [ + "# define models with different preferences\n", + "model = set_constraints(model, constraints)\n", + "model_grid = set_preferences(model, preferences_grid)\n", + "model_star = set_preferences(model, preferences_star)\n", + "\n", + "\n", + "# write models to files\n", + "write_qmod(model_grid, \"hardware_aware_mcx_grid\")\n", + "write_qmod(model_star, \"hardware_aware_mcx_star\")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hWP-uuNmsf5g", + "outputId": "c9be259f-0ef0-43c9-d664-fcabae22a141" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/305a7290-64c8-47e4-af71-5a80aa306056?version=0.41.2\n" + ] + } + ], + "source": [ + "qprog_grid= synthesize(model_grid)\n", + "show(qprog_grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7-1tx3a3squr", + "outputId": "44587537-314b-4002-99b1-603b8d2ee0d0" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized MCX cx-count for grid connectivity is 66\n", + "Opening: https://platform.classiq.io/circuit/305a7290-64c8-47e4-af71-5a80aa306056?version=0.41.2\n" + ] + } + ], + "source": [ + "circuit_grid = QuantumProgram.from_qprog(qprog_grid)\n", + "\n", + "print(f\"Synthesized MCX cx-count for grid connectivity is {circuit_grid.transpiled_circuit.count_ops['cx']}\")\n", + "circuit_grid.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cYcpNdbos3is", + "outputId": "1a56c67c-8b47-4a84-cc81-506a5e8267f4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/3d0aa65f-1ab3-43cb-b0bc-5abc15636b3e?version=0.41.2\n" + ] + } + ], + "source": [ + "qprog_star = synthesize(model_star)\n", + "show(qprog_star)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FySbcicutSXk", + "outputId": "15100171-b019-4255-e581-033cfd84aab2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized MCX cx-count for star connectivity is 60\n", + "Opening: https://platform.classiq.io/circuit/3d0aa65f-1ab3-43cb-b0bc-5abc15636b3e?version=0.41.2\n" + ] + } + ], + "source": [ + "circuit_star = QuantumProgram.from_qprog(qprog_star)\n", + "\n", + "print(f\"Synthesized MCX cx-count for star connectivity is {circuit_star.transpiled_circuit.count_ops['cx']}\")\n", + "circuit_star.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4p-TBa9ztebZ", + "outputId": "6c905e75-1b2f-44ce-a140-22be2d09b1a8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized Depth for grid connectivity is 54\n" + ] + } + ], + "source": [ + "print(f\"Synthesized Depth for grid connectivity is {circuit_grid.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EVxTVGqf1HIS", + "outputId": "377e210b-263f-4c8d-c173-129fa91c822f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized Depth for star connectivity is 63\n" + ] + } + ], + "source": [ + "print(f\"Synthesized Depth for star connectivity is {circuit_star.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "markdown", + "source": [ + "**Conclusion:** Given the connectivity of the hardware and its preferences (device, backend) the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n", + "\n", + "With `Star Connectivity` and `Classiq's Simulator` the minimum number of cx gates required after transpiling the circuit is 66 and depth of the circuit turned out to be 63.\n", + "\n", + "Whereas with `Grid Connectivity` and `IonQ's Simulator` the minimum number of cx gates required after transpiling the circuit is just 60 and depth of the circuit is 54.\n", + "\n", + "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a mcx circuit.\n", + "\n" + ], + "metadata": { + "id": "b043xgbpHGEO" + } + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 1a98bfda2ed8700df7d6b8b69367f097eb47b521 Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Wed, 5 Jun 2024 15:45:59 +0530 Subject: [PATCH 4/9] Fixed the changes --- .../basic_examples/hw_aware_synthesis.ipynb | 184 +++++++----------- 1 file changed, 72 insertions(+), 112 deletions(-) diff --git a/community/basic_examples/hw_aware_synthesis.ipynb b/community/basic_examples/hw_aware_synthesis.ipynb index 35b6543a..e9465c24 100644 --- a/community/basic_examples/hw_aware_synthesis.ipynb +++ b/community/basic_examples/hw_aware_synthesis.ipynb @@ -29,46 +29,13 @@ "## 1. How to create a 10-CONTROL MCX gate with Classiq" ] }, - { - "cell_type": "markdown", - "source": [ - "Before diving into the tutorial, let us first install and authenticate classiq(connecting your notebook to classiq platform)" - ], - "metadata": { - "id": "mGbBn5_6D25t" - } - }, - { - "cell_type": "code", - "source": [ - "! pip install classiq" - ], - "metadata": { - "id": "-Rmw4wH2D9XF" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "#Restart your runtime if you have any error here\n", - "import classiq\n", - "classiq.authenticate()" - ], - "metadata": { - "id": "3C--UrljEAJP" - }, - "execution_count": null, - "outputs": [] - }, { "cell_type": "markdown", "metadata": { "id": "CiCAjWxbC_Ma" }, "source": [ - "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called my_mcx, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target." + "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called `my_mcx`, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target." ] }, { @@ -82,25 +49,7 @@ "#importing all the necessary libraries from classiq\n", "\n", "from math import pi\n", - "from classiq import (\n", - " Constraints,\n", - " CustomHardwareSettings,\n", - " OptimizationParameter,\n", - " Output,\n", - " Preferences,\n", - " QArray,\n", - " QBit,\n", - " QuantumProgram,\n", - " X,\n", - " allocate,\n", - " control,\n", - " create_model,\n", - " qfunc,\n", - " set_constraints,\n", - " set_preferences,\n", - " show,\n", - " synthesize,\n", - ")" + "from classiq import *" ] }, { @@ -113,8 +62,8 @@ "source": [ "# define MCX quantum function\n", "@qfunc\n", - "def my_mcx(cntrl: QArray[QBit], target: QBit) -> None:\n", - " control(cntrl, lambda: X(target))" + "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", + " control(ctrl, lambda: X(target))" ] }, { @@ -123,7 +72,7 @@ "id": "DxI88JO1C_Mh" }, "source": [ - "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our my_mcx function with 10 qubits allocated to the control argument." + "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our `my_mcx` function with 10 qubits allocated to the control argument." ] }, { @@ -136,10 +85,10 @@ "source": [ "# define the MCX parameters within the quantum 'main' function\n", "@qfunc\n", - "def main(cntrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", - " allocate(10, cntrl)\n", + "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(10, ctrl)\n", " allocate(1, target)\n", - " my_mcx(cntrl, target)" + " my_mcx(ctrl, target)" ] }, { @@ -187,7 +136,7 @@ ")\n", "model = set_constraints(model, constraints)\n", "\n", - "write_qmod(model, \"mcx_14_ctrl_depth\")" + "write_qmod(model, \"mcx_10_ctrl_depth\")" ] }, { @@ -211,8 +160,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Opening: https://platform.classiq.io/circuit/fd469125-c5d1-42e8-9d04-9cdba8b62f25?version=0.41.2\n" ] @@ -244,8 +193,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Synthesized MCX depth is 52\n" ] @@ -271,54 +220,54 @@ "id": "74aCfp3IC_Mq" }, "source": [ - "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. IN this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n", + "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. In this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n", "\n", "The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.\n", "\n", - "The two fictitious hardware created are using two different simulators: Classiq's Simulator and IonQ's Simulator. We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n" + "We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n" ] }, { "cell_type": "code", - "source": [ - "# define MCX quantum function\n", - "@qfunc\n", - "def my_mcx(cntrl: QArray[QBit], target: QBit) -> None:\n", - " control(cntrl, lambda: X(target))" - ], + "execution_count": 36, "metadata": { "id": "kDz3GbcKEwwB" }, - "execution_count": 36, - "outputs": [] + "outputs": [], + "source": [ + "# define MCX quantum function\n", + "@qfunc\n", + "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", + " control(ctrl, lambda: X(target))" + ] }, { "cell_type": "code", + "execution_count": 37, + "metadata": { + "id": "yOzokSMZEw78" + }, + "outputs": [], "source": [ "# define the MCX parameters within the quantum 'main' function\n", "@qfunc\n", - "def main(cntrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", - " allocate(12, cntrl)\n", + "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(12, ctrl)\n", " allocate(1, target)\n", - " my_mcx(cntrl, target)" - ], - "metadata": { - "id": "yOzokSMZEw78" - }, - "execution_count": 37, - "outputs": [] + " my_mcx(ctrl, target)" + ] }, { "cell_type": "code", - "source": [ - "# build a model\n", - "model = create_model(main)" - ], + "execution_count": 38, "metadata": { "id": "5bGo7UFBEw_V" }, - "execution_count": 38, - "outputs": [] + "outputs": [], + "source": [ + "# build a model\n", + "model = create_model(main)" + ] }, { "cell_type": "code", @@ -350,6 +299,21 @@ }, { "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f'Grid Connectivity is ', grid_connectivity)\n", + "print(f'Star Connectivity is ', star_connectivity )" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "id": "1ogjh7qTGJd3" + }, + "outputs": [], "source": [ "#Grid Preferences - Device:Classiq, backend:Simulator\n", "preferences_grid = Preferences(\n", @@ -357,8 +321,6 @@ " basis_gates=[\"cx\", \"u\"],\n", " connectivity_map=grid_connectivity,\n", " ),\n", - " backend_service_provider=\"Classiq\", #Feel free to change this to any provider classiq supports (IBM Quantum. Amazon Bracket, INOQ, etc)\n", - " backend_name=\"simulator\", #Change this according to backend_service_provider\n", " random_seed=-1,\n", ")\n", "\n", @@ -367,16 +329,9 @@ "preferences_star = Preferences(\n", " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"],\n", " connectivity_map=star_connectivity,),\n", - " backend_service_provider=\"IonQ\", #Feel free to change this to any provider classiq supports (IBM Quantum. Amazon Bracket, INOQ, etc)\n", - " backend_name=\"simulator\", #Change this according to backend_service_provider\n", " random_seed=-1,\n", ")" - ], - "metadata": { - "id": "1ogjh7qTGJd3" - }, - "execution_count": 40, - "outputs": [] + ] }, { "cell_type": "code", @@ -421,8 +376,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Opening: https://platform.classiq.io/circuit/305a7290-64c8-47e4-af71-5a80aa306056?version=0.41.2\n" ] @@ -445,8 +400,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Synthesized MCX cx-count for grid connectivity is 66\n", "Opening: https://platform.classiq.io/circuit/305a7290-64c8-47e4-af71-5a80aa306056?version=0.41.2\n" @@ -472,8 +427,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Opening: https://platform.classiq.io/circuit/3d0aa65f-1ab3-43cb-b0bc-5abc15636b3e?version=0.41.2\n" ] @@ -496,8 +451,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Synthesized MCX cx-count for star connectivity is 60\n", "Opening: https://platform.classiq.io/circuit/3d0aa65f-1ab3-43cb-b0bc-5abc15636b3e?version=0.41.2\n" @@ -523,8 +478,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Synthesized Depth for grid connectivity is 54\n" ] @@ -546,8 +501,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Synthesized Depth for star connectivity is 63\n" ] @@ -559,19 +514,24 @@ }, { "cell_type": "markdown", + "metadata": { + "id": "b043xgbpHGEO" + }, "source": [ - "**Conclusion:** Given the connectivity of the hardware and its preferences (device, backend) the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n", + "**Conclusion:** Given the connectivity of the hardware and its preferences the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n", "\n", - "With `Star Connectivity` and `Classiq's Simulator` the minimum number of cx gates required after transpiling the circuit is 66 and depth of the circuit turned out to be 63.\n", + "With `Star Connectivity` the minimum number of cx gates required after transpiling the circuit is 66 and depth of the circuit turned out to be 63.\n", "\n", - "Whereas with `Grid Connectivity` and `IonQ's Simulator` the minimum number of cx gates required after transpiling the circuit is just 60 and depth of the circuit is 54.\n", + "Whereas with `Grid Connectivity` the minimum number of cx gates required after transpiling the circuit is just 60 and depth of the circuit is 54.\n", "\n", - "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a mcx circuit.\n", + "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a MCX circuit.\n", "\n" - ], - "metadata": { - "id": "b043xgbpHGEO" - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { @@ -598,4 +558,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} From 59585fd0bf688ef50f737c2f00b0f314ae38f0b9 Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Wed, 5 Jun 2024 15:53:38 +0530 Subject: [PATCH 5/9] Update hw_aware_synthesis.ipynb From 7813d791ba956195ce67a5afb8d524bd4340fe85 Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Wed, 5 Jun 2024 21:11:54 +0530 Subject: [PATCH 6/9] With connectivity plots --- .../basic_examples/hw_aware_synthesis.ipynb | 52 +++++++++++++++++-- 1 file changed, 48 insertions(+), 4 deletions(-) diff --git a/community/basic_examples/hw_aware_synthesis.ipynb b/community/basic_examples/hw_aware_synthesis.ipynb index e9465c24..2d343340 100644 --- a/community/basic_examples/hw_aware_synthesis.ipynb +++ b/community/basic_examples/hw_aware_synthesis.ipynb @@ -303,8 +303,52 @@ "metadata": {}, "outputs": [], "source": [ - "print(f'Grid Connectivity is ', grid_connectivity)\n", - "print(f'Star Connectivity is ', star_connectivity )" + "#Plotting Grid Connectivity\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "\n", + "G = nx.Graph()\n", + "G.add_edges_from(grid_connectivity)\n", + "\n", + "# Define the positions of the nodes in a 3x6 grid\n", + "pos = {}\n", + "for i in range(3):\n", + " for j in range(6):\n", + " pos[i * 6 + j] = (j, -i) # (x, y) coordinates\n", + "\n", + "# Plot the graph\n", + "plt.figure(figsize=(10, 6))\n", + "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", + "plt.title(\"3x6 Grid Connectivity Map\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#plotting Star Connectivity\n", + "import numpy as np\n", + "\n", + "G = nx.Graph()\n", + "G.add_edges_from(star_connectivity)\n", + "\n", + "# Define the positions of the nodes in a star configuration\n", + "pos = {}\n", + "pos[0] = (0, 0) # Central node\n", + "angle_step = 360 / (len(star_connectivity))\n", + "for i in range(1, 18):\n", + " angle = angle_step * (i - 1)\n", + " radians = np.deg2rad(angle)\n", + " pos[i] = (np.cos(radians), np.sin(radians))\n", + "\n", + "# Plot the graph\n", + "plt.figure(figsize=(10, 10))\n", + "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", + "plt.title(\"Star Connectivity Map\")\n", + "plt.show()" ] }, { @@ -315,7 +359,7 @@ }, "outputs": [], "source": [ - "#Grid Preferences - Device:Classiq, backend:Simulator\n", + "#Grid Preferences \n", "preferences_grid = Preferences(\n", " custom_hardware_settings=CustomHardwareSettings(\n", " basis_gates=[\"cx\", \"u\"],\n", @@ -325,7 +369,7 @@ ")\n", "\n", "\n", - "#Star Preferences - Device:IonQ, backend:Simulator\n", + "#Star Preferences \n", "preferences_star = Preferences(\n", " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"],\n", " connectivity_map=star_connectivity,),\n", From 28bded7fd5fdb2fe7d19ab3d0d69efc88ef5b856 Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Thu, 6 Jun 2024 14:27:40 +0530 Subject: [PATCH 7/9] Create hw_aware_synthesis.ipynb with plotted graphs --- .../hw_aware_synthesis.ipynb | 645 ++++++++++++++++++ 1 file changed, 645 insertions(+) create mode 100644 community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb diff --git a/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb b/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb new file mode 100644 index 00000000..7618195a --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis/hw_aware_synthesis.ipynb @@ -0,0 +1,645 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "S5a8KVmhRyCm" + }, + "source": [ + "# HW-aware Synthesis of MCX\n", + "\n", + "This tutorial consists of two parts,\n", + "1. How to create a 10-CONTROL MCX gate with Classiq\n", + "2. Classiq's Hardware-Aware Synthesis capability\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AE1ksqSMC_MY" + }, + "source": [ + "## 1. How to create a 10-CONTROL MCX gate with Classiq" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CiCAjWxbC_Ma" + }, + "source": [ + "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called `my_mcx`, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "N55CY8rJo6nu" + }, + "outputs": [], + "source": [ + "#importing all the necessary libraries from classiq\n", + "\n", + "from math import pi\n", + "from classiq import *" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "8jxKs0RkpLqf" + }, + "outputs": [], + "source": [ + "# define MCX quantum function\n", + "@qfunc\n", + "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", + " control(ctrl, lambda: X(target))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DxI88JO1C_Mh" + }, + "source": [ + "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our `my_mcx` function with 10 qubits allocated to the control argument." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "NIxnhfOgpSSI" + }, + "outputs": [], + "source": [ + "# define the MCX parameters within the quantum 'main' function\n", + "@qfunc\n", + "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(10, ctrl)\n", + " allocate(1, target)\n", + " my_mcx(ctrl, target)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Iu8uortFC_Mi" + }, + "source": [ + "To build our model we will use the `create_model` function:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "iHVgE7SCpZBL" + }, + "outputs": [], + "source": [ + "# build a model\n", + "model = create_model(main)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CTi8GIBrC_Mk" + }, + "source": [ + "To constrain a circuit to only 20 qubits and optimize for circuit depth, we pass the max width and optimization parameter to a `Constraints` object and update our model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "zbzL6MksC_Ml" + }, + "outputs": [], + "source": [ + "from classiq import write_qmod\n", + "\n", + "constraints = Constraints(\n", + " max_width=20, optimization_parameter=OptimizationParameter.DEPTH\n", + ")\n", + "model = set_constraints(model, constraints)\n", + "\n", + "write_qmod(model, \"mcx_10_ctrl_depth\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bpBmDJcBC_Mm" + }, + "source": [ + "We can now synthesize our model, create a quantum program and view it:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OebNdwj-C_Mn", + "outputId": "d6b32f26-36b9-42a8-f8d0-629dbcd5598d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/c51e64f0-fc0a-43a8-b484-2ddf7366c956?version=0.42.0\n" + ] + } + ], + "source": [ + "qprog = synthesize(model)\n", + "show(qprog)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HDdeZAmNC_Mo" + }, + "source": [ + "Additionally, To get the transpiled circuit from our qprog object and print its depth:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4Ykj96NcC_Mp", + "outputId": "759f30d6-34e5-4e17-9e68-ec112c1ef074" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized MCX depth is 52\n" + ] + } + ], + "source": [ + "circuit = QuantumProgram.from_qprog(qprog)\n", + "print(f\"Synthesized MCX depth is {circuit.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rF_sE_vHC_Mq" + }, + "source": [ + "# 2. Classiq's Hardware-Aware Synthesis capability" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "74aCfp3IC_Mq" + }, + "source": [ + "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. In this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n", + "\n", + "The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.\n", + "\n", + "The two fictitious hardware created are using two different simulators: Classiq's Simulator and IonQ's Simulator. We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# define MCX quantum function\n", + "@qfunc\n", + "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", + " control(ctrl, lambda: X(target))" + ], + "metadata": { + "id": "kDz3GbcKEwwB" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# define the MCX parameters within the quantum 'main' function\n", + "@qfunc\n", + "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", + " allocate(12, ctrl)\n", + " allocate(1, target)\n", + " my_mcx(ctrl, target)" + ], + "metadata": { + "id": "yOzokSMZEw78" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# build a model\n", + "model = create_model(main)" + ], + "metadata": { + "id": "5bGo7UFBEw_V" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "NlxS3xSTC_Mr" + }, + "outputs": [], + "source": [ + "# define the hardware parameters\n", + "max_width = 18\n", + "\n", + "#Grid Connectivity\n", + "grid_connectivity = [\n", + " [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], # Row 1\n", + " [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], # Row 2\n", + " [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], # Row 3\n", + " [0, 6], [6, 12], # Column 1\n", + " [1, 7], [7, 13], # Column 2\n", + " [2, 8], [8, 14], # Column 3\n", + " [3, 9], [9, 15], # Column 4\n", + " [4, 10], [10, 16], # Column 5\n", + " [5, 11], [11, 17] # Column 6\n", + "]\n", + "\n", + "#Star Connectivity\n", + "star_connectivity = [[0, i] for i in range(1, max_width-1)]" + ] + }, + { + "cell_type": "code", + "source": [ + "#Plotting Grid Connectivity\n", + "import matplotlib.pyplot as plt\n", + "import networkx as nx\n", + "\n", + "G = nx.Graph()\n", + "G.add_edges_from(grid_connectivity)\n", + "\n", + "# Define the positions of the nodes in a 3x6 grid\n", + "pos = {}\n", + "for i in range(3):\n", + " for j in range(6):\n", + " pos[i * 6 + j] = (j, -i) # (x, y) coordinates\n", + "\n", + "# Plot the graph\n", + "plt.figure(figsize=(10, 6))\n", + "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", + "plt.title(\"3x6 Grid Connectivity Map\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 659 + }, + "id": "qVDIz-txBcRS", + "outputId": "62566d81-b841-4eb0-e4fa-046f1a6151bd" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#plotting Star Connectivity\n", + "import numpy as np\n", + "\n", + "G = nx.Graph()\n", + "G.add_edges_from(star_connectivity)\n", + "\n", + "# Define the positions of the nodes in a star configuration\n", + "pos = {}\n", + "pos[0] = (0, 0) # Central node\n", + "angle_step = 360 / (len(star_connectivity))\n", + "for i in range(1, 18):\n", + " angle = angle_step * (i - 1)\n", + " radians = np.deg2rad(angle)\n", + " pos[i] = (np.cos(radians), np.sin(radians))\n", + "\n", + "# Plot the graph\n", + "plt.figure(figsize=(10, 10))\n", + "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", + "plt.title(\"Star Connectivity Map\")\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "0AEHYvxACpS7", + "outputId": "62c17d67-b8f0-403c-96ba-41bcc319619f" + }, + "execution_count": 15, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#Grid Preferences\n", + "preferences_grid = Preferences(\n", + " custom_hardware_settings=CustomHardwareSettings(\n", + " basis_gates=[\"cx\", \"u\"],\n", + " connectivity_map=grid_connectivity,\n", + " ),\n", + " random_seed=-1,\n", + ")\n", + "\n", + "\n", + "#Star Preferences\n", + "preferences_star = Preferences(\n", + " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"],\n", + " connectivity_map=star_connectivity,),\n", + " random_seed=-1,\n", + ")" + ], + "metadata": { + "id": "1ogjh7qTGJd3" + }, + "execution_count": 16, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "_3KIstIjC_Ms" + }, + "outputs": [], + "source": [ + "# define synthesis engine constraints\n", + "constraints = Constraints(optimization_parameter=\"cx\", max_width=max_width)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "wviSbVIqsavi" + }, + "outputs": [], + "source": [ + "# define models with different preferences\n", + "model = set_constraints(model, constraints)\n", + "model_grid = set_preferences(model, preferences_grid)\n", + "model_star = set_preferences(model, preferences_star)\n", + "\n", + "\n", + "# write models to files\n", + "write_qmod(model_grid, \"hardware_aware_mcx_grid\")\n", + "write_qmod(model_star, \"hardware_aware_mcx_star\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hWP-uuNmsf5g", + "outputId": "762decbc-3005-4419-bb7e-6e14571db2a3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/4e728c67-0064-4699-87cd-e689b15937e7?version=0.42.0\n" + ] + } + ], + "source": [ + "qprog_grid= synthesize(model_grid)\n", + "show(qprog_grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7-1tx3a3squr", + "outputId": "65034a5d-dd40-42e4-b045-88e2a9401c37" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized MCX cx-count for grid connectivity is 117\n", + "Opening: https://platform.classiq.io/circuit/4e728c67-0064-4699-87cd-e689b15937e7?version=0.42.0\n" + ] + } + ], + "source": [ + "circuit_grid = QuantumProgram.from_qprog(qprog_grid)\n", + "\n", + "print(f\"Synthesized MCX cx-count for grid connectivity is {circuit_grid.transpiled_circuit.count_ops['cx']}\")\n", + "circuit_grid.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cYcpNdbos3is", + "outputId": "fd1c4e8b-623a-425f-bebe-a39d7f051f7f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Opening: https://platform.classiq.io/circuit/b94a1120-5b81-4a27-a949-b90e018518e0?version=0.42.0\n" + ] + } + ], + "source": [ + "qprog_star = synthesize(model_star)\n", + "show(qprog_star)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FySbcicutSXk", + "outputId": "c1d536d1-67e4-4f99-95d1-60884614ed2d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized MCX cx-count for star connectivity is 114\n", + "Opening: https://platform.classiq.io/circuit/b94a1120-5b81-4a27-a949-b90e018518e0?version=0.42.0\n" + ] + } + ], + "source": [ + "circuit_star = QuantumProgram.from_qprog(qprog_star)\n", + "\n", + "print(f\"Synthesized MCX cx-count for star connectivity is {circuit_star.transpiled_circuit.count_ops['cx']}\")\n", + "circuit_star.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4p-TBa9ztebZ", + "outputId": "39293b2b-7081-4267-f3b5-005f37ee830b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized Depth for grid connectivity is 82\n" + ] + } + ], + "source": [ + "print(f\"Synthesized Depth for grid connectivity is {circuit_grid.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EVxTVGqf1HIS", + "outputId": "53561623-3c04-4931-d8f3-b6d82c680be5" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Synthesized Depth for star connectivity is 191\n" + ] + } + ], + "source": [ + "print(f\"Synthesized Depth for star connectivity is {circuit_star.transpiled_circuit.depth}\")" + ] + }, + { + "cell_type": "markdown", + "source": [ + "**Conclusion:** Given the connectivity of the hardware and its preferences the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n", + "\n", + "With `Star Connectivity` the minimum number of cx gates required after transpiling the circuit is just 114 and depth of the circuit turned out to be 191.\n", + "\n", + "Whereas with `Grid Connectivity` the minimum number of cx gates required after transpiling the circuit is 117 and depth of the circuit is 82.\n", + "\n", + "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a `mcx circuit`.\n", + "\n" + ], + "metadata": { + "id": "b043xgbpHGEO" + } + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "0oDCHQ3Pczgt" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From e5c198b2fe4cf7b4d59b604ef9697c824ab14842 Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Thu, 6 Jun 2024 14:28:37 +0530 Subject: [PATCH 8/9] Delete community/basic_examples/hw_aware_synthesis.ipynb --- .../basic_examples/hw_aware_synthesis.ipynb | 605 ------------------ 1 file changed, 605 deletions(-) delete mode 100644 community/basic_examples/hw_aware_synthesis.ipynb diff --git a/community/basic_examples/hw_aware_synthesis.ipynb b/community/basic_examples/hw_aware_synthesis.ipynb deleted file mode 100644 index 2d343340..00000000 --- a/community/basic_examples/hw_aware_synthesis.ipynb +++ /dev/null @@ -1,605 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "S5a8KVmhRyCm" - }, - "source": [ - "# HW-aware Synthesis of MCX\n", - "\n", - "This tutorial consists of two parts,\n", - "1. How to create a 10-CONTROL MCX gate with Classiq\n", - "2. Classiq's Hardware-Aware Synthesis capability\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "AE1ksqSMC_MY" - }, - "source": [ - "## 1. How to create a 10-CONTROL MCX gate with Classiq" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CiCAjWxbC_Ma" - }, - "source": [ - "To create an MCX gate with 10 control qubits using Classiq, we will first define a quantum function called `my_mcx`, whose arguments are an array of qubits (of any size) to be used as control, and a single qubit argument to be used as the target." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "N55CY8rJo6nu" - }, - "outputs": [], - "source": [ - "#importing all the necessary libraries from classiq\n", - "\n", - "from math import pi\n", - "from classiq import *" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "8jxKs0RkpLqf" - }, - "outputs": [], - "source": [ - "# define MCX quantum function\n", - "@qfunc\n", - "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", - " control(ctrl, lambda: X(target))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "DxI88JO1C_Mh" - }, - "source": [ - "Then, to create an MCX gate with 10 control qubits we will create a quantum main function that will simply execute our `my_mcx` function with 10 qubits allocated to the control argument." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "NIxnhfOgpSSI" - }, - "outputs": [], - "source": [ - "# define the MCX parameters within the quantum 'main' function\n", - "@qfunc\n", - "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", - " allocate(10, ctrl)\n", - " allocate(1, target)\n", - " my_mcx(ctrl, target)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Iu8uortFC_Mi" - }, - "source": [ - "To build our model we will use the `create_model` function:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "iHVgE7SCpZBL" - }, - "outputs": [], - "source": [ - "# build a model\n", - "model = create_model(main)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CTi8GIBrC_Mk" - }, - "source": [ - "To constrain a circuit to only 20 qubits and optimize for circuit depth, we pass the max width and optimization parameter to a `Constraints` object and update our model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "zbzL6MksC_Ml" - }, - "outputs": [], - "source": [ - "from classiq import write_qmod\n", - "\n", - "constraints = Constraints(\n", - " max_width=20, optimization_parameter=OptimizationParameter.DEPTH\n", - ")\n", - "model = set_constraints(model, constraints)\n", - "\n", - "write_qmod(model, \"mcx_10_ctrl_depth\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "bpBmDJcBC_Mm" - }, - "source": [ - "We can now synthesize our model, create a quantum program and view it:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "OebNdwj-C_Mn", - "outputId": "7b44a787-fd22-4392-e76a-804a6de89870" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/fd469125-c5d1-42e8-9d04-9cdba8b62f25?version=0.41.2\n" - ] - } - ], - "source": [ - "qprog = synthesize(model)\n", - "show(qprog)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "HDdeZAmNC_Mo" - }, - "source": [ - "Additionally, To get the transpiled circuit from our qprog object and print its depth:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "4Ykj96NcC_Mp", - "outputId": "938cd55b-895f-47f5-ffab-99d29be7b4e0" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized MCX depth is 52\n" - ] - } - ], - "source": [ - "circuit = QuantumProgram.from_qprog(qprog)\n", - "print(f\"Synthesized MCX depth is {circuit.transpiled_circuit.depth}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rF_sE_vHC_Mq" - }, - "source": [ - "# 2. Classiq's Hardware-Aware Synthesis capability" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "74aCfp3IC_Mq" - }, - "source": [ - "In the above section we have seen how to create a MCX circuit, add constraints to it and optimize its depth in Classiq. In this section we will check the hardware-aware synthesis capability of Classiq. In this example we will implement and synthesize a simple MCX (Multiple Control-X) circuit with two different HW-aware configuration settings using Classiq's synthesis engine.\n", - "\n", - "The two different fictitious hardware created here demonstrates how to insert your own custom-designed machine. For comparison, we create two types of hardware with `cx, u` basis gates. The difference between them manifests in the connectivity map: one has grid connectivity while the other has star connectivity.\n", - "\n", - "We will compare the depth of the circuit and we will optimise the number of cnot gates as it is important in quantum computation because they cause more errors and are very expensive.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": { - "id": "kDz3GbcKEwwB" - }, - "outputs": [], - "source": [ - "# define MCX quantum function\n", - "@qfunc\n", - "def my_mcx(ctrl: QArray[QBit], target: QBit) -> None:\n", - " control(ctrl, lambda: X(target))" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": { - "id": "yOzokSMZEw78" - }, - "outputs": [], - "source": [ - "# define the MCX parameters within the quantum 'main' function\n", - "@qfunc\n", - "def main(ctrl: Output[QArray[QBit]], target: Output[QBit]) -> None:\n", - " allocate(12, ctrl)\n", - " allocate(1, target)\n", - " my_mcx(ctrl, target)" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": { - "id": "5bGo7UFBEw_V" - }, - "outputs": [], - "source": [ - "# build a model\n", - "model = create_model(main)" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": { - "id": "NlxS3xSTC_Mr" - }, - "outputs": [], - "source": [ - "# define the hardware parameters\n", - "max_width = 18\n", - "\n", - "#Grid Connectivity\n", - "grid_connectivity = [\n", - " [0, 1], [1, 2], [2, 3], [3, 4], [4, 5], # Row 1\n", - " [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], # Row 2\n", - " [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], # Row 3\n", - " [0, 6], [6, 12], # Column 1\n", - " [1, 7], [7, 13], # Column 2\n", - " [2, 8], [8, 14], # Column 3\n", - " [3, 9], [9, 15], # Column 4\n", - " [4, 10], [10, 16], # Column 5\n", - " [5, 11], [11, 17] # Column 6\n", - "]\n", - "\n", - "#Star Connectivity\n", - "star_connectivity = [[0, i] for i in range(1, max_width-1)]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#Plotting Grid Connectivity\n", - "import matplotlib.pyplot as plt\n", - "import networkx as nx\n", - "\n", - "G = nx.Graph()\n", - "G.add_edges_from(grid_connectivity)\n", - "\n", - "# Define the positions of the nodes in a 3x6 grid\n", - "pos = {}\n", - "for i in range(3):\n", - " for j in range(6):\n", - " pos[i * 6 + j] = (j, -i) # (x, y) coordinates\n", - "\n", - "# Plot the graph\n", - "plt.figure(figsize=(10, 6))\n", - "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", - "plt.title(\"3x6 Grid Connectivity Map\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "#plotting Star Connectivity\n", - "import numpy as np\n", - "\n", - "G = nx.Graph()\n", - "G.add_edges_from(star_connectivity)\n", - "\n", - "# Define the positions of the nodes in a star configuration\n", - "pos = {}\n", - "pos[0] = (0, 0) # Central node\n", - "angle_step = 360 / (len(star_connectivity))\n", - "for i in range(1, 18):\n", - " angle = angle_step * (i - 1)\n", - " radians = np.deg2rad(angle)\n", - " pos[i] = (np.cos(radians), np.sin(radians))\n", - "\n", - "# Plot the graph\n", - "plt.figure(figsize=(10, 10))\n", - "nx.draw(G, pos, with_labels=True, node_size=500, node_color=\"skyblue\", font_size=16, font_color=\"black\", edge_color=\"gray\")\n", - "plt.title(\"Star Connectivity Map\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": { - "id": "1ogjh7qTGJd3" - }, - "outputs": [], - "source": [ - "#Grid Preferences \n", - "preferences_grid = Preferences(\n", - " custom_hardware_settings=CustomHardwareSettings(\n", - " basis_gates=[\"cx\", \"u\"],\n", - " connectivity_map=grid_connectivity,\n", - " ),\n", - " random_seed=-1,\n", - ")\n", - "\n", - "\n", - "#Star Preferences \n", - "preferences_star = Preferences(\n", - " custom_hardware_settings=CustomHardwareSettings(basis_gates=[\"cx\", \"u\"],\n", - " connectivity_map=star_connectivity,),\n", - " random_seed=-1,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": { - "id": "_3KIstIjC_Ms" - }, - "outputs": [], - "source": [ - "# define synthesis engine constraints\n", - "constraints = Constraints(optimization_parameter=\"cx\", max_width=max_width)" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": { - "id": "wviSbVIqsavi" - }, - "outputs": [], - "source": [ - "# define models with different preferences\n", - "model = set_constraints(model, constraints)\n", - "model_grid = set_preferences(model, preferences_grid)\n", - "model_star = set_preferences(model, preferences_star)\n", - "\n", - "\n", - "# write models to files\n", - "write_qmod(model_grid, \"hardware_aware_mcx_grid\")\n", - "write_qmod(model_star, \"hardware_aware_mcx_star\")" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "hWP-uuNmsf5g", - "outputId": "c9be259f-0ef0-43c9-d664-fcabae22a141" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/305a7290-64c8-47e4-af71-5a80aa306056?version=0.41.2\n" - ] - } - ], - "source": [ - "qprog_grid= synthesize(model_grid)\n", - "show(qprog_grid)" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7-1tx3a3squr", - "outputId": "44587537-314b-4002-99b1-603b8d2ee0d0" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized MCX cx-count for grid connectivity is 66\n", - "Opening: https://platform.classiq.io/circuit/305a7290-64c8-47e4-af71-5a80aa306056?version=0.41.2\n" - ] - } - ], - "source": [ - "circuit_grid = QuantumProgram.from_qprog(qprog_grid)\n", - "\n", - "print(f\"Synthesized MCX cx-count for grid connectivity is {circuit_grid.transpiled_circuit.count_ops['cx']}\")\n", - "circuit_grid.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cYcpNdbos3is", - "outputId": "1a56c67c-8b47-4a84-cc81-506a5e8267f4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Opening: https://platform.classiq.io/circuit/3d0aa65f-1ab3-43cb-b0bc-5abc15636b3e?version=0.41.2\n" - ] - } - ], - "source": [ - "qprog_star = synthesize(model_star)\n", - "show(qprog_star)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "FySbcicutSXk", - "outputId": "15100171-b019-4255-e581-033cfd84aab2" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized MCX cx-count for star connectivity is 60\n", - "Opening: https://platform.classiq.io/circuit/3d0aa65f-1ab3-43cb-b0bc-5abc15636b3e?version=0.41.2\n" - ] - } - ], - "source": [ - "circuit_star = QuantumProgram.from_qprog(qprog_star)\n", - "\n", - "print(f\"Synthesized MCX cx-count for star connectivity is {circuit_star.transpiled_circuit.count_ops['cx']}\")\n", - "circuit_star.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "4p-TBa9ztebZ", - "outputId": "6c905e75-1b2f-44ce-a140-22be2d09b1a8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized Depth for grid connectivity is 54\n" - ] - } - ], - "source": [ - "print(f\"Synthesized Depth for grid connectivity is {circuit_grid.transpiled_circuit.depth}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "EVxTVGqf1HIS", - "outputId": "377e210b-263f-4c8d-c173-129fa91c822f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Synthesized Depth for star connectivity is 63\n" - ] - } - ], - "source": [ - "print(f\"Synthesized Depth for star connectivity is {circuit_star.transpiled_circuit.depth}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "b043xgbpHGEO" - }, - "source": [ - "**Conclusion:** Given the connectivity of the hardware and its preferences the engince optimizes the constraints of the model. In this case the constraits were `max_width` which is the maximum number of qubits it can use and the number of `cx gates`. Our main aim is to minimize the number of cx gates.\n", - "\n", - "With `Star Connectivity` the minimum number of cx gates required after transpiling the circuit is 66 and depth of the circuit turned out to be 63.\n", - "\n", - "Whereas with `Grid Connectivity` the minimum number of cx gates required after transpiling the circuit is just 60 and depth of the circuit is 54.\n", - "\n", - "Looking at the both the cases we can come to a conclusion that star connectivity is more favourable to synthesize and execute a MCX circuit.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} From fab0e5b4792bcea3490d38e24b4bb09d23881835 Mon Sep 17 00:00:00 2001 From: Sai Nandan Morapakula Date: Thu, 6 Jun 2024 14:30:56 +0530 Subject: [PATCH 9/9] qmod and synthesis_options files --- .../hardware_aware_mcx_grid.qmod | 12 + ...ware_aware_mcx_grid.synthesis_options.json | 233 ++++++++++++++++++ .../hardware_aware_mcx_star.qmod | 12 + ...ware_aware_mcx_star.synthesis_options.json | 145 +++++++++++ .../hw_aware_synthesis/mcx_10_ctrl_depth.qmod | 12 + .../mcx_10_ctrl_depth.synthesis_options.json | 6 + 6 files changed, 420 insertions(+) create mode 100644 community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod create mode 100644 community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json create mode 100644 community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod create mode 100644 community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json create mode 100644 community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod create mode 100644 community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod new file mode 100644 index 00000000..afa2dbc1 --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.qmod @@ -0,0 +1,12 @@ +qfunc my_mcx(ctrl: qbit[], target: qbit) { + control (ctrl) { + X(target); + } +} + +qfunc main(output ctrl: qbit[], output target: qbit) { + allocate<12>(ctrl); + allocate<1>(target); + my_mcx(ctrl, target); +} + diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json new file mode 100644 index 00000000..eccba304 --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_grid.synthesis_options.json @@ -0,0 +1,233 @@ +{ + "constraints": { + "max_width": 18, + "optimization_parameter": "cx" + }, + "preferences": { + "custom_hardware_settings": { + "basis_gates": [ + "cx", + "u" + ], + "connectivity_map": [ + [ + 0, + 1 + ], + [ + 1, + 2 + ], + [ + 2, + 3 + ], + [ + 3, + 4 + ], + [ + 4, + 5 + ], + [ + 6, + 7 + ], + [ + 7, + 8 + ], + [ + 8, + 9 + ], + [ + 9, + 10 + ], + [ + 10, + 11 + ], + [ + 12, + 13 + ], + [ + 13, + 14 + ], + [ + 14, + 15 + ], + [ + 15, + 16 + ], + [ + 16, + 17 + ], + [ + 0, + 6 + ], + [ + 6, + 12 + ], + [ + 1, + 7 + ], + [ + 7, + 13 + ], + [ + 2, + 8 + ], + [ + 8, + 14 + ], + [ + 3, + 9 + ], + [ + 9, + 15 + ], + [ + 4, + 10 + ], + [ + 10, + 16 + ], + [ + 5, + 11 + ], + [ + 11, + 17 + ], + [ + 1, + 0 + ], + [ + 2, + 1 + ], + [ + 3, + 2 + ], + [ + 4, + 3 + ], + [ + 5, + 4 + ], + [ + 7, + 6 + ], + [ + 8, + 7 + ], + [ + 9, + 8 + ], + [ + 10, + 9 + ], + [ + 11, + 10 + ], + [ + 13, + 12 + ], + [ + 14, + 13 + ], + [ + 15, + 14 + ], + [ + 16, + 15 + ], + [ + 17, + 16 + ], + [ + 6, + 0 + ], + [ + 12, + 6 + ], + [ + 7, + 1 + ], + [ + 13, + 7 + ], + [ + 8, + 2 + ], + [ + 14, + 8 + ], + [ + 9, + 3 + ], + [ + 15, + 9 + ], + [ + 10, + 4 + ], + [ + 16, + 10 + ], + [ + 11, + 5 + ], + [ + 17, + 11 + ] + ] + }, + "random_seed": -1 + } +} \ No newline at end of file diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod new file mode 100644 index 00000000..afa2dbc1 --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.qmod @@ -0,0 +1,12 @@ +qfunc my_mcx(ctrl: qbit[], target: qbit) { + control (ctrl) { + X(target); + } +} + +qfunc main(output ctrl: qbit[], output target: qbit) { + allocate<12>(ctrl); + allocate<1>(target); + my_mcx(ctrl, target); +} + diff --git a/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json new file mode 100644 index 00000000..54a8c00f --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis/hardware_aware_mcx_star.synthesis_options.json @@ -0,0 +1,145 @@ +{ + "constraints": { + "max_width": 18, + "optimization_parameter": "cx" + }, + "preferences": { + "custom_hardware_settings": { + "basis_gates": [ + "cx", + "u" + ], + "connectivity_map": [ + [ + 0, + 1 + ], + [ + 0, + 2 + ], + [ + 0, + 3 + ], + [ + 0, + 4 + ], + [ + 0, + 5 + ], + [ + 0, + 6 + ], + [ + 0, + 7 + ], + [ + 0, + 8 + ], + [ + 0, + 9 + ], + [ + 0, + 10 + ], + [ + 0, + 11 + ], + [ + 0, + 12 + ], + [ + 0, + 13 + ], + [ + 0, + 14 + ], + [ + 0, + 15 + ], + [ + 0, + 16 + ], + [ + 1, + 0 + ], + [ + 2, + 0 + ], + [ + 3, + 0 + ], + [ + 4, + 0 + ], + [ + 5, + 0 + ], + [ + 6, + 0 + ], + [ + 7, + 0 + ], + [ + 8, + 0 + ], + [ + 9, + 0 + ], + [ + 10, + 0 + ], + [ + 11, + 0 + ], + [ + 12, + 0 + ], + [ + 13, + 0 + ], + [ + 14, + 0 + ], + [ + 15, + 0 + ], + [ + 16, + 0 + ] + ] + }, + "random_seed": -1 + } +} \ No newline at end of file diff --git a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod new file mode 100644 index 00000000..293534ae --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.qmod @@ -0,0 +1,12 @@ +qfunc my_mcx(ctrl: qbit[], target: qbit) { + control (ctrl) { + X(target); + } +} + +qfunc main(output ctrl: qbit[], output target: qbit) { + allocate<10>(ctrl); + allocate<1>(target); + my_mcx(ctrl, target); +} + diff --git a/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json new file mode 100644 index 00000000..1c4b772e --- /dev/null +++ b/community/basic_examples/hw_aware_synthesis/mcx_10_ctrl_depth.synthesis_options.json @@ -0,0 +1,6 @@ +{ + "constraints": { + "max_width": 20, + "optimization_parameter": "depth" + } +} \ No newline at end of file