Minor fixes - Part 2 of 8 (#800)

* Fix README and INSTALL files.

This fixes the following issues:
- installation instructions updated to IBMQ v3
- old links are moved to correct location
- some typos
- consistent formatting

* Update gitignore to properly ignore any checkpoints folder

* Remove unnecessary executable permissions

* Fix start and index notebooks.

This introduces the following changes:
- fixes typos
- adds missing references to other notebooks

* Fix typos in qiskit/fundamentals chapter 1

* Update qiskit/fundamentals chapter 2

- fixes typos
- adds missing figure of `plot_state_qsphere(psi)`

* Fix qiskit/fundamentals chapter 3

- fixes typos
- adds links to the final section ("Updating from previous versions")
- removes some redundant cells

* Fix typos in qiskit/fundamentals chapter 4

* Fix typos in qiskit/fundamentals chapter 5

* Fix typos in qiskit/fundamentals chapter 6

* Fix typos in qiskit/fundamentals chapter 7

Author: mrossinek

qiskit/fundamentals/1_getting_started_with_qiskit.ipynb

@@ -585,7 +585,7 @@
    "source": [
     "## Running circuits from the IBM Q account <a name='ibmq'></a>\n",
     "\n",
-    "To faciliate access to real quantum computing hardware, we have provided a simple API interface.\n",
+    "To facilitate access to real quantum computing hardware, we have provided a simple API interface.\n",
     "To access IBM Q devices, you'll need an API token. You can generate, or view, your API token [here](https://quantum-computing.ibm.com/account) (create an account if you don't already have one).\n",
     "\n",
     "Your IBM Q account lets you run your circuit on real devices or on our cloud simulator. Basic account usage can be seen in the examples below. For more detailed instructions on using the IBM Q account, see [Part 3: The IBMQ Account](3_the_ibmq_account.ipynb)."
@@ -700,7 +700,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "the ask the provider to list its backends:"
+    "then ask the provider to list its backends:"
    ]
   },
   {
@@ -867,8 +867,7 @@
    "source": [
     "### Simulating circuits using the IBM Q cloud simulator\n",
     "\n",
-    "The IBM Q provider also comes with a remote optimized simulator called ``ibmq_qasm_simulator``. This remote simulator is capable of simulating up to 32 qubits. It can be used the \n",
-    "same way as the remote real backends. "
+    "The IBM Q provider also comes with a remote optimized simulator called ``ibmq_qasm_simulator``. This remote simulator is capable of simulating up to 32 qubits. It can be used the same way as the remote real backends. "
    ]
   },
   {
@@ -947,7 +946,7 @@
     "### Retrieving a previously run job\n",
     "\n",
     "If your experiment takes longer to run then you have time to wait around, or if you simply want to retrieve old jobs, the IBM Q backends allow you to do that.\n",
-    "First you would need to note your job's ID:"
+    "First, you would need to note your job's ID:"
    ]
   },
   {
@@ -979,7 +978,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Given a job ID, that job object can be later reconstructed from the backend using retrieve_job:"
+    "Given a job ID, that job object can be later reconstructed from the backend using ```retrieve_job```:"
    ]
   },
   {

qiskit/fundamentals/2_plotting_data_in_qiskit.ipynb

@@ -20,15 +20,15 @@
    "source": [
     "In Qiskit we have an interface for backends and jobs that is 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 account as an example.\n",
     "\n",
-    "The interface has four main component: the account, providers, backends, and jobs:\n",
+    "The interface has four main components: the account, providers, backends, and jobs:\n",
     "\n",
-    "- **account**: Gives access to one or more ‘providers’ based on account permissions.\n",
+    "- **account**: Gives access to one or more ‘providers’ based on the account's permissions.\n",
     "\n",
-    "- **providers**: Provides access to quantum devices and simulators, collectively called ‘backends’, and additional services tailored to a specific backend instance.\n",
+    "- **provider**: Provides access to quantum devices and simulators, collectively called ‘backends’, and additional services tailored to a specific backend instance.\n",
     "\n",
-    "- **backends**: A quantum device or simulator capable of running quantum circuits or pulse schedules.\n",
+    "- **backend**: A quantum device or simulator capable of running quantum circuits or pulse schedules.\n",
     "\n",
-    "- **jobs**: A local reference to a collection of quantum circuits or pulse schedules submitted to a given backend."
+    "- **job**: A local reference to a collection of quantum circuits or pulse schedules submitted to a given backend."
    ]
   },
   {
@@ -51,7 +51,10 @@
     "3) [Backends](#backends)\n",
     "    \n",
     "    \n",
-    "3) [Jobs](#jobs)"
+    "4) [Jobs](#jobs)\n",
+    "\n",
+    "\n",
+    "5) [Updating from previous versions](#updating)"
    ]
   },
   {
@@ -64,7 +67,7 @@
     "\n",
     "The `IBMQ` account has 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)`: Enable your account in the current session\n",
+    "- `enable_account(TOKEN)`: Enable your account in the current session.\n",
     "- `save_account(TOKEN)`: Save your account to disk for future use.\n",
     "- `load_account()`: Load account using stored credentials.\n",
     "- `disable_account()`: Disable your account in the current session.\n",
@@ -74,12 +77,7 @@
     "\n",
     "\n",
     "\n",
-    "In order to access quantum devices, simulators, or other services, you must specify the source of these items by selecting a provider. To see all the providers available:\n",
-    "\n",
-    "\n",
-    "<div class=\"alert alert-block alert-info\">\n",
-    "<b>Note:</b> The use of `provider` instances is the default way of retrieving backends from Qiskit 0.11 onwards - if you have been using earlier versions of Qiskit, check the \"Updating from previous versions\" section for more detailed instructions on updating and using the different options.</div>\n",
-    "</div>"
+    "In order to access quantum devices, simulators, or other services, you must specify the source of these items by selecting a provider. To see all the providers available do the following:"
    ]
   },
   {
@@ -120,14 +118,18 @@
    "source": [
     "where we have assumed that the user has stored their IBMQ account information locally ahead of time using `IBMQ.save_account(TOKEN)`.\n",
     "\n",
+    "<div class=\"alert alert-block alert-info\">\n",
+    "<b>Note:</b> The use of `provider` instances is the default way of retrieving backends from Qiskit 0.11 onwards - if you have been using earlier versions of Qiskit, check the <a href=\"#updating\">\"Updating from previous versions\"</a> section for more detailed instructions on updating and using the different options.</div>\n",
+    "</div>\n",
+    "\n",
     "The above example shows two different providers. All `IBMQ` providers are specified by a `hub`, `group`, and `project`. The provider given by `hub='ibm-q', group='open', project='main'` is the provider that gives access to the public IBM Q devices available to all IQX users. The second is an example of a provider that is only unlocked for a specific set of users. Members of the IBM Q network may see one or more providers (with names different than those shown above) depending on the access level granted to them."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To access a given provider one should use the get_provider() method of the IBMQ account, filtering by `hub`, `group`, or `project`:"
+    "To access a given provider one should use the `get_provider()` method of the `IBMQ` account, filtering by `hub`, `group`, or `project`:"
    ]
   },
   {
@@ -265,43 +267,13 @@
     "backend"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "and backends which are available in the default provider"
-   ]
-  },
-  {
-   "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": [
-    "provider.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`, `status`, or `properties`. The filters are passed by conditions and, for more general filters, you can make advanced functions using the lambda function.\n",
+    "You may also optionally filter the set of returned backends, by passing arguments that query the backend’s `configuration`, `status`, or `properties`. The filters are passed by conditions and, for more general filters, you can make advanced functions using a lambda function.\n",
     "\n",
     "As a first example lets return only those backends that are real quantum devices, and that are currently operational:"
    ]
@@ -438,17 +410,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "For remote backends they must support the additional\n",
+    "For remote backends they must support the additional methods:\n",
     "\n",
     "- `jobs()`: Returns a list of previous jobs executed on this backend through the current provider instance.\n",
     "- `retrieve_job(JOB_ID)`:  Returns a job by a job_id.\n",
     "\n",
     "On a per device basis, the following commands may be supported:\n",
     "\n",
     "- `defaults()`: Gives a data structure of typical default parameters.\n",
-    "- `schema()`: Fets a schema for the backend.\n",
+    "- `schema()`: Gets a schema for the backend.\n",
     "\n",
-    "There are some IBM Q backend only attributes:\n",
+    "There are some \"IBM Q backend\"-only attributes:\n",
     "\n",
     "- `hub`: The IBMQ hub for this backend.\n",
     "- `group`:  The IBMQ group for this backend.\n",
@@ -656,7 +628,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "A `job` can be retrieved using `retrieve_job(JOB_ID)` method"
+    "A `job` can be retrieved using the `retrieve_job(JOB_ID)` method:"
    ]
   },
   {
@@ -687,20 +659,18 @@
     "- `cancel()`: Cancels the job.\n",
     "- `result()`: Gets the results from the circuit run.\n",
     "\n",
-    "IBM Q job only functions include:\n",
+    "\"IBM Q job\"-only functions include:\n",
     "\n",
     "- `creation_date()`: Gives the date at which the job was created.\n",
     "- `queue_position()`: Returns the position of the job in the queue.\n",
-    "- `error_message()`: The error message of failed jobs, if any.\n",
-    "\n",
-    "Let’s start with the `status()`. This returns the job status and a message"
+    "- `error_message()`: The error message of failed jobs, if any."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's start with the `status()`. This returns the job status and a message"
+    "Let's start with the `status()`. This returns the job status and a message:"
    ]
   },
   {
@@ -732,7 +702,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To get a backend object from the job, use the `backend()` method"
+    "To get a backend object from the job, use the `backend()` method:"
    ]
   },
   {
@@ -765,7 +735,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To get the job_id use the `job_id()` method"
+    "To get the job_id use the `job_id()` method:"
    ]
   },
   {
@@ -797,7 +767,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To get the result from the job, use the `result()` method"
+    "To get the result from the job, use the `result()` method:"
    ]
   },
   {
@@ -828,7 +798,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you want to check the creation date, use `creation_date()`"
+    "If you want to check the creation date, use `creation_date()`:"
    ]
   },
   {
@@ -860,7 +830,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's make an active example"
+    "Let's make an active example."
    ]
   },
   {
@@ -965,7 +935,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Updating from previous versions\n",
+    "## Updating from previous versions <a name='updating'></a>\n",
     "\n",
     "Since `Qiskit` version `0.11`, the IBM Q account defaults to using the new [IBM Q Experience](https://quantum-computing.ibm.com), which supersedes the legacy Quantum Experience and Q-console.\n",
     "\n",

qiskit/fundamentals/3_the_ibmq_account.ipynb

@@ -63,7 +63,7 @@
    "source": [
     "## Introduction <a name='introduction'></a>\n",
     "\n",
-    "When constructing quantum circuits, there are several properties that help quantify the \"size\" of the circuits, and their ability to be run on a noisy quantum device.  Some of these, like number of qubits, are straightforward to understand.  While others like depth and number of tensor components require a bit more explanation.  Here we will explain all of these properties, and in preparation of understanding how circuits change when run on actual devices, highlight the conditions under which they change.\n",
+    "When constructing quantum circuits, there are several properties that help quantify the \"size\" of the circuits, and their ability to be run on a noisy quantum device.  Some of these, like number of qubits, are straightforward to understand, while others like depth and number of tensor components require a bit more explanation.  Here we will explain all of these properties, and, in preparation for understanding how circuits change when run on actual devices, highlight the conditions under which they change.\n",
     "\n",
     "\n",
     "### Basics\n",
@@ -156,7 +156,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "we can also just get the number of qubits directly:"
+    "We can also just get the number of qubits directly:"
    ]
   },
   {
@@ -188,7 +188,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "It is also straightforward to get the number and type of the gates in a circuit using `count_ops`:"
+    "It is also straightforward to get the number and type of the gates in a circuit using `count_ops()`:"
    ]
   },
   {
@@ -220,7 +220,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can also get just the raw count of operations by computing the circuits **size**."
+    "We can also get just the raw count of operations by computing the circuits **size**:"
    ]
   },
   {
@@ -261,7 +261,7 @@
    "source": [
     "A particularly important circuit property is known as the **depth**.  The depth of a quantum circuit is a measure of how many \"layers\" of quantum gates, executed in parallel, it takes to complete the computation defined by the circuit.  Because quantum gates take time to implement, the depth of a circuit roughly corresponds to the amount of time it takes the quantum computer to execute the circuit.  Thus, the depth of a circuit is one important quantity used to measure if a quantum circuit can be run on a device.\n",
     "\n",
-    "The depth of a quantum circuit has a mathematical definition as the longest path in a directed acyclic graph (DAG).  However, such a definition is a bit hard to grasp, even for experts.  Fortunately, the depth of a circuit can be easily understood by anyone familiar with playing [Tetris](https://en.wikipedia.org/wiki/Tetris).  To undertand this let us redraw the circuit, with the first five CNOT gates colored differently for clarity:"
+    "The depth of a quantum circuit has a mathematical definition as the longest path in a directed acyclic graph (DAG).  However, such a definition is a bit hard to grasp, even for experts.  Fortunately, the depth of a circuit can be easily understood by anyone familiar with playing [Tetris](https://en.wikipedia.org/wiki/Tetris).  To understand this, let us redraw the circuit with the first five CNOT gates colored differently for clarity:"
    ]
   },
   {
@@ -435,7 +435,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The **width** of the circuit now includes the number of qubits and number of classical bits:"
+    "The **width** of the circuit now includes the number of qubits _and_ number of classical bits:"
    ]
   },
   {
@@ -541,9 +541,7 @@
     }
    },
    "source": [
-    "### Depth\n",
-    "\n",
-    "The depth of the circuit has now increased because measurements are included in the depth computation as they perform physical operations:"
+    "The **depth** of the circuit has now increased because measurements are included in the depth computation as they perform physical operations:"
    ]
   },
   {
@@ -575,7 +573,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Barriers and other special commands like snapshots do not count toward the depth directly. However, gates cannot pass through them and must therefore start stacking on top."
+    "Barriers and other special commands like snapshots do not count towards the depth directly. However, gates cannot pass through them and must therefore start stacking on top."
    ]
   },
   {
@@ -746,7 +744,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This simple example is meant to illustrate a very important point: **When running circuits on actual quantum devices, the circuit that gets run is in general not the same circuit that you constructed**.  In addition, the depth of that new circuit is likely to be larger, and in some cases much larger, than the original one.  Fortunately, there are often times where one can reduce this overhead through smart circuit rewriting toolchains."
+    "This simple example is meant to illustrate a very important point: **When running circuits on actual quantum devices, the circuit that gets run is in general not the same circuit that you constructed**.  In addition, the depth of that new circuit is likely to be larger, and in some cases much larger, than the original one.  Fortunately, often times one can reduce this overhead through smart circuit rewriting toolchains."
    ]
   },
   {