qiskit/basics/2_the_ibmq_provider.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"../../images/qiskit-heading.gif\" alt=\"Note: In order for images to show up in this jupyter notebook you need to select File => Trusted Notebook\" width=\"500 px\" align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The IBM Q provider "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Qiskit we have an interface for backends and jobs that will be useful for running circuits and extending to third-party backends. In this tutorial, we will review the core components of Qiskit’s base backend framework, using the IBM Q provider as an example.\n",
    "\n",
    "The interface has three parts: the provider, the backend, and the job:\n",
    "\n",
    "- provider: accesses backends and provides backend objects\n",
    "- backend: runs the quantum circuit\n",
    "- job: keeps track of the submitted job"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Provider\n",
    "\n",
    "The IBMQ Provider is an entity that provides access to a group of different backends (for example, backends available through IBM Q Experience or IBM Q Network).\n",
    "\n",
    "The IBMQ provider inherits from BaseProvider and implements the methods:\n",
    "\n",
    "- `backends()`: returns all backend objects known to the provider.\n",
    "- `get_backend(name)`: returns the named backend.\n",
    "\n",
    "The IBM Q provider has some extra functions for handling administrative tasks. The credentials can be saved to disk or used in a session and never saved. \n",
    "\n",
    "- `enable_account(token, url)`: enable an account in the current session\n",
    "- `disable_accounts(**kwargs)`: disable one or more accounts from current session\n",
    "- `save_account(token, url)`: save an account to disk\n",
    "- `delete_accounts(**kwargs)`: delete the account or accounts from disk\n",
    "- `load_accounts(**kwargs)`: load previously-saved account or accounts into session\n",
    "- `active_accounts()`: list all accounts active in this session\n",
    "- `stored_accounts()`: list all accounts saved to disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit import IBMQ \n",
    "\n",
    "IBMQ.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see that there are no backends. This is because no accounts have been loaded."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start fresh and delete any accounts on disk. If no accounts are on disk this will error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.delete_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "verify that there are no accounts stored now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.stored_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To demonstrate that we can load multiple accounts using the IBMQ provider, here we use two files `Qconfig_IBMQ_experience.py` and `Qconfig_IBMQ_network.py`, which are just containers of the `APItoken` and `URL`.\n",
    "\n",
    "- `APItoken = 'MY_API_TOKEN'`\n",
    "- `URL = 'THE_URL'`\n",
    "\n",
    "For the IBM Q experience the URL is not needed and is loaded by default in `enable_account` and `save_account`. For the IBM Q Network the url is found on your q-console account page. We don't recommend saving and using files like this. We recommend just inputting the `APItoken` and `URL` directly into the methods `enable_account` and `save_account`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Skip this import if you have not created these 2 files as described above\n",
    "import Qconfig_IBMQ_experience\n",
    "import Qconfig_IBMQ_network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To enable an account (useful for one-off use, or if you don't want to save to disk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change this to be your API Token\n",
    "my_api_token = Qconfig_IBMQ_experience.APItoken\n",
    "IBMQ.enable_account(my_api_token)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see that accounts which are enabled for use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uncomment to print to screen (it will show your token and url)\n",
    "# IBMQ.active_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and backends which are available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQBackend('ibmqx4') from IBMQ()>,\n",
       " <IBMQBackend('ibmqx2') from IBMQ()>,\n",
       " <IBMQBackend('ibmq_16_melbourne') from IBMQ()>,\n",
       " <IBMQSimulator('ibmq_qasm_simulator') from IBMQ()>]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Disable that account (so we go back to no accounts active)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.disable_accounts(token=my_api_token)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now no backends are available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Save two accounts: a public (IBM Q experience) and a premium (IBM Q network)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.save_account(my_api_token, overwrite=True)\n",
    "\n",
    "# To save your second account you need to update these values with your API token and URL\n",
    "q_network_api_token = Qconfig_IBMQ_network.APItoken\n",
    "q_network_url = Qconfig_IBMQ_network.url\n",
    "IBMQ.save_account(q_network_api_token, q_network_url, overwrite=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now they should show up as present on disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uncomment to print to screen (it will show your token and url)\n",
    "# IBMQ.stored_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but no account active in current session yet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.active_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so IBMQ can't see any backends yet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now load up every account stored to disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.load_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "backends from two different accounts available for use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQBackend('ibmqx4') from IBMQ()>,\n",
       " <IBMQBackend('ibmqx2') from IBMQ()>,\n",
       " <IBMQBackend('ibmq_16_melbourne') from IBMQ()>,\n",
       " <IBMQSimulator('ibmq_qasm_simulator') from IBMQ()>,\n",
       " <IBMQBackend('ibmq_20_tokyo') from IBMQ(ibm-q-internal, yrk, main)>,\n",
       " <IBMQBackend('ibmq_poughkeepsie') from IBMQ(ibm-q-internal, yrk, main)>,\n",
       " <IBMQSimulator('ibmq_qasm_simulator') from IBMQ(ibm-q-internal, yrk, main)>]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "now if you want to work with backends of a single account,\n",
    "you can do so via account filtering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQBackend('ibmq_20_tokyo') from IBMQ(ibm-q-internal, yrk, main)>,\n",
       " <IBMQBackend('ibmq_poughkeepsie') from IBMQ(ibm-q-internal, yrk, main)>,\n",
       " <IBMQSimulator('ibmq_qasm_simulator') from IBMQ(ibm-q-internal, yrk, main)>]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends(hub='ibm-q-internal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but you can also just disable account in the current session"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "IBMQ.disable_accounts(hub='ibm-q-internal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "so now only one account is active"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# uncomment to print to screen (it will show your token and url)\n",
    "# IBMQ.active_accounts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and only that account's backends are available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQBackend('ibmqx4') from IBMQ()>,\n",
       " <IBMQBackend('ibmqx2') from IBMQ()>,\n",
       " <IBMQBackend('ibmq_16_melbourne') from IBMQ()>,\n",
       " <IBMQSimulator('ibmq_qasm_simulator') from IBMQ()>]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or from the start use the filtering to just load up that account you're interested in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQBackend('ibmqx4') from IBMQ()>,\n",
       " <IBMQBackend('ibmqx2') from IBMQ()>,\n",
       " <IBMQBackend('ibmq_16_melbourne') from IBMQ()>,\n",
       " <IBMQSimulator('ibmq_qasm_simulator') from IBMQ()>]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.disable_accounts()\n",
    "IBMQ.load_accounts(hub=None)\n",
    "IBMQ.backends()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Filtering the backends\n",
    "\n",
    "You may also optionally filter the set of returned backends, by passing arguments that query the backend's `configuration` or `status` or `properties`. The filters are passed by conditions and for more general filters you can make advanced functions using the lambda function.\n",
    "\n",
    "As a first example: only return currently operational devices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQBackend('ibmqx4') from IBMQ()>,\n",
       " <IBMQBackend('ibmqx2') from IBMQ()>,\n",
       " <IBMQBackend('ibmq_16_melbourne') from IBMQ()>]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends(operational=True, simulator=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "only return backends that are real devices, have at most 5 qubits and are operational"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<IBMQBackend('ibmqx4') from IBMQ()>, <IBMQBackend('ibmqx2') from IBMQ()>]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.backends(filters=lambda x: x.configuration().n_qubits <= 5 and \n",
    "              not x.configuration().simulator and x.status().operational==True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Filter: show the least busy device (in terms of pending jobs in the queue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IBMQBackend('ibmqx4') from IBMQ()>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from qiskit.providers.ibmq import least_busy\n",
    "\n",
    "small_devices = IBMQ.backends(filters=lambda x: x.configuration().n_qubits == 5 and\n",
    "                                                       not x.configuration().simulator)\n",
    "least_busy(small_devices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above filters can be combined as desired.\n",
    "\n",
    "If you just want to get an instance of a particular backend, you can use the `get_backend()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IBMQBackend('ibmq_16_melbourne') from IBMQ()>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IBMQ.get_backend('ibmq_16_melbourne')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The backend\n",
    "\n",
    "Backends represent either a simulator or a real quantum computer, and are responsible for running quantum circuits and returning results. They have a `run` method which takes in a `qobj` as input, which is a quantum object and the result of the compilation process, and returns a BaseJob object. This object allows asynchronous running of jobs for retrieving results from a backend when the job is completed.\n",
    "\n",
    "At a minimum, backends use the following methods, inherited from BaseBackend:\n",
    "\n",
    "\n",
    "- `provider` - returns the provider of the backend.\n",
    "- `name()` - gets the name of the backend.\n",
    "- `status()` - gets the status of the backend.\n",
    "- `configuration()` - gets the configuration of the backend.\n",
    "- `properties()` - gets the properties of the backend.\n",
    "- `run()` - runs a qobj on the backend.\n",
    "\n",
    "For remote backends they must support the additional\n",
    "\n",
    "- `jobs()` - returns a list of previous jobs executed by this user on this backend.\n",
    "- `retrieve_job()` - returns a job by a job_id.\n",
    "\n",
    "In future updates they will introduce the following commands\n",
    "\n",
    "- `defaults()` - gives a data structure of typical default parameters.\n",
    "- `schema()` - gets a schema for the backend\n",
    "\n",
    "There are some IBMQ only functions \n",
    "\n",
    "- `hub`  - returns the IBMQ hub for this backend.\n",
    "- `group` - returns the IBMQ group for this backend.\n",
    "- `project` - returns the IBMQ project for this backend."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend = least_busy(small_devices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with the `backend.provider`, which returns a provider object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<bound method BaseBackend.provider of <IBMQBackend('ibmqx4') from IBMQ()>>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend.provider"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next is the `name()`, which returns the name of the backend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ibmqx4'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend.name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next let's look at the `status()`:\n",
    "\n",
    "    operational lets you know that the backend is taking jobs\n",
    "    pending_jobs lets you know how many jobs are in the queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BackendStatus(backend_name='ibmqx4', backend_version='1.0.0', operational=True, pending_jobs=7, status_msg='active')"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next is `configuration()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-09-26T14:38:43.707148Z",
     "start_time": "2018-09-26T14:38:43.696135Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "QasmBackendConfiguration(allow_q_object=True, backend_name='ibmqx4', backend_version='1.0.0', basis_gates=['u1', 'u2', 'u3', 'cx', 'id'], conditional=False, coupling_map=[[1, 0], [2, 0], [2, 1], [3, 2], [3, 4], [4, 2]], credits_required=True, description='5 qubit device', gates=[GateConfig(coupling_map=[[0], [1], [2], [3], [4]], name='id', parameters=[], qasm_def='gate id q { U(0,0,0) q; }'), GateConfig(coupling_map=[[0], [1], [2], [3], [4]], name='u1', parameters=['lambda'], qasm_def='gate u1(lambda) q { U(0,0,lambda) q; }'), GateConfig(coupling_map=[[0], [1], [2], [3], [4]], name='u2', parameters=['phi', 'lambda'], qasm_def='gate u2(phi,lambda) q { U(pi/2,phi,lambda) q; }'), GateConfig(coupling_map=[[0], [1], [2], [3], [4]], name='u3', parameters=['theta', 'phi', 'lambda'], qasm_def='u3(theta,phi,lambda) q { U(theta,phi,lambda) q; }'), GateConfig(coupling_map=[[1, 0], [2, 0], [2, 1], [3, 2], [3, 4], [4, 2]], name='cx', parameters=[], qasm_def='gate cx q1,q2 { CX q1,q2; }')], local=False, max_experiments=75, max_shots=8192, memory=True, n_qubits=5, n_registers=1, online_date=datetime.datetime(2018, 11, 6, 5, 0, tzinfo=tzutc()), open_pulse=False, sample_name='raven', simulator=False, url='None')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend.configuration()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next is `properties()` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-09-26T14:39:02.682614Z",
     "start_time": "2018-09-26T14:38:54.191129Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BackendProperties(backend_name='ibmqx4', backend_version='1.0.0', gates=[Gate(gate='u1', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0)], qubits=[0]), Gate(gate='u2', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0007726307293453583)], qubits=[0]), Gate(gate='u3', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0015452614586907165)], qubits=[0]), Gate(gate='u1', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0)], qubits=[1]), Gate(gate='u2', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0017172252255832077)], qubits=[1]), Gate(gate='u3', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0034344504511664153)], qubits=[1]), Gate(gate='u1', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0)], qubits=[2]), Gate(gate='u2', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0010302181416348977)], qubits=[2]), Gate(gate='u3', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0020604362832697953)], qubits=[2]), Gate(gate='u1', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0)], qubits=[3]), Gate(gate='u2', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.001545458810288558)], qubits=[3]), Gate(gate='u3', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.003090917620577116)], qubits=[3]), Gate(gate='u1', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0)], qubits=[4]), Gate(gate='u2', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0011160854878761173)], qubits=[4]), Gate(gate='u3', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 9, 55, 18, tzinfo=tzutc()), name='gate_error', unit='', value=0.0022321709757522346)], qubits=[4]), Gate(gate='cx', name='CX1_0', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 1, 26, 17, tzinfo=tzutc()), name='gate_error', unit='', value=0.03529098518339932)], qubits=[1, 0]), Gate(gate='cx', name='CX2_0', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 1, 32, 22, tzinfo=tzutc()), name='gate_error', unit='', value=0.027082586917354767)], qubits=[2, 0]), Gate(gate='cx', name='CX2_1', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 1, 38, 11, tzinfo=tzutc()), name='gate_error', unit='', value=0.06755898860266202)], qubits=[2, 1]), Gate(gate='cx', name='CX3_2', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 1, 44, 24, tzinfo=tzutc()), name='gate_error', unit='', value=0.06595243216514216)], qubits=[3, 2]), Gate(gate='cx', name='CX3_4', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 1, 51, 10, tzinfo=tzutc()), name='gate_error', unit='', value=0.037170390854041696)], qubits=[3, 4]), Gate(gate='cx', name='CX4_2', parameters=[Nduv(date=datetime.datetime(2019, 5, 5, 1, 57, 9, tzinfo=tzutc()), name='gate_error', unit='', value=0.06375858422041455)], qubits=[4, 2])], general=[], last_update_date=datetime.datetime(2019, 5, 5, 1, 57, 9, tzinfo=tzutc()), qconsole=False, qubits=[[Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 19, tzinfo=tzutc()), name='T1', unit='µs', value=46.944471549733265), Nduv(date=datetime.datetime(2019, 5, 5, 1, 17, 2, tzinfo=tzutc()), name='T2', unit='µs', value=21.01917248316493), Nduv(date=datetime.datetime(2019, 5, 5, 1, 57, 9, tzinfo=tzutc()), name='frequency', unit='GHz', value=5.246586904931009), Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 1, tzinfo=tzutc()), name='readout_error', unit='', value=0.09725000000000006)], [Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 19, tzinfo=tzutc()), name='T1', unit='µs', value=34.8386350043575), Nduv(date=datetime.datetime(2019, 5, 5, 1, 17, 44, tzinfo=tzutc()), name='T2', unit='µs', value=8.96669288491999), Nduv(date=datetime.datetime(2019, 5, 5, 1, 57, 9, tzinfo=tzutc()), name='frequency', unit='GHz', value=5.298307369106327), Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 1, tzinfo=tzutc()), name='readout_error', unit='', value=0.08074999999999999)], [Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 19, tzinfo=tzutc()), name='T1', unit='µs', value=46.02627218549318), Nduv(date=datetime.datetime(2019, 5, 5, 1, 18, 25, tzinfo=tzutc()), name='T2', unit='µs', value=44.404522856528764), Nduv(date=datetime.datetime(2019, 5, 5, 1, 57, 9, tzinfo=tzutc()), name='frequency', unit='GHz', value=5.338330607825444), Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 1, tzinfo=tzutc()), name='readout_error', unit='', value=0.03574999999999995)], [Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 19, tzinfo=tzutc()), name='T1', unit='µs', value=48.31374510001719), Nduv(date=datetime.datetime(2019, 5, 5, 1, 17, 44, tzinfo=tzutc()), name='T2', unit='µs', value=59.49375656436664), Nduv(date=datetime.datetime(2019, 5, 5, 1, 57, 9, tzinfo=tzutc()), name='frequency', unit='GHz', value=5.426115066671996), Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 1, tzinfo=tzutc()), name='readout_error', unit='', value=0.3295)], [Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 19, tzinfo=tzutc()), name='T1', unit='µs', value=49.13053181348111), Nduv(date=datetime.datetime(2019, 5, 5, 1, 17, 2, tzinfo=tzutc()), name='T2', unit='µs', value=5.831014210003844), Nduv(date=datetime.datetime(2019, 5, 5, 1, 57, 9, tzinfo=tzutc()), name='frequency', unit='GHz', value=5.174509016067556), Nduv(date=datetime.datetime(2019, 5, 5, 1, 16, 1, tzinfo=tzutc()), name='readout_error', unit='', value=0.25049999999999994)]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend.properties()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next is `hub`, `group`, and `project`. For the IBM Q experience these will return `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend.hub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend.group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "backend.project"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To see your last 5 jobs ran on the backend use the `jobs()` method of that backend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5ccf80446443ec007394c5c8 JobStatus.DONE\n",
      "5ccf80389bfaab0074c5cf78 JobStatus.CANCELLED\n",
      "5ccf7ff47b9d00006d60b9cd JobStatus.DONE\n",
      "5ccf7d36557a5600718c5793 JobStatus.DONE\n",
      "5ccf450535c8b100714dcc53 JobStatus.DONE\n"
     ]
    }
   ],
   "source": [
    "for ran_job in backend.jobs(limit=5):\n",
    "    print(str(ran_job.job_id()) + \" \" + str(ran_job.status()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then the job can be retreived using `retrieve_job(job_id())` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "job = backend.retrieve_job(ran_job.job_id())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Job object\n",
    "\n",
    "Job instances can be thought of as the “ticket” for a submitted job. They find out the execution’s state at a given point in time (for example, if the job is queued, running, or has failed) and also allow control over the job. They have the following methods:\n",
    "\n",
    "- `status()` - returns the status of the job.\n",
    "- `backend()` - returns the backend the job was run on.\n",
    "- `job_id()` - gets the job_id.\n",
    "- `cancel()` - cancels the job.\n",
    "- `result()` - gets the results from the circuit run.\n",
    "\n",
    "IBMQ only functions \n",
    "\n",
    "- `creation_date()` - gives the date at which the job was created.\n",
    "- `queue_position()` - gives the position of the job in the queue.\n",
    "- `error_message()` - gives the error message of failed jobs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with the `status()`. This returns the job status and a message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.DONE: 'job has successfully run'>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get a backend object from the job use the `backend()` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<IBMQBackend('ibmqx4') from IBMQ()>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "backend_temp = job.backend()\n",
    "backend_temp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the job_id use the `job_id()` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'5ccf450535c8b100714dcc53'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.job_id()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get the result from the job use the `result()` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'011': 25, '000': 452, '100': 22, '001': 19, '110': 77, '010': 21, '101': 67, '111': 341}\n"
     ]
    }
   ],
   "source": [
    "result = job.result()\n",
    "counts = result.get_counts()\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to check the creation date use `creation_date()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2019-05-05T20:18:13.060Z'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.creation_date()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's make an active example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "from qiskit.compiler import transpile, assemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-09-26T14:39:13.343626Z",
     "start_time": "2018-09-26T14:39:13.334395Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qiskit.circuit.instructionset.InstructionSet at 0x123ccb860>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qr = QuantumRegister(3)\n",
    "cr = ClassicalRegister(3)\n",
    "circuit = QuantumCircuit(qr, cr)\n",
    "circuit.x(qr[0])\n",
    "circuit.x(qr[1])\n",
    "circuit.ccx(qr[0], qr[1], qr[2])\n",
    "circuit.cx(qr[0], qr[1])\n",
    "circuit.measure(qr, cr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To compile this circuit for the backend use the compile function. It will make a qobj (quantum object) that can be run on the backend using the `run(qobj)` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "qobj = assemble(transpile(circuit, backend=backend), shots=1024)\n",
    "job = backend.run(qobj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The status of this job can be checked with the `status()` method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.INITIALIZING: 'job is being initialized'>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you made a mistake and need to cancel the job use the `cancel()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "#time.sleep(10)\n",
    "\n",
    "job.cancel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `status()` will show that the job cancelled. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<JobStatus.INITIALIZING: 'job is being initialized'>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "job.status()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To rerun the job and set up a loop to check the status and queue position you can use the `queue_position()` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-09-26T14:39:14.902205Z",
     "start_time": "2018-09-26T14:39:14.898287Z"
    }
   },
   "outputs": [],
   "source": [
    "job = backend.run(qobj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    }
   ],
   "source": [
    "from qiskit.tools.monitor import job_monitor\n",
    "job_monitor(job)\n",
    "result = job.result()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'011': 45, '000': 45, '100': 147, '001': 100, '110': 24, '010': 18, '101': 599, '111': 46}\n"
     ]
    }
   ],
   "source": [
    "counts = result.get_counts()\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}