From ce7e88d07b2ccbaa020c3e7ea910d8a559e29650 Mon Sep 17 00:00:00 2001 From: Yusharth Singh Date: Sun, 29 Jan 2023 15:20:22 +0000 Subject: [PATCH 1/2] vrdbst --- part1_example_qiskit.ipynb | 486 +++++++++++++++++++++++++++++++++++-- 1 file changed, 470 insertions(+), 16 deletions(-) diff --git a/part1_example_qiskit.ipynb b/part1_example_qiskit.ipynb index 3c72b02..46c6671 100644 --- a/part1_example_qiskit.ipynb +++ b/part1_example_qiskit.ipynb @@ -2,9 +2,18 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/yusharthsingh/anaconda3/lib/python3.8/site-packages/scipy/__init__.py:138: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.24.1)\n", + " warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion} is required for this version of \"\n" + ] + } + ], "source": [ "import qiskit\n", "from qiskit import quantum_info\n", @@ -64,7 +73,34 @@ "def image_mse(image1,image2):\n", " # Using sklearns mean squared error:\n", " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", - " return mean_squared_error(255*image1,255*image2)" + " return mean_squared_error(image1, image2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: 'mock_data'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#load the mock data (for testing only)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfiles\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"mock_data\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mdataset\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mfile\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mfiles\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'mock_data/'\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0minfile\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'mock_data'" + ] + } + ], + "source": [ + "#load the mock data (for testing only)\n", + "files=os.listdir(\"mock_data\")\n", + "dataset=list()\n", + "for file in files:\n", + " with open('mock_data/'+file, \"r\") as infile:\n", + " loaded = json.load(infile)\n", + " dataset.append(loaded)" ] }, { @@ -75,7 +111,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -84,7 +120,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -96,13 +132,11 @@ } ], "source": [ - "data_path='mock_data'\n", "#load the actual hackthon data (fashion-mnist)\n", - "images=np.load(data_path+'/images.npy')\n", - "labels=np.load(data_path+'/labels.npy')\n", + "images=np.load('data/images.npy')\n", + "labels=np.load('data/labels.npy')\n", "#you can visualize it\n", - "import matplotlib.pyplot as plt\n", - "plt.imshow(images[1])" + "plt.imshow(images[1100])" ] }, { @@ -113,7 +147,7 @@ "source": [ "#submission to part 1, you should make this into a .py file\n", "\n", - "n=len(images)\n", + "n=len(dataset)\n", "mse=0\n", "gatecount=0\n", "\n", @@ -161,11 +195,11 @@ "source": [ "#how we grade your submission\n", "\n", - "n=len(images)\n", + "n=len(dataset)\n", "mse=0\n", "gatecount=0\n", "\n", - "for data in images:\n", + "for data in dataset:\n", " #encode image into circuit\n", " circuit,image_re=run_part1(data['image'])\n", " \n", @@ -176,13 +210,434 @@ " mse+=image_mse(data['image'],image_re)\n", " \n", "#fidelity of reconstruction\n", - "f=1-mse/n\n", + "f=1-mse\n", "gatecount=gatecount/n\n", "\n", "#score for part1 \n", "print(f*(0.999**gatecount))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------------------------MY CODE--------------------------" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import qiskit\n", + "from qiskit import quantum_info\n", + "from qiskit.execute_function import execute\n", + "from qiskit import BasicAer\n", + "import numpy as np\n", + "import pickle\n", + "import json\n", + "import os\n", + "from collections import Counter\n", + "from sklearn.metrics import mean_squared_error\n", + "from typing import Dict, List\n", + "import matplotlib.pyplot as plt\n", + "\n", + "#define utility functions\n", + "\n", + "def simulate(circuit: qiskit.QuantumCircuit) -> dict:\n", + " \"\"\"Simulate the circuit, give the state vector as the result.\"\"\"\n", + " backend = BasicAer.get_backend('statevector_simulator')\n", + " job = execute(circuit, backend)\n", + " result = job.result()\n", + " state_vector = result.get_statevector()\n", + " \n", + " histogram = dict()\n", + " for i in range(len(state_vector)):\n", + " population = abs(state_vector[i]) ** 2\n", + " if population > 1e-9:\n", + " histogram[i] = population\n", + " \n", + " return histogram\n", + "\n", + "\n", + "def histogram_to_category(histogram):\n", + " \"\"\"This function take a histogram representations of circuit execution results, and process into labels as described in \n", + " the problem description.\"\"\"\n", + " assert abs(sum(histogram.values())-1)<1e-8\n", + " positive=0\n", + " for key in histogram.keys():\n", + " digits = bin(int(key))[2:].zfill(20)\n", + " if digits[-1]=='0':\n", + " positive+=histogram[key]\n", + " \n", + " return positive\n", + "\n", + "\n", + "def count_gates(circuit: qiskit.QuantumCircuit) -> Dict[int, int]:\n", + " \"\"\"Returns the number of gate operations with each number of qubits.\"\"\"\n", + " counter = Counter([len(gate[1]) for gate in circuit.data])\n", + " #feel free to comment out the following two lines. But make sure you don't have k-qubit gates in your circuit\n", + " #for k>2\n", + " for i in range(2,20):\n", + " assert counter[i]==0\n", + " \n", + " return counter\n", + "\n", + "\n", + "def image_mse(image1,image2):\n", + " # Using sklearns mean squared error:\n", + " # https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html\n", + " return mean_squared_error(image1, image2)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "images=np.load('data/images.npy')\n", + "labels=np.load('data/labels.npy')" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister\n", + "from qiskit import execute, QuantumRegister\n", + "from qiskit.qasm import pi\n", + "from qiskit.tools.visualization import plot_histogram, circuit_drawer\n", + "from qiskit import execute, Aer, BasicAer\n", + "import numpy as np\n", + "import random\n", + "import keras\n", + "from keras.models import Sequential\n", + "from keras.layers import Dense, Activation\n", + "from keras.datasets import mnist\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import mean_squared_error, mean_absolute_error, mutual_info_score, r2_score\n", + "\n", + "dataset=images\n", + "n=len(dataset)\n", + "mse=0\n", + "gatecount=0\n", + "\n", + "# Functions 'encode' and 'decode' are dummy (not anymore).\n", + "def encode(image):\n", + " \n", + " #Implementation of MRQI fro 28x28 images\n", + " \n", + " qubit = 12\n", + " q = qiskit.QuantumRegister(qubit)\n", + " qc = qiskit.QuantumCircuit(q)\n", + " \n", + " #Necessary gates for the whole circuit\n", + " \n", + " def rccx(circ, t, c0, c1):\n", + " circ.h(t)\n", + " circ.t(t)\n", + " circ.cx(c0, t)\n", + " circ.tdg(t)\n", + " circ.cx(c1, t)\n", + " circ.t(t)\n", + " circ.cx(c0, t)\n", + " circ.tdg(t)\n", + " circ.h(t)\n", + "\n", + " def rcccx(circ, t, c0, c1, c2):\n", + " circ.h(t)\n", + " circ.t(t)\n", + " circ.cx(c0, t)\n", + " circ.tdg(t)\n", + " circ.h(t)\n", + " circ.cx(c1, t)\n", + " circ.t(t)\n", + " circ.cx(c2, t)\n", + " circ.tdg(t)\n", + " circ.cx(c1, t)\n", + " circ.t(t)\n", + " circ.cx(c2, t)\n", + " circ.tdg(t)\n", + " circ.h(t)\n", + " circ.t(t)\n", + " circ.cx(c0, t)\n", + " circ.tdg(t)\n", + " circ.h(t)\n", + " \n", + " def mary_8(circ, angle, t, c0, c1, c2, c3, c4, c5, c6):\n", + " angle = float(angle)\n", + " #print(angle)\n", + " circ.h(t)\n", + " circ.t(t)\n", + " rccx(circ, t, c0, c1)\n", + " circ.tdg(t)\n", + " circ.h(t)\n", + " rccx(circ, t, c2, c3)\n", + " circ.rz(angle/4,t)\n", + " rcccx(circ, t, c4, c5, c6)\n", + " circ.rz(-angle/4,t)\n", + " rccx(circ, t, c2, c3)\n", + " circ.rz(angle/4,t)\n", + " rcccx(circ, t, c4, c5, c6)\n", + " circ.rz(-angle/4,t)\n", + " circ.h(t)\n", + " circ.t(t)\n", + " rccx(circ, t, c0, c1)\n", + " circ.tdg(t)\n", + " circ.h(t)\n", + " \n", + " def c10mary(circ, angle, bin, target, anc, controls):\n", + " clist = []\n", + "\n", + " for i in bin:\n", + " clist.append(int(i))\n", + "\n", + " for i in range(len(clist)):\n", + " if clist[i] == 0:\n", + " circ.x(controls[-i-1])\n", + "\n", + " rccx(circ, anc, controls[4], controls[5])\n", + " circ.x(controls[4])\n", + " circ.x(controls[5])\n", + " rccx(circ, controls[4], controls[6], controls[7])\n", + " rccx(circ, controls[5], controls[8], controls[9])\n", + "\n", + "\n", + " mary_8(circ, angle, target, anc, controls[0], controls[1], controls[2], controls[3], controls[4], controls[5])\n", + "\n", + " rccx(circ, controls[5], controls[8], controls[9])\n", + " rccx(circ, controls[4], controls[6], controls[7])\n", + " circ.x(controls[5])\n", + " circ.x(controls[4])\n", + " rccx(circ, anc, controls[4], controls[5])\n", + "\n", + " for i in range(len(clist)):\n", + " if clist[i] == 0:\n", + " circ.x(controls[-i-1])\n", + " \n", + " \n", + " #Apply the whole ciruit with the reshpaed image\n", + " \n", + " image = image.flatten().astype('float64')\n", + " \n", + " qc.h(range(2,qubit))\n", + " \n", + " \n", + " for i in range(len(image)): #NOT SURE ABOUT THIS\n", + " if image[i] != 0:\n", + " #print(t)\n", + " c10mary(qc, 2 * image[i], format(i, '010b'), 0, 1, [i for i in range(2,12)])\n", + " \n", + " return qc\n", + "\n", + "def decode(histogram, image): #THIS DECODING IS THE ONE FROM THE GITHUB REPO\n", + " \n", + " genimg = np.array([])\n", + "\n", + " for i in range(len(image)):\n", + " try:\n", + " genimg = np.append(genimg,[np.sqrt(result.get_counts(circuit)[format(i, '010b')+'01']/numOfShots)])\n", + " genimg = np.append(genimg,[])\n", + " except KeyError:\n", + " genimg = np.append(genimg,[0.0])\n", + " \n", + " image = genimg.astype('int')\n", + " \n", + " image = genimg.reshape((28,28)) \n", + " \n", + " return image\n", + "\n", + "def decode(histogram):\n", + " \n", + " image = np.sqrt(np.array(list(histogram.values())))[0:784]#NOT SURE ABOUT THIS\n", + " image = image.astype('int').reshape((28,28))\n", + " \n", + " return image\n", + " \n", + "\n", + "def run_part1(image):\n", + " #encode image into a circuit\n", + " circuit = encode(image)\n", + "\n", + " #simulate circuit\n", + " histogram = simulate(circuit)\n", + "\n", + " #reconstruct the image\n", + " image_re = decode(histogram)\n", + "\n", + " return circuit,image_re\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#images[1100]\n", + "#plt.imshow(images[1100])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "#images[1100].flatten()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from qiskit import IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister\n", + "from qiskit import execute, QuantumRegister\n", + "from qiskit.qasm import pi\n", + "from qiskit.tools.visualization import plot_histogram, circuit_drawer\n", + "from qiskit import execute, Aer, BasicAer\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "#from resizeimage import resizeimage\n", + "from PIL import Image\n", + "\n", + "#import frqi\n", + "#import quantum_edge_detection as qed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's try it with one example" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 168, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "image=images[1000]\n", + "plt.imshow(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": {}, + "outputs": [], + "source": [ + "circuit = encode(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [], + "source": [ + "histogram = simulate(circuit)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "metadata": {}, + "outputs": [], + "source": [ + "#circuit_drawer(circuit)\n", + "#print(histogram)\n", + "#print(np.array(list(histogram.values())))" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "image = image.flatten().astype('float64')" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "metadata": {}, + "outputs": [], + "source": [ + "image_re = decode(histogram)" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 172, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(image_re) #DOES NOT LOOK GOOD AT ALL" + ] + }, { "cell_type": "code", "execution_count": null, @@ -207,9 +662,8 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.15 (main, Oct 11 2022, 22:27:25) \n[Clang 14.0.0 (clang-1400.0.29.102)]" + "version": "3.8.8" }, - "orig_nbformat": 4, "vscode": { "interpreter": { "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b" From 31290a8527f1a3538f95ea6a2346e7dc025b93a7 Mon Sep 17 00:00:00 2001 From: Yusharth Singh Date: Thu, 2 Feb 2023 16:32:56 +0000 Subject: [PATCH 2/2] req files added --- requirements.txt | 209 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 209 insertions(+) create mode 100644 requirements.txt diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3b25f78 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,209 @@ +aiofile==3.8.1 +aiohttp==3.8.3 +aiosignal==1.3.1 +alembic @ file:///home/conda/feedstock_root/build_artifacts/alembic_1647367721563/work +anyio @ file:///home/conda/feedstock_root/build_artifacts/anyio_1641898043316/work/dist +argon2-cffi @ file:///home/conda/feedstock_root/build_artifacts/argon2-cffi_1640817743617/work +argon2-cffi-bindings @ file:///home/conda/feedstock_root/build_artifacts/argon2-cffi-bindings_1640855140139/work +asttokens @ file:///home/conda/feedstock_root/build_artifacts/asttokens_1618968359944/work +async-generator==1.10 +async-timeout==4.0.2 +attrs @ file:///home/conda/feedstock_root/build_artifacts/attrs_1640799537051/work +awscli==1.27.57 +azure-core==1.26.2 +azure-identity==1.12.0 +azure-quantum @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/azure_quantum-0.27.244707-py3-none-any.whl +azure-storage-blob==12.14.1 +Babel @ file:///home/conda/feedstock_root/build_artifacts/babel_1619719576210/work +backcall @ file:///home/conda/feedstock_root/build_artifacts/backcall_1592338393461/work +backports.functools-lru-cache @ file:///home/conda/feedstock_root/build_artifacts/backports.functools_lru_cache_1618230623929/work +beautifulsoup4 @ file:///home/conda/feedstock_root/build_artifacts/beautifulsoup4_1631087867185/work +bleach @ file:///home/conda/feedstock_root/build_artifacts/bleach_1629908509068/work +blinker==1.4 +bokeh==3.0.3 +botocore==1.29.57 +brotlipy @ file:///home/conda/feedstock_root/build_artifacts/brotlipy_1636012194889/work +caio==0.9.11 +certifi==2022.12.7 +certipy==0.1.3 +cffi @ file:///home/conda/feedstock_root/build_artifacts/cffi_1636046055389/work +charset-normalizer==3.0.1 +cirq-core==0.14.1 +cirq-ionq==0.14.1 +code-snippets @ file:///tmp/qbraid/wheels/code_snippets-0.1.2-py3-none-any.whl +colorama @ file:///home/conda/feedstock_root/build_artifacts/colorama_1602866480661/work +comm==0.1.2 +conda==4.11.0 +conda-package-handling @ file:///home/conda/feedstock_root/build_artifacts/conda-package-handling_1636021710069/work +configobj==5.0.8 +contourpy==1.0.7 +cryptography @ file:///home/conda/feedstock_root/build_artifacts/cryptography_1639699280527/work +cycler==0.11.0 +Cython==0.29.33 +debugpy @ file:///home/conda/feedstock_root/build_artifacts/debugpy_1636043249011/work +decorator==5.1.1 +defusedxml @ file:///home/conda/feedstock_root/build_artifacts/defusedxml_1615232257335/work +Deprecated==1.2.13 +dill==0.3.6 +docs-react-widget @ file:///tmp/qbraid/wheels/docs_react_widget-0.1.0-py3-none-any.whl +docutils==0.16 +duet==0.2.7 +entrypoints @ file:///home/conda/feedstock_root/build_artifacts/entrypoints_1643888246732/work +environment-manager @ file:///tmp/qbraid/wheels/environment_manager-0.1.4-py3-none-any.whl +executing @ file:///home/conda/feedstock_root/build_artifacts/executing_1646044401614/work +fastjsonschema==2.16.2 +flit_core @ file:///home/conda/feedstock_root/build_artifacts/flit-core_1645629044586/work/source/flit_core +fonttools==4.38.0 +frozenlist==1.3.3 +future==0.18.3 +gitdb==4.0.10 +GitPython==3.1.30 +greenlet @ file:///home/conda/feedstock_root/build_artifacts/greenlet_1635836790477/work +idna==3.4 +importlib-metadata==6.0.0 +importlib-resources @ file:///home/conda/feedstock_root/build_artifacts/importlib_resources_1635615662634/work +ipykernel==6.20.2 +ipyparallel==8.4.1 +ipython==8.8.0 +ipython-genutils==0.2.0 +ipyvue==1.8.0 +ipyvuetify==1.8.4 +ipywidgets==8.0.4 +isodate==0.6.1 +jedi @ file:///home/conda/feedstock_root/build_artifacts/jedi_1637175083648/work +Jinja2 @ file:///home/conda/feedstock_root/build_artifacts/jinja2_1636510082894/work +jmespath==1.0.1 +json5 @ file:///home/conda/feedstock_root/build_artifacts/json5_1600692310011/work +jsonschema @ file:///home/conda/feedstock_root/build_artifacts/jsonschema-meta_1642000296051/work +jupyter-bokeh==3.0.5 +jupyter-client @ file:///home/conda/feedstock_root/build_artifacts/jupyter_client_1642858610849/work +jupyter-server==1.23.5 +jupyter-server-mathjax==0.2.6 +jupyter-telemetry @ file:///home/conda/feedstock_root/build_artifacts/jupyter_telemetry_1605173804246/work +jupyter_core==5.1.5 +jupyterhub @ file:///home/conda/feedstock_root/build_artifacts/jupyterhub-feedstock_1647267198467/work +jupyterlab==3.5.3 +jupyterlab-git==0.41.0 +jupyterlab-pygments @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_pygments_1601375948261/work +jupyterlab-server @ file:///home/conda/feedstock_root/build_artifacts/jupyterlab_server_1641592475363/work +jupyterlab-widgets==3.0.5 +kiwisolver==1.4.4 +lab-main-menu @ file:///tmp/qbraid/wheels/lab_main_menu-0.1.1-py3-none-any.whl +libmambapy @ file:///home/conda/feedstock_root/build_artifacts/mamba-split_1644831758535/work/libmambapy +Mako @ file:///home/conda/feedstock_root/build_artifacts/mako_1646959760357/work +mamba @ file:///home/conda/feedstock_root/build_artifacts/mamba-split_1644831758535/work/mamba +Markdown==3.4.1 +MarkupSafe @ file:///home/conda/feedstock_root/build_artifacts/markupsafe_1647364298597/work +matplotlib==3.6.3 +matplotlib-inline @ file:///home/conda/feedstock_root/build_artifacts/matplotlib-inline_1631080358261/work +mistune==2.0.4 +mpltools==0.2.0 +mpmath==1.2.1 +msal==1.20.0 +msal-extensions==1.0.0 +msrest==0.7.1 +multidict==6.0.4 +nbclassic==0.4.8 +nbclient==0.7.2 +nbconvert==7.2.9 +nbdime==3.1.1 +nbformat==5.7.3 +nest-asyncio @ file:///home/conda/feedstock_root/build_artifacts/nest-asyncio_1638419302549/work +networkx==2.8.8 +notebook==6.5.2 +notebook-shim @ file:///home/conda/feedstock_root/build_artifacts/notebook-shim_1646330736330/work +ntlm-auth==1.5.0 +numpy==1.24.1 +oauthlib @ file:///home/conda/feedstock_root/build_artifacts/oauthlib_1643507977997/work +packaging==23.0 +pamela==1.0.0 +pandas==1.5.3 +pandocfilters @ file:///home/conda/feedstock_root/build_artifacts/pandocfilters_1631603243851/work +parso @ file:///home/conda/feedstock_root/build_artifacts/parso_1638334955874/work +pbr==5.11.1 +pexpect @ file:///home/conda/feedstock_root/build_artifacts/pexpect_1602535608087/work +pickleshare @ file:///home/conda/feedstock_root/build_artifacts/pickleshare_1602536217715/work +Pillow==9.4.0 +platformdirs==2.6.2 +ply==3.11 +portalocker==2.7.0 +prometheus-client @ file:///home/conda/feedstock_root/build_artifacts/prometheus_client_1643395600215/work +prompt-toolkit @ file:///home/conda/feedstock_root/build_artifacts/prompt-toolkit_1644497866770/work +protobuf==3.20.3 +psutil==5.9.4 +ptyprocess @ file:///home/conda/feedstock_root/build_artifacts/ptyprocess_1609419310487/work/dist/ptyprocess-0.7.0-py2.py3-none-any.whl +pure-eval @ file:///home/conda/feedstock_root/build_artifacts/pure_eval_1642875951954/work +py==1.11.0 +pyasn1==0.4.8 +pycosat @ file:///home/conda/feedstock_root/build_artifacts/pycosat_1636020362356/work +pycparser @ file:///home/conda/feedstock_root/build_artifacts/pycparser_1636257122734/work +pycurl==7.45.1 +Pygments @ file:///home/conda/feedstock_root/build_artifacts/pygments_1641580240686/work +PyJWT @ file:///home/conda/feedstock_root/build_artifacts/pyjwt_1638819640841/work +pyOpenSSL @ file:///home/conda/feedstock_root/build_artifacts/pyopenssl_1643496850550/work +pyparsing==3.0.9 +pyqir-generator==0.4.2a1 +pyrsistent @ file:///home/conda/feedstock_root/build_artifacts/pyrsistent_1642534390768/work +PySocks @ file:///home/conda/feedstock_root/build_artifacts/pysocks_1635862404942/work +python-dateutil==2.8.2 +python-json-logger @ file:///home/conda/feedstock_root/build_artifacts/python-json-logger_1602545356084/work +python-markdown-math==0.8 +pytz==2022.7.1 +PyYAML==5.4.1 +pyzmq @ file:///home/conda/feedstock_root/build_artifacts/pyzmq_1635877397296/work +qdk @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qdk-0.27.244707-py3-none-any.whl +QInfer==1.0 +qiskit==0.39.5 +qiskit-aer==0.11.2 +qiskit-ibmq-provider==0.19.2 +qiskit-ionq==0.3.10 +qiskit-qir==0.2.0 +qiskit-terra==0.23.0 +qsharp @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qsharp-0.27.244707-py3-none-any.whl +qsharp-chemistry @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qsharp_chemistry-0.27.244707-py3-none-any.whl +qsharp-core @ file:///home/vsts_azpcontainer/conda-bld/qsharp_1670279498240/work/src/drops/wheels/qsharp_core-0.27.244707-py3-none-any.whl +quantum-jobs @ file:///tmp/qbraid/wheels/quantum_jobs-0.1.1-py3-none-any.whl +qutip==4.7.1 +requests==2.28.2 +requests-ntlm==1.1.0 +requests-oauthlib==1.3.1 +retry==0.9.2 +retworkx==0.12.1 +rsa==4.7.2 +ruamel-yaml-conda @ file:///home/conda/feedstock_root/build_artifacts/ruamel_yaml_1636009144459/work +ruamel.yaml @ file:///home/conda/feedstock_root/build_artifacts/ruamel.yaml_1644759508211/work +ruamel.yaml.clib @ file:///home/conda/feedstock_root/build_artifacts/ruamel.yaml.clib_1636815619750/work +rustworkx==0.12.1 +s3transfer==0.6.0 +scipy==1.10.0 +Send2Trash @ file:///home/conda/feedstock_root/build_artifacts/send2trash_1628511208346/work +six==1.16.0 +smmap==5.0.0 +sniffio @ file:///home/conda/feedstock_root/build_artifacts/sniffio_1635844660462/work +sortedcontainers==2.4.0 +soupsieve @ file:///home/conda/feedstock_root/build_artifacts/soupsieve_1638550740809/work +SQLAlchemy @ file:///home/conda/feedstock_root/build_artifacts/sqlalchemy_1646615291967/work +stack-data @ file:///home/conda/feedstock_root/build_artifacts/stack_data_1644872665635/work +stevedore==4.1.1 +symengine==0.9.2 +sympy==1.9 +terminado @ file:///home/conda/feedstock_root/build_artifacts/terminado_1646684455438/work +testpath @ file:///home/conda/feedstock_root/build_artifacts/testpath_1645693042223/work +tinycss2==1.2.1 +tomli==2.0.1 +tornado @ file:///home/conda/feedstock_root/build_artifacts/tornado_1635819584296/work +tqdm==4.64.1 +traitlets==5.8.1 +tweedledum==1.1.1 +typing_extensions==4.4.0 +ui-tweaks @ file:///tmp/qbraid/wheels/ui_tweaks-0.1.1-py3-none-any.whl +urllib3==1.26.14 +wcwidth @ file:///home/conda/feedstock_root/build_artifacts/wcwidth_1600965781394/work +webencodings==0.5.1 +websocket-client @ file:///home/conda/feedstock_root/build_artifacts/websocket-client_1645884408572/work +websockets==10.4 +widgetsnbextension==4.0.5 +wrapt==1.14.1 +xyzservices==2022.9.0 +yarl==1.8.2 +zipp==3.11.0